mirror of
https://github.com/meshcore-dev/MeshCore.git
synced 2026-03-30 17:05:52 +00:00
437 lines
12 KiB
C++
437 lines
12 KiB
C++
#include <Arduino.h>
|
|
#include "target.h"
|
|
#include <helpers/ArduinoHelpers.h>
|
|
#include <helpers/sensors/MicroNMEALocationProvider.h>
|
|
|
|
RAK4631Board board;
|
|
|
|
RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
|
|
|
|
WRAPPER_CLASS radio_driver(radio, board);
|
|
|
|
VolatileRTCClock fallback_clock;
|
|
AutoDiscoverRTCClock rtc_clock(fallback_clock);
|
|
|
|
#if ENV_INCLUDE_GPS
|
|
MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Wire);
|
|
RAK4631SensorManager sensors = RAK4631SensorManager(nmea);
|
|
#else
|
|
RAK4631SensorManager sensors;
|
|
#endif
|
|
|
|
#if ENV_INCLUDE_BME680
|
|
#ifndef TELEM_BME680_ADDRESS
|
|
#define TELEM_BME680_ADDRESS 0x76 // BME680 environmental sensor I2C address
|
|
#endif
|
|
#include <bsec2.h>
|
|
static Bsec2 BME680;
|
|
float rawPressure = 0;
|
|
float rawTemperature = 0;
|
|
float compTemperature = 0;
|
|
float rawHumidity = 0;
|
|
float compHumidity = 0;
|
|
float readIAQ = 0;
|
|
float readStaticIAQ = 0;
|
|
float readCO2 = 0;
|
|
#endif
|
|
|
|
#ifdef DISPLAY_CLASS
|
|
DISPLAY_CLASS display;
|
|
#endif
|
|
|
|
#ifdef MESH_DEBUG
|
|
uint32_t deviceOnline = 0x00;
|
|
void scanDevices(TwoWire *w)
|
|
{
|
|
uint8_t err, addr;
|
|
int nDevices = 0;
|
|
uint32_t start = 0;
|
|
|
|
Serial.println("Scanning I2C for Devices");
|
|
for (addr = 1; addr < 127; addr++) {
|
|
start = millis();
|
|
w->beginTransmission(addr); delay(2);
|
|
err = w->endTransmission();
|
|
if (err == 0) {
|
|
nDevices++;
|
|
switch (addr) {
|
|
case 0x42:
|
|
Serial.println("\tFound RAK12500 GPS Sensor");
|
|
deviceOnline |= RAK12500_ONLINE;
|
|
break;
|
|
case 0x76:
|
|
Serial.println("\tFound RAK1906 Environment Sensor");
|
|
deviceOnline |= BME680_ONLINE;
|
|
break;
|
|
default:
|
|
Serial.print("\tI2C device found at address 0x");
|
|
if (addr < 16) {
|
|
Serial.print("0");
|
|
}
|
|
Serial.print(addr, HEX);
|
|
Serial.println(" !");
|
|
break;
|
|
}
|
|
|
|
} else if (err == 4) {
|
|
Serial.print("Unknow error at address 0x");
|
|
if (addr < 16) {
|
|
Serial.print("0");
|
|
}
|
|
Serial.println(addr, HEX);
|
|
}
|
|
}
|
|
if (nDevices == 0)
|
|
Serial.println("No I2C devices found\n");
|
|
|
|
Serial.println("Scan for devices is complete.");
|
|
Serial.println("\n");
|
|
}
|
|
#endif
|
|
|
|
bool radio_init() {
|
|
rtc_clock.begin(Wire);
|
|
return radio.std_init(&SPI);
|
|
}
|
|
|
|
uint32_t radio_get_rng_seed() {
|
|
return radio.random(0x7FFFFFFF);
|
|
}
|
|
|
|
void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
|
|
radio.setFrequency(freq);
|
|
radio.setSpreadingFactor(sf);
|
|
radio.setBandwidth(bw);
|
|
radio.setCodingRate(cr);
|
|
}
|
|
|
|
void radio_set_tx_power(uint8_t dbm) {
|
|
radio.setOutputPower(dbm);
|
|
}
|
|
|
|
#if ENV_INCLUDE_GPS
|
|
void RAK4631SensorManager::start_gps()
|
|
{
|
|
//function currently not used
|
|
gps_active = true;
|
|
pinMode(disStandbyPin, OUTPUT);
|
|
digitalWrite(disStandbyPin, 1);
|
|
MESH_DEBUG_PRINTLN("GPS should be on now");
|
|
}
|
|
|
|
void RAK4631SensorManager::stop_gps()
|
|
{
|
|
//function currently not used
|
|
gps_active = false;
|
|
pinMode(disStandbyPin, OUTPUT);
|
|
digitalWrite(disStandbyPin, 0);
|
|
MESH_DEBUG_PRINTLN("GPS should be off now");
|
|
}
|
|
|
|
void RAK4631SensorManager::sleep_gps() {
|
|
gps_active = false;
|
|
ublox_GNSS.powerSaveMode();
|
|
MESH_DEBUG_PRINTLN("GPS should be sleeping now");
|
|
}
|
|
|
|
void RAK4631SensorManager::wake_gps() {
|
|
gps_active = true;
|
|
ublox_GNSS.powerSaveMode(false);
|
|
MESH_DEBUG_PRINTLN("GPS should be waking now");
|
|
}
|
|
|
|
bool RAK4631SensorManager::gpsIsAwake(uint32_t ioPin){
|
|
|
|
int pinInitialState = 0;
|
|
|
|
//set initial waking state
|
|
pinMode(ioPin,OUTPUT);
|
|
digitalWrite(ioPin,0);
|
|
delay(1000);
|
|
digitalWrite(ioPin,1);
|
|
delay(1000);
|
|
|
|
if (ublox_GNSS.begin(Wire) == true){
|
|
MESH_DEBUG_PRINTLN("GPS init correctly and GPS is turned on");
|
|
ublox_GNSS.setI2COutput(COM_TYPE_NMEA);
|
|
ublox_GNSS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT);
|
|
disStandbyPin = ioPin;
|
|
gps_active = true;
|
|
gps_detected = true;
|
|
return true;
|
|
}
|
|
else
|
|
MESH_DEBUG_PRINTLN("GPS failed to init on this IO pin... try the next");
|
|
//digitalWrite(ioPin,pinInitialState); //reset the IO pin to initial state
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
#if ENV_INCLUDE_BME680
|
|
void checkBMEStatus(Bsec2 bsec)
|
|
{
|
|
if (bsec.status < BSEC_OK)
|
|
{
|
|
MESH_DEBUG_PRINTLN("BSEC error code : %f", float(bsec.status));
|
|
}
|
|
else if (bsec.status > BSEC_OK)
|
|
{
|
|
MESH_DEBUG_PRINTLN("BSEC warning code : %f", float(bsec.status));
|
|
}
|
|
|
|
if (bsec.sensor.status < BME68X_OK)
|
|
{
|
|
MESH_DEBUG_PRINTLN("BME68X error code : %f", bsec.sensor.status);
|
|
}
|
|
else if (bsec.sensor.status > BME68X_OK)
|
|
{
|
|
MESH_DEBUG_PRINTLN("BME68X warning code : %f", bsec.sensor.status);
|
|
}
|
|
}
|
|
void newDataCallback(const bme68xData data, const bsecOutputs outputs, Bsec2 bsec)
|
|
{
|
|
if (!outputs.nOutputs)
|
|
{
|
|
MESH_DEBUG_PRINTLN("No new data to report out");
|
|
return;
|
|
}
|
|
|
|
MESH_DEBUG_PRINTLN("BSEC outputs:\n\tTime stamp = %f", (int) (outputs.output[0].time_stamp / INT64_C(1000000)));
|
|
for (uint8_t i = 0; i < outputs.nOutputs; i++)
|
|
{
|
|
const bsecData output = outputs.output[i];
|
|
switch (output.sensor_id)
|
|
{
|
|
case BSEC_OUTPUT_IAQ:
|
|
readIAQ = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tIAQ = %f", output.signal);
|
|
MESH_DEBUG_PRINTLN("\tIAQ accuracy = %f", output.accuracy);
|
|
break;
|
|
case BSEC_OUTPUT_RAW_TEMPERATURE:
|
|
rawTemperature = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tTemperature = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_RAW_PRESSURE:
|
|
rawPressure = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tPressure = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_RAW_HUMIDITY:
|
|
rawHumidity = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tHumidity = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_RAW_GAS:
|
|
MESH_DEBUG_PRINTLN("\tGas resistance = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_STABILIZATION_STATUS:
|
|
MESH_DEBUG_PRINTLN("\tStabilization status = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_RUN_IN_STATUS:
|
|
MESH_DEBUG_PRINTLN("\tRun in status = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE:
|
|
compTemperature = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tCompensated temperature = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY:
|
|
compHumidity = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tCompensated humidity = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_STATIC_IAQ:
|
|
readStaticIAQ = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tStatic IAQ = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_CO2_EQUIVALENT:
|
|
readCO2 = output.signal;
|
|
MESH_DEBUG_PRINTLN("\tCO2 Equivalent = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_BREATH_VOC_EQUIVALENT:
|
|
MESH_DEBUG_PRINTLN("\tbVOC equivalent = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_GAS_PERCENTAGE:
|
|
MESH_DEBUG_PRINTLN("\tGas percentage = %f", output.signal);
|
|
break;
|
|
case BSEC_OUTPUT_COMPENSATED_GAS:
|
|
MESH_DEBUG_PRINTLN("\tCompensated gas = %f", output.signal);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
bool RAK4631SensorManager::begin() {
|
|
|
|
#ifdef MESH_DEBUG
|
|
scanDevices(&Wire);
|
|
#endif
|
|
|
|
#if ENV_INCLUDE_GPS
|
|
//search for the correct IO standby pin depending on socket used
|
|
if(gpsIsAwake(P_GPS_STANDBY_A)){
|
|
MESH_DEBUG_PRINTLN("GPS is on socket A");
|
|
}
|
|
else if(gpsIsAwake(P_GPS_STANDBY_C)){
|
|
MESH_DEBUG_PRINTLN("GPS is on socket C");
|
|
}
|
|
else if(gpsIsAwake(P_GPS_STANDBY_F)){
|
|
MESH_DEBUG_PRINTLN("GPS is on socket F");
|
|
}
|
|
else{
|
|
MESH_DEBUG_PRINTLN("Error: No GPS found on sockets A, C or F");
|
|
gps_active = false;
|
|
gps_detected = false;
|
|
return false;
|
|
}
|
|
|
|
#ifndef FORCE_GPS_ALIVE
|
|
//Now that GPS is found and set up, set to sleep for initial state
|
|
stop_gps();
|
|
#endif
|
|
#endif
|
|
|
|
#if ENV_INCLUDE_BME680
|
|
|
|
bsecSensor sensorList[5] = {
|
|
BSEC_OUTPUT_IAQ,
|
|
// BSEC_OUTPUT_RAW_TEMPERATURE,
|
|
BSEC_OUTPUT_RAW_PRESSURE,
|
|
// BSEC_OUTPUT_RAW_HUMIDITY,
|
|
// BSEC_OUTPUT_RAW_GAS,
|
|
// BSEC_OUTPUT_STABILIZATION_STATUS,
|
|
// BSEC_OUTPUT_RUN_IN_STATUS,
|
|
BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
|
|
BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
|
|
BSEC_OUTPUT_STATIC_IAQ,
|
|
// BSEC_OUTPUT_CO2_EQUIVALENT,
|
|
// BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
|
|
// BSEC_OUTPUT_GAS_PERCENTAGE,
|
|
// BSEC_OUTPUT_COMPENSATED_GAS
|
|
};
|
|
|
|
if(!BME680.begin(TELEM_BME680_ADDRESS, Wire)){
|
|
checkBMEStatus(BME680);
|
|
bme680_present = false;
|
|
bme680_active = false;
|
|
return false;
|
|
}
|
|
|
|
MESH_DEBUG_PRINTLN("Found BME680 at address: %02X", TELEM_BME680_ADDRESS);
|
|
bme680_present = true;
|
|
bme680_active = true;
|
|
|
|
if (SAMPLING_RATE == BSEC_SAMPLE_RATE_ULP)
|
|
{
|
|
BME680.setTemperatureOffset(BSEC_SAMPLE_RATE_ULP);
|
|
}
|
|
else if (SAMPLING_RATE == BSEC_SAMPLE_RATE_LP)
|
|
{
|
|
BME680.setTemperatureOffset(TEMP_OFFSET_LP);
|
|
}
|
|
|
|
if (!BME680.updateSubscription(sensorList, ARRAY_LEN(sensorList), SAMPLING_RATE))
|
|
{
|
|
checkBMEStatus(BME680);
|
|
}
|
|
|
|
BME680.attachCallback(newDataCallback);
|
|
|
|
#endif
|
|
}
|
|
|
|
bool RAK4631SensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) {
|
|
#ifdef ENV_INCLUDE_GPS
|
|
if (requester_permissions & TELEM_PERM_LOCATION && gps_active) { // does requester have permission?
|
|
telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude);
|
|
}
|
|
#endif
|
|
|
|
if (requester_permissions & TELEM_PERM_ENVIRONMENT) {
|
|
|
|
#if ENV_INCLUDE_BME680
|
|
if (bme680_active) {
|
|
telemetry.addTemperature(TELEM_CHANNEL_SELF, compTemperature);
|
|
telemetry.addRelativeHumidity(TELEM_CHANNEL_SELF, compHumidity);
|
|
telemetry.addBarometricPressure(TELEM_CHANNEL_SELF, rawPressure);
|
|
telemetry.addTemperature(TELEM_CHANNEL_SELF+1, readIAQ);
|
|
telemetry.addRelativeHumidity(TELEM_CHANNEL_SELF+1, readStaticIAQ);
|
|
}
|
|
#endif
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RAK4631SensorManager::loop() {
|
|
static long next_update = 0;
|
|
|
|
#ifdef ENV_INCLUDE_GPS
|
|
_nmea->loop();
|
|
#endif
|
|
|
|
if (millis() > next_update) {
|
|
|
|
#ifdef ENV_INCLUDE_GPS
|
|
if(gps_active){
|
|
node_lat = (double)ublox_GNSS.getLatitude()/10000000.;
|
|
node_lon = (double)ublox_GNSS.getLongitude()/10000000.;
|
|
node_altitude = (double)ublox_GNSS.getAltitude()/1000.;
|
|
MESH_DEBUG_PRINT("lat %f lon %f alt %f\r\n", node_lat, node_lon, node_altitude);
|
|
}
|
|
#endif
|
|
|
|
#ifdef ENV_INCLUDE_BME680
|
|
if(bme680_active){
|
|
if (!BME680.run()){
|
|
checkBMEStatus(BME680);
|
|
}
|
|
}
|
|
#endif
|
|
next_update = millis() + 1000;
|
|
}
|
|
|
|
}
|
|
|
|
int RAK4631SensorManager::getNumSettings() const {
|
|
#if ENV_INCLUDE_GPS
|
|
return gps_detected ? 1 : 0; // only show GPS setting if GPS is detected
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
const char* RAK4631SensorManager::getSettingName(int i) const {
|
|
#if ENV_INCLUDE_GPS
|
|
return (gps_detected && i == 0) ? "gps" : NULL;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
const char* RAK4631SensorManager::getSettingValue(int i) const {
|
|
#if ENV_INCLUDE_GPS
|
|
if (gps_detected && i == 0) {
|
|
return gps_active ? "1" : "0";
|
|
}
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
bool RAK4631SensorManager::setSettingValue(const char* name, const char* value) {
|
|
#if ENV_INCLUDE_GPS
|
|
if (gps_detected && strcmp(name, "gps") == 0) {
|
|
if (strcmp(value, "0") == 0) {
|
|
stop_gps();
|
|
} else {
|
|
start_gps();
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
return false; // not supported
|
|
}
|
|
|
|
mesh::LocalIdentity radio_new_identity() {
|
|
RadioNoiseListener rng(radio);
|
|
return mesh::LocalIdentity(&rng); // create new random identity
|
|
}
|