pohui_pohui/firmware
1
0
Fork 0
mirror of https://github.com/meshtastic/firmware.git synced 2025-06-21 20:44:47 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:meshtastic/Meshtastic-device

Browse Source
This commit is contained in:
Thomas Göttgens 2022-06-12 17:37:43 +02:00
commit 77f096e56c
30 changed files with 300 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
platformio.ini
View File

@ -84,7 +84,8 @@ lib_deps =
adafruit/Adafruit BME280 Library@^2.2.2
adafruit/Adafruit BME680 Library@^2.0.1
adafruit/Adafruit MCP9808 Library@^2.0.0
adafruit/Adafruit INA260 Library@^1.5.0
adafruit/Adafruit INA219@^1.2.0
; Common settings for ESP targes, mixin with extends = esp32_base
[esp32_base]
extends = arduino_base

2
protobufs

@ -1 +1 @@
Subproject commit 33b3ab5fde6b6ef158e3b111bf240d1d59c152ef
Subproject commit e5b5adc196d3593ab15c04101093443ab8b36c9c

3
src/PowerFSM.cpp
View File

@ -348,9 +348,6 @@ void PowerFSM_setup()
// See: https://github.com/meshtastic/Meshtastic-device/issues/1071
if (isRouter || config.power.is_power_saving) {
// I don't think this transition is correct, turning off for now - @geeksville
// powerFSM.add_timed_transition(&stateDARK, &stateNB, getPref_phone_timeout_secs() * 1000, NULL, "Phone timeout");
powerFSM.add_timed_transition(&stateNB, &stateLS,
config.power.min_wake_secs ? config.power.min_wake_secs
: default_min_wake_secs * 1000,

6
src/SerialConsole.cpp
View File

@ -4,6 +4,8 @@
#include "configuration.h"
#define Port Serial
// Defaulting to the formerly removed phone_timeout_secs value of 15 minutes
#define SERIAL_CONNECTION_TIMEOUT (15 * 60) * 1000UL
SerialConsole *console;
@ -41,12 +43,12 @@ SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
emitRebooted();
}
// For the serial port we can't really detect if any client is on the other side, so instead just look for recent messages
bool SerialConsole::checkIsConnected()
{
uint32_t now = millis();
uint32_t timeout = (config.power.phone_timeout_secs > 0 ? config.power.phone_timeout_secs : default_phone_timeout_secs )* 1000UL;
return (now - lastContactMsec) < timeout;
return (now - lastContactMsec) < SERIAL_CONNECTION_TIMEOUT;
}
/**

2
src/configuration.h
View File

@ -177,6 +177,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BME_ADDR 0x76
#define BME_ADDR_ALTERNATE 0x77
#define MCP9808_ADDR 0x18
#define INA_ADDR 0x40
#define INA_ADDR_ALTERNATE 0x41
// -----------------------------------------------------------------------------
// GPS

55
src/debug/i2cScan.h
View File

@ -4,6 +4,24 @@
#include "mesh/generated/telemetry.pb.h"
#ifndef NO_WIRE
uint16_t getRegisterValue(uint8_t address, uint8_t reg, uint8_t length) {
uint16_t value = 0x00;
Wire.beginTransmission(address);
Wire.write(reg);
Wire.endTransmission();
delay(20);
Wire.requestFrom((int)address, length);
DEBUG_MSG("Wire.available() = %d\n", Wire.available());
if (Wire.available() == 2) {
// Read MSB, then LSB
value = (uint16_t)Wire.read() << 8;
value |= Wire.read();
} else if (Wire.available()) {
value = Wire.read();
}
return value;
}
uint8_t oled_probe(byte addr)
{
uint8_t r = 0;
@ -35,7 +53,7 @@ uint8_t oled_probe(byte addr)
void scanI2Cdevice(void)
{
byte err, addr;
uint8_t r = 0x00;
uint16_t registerValue = 0x00;
int nDevices = 0;
for (addr = 1; addr < 127; addr++) {
Wire.beginTransmission(addr);
@ -75,15 +93,8 @@ void scanI2Cdevice(void)
if (addr == CARDKB_ADDR) {
cardkb_found = addr;
// Do we have the RAK14006 instead?
Wire.beginTransmission(addr);
Wire.write(0x04); // SENSOR_GET_VERSION
Wire.endTransmission();
delay(20);
Wire.requestFrom((int)addr, 1);
if (Wire.available()) {
r = Wire.read();
}
if (r == 0x02) { // KEYPAD_VERSION
registerValue = getRegisterValue(addr, 0x04, 1);
if (registerValue == 0x02) { // KEYPAD_VERSION
DEBUG_MSG("RAK14004 found\n");
kb_model = 0x02;
} else {
@ -106,22 +117,26 @@ void scanI2Cdevice(void)
}
#endif
if (addr == BME_ADDR || addr == BME_ADDR_ALTERNATE) {
Wire.beginTransmission(addr);
Wire.write(0xD0); // GET_ID
Wire.endTransmission();
delay(20);
Wire.requestFrom((int)addr, 1);
if (Wire.available()) {
r = Wire.read();
}
if (r == 0x61) {
registerValue = getRegisterValue(addr, 0xD0, 1); // GET_ID
if (registerValue == 0x61) {
DEBUG_MSG("BME-680 sensor found at address 0x%x\n", (uint8_t)addr);
nodeTelemetrySensorsMap[TelemetrySensorType_BME680] = addr;
} else if (r == 0x60) {
} else if (registerValue == 0x60) {
DEBUG_MSG("BME-280 sensor found at address 0x%x\n", (uint8_t)addr);
nodeTelemetrySensorsMap[TelemetrySensorType_BME280] = addr;
}
}
if (addr == INA_ADDR || addr == INA_ADDR_ALTERNATE) {
registerValue = getRegisterValue(addr, 0xFE, 2);
DEBUG_MSG("Register MFG_UID: 0x%x\n", registerValue);
if (registerValue == 0x5449) {
DEBUG_MSG("INA260 sensor found at address 0x%x\n", (uint8_t)addr);
nodeTelemetrySensorsMap[TelemetrySensorType_INA260] = addr;
} else { // Assume INA219 if INA260 ID is not found
DEBUG_MSG("INA219 sensor found at address 0x%x\n", (uint8_t)addr);
nodeTelemetrySensorsMap[TelemetrySensorType_INA219] = addr;
}
}
if (addr == MCP9808_ADDR) {
nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808] = addr;
DEBUG_MSG("MCP9808 sensor found at address 0x%x\n", (uint8_t)addr);

3
src/main.cpp
View File

@ -89,8 +89,9 @@ bool eink_found = true;
uint32_t serialSinceMsec;
bool axp192_found;
// Array map of sensor types (as array index) and i2c address as value we'll find in the i2c scan
uint8_t nodeTelemetrySensorsMap[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint8_t nodeTelemetrySensorsMap[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
Router *router = NULL; // Users of router don't care what sort of subclass implements that API

2
src/main.h
View File

@ -19,7 +19,7 @@ extern bool axp192_found;
extern bool isCharging;
extern bool isUSBPowered;
extern uint8_t nodeTelemetrySensorsMap[10];
extern uint8_t nodeTelemetrySensorsMap[12];
// Global Screen singleton.
extern graphics::Screen *screen;

1
src/mesh/NodeDB.h
View File

@ -168,7 +168,6 @@ extern NodeDB nodeDB;
#define default_mesh_sds_timeout_secs IF_ROUTER(NODE_DELAY_FOREVER, 2 * 60 * 60)
#define default_sds_secs 365 * 24 * 60 * 60
#define default_ls_secs IF_ROUTER(24 * 60 * 60, 5 * 60)
#define default_phone_timeout_secs 15 * 60
#define default_min_wake_secs 10

21
src/mesh/generated/config.pb.h
View File

@ -120,8 +120,6 @@ typedef struct _Config_PositionConfig {
bool gps_disabled;
uint32_t gps_update_interval;
uint32_t gps_attempt_time;
bool gps_accept_2d;
uint32_t gps_max_dop;
uint32_t position_flags;
} Config_PositionConfig;
@ -133,7 +131,6 @@ typedef struct _Config_PowerConfig {
bool is_power_saving;
float adc_multiplier_override;
uint32_t wait_bluetooth_secs;
uint32_t phone_timeout_secs;
uint32_t mesh_sds_timeout_secs;
uint32_t sds_secs;
uint32_t ls_secs;
@ -194,15 +191,15 @@ extern "C" {
/* Initializer values for message structs */
#define Config_init_default {0, {Config_DeviceConfig_init_default}}
#define Config_DeviceConfig_init_default {_Config_DeviceConfig_Role_MIN, 0, 0, 0, ""}
#define Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0}
#define Config_PowerConfig_init_default {_Config_PowerConfig_ChargeCurrent_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define Config_PositionConfig_init_default {0, 0, 0, 0, 0, 0, 0}
#define Config_PowerConfig_init_default {_Config_PowerConfig_ChargeCurrent_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define Config_WiFiConfig_init_default {"", "", 0, 0}
#define Config_DisplayConfig_init_default {0, _Config_DisplayConfig_GpsCoordinateFormat_MIN, 0}
#define Config_LoRaConfig_init_default {0, _Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, {0, 0, 0}}
#define Config_init_zero {0, {Config_DeviceConfig_init_zero}}
#define Config_DeviceConfig_init_zero {_Config_DeviceConfig_Role_MIN, 0, 0, 0, ""}
#define Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0}
#define Config_PowerConfig_init_zero {_Config_PowerConfig_ChargeCurrent_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define Config_PositionConfig_init_zero {0, 0, 0, 0, 0, 0, 0}
#define Config_PowerConfig_init_zero {_Config_PowerConfig_ChargeCurrent_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define Config_WiFiConfig_init_zero {"", "", 0, 0}
#define Config_DisplayConfig_init_zero {0, _Config_DisplayConfig_GpsCoordinateFormat_MIN, 0}
#define Config_LoRaConfig_init_zero {0, _Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, {0, 0, 0}}
@ -232,8 +229,6 @@ extern "C" {
#define Config_PositionConfig_gps_disabled_tag 5
#define Config_PositionConfig_gps_update_interval_tag 6
#define Config_PositionConfig_gps_attempt_time_tag 7
#define Config_PositionConfig_gps_accept_2d_tag 8
#define Config_PositionConfig_gps_max_dop_tag 9
#define Config_PositionConfig_position_flags_tag 10
#define Config_PowerConfig_charge_current_tag 1
#define Config_PowerConfig_is_low_power_tag 2
@ -242,7 +237,6 @@ extern "C" {
#define Config_PowerConfig_is_power_saving_tag 5
#define Config_PowerConfig_adc_multiplier_override_tag 6
#define Config_PowerConfig_wait_bluetooth_secs_tag 7
#define Config_PowerConfig_phone_timeout_secs_tag 8
#define Config_PowerConfig_mesh_sds_timeout_secs_tag 9
#define Config_PowerConfig_sds_secs_tag 10
#define Config_PowerConfig_ls_secs_tag 11
@ -291,8 +285,6 @@ X(a, STATIC, SINGULAR, BOOL, fixed_position, 3) \
X(a, STATIC, SINGULAR, BOOL, gps_disabled, 5) \
X(a, STATIC, SINGULAR, UINT32, gps_update_interval, 6) \
X(a, STATIC, SINGULAR, UINT32, gps_attempt_time, 7) \
X(a, STATIC, SINGULAR, BOOL, gps_accept_2d, 8) \
X(a, STATIC, SINGULAR, UINT32, gps_max_dop, 9) \
X(a, STATIC, SINGULAR, UINT32, position_flags, 10)
#define Config_PositionConfig_CALLBACK NULL
#define Config_PositionConfig_DEFAULT NULL
@ -305,7 +297,6 @@ X(a, STATIC, SINGULAR, UINT32, on_battery_shutdown_after_secs, 4) \
X(a, STATIC, SINGULAR, BOOL, is_power_saving, 5) \
X(a, STATIC, SINGULAR, FLOAT, adc_multiplier_override, 6) \
X(a, STATIC, SINGULAR, UINT32, wait_bluetooth_secs, 7) \
X(a, STATIC, SINGULAR, UINT32, phone_timeout_secs, 8) \
X(a, STATIC, SINGULAR, UINT32, mesh_sds_timeout_secs, 9) \
X(a, STATIC, SINGULAR, UINT32, sds_secs, 10) \
X(a, STATIC, SINGULAR, UINT32, ls_secs, 11) \
@ -363,8 +354,8 @@ extern const pb_msgdesc_t Config_LoRaConfig_msg;
#define Config_DeviceConfig_size 42
#define Config_DisplayConfig_size 14
#define Config_LoRaConfig_size 67
#define Config_PositionConfig_size 38
#define Config_PowerConfig_size 55
#define Config_PositionConfig_size 30
#define Config_PowerConfig_size 49
#define Config_WiFiConfig_size 103
#define Config_size 105

2
src/mesh/generated/localonly.pb.h
View File

@ -126,7 +126,7 @@ extern const pb_msgdesc_t LocalModuleConfig_msg;
#define LocalModuleConfig_fields &LocalModuleConfig_msg
/* Maximum encoded size of messages (where known) */
#define LocalConfig_size 331
#define LocalConfig_size 317
#define LocalModuleConfig_size 282
#ifdef __cplusplus

30
src/mesh/generated/telemetry.pb.h
View File

@ -12,26 +12,30 @@
/* Enum definitions */
/* TODO: REPLACE */
typedef enum _TelemetrySensorType {
/* No external telemetry sensor */
/* No external telemetry sensor explicitly set */
TelemetrySensorType_NotSet = 0,
/* TODO: REPLACE */
/* Moderate accuracy temperature */
TelemetrySensorType_DHT11 = 1,
/* TODO: REPLACE */
/* High accuracy temperature */
TelemetrySensorType_DS18B20 = 2,
/* TODO: REPLACE */
/* Moderate accuracy temperature and humidity */
TelemetrySensorType_DHT12 = 3,
/* TODO: REPLACE */
/* Moderate accuracy temperature and humidity */
TelemetrySensorType_DHT21 = 4,
/* TODO: REPLACE */
/* Moderate accuracy temperature and humidity */
TelemetrySensorType_DHT22 = 5,
/* TODO: REPLACE */
/* High accuracy temperature, pressure, humidity */
TelemetrySensorType_BME280 = 6,
/* TODO: REPLACE */
/* High accuracy temperature, pressure, humidity, and air resistance */
TelemetrySensorType_BME680 = 7,
/* TODO: REPLACE */
/* Very high accuracy temperature */
TelemetrySensorType_MCP9808 = 8,
/* TODO: REPLACE */
TelemetrySensorType_SHTC3 = 9
/* Moderate accuracy temperature and humidity */
TelemetrySensorType_SHTC3 = 9,
/* Moderate accuracy current and voltage */
TelemetrySensorType_INA260 = 10,
/* Moderate accuracy current and voltage */
TelemetrySensorType_INA219 = 11
} TelemetrySensorType;
/* Struct definitions */
@ -82,8 +86,8 @@ typedef struct _Telemetry {
/* Helper constants for enums */
#define _TelemetrySensorType_MIN TelemetrySensorType_NotSet
#define _TelemetrySensorType_MAX TelemetrySensorType_SHTC3
#define _TelemetrySensorType_ARRAYSIZE ((TelemetrySensorType)(TelemetrySensorType_SHTC3+1))
#define _TelemetrySensorType_MAX TelemetrySensorType_INA219
#define _TelemetrySensorType_ARRAYSIZE ((TelemetrySensorType)(TelemetrySensorType_INA219+1))
#ifdef __cplusplus

6
src/modules/AdminModule.cpp
View File

@ -306,11 +306,10 @@ void AdminModule::handleGetConfig(const MeshPacket &req, const uint32_t configTy
break;
}
// NOTE: The phone app needs to know the ls_secs & phone_timeout value so it can properly expect sleep behavior.
// NOTE: The phone app needs to know the ls_secs value so it can properly expect sleep behavior.
// So even if we internally use 0 to represent 'use default' we still need to send the value we are
// using to the app (so that even old phone apps work with new device loads).
// r.get_radio_response.preferences.ls_secs = getPref_ls_secs();
// r.get_radio_response.preferences.phone_timeout_secs = getPref_phone_timeout_secs();
// hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally private
// and useful for users to know current provisioning) hideSecret(r.get_radio_response.preferences.wifi_password);
// r.get_config_response.which_payloadVariant = Config_ModuleConfig_telemetry_tag;
@ -363,11 +362,10 @@ void AdminModule::handleGetModuleConfig(const MeshPacket &req, const uint32_t co
break;
}
// NOTE: The phone app needs to know the ls_secs & phone_timeout value so it can properly expect sleep behavior.
// NOTE: The phone app needs to know the ls_secsvalue so it can properly expect sleep behavior.
// So even if we internally use 0 to represent 'use default' we still need to send the value we are
// using to the app (so that even old phone apps work with new device loads).
// r.get_radio_response.preferences.ls_secs = getPref_ls_secs();
// r.get_radio_response.preferences.phone_timeout_secs = getPref_phone_timeout_secs();
// hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally private
// and useful for users to know current provisioning) hideSecret(r.get_radio_response.preferences.wifi_password);
// r.get_config_response.which_payloadVariant = Config_ModuleConfig_telemetry_tag;

35
src/modules/Telemetry/EnvironmentTelemetry.cpp
View File

@ -16,12 +16,17 @@
#include "Sensor/DHTSensor.h"
#include "Sensor/DallasSensor.h"
#include "Sensor/MCP9808Sensor.h"
#include "Sensor/INA260Sensor.h"
#include "Sensor/INA219Sensor.h"
BME280Sensor bme280Sensor;
BME680Sensor bme680Sensor;
DHTSensor dhtSensor;
DallasSensor dallasSensor;
MCP9808Sensor mcp9808Sensor;
INA260Sensor ina260Sensor;
INA219Sensor ina219Sensor;
#define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
#define DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN true
@ -90,12 +95,16 @@ int32_t EnvironmentTelemetryModule::runOnce()
DEBUG_MSG("Environment Telemetry: No sensor type specified; Checking for detected i2c sensors\n");
break;
}
if (hasSensor(TelemetrySensorType_BME680))
if (bme680Sensor.hasSensor())
result = bme680Sensor.runOnce();
if (hasSensor(TelemetrySensorType_BME280))
if (bme280Sensor.hasSensor())
result = bme280Sensor.runOnce();
if (hasSensor(TelemetrySensorType_MCP9808))
if (mcp9808Sensor.hasSensor())
result = mcp9808Sensor.runOnce();
if (ina260Sensor.hasSensor())
result = ina260Sensor.runOnce();
if (ina219Sensor.hasSensor())
result = ina219Sensor.runOnce();
}
return result;
} else {
@ -233,25 +242,29 @@ bool EnvironmentTelemetryModule::sendOurTelemetry(NodeNum dest, bool wantReplies
switch (moduleConfig.telemetry.environment_sensor_type) {
case TelemetrySensorType_DS18B20:
if (!dallasSensor.getMeasurement(&m))
if (!dallasSensor.getMetrics(&m))
sensor_read_error_count++;
break;
case TelemetrySensorType_DHT11:
case TelemetrySensorType_DHT12:
case TelemetrySensorType_DHT21:
case TelemetrySensorType_DHT22:
if (!dhtSensor.getMeasurement(&m))
if (!dhtSensor.getMetrics(&m))
sensor_read_error_count++;
break;
default:
DEBUG_MSG("Environment Telemetry: No specified sensor type; Trying any detected i2c sensors\n");
}
if (hasSensor(TelemetrySensorType_BME280))
bme280Sensor.getMeasurement(&m);
if (hasSensor(TelemetrySensorType_BME680))
bme680Sensor.getMeasurement(&m);
if (hasSensor(TelemetrySensorType_MCP9808))
mcp9808Sensor.getMeasurement(&m);
if (bme280Sensor.hasSensor())
bme280Sensor.getMetrics(&m);
if (bme680Sensor.hasSensor())
bme680Sensor.getMetrics(&m);
if (mcp9808Sensor.hasSensor())
mcp9808Sensor.getMetrics(&m);
if (ina219Sensor.hasSensor())
ina219Sensor.getMetrics(&m);
if (ina260Sensor.hasSensor())
ina260Sensor.getMetrics(&m);
DEBUG_MSG("Telemetry->time: %i\n", m.time);
DEBUG_MSG("Telemetry->barometric_pressure: %f\n", m.variant.environment_metrics.barometric_pressure);

25
src/modules/Telemetry/Sensor/BME280Sensor.cpp
View File

@ -3,29 +3,26 @@
#include "TelemetrySensor.h"
#include "BME280Sensor.h"
#include <Adafruit_BME280.h>
#include <typeinfo>
BME280Sensor::BME280Sensor() : TelemetrySensor {}
BME280Sensor::BME280Sensor() :
TelemetrySensor(TelemetrySensorType_BME280, "BME280")
{
}
int32_t BME280Sensor::runOnce() {
unsigned bme280Status;
DEBUG_MSG("Init sensor: TelemetrySensorType_BME280\n");
if (!hasSensor(TelemetrySensorType_BME280)) {
DEBUG_MSG("Init sensor: %s\n", sensorName);
if (!hasSensor()) {
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
bme280Status = bme280.begin(nodeTelemetrySensorsMap[TelemetrySensorType_BME280]);
if (!bme280Status) {
DEBUG_MSG("Could not connect to any detected BME-280 sensor.\nRemoving from nodeTelemetrySensorsMap.\n");
nodeTelemetrySensorsMap[TelemetrySensorType_BME280] = 0;
} else {
DEBUG_MSG("Opened BME280 on default i2c bus\n");
}
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
status = bme280.begin(nodeTelemetrySensorsMap[sensorType]);
return initI2CSensor();
}
bool BME280Sensor::getMeasurement(Telemetry *measurement) {
DEBUG_MSG("BME280Sensor::getMeasurement\n");
void BME280Sensor::setup() { }
bool BME280Sensor::getMetrics(Telemetry *measurement) {
DEBUG_MSG("BME280Sensor::getMetrics\n");
measurement->variant.environment_metrics.temperature = bme280.readTemperature();
measurement->variant.environment_metrics.relative_humidity = bme280.readHumidity();
measurement->variant.environment_metrics.barometric_pressure = bme280.readPressure() / 100.0F;

5
src/modules/Telemetry/Sensor/BME280Sensor.h
View File

@ -6,8 +6,11 @@ class BME280Sensor : virtual public TelemetrySensor {
private:
Adafruit_BME280 bme280;
protected:
virtual void setup() override;
public:
BME280Sensor();
virtual int32_t runOnce() override;
virtual bool getMeasurement(Telemetry *measurement) override;
virtual bool getMetrics(Telemetry *measurement) override;
};

37
src/modules/Telemetry/Sensor/BME680Sensor.cpp
View File

@ -4,34 +4,31 @@
#include "BME680Sensor.h"
#include <Adafruit_BME680.h>
BME680Sensor::BME680Sensor() : TelemetrySensor {}
BME680Sensor::BME680Sensor() :
TelemetrySensor(TelemetrySensorType_BME680, "BME680")
{
}
int32_t BME680Sensor::runOnce() {
unsigned bme680Status;
DEBUG_MSG("Init sensor: TelemetrySensorType_BME680\n");
if (!hasSensor(TelemetrySensorType_BME680)) {
DEBUG_MSG("Init sensor: %s\n", sensorName);
if (!hasSensor()) {
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
bme680Status = bme680.begin(nodeTelemetrySensorsMap[TelemetrySensorType_BME680]);
if (!bme680Status) {
DEBUG_MSG("Could not connect to any detected BME-680 sensor.\nRemoving from nodeTelemetrySensorsMap.\n");
nodeTelemetrySensorsMap[TelemetrySensorType_BME680] = 0;
} else {
DEBUG_MSG("Opened BME680 on default i2c bus\n");
// Set up oversampling and filter initialization
bme680.setTemperatureOversampling(BME680_OS_8X);
bme680.setHumidityOversampling(BME680_OS_2X);
bme680.setPressureOversampling(BME680_OS_4X);
bme680.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme680.setGasHeater(320, 150); // 320*C for 150 ms
}
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
status = bme680.begin(nodeTelemetrySensorsMap[sensorType]);
return initI2CSensor();
}
bool BME680Sensor::getMeasurement(Telemetry *measurement) {
DEBUG_MSG("BME680Sensor::getMeasurement\n");
void BME680Sensor::setup()
{
// Set up oversampling and filter initialization
bme680.setTemperatureOversampling(BME680_OS_8X);
bme680.setHumidityOversampling(BME680_OS_2X);
bme680.setPressureOversampling(BME680_OS_4X);
bme680.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme680.setGasHeater(320, 150); // 320*C for 150 ms
}
bool BME680Sensor::getMetrics(Telemetry *measurement) {
measurement->variant.environment_metrics.temperature = bme680.readTemperature();
measurement->variant.environment_metrics.relative_humidity = bme680.readHumidity();
measurement->variant.environment_metrics.barometric_pressure = bme680.readPressure() / 100.0F;

5
src/modules/Telemetry/Sensor/BME680Sensor.h
View File

@ -6,8 +6,11 @@ class BME680Sensor : virtual public TelemetrySensor {
private:
Adafruit_BME680 bme680;
protected:
virtual void setup() override;
public:
BME680Sensor();
virtual int32_t runOnce() override;
virtual bool getMeasurement(Telemetry *measurement) override;
virtual bool getMetrics(Telemetry *measurement) override;
};

15
src/modules/Telemetry/Sensor/DHTSensor.cpp
View File

@ -5,10 +5,12 @@
#include "configuration.h"
#include <DHT.h>
DHTSensor::DHTSensor() : TelemetrySensor{} {}
int32_t DHTSensor::runOnce()
DHTSensor::DHTSensor() :
TelemetrySensor(TelemetrySensorType_NotSet, "DHT")
{
}
int32_t DHTSensor::runOnce() {
if (moduleConfig.telemetry.environment_sensor_type == TelemetrySensorType_DHT11 ||
moduleConfig.telemetry.environment_sensor_type == TelemetrySensorType_DHT12) {
dht = new DHT(moduleConfig.telemetry.environment_sensor_pin, DHT11);
@ -23,9 +25,10 @@ int32_t DHTSensor::runOnce()
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
bool DHTSensor::getMeasurement(Telemetry *measurement)
{
DEBUG_MSG("DHTSensor::getMeasurement\n");
void DHTSensor::setup() { }
bool DHTSensor::getMetrics(Telemetry *measurement) {
DEBUG_MSG("DHTSensor::getMetrics\n");
if (!dht->read(true)) {
DEBUG_MSG("Telemetry: FAILED TO READ DATA\n");
return false;

5
src/modules/Telemetry/Sensor/DHTSensor.h
View File

@ -6,8 +6,11 @@ class DHTSensor : virtual public TelemetrySensor {
private:
DHT *dht = NULL;
protected:
virtual void setup() override;
public:
DHTSensor();
virtual int32_t runOnce() override;
virtual bool getMeasurement(Telemetry *measurement) override;
virtual bool getMetrics(Telemetry *measurement) override;
};

15
src/modules/Telemetry/Sensor/DallasSensor.cpp
View File

@ -6,10 +6,12 @@
#include <DS18B20.h>
#include <OneWire.h>
DallasSensor::DallasSensor() : TelemetrySensor{} {}
int32_t DallasSensor::runOnce()
DallasSensor::DallasSensor() :
TelemetrySensor(TelemetrySensorType_DS18B20, "DS18B20")
{
}
int32_t DallasSensor::runOnce() {
oneWire = new OneWire(moduleConfig.telemetry.environment_sensor_pin);
ds18b20 = new DS18B20(oneWire);
ds18b20->begin();
@ -19,9 +21,10 @@ int32_t DallasSensor::runOnce()
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
bool DallasSensor::getMeasurement(Telemetry *measurement)
{
DEBUG_MSG("DallasSensor::getMeasurement\n");
void DallasSensor::setup() {}
bool DallasSensor::getMetrics(Telemetry *measurement){
DEBUG_MSG("DallasSensor::getMetrics\n");
if (ds18b20->isConversionComplete()) {
measurement->variant.environment_metrics.temperature = ds18b20->getTempC();
measurement->variant.environment_metrics.relative_humidity = 0;

5
src/modules/Telemetry/Sensor/DallasSensor.h
View File

@ -8,8 +8,11 @@ private:
OneWire *oneWire = NULL;
DS18B20 *ds18b20 = NULL;
protected:
virtual void setup() override;
public:
DallasSensor();
virtual int32_t runOnce() override;
virtual bool getMeasurement(Telemetry *measurement) override;
virtual bool getMetrics(Telemetry *measurement) override;
};

30
src/modules/Telemetry/Sensor/INA219Sensor.cpp Normal file
View File

@ -0,0 +1,30 @@
#include "../mesh/generated/telemetry.pb.h"
#include "configuration.h"
#include "TelemetrySensor.h"
#include "INA219Sensor.h"
#include <Adafruit_INA219.h>
INA219Sensor::INA219Sensor() :
TelemetrySensor(TelemetrySensorType_INA219, "INA219")
{
}
int32_t INA219Sensor::runOnce() {
DEBUG_MSG("Init sensor: %s\n", sensorName);
if (!hasSensor()) {
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
ina219 = Adafruit_INA219(nodeTelemetrySensorsMap[sensorType]);
status = ina219.begin();
return initI2CSensor();
}
void INA219Sensor::setup()
{
}
bool INA219Sensor::getMetrics(Telemetry *measurement) {
measurement->variant.environment_metrics.voltage = ina219.getBusVoltage_V();
measurement->variant.environment_metrics.current = ina219.getCurrent_mA();
return true;
}

17
src/modules/Telemetry/Sensor/INA219Sensor.h Normal file
View File

@ -0,0 +1,17 @@
#include "../mesh/generated/telemetry.pb.h"
#include "TelemetrySensor.h"
#include <Adafruit_INA219.h>
class INA219Sensor : virtual public TelemetrySensor {
private:
Adafruit_INA219 ina219;
protected:
virtual void setup() override;
public:
INA219Sensor();
virtual int32_t runOnce() override;
virtual bool getMetrics(Telemetry *measurement) override;
};

30
src/modules/Telemetry/Sensor/INA260Sensor.cpp Normal file
View File

@ -0,0 +1,30 @@
#include "../mesh/generated/telemetry.pb.h"
#include "configuration.h"
#include "TelemetrySensor.h"
#include "INA260Sensor.h"
#include <Adafruit_INA260.h>
INA260Sensor::INA260Sensor() :
TelemetrySensor(TelemetrySensorType_INA260, "INA260")
{
}
int32_t INA260Sensor::runOnce() {
DEBUG_MSG("Init sensor: %s\n", sensorName);
if (!hasSensor()) {
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
status = ina260.begin(nodeTelemetrySensorsMap[sensorType]);
return initI2CSensor();
}
void INA260Sensor::setup()
{
}
bool INA260Sensor::getMetrics(Telemetry *measurement) {
// mV conversion to V
measurement->variant.environment_metrics.voltage = ina260.readBusVoltage() / 1000;
measurement->variant.environment_metrics.current = ina260.readCurrent();
return true;
}

17
src/modules/Telemetry/Sensor/INA260Sensor.h Normal file
View File

@ -0,0 +1,17 @@
#include "../mesh/generated/telemetry.pb.h"
#include "TelemetrySensor.h"
#include <Adafruit_INA260.h>
class INA260Sensor : virtual public TelemetrySensor {
private:
Adafruit_INA260 ina260 = Adafruit_INA260();
protected:
virtual void setup() override;
public:
INA260Sensor();
virtual int32_t runOnce() override;
virtual bool getMetrics(Telemetry *measurement) override;
};

29
src/modules/Telemetry/Sensor/MCP9808Sensor.cpp
View File

@ -4,31 +4,26 @@
#include "MCP9808Sensor.h"
#include <Adafruit_MCP9808.h>
MCP9808Sensor::MCP9808Sensor() : TelemetrySensor {}
MCP9808Sensor::MCP9808Sensor() :
TelemetrySensor(TelemetrySensorType_MCP9808, "MCP9808")
{
}
int32_t MCP9808Sensor::runOnce() {
unsigned mcp9808Status;
DEBUG_MSG("Init sensor: TelemetrySensorType_MCP9808\n");
if (!hasSensor(TelemetrySensorType_MCP9808)) {
DEBUG_MSG("Init sensor: %s\n", sensorName);
if (!hasSensor()) {
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
mcp9808Status = mcp9808.begin(nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808]);
if (!mcp9808Status) {
DEBUG_MSG("Could not connect to detected MCP9808 sensor.\n Removing from nodeTelemetrySensorsMap.\n");
nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808] = 0;
} else {
DEBUG_MSG("TelemetrySensor: Opened MCP9808 on default i2c bus\n");
// Reduce resolution from 0.0625 degrees (precision) to 0.125 degrees (high).
mcp9808.setResolution(2);
}
return (DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
status = mcp9808.begin(nodeTelemetrySensorsMap[sensorType]);
return initI2CSensor();
}
bool MCP9808Sensor::getMeasurement(Telemetry *measurement) {
DEBUG_MSG("MCP9808Sensor::getMeasurement\n");
void MCP9808Sensor::setup() {
mcp9808.setResolution(2);
}
bool MCP9808Sensor::getMetrics(Telemetry *measurement) {
DEBUG_MSG("MCP9808Sensor::getMetrics\n");
measurement->variant.environment_metrics.temperature = mcp9808.readTempC();
return true;
}

5
src/modules/Telemetry/Sensor/MCP9808Sensor.h
View File

@ -6,8 +6,11 @@ class MCP9808Sensor : virtual public TelemetrySensor {
private:
Adafruit_MCP9808 mcp9808;
protected:
virtual void setup() override;
public:
MCP9808Sensor();
virtual int32_t runOnce() override;
virtual bool getMeasurement(Telemetry *measurement) override;
virtual bool getMetrics(Telemetry *measurement) override;
};

4
src/modules/Telemetry/Sensor/TelemetrySensor.cpp Normal file
View File

@ -0,0 +1,4 @@
#include "TelemetrySensor.h"
#include "../mesh/generated/telemetry.pb.h"
#include "NodeDB.h"
#include "main.h"

33
src/modules/Telemetry/Sensor/TelemetrySensor.h
View File

@ -5,16 +5,37 @@
#define DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
inline bool hasSensor(TelemetrySensorType sensorType) {
return sensorType < sizeof(nodeTelemetrySensorsMap) && nodeTelemetrySensorsMap[sensorType] > 0;
}
class TelemetrySensor
{
protected:
TelemetrySensor() {}
TelemetrySensor(TelemetrySensorType sensorType, const char *sensorName)
{
this->sensorName = sensorName;
this->sensorType = sensorType;
this->status = 0;
}
const char *sensorName;
TelemetrySensorType sensorType;
unsigned status;
int32_t initI2CSensor() {
if (!status) {
DEBUG_MSG("Could not connect to detected %s sensor.\n Removing from nodeTelemetrySensorsMap.\n", sensorName);
nodeTelemetrySensorsMap[sensorType] = 0;
} else {
DEBUG_MSG("Opened %s sensor on default i2c bus\n", sensorName);
setup();
}
return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
}
virtual void setup();
public:
bool hasSensor() {
return sensorType < sizeof(nodeTelemetrySensorsMap) && nodeTelemetrySensorsMap[sensorType] > 0;
}
virtual int32_t runOnce() = 0;
virtual bool getMeasurement(Telemetry *measurement) = 0;
virtual bool getMetrics(Telemetry *measurement) = 0;
};