mv plugins/ to modules/

src/modules/Telemetry/Sensor/BME280Sensor.cpp

@@ -0,0 +1,29 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "TelemetrySensor.h"
+#include "BME280Sensor.h"
+#include <Adafruit_BME280.h>
+
+BME280Sensor::BME280Sensor() : TelemetrySensor {} {
+}
+
+int32_t BME280Sensor::runOnce() {
+    unsigned bme280Status;
+    // Default i2c address for BME280
+    bme280Status = bme280.begin(0x76); 
+    if (!bme280Status) {
+        DEBUG_MSG("Could not find a valid BME280 sensor, check wiring, address, sensor ID!");
+        // TODO more verbose diagnostics
+    } else {
+        DEBUG_MSG("Telemetry: Opened BME280 on default i2c bus");
+    }
+    return BME_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+}
+
+bool BME280Sensor::getMeasurement(Telemetry *measurement) {
+    measurement->temperature = bme280.readTemperature();
+    measurement->relative_humidity = bme280.readHumidity();
+    measurement->barometric_pressure = bme280.readPressure() / 100.0F;
+
+    return true;
+}    

src/modules/Telemetry/Sensor/BME280Sensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_BME280.h>
+
+#define BME_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class BME280Sensor : virtual public TelemetrySensor {
+private:
+    Adafruit_BME280 bme280;
+
+public:
+    BME280Sensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/BME680Sensor.cpp

@@ -0,0 +1,36 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "TelemetrySensor.h"
+#include "BME680Sensor.h"
+#include <Adafruit_BME680.h>
+
+BME680Sensor::BME680Sensor() : TelemetrySensor {} {
+}
+
+int32_t BME680Sensor::runOnce() {
+    unsigned bme680Status;
+    // Default i2c address for BME680
+    bme680Status = bme680.begin(0x76); 
+    if (!bme680Status) {
+        DEBUG_MSG("Could not find a valid BME680 sensor, check wiring, address, sensor ID!");
+        // TODO more verbose TelemetrySensor
+    } else {
+        DEBUG_MSG("Telemetry: Opened BME680 on default i2c bus");
+        // 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 (BME_680_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool BME680Sensor::getMeasurement(Telemetry *measurement) {
+    measurement->temperature = bme680.readTemperature();
+    measurement->relative_humidity = bme680.readHumidity();
+    measurement->barometric_pressure = bme680.readPressure() / 100.0F;
+    measurement->gas_resistance = bme680.readGas() / 1000.0;
+
+    return true;
+}    

src/modules/Telemetry/Sensor/BME680Sensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_BME680.h>
+
+#define BME_680_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class BME680Sensor : virtual public TelemetrySensor {
+private:
+    Adafruit_BME680 bme680;
+
+public:
+    BME680Sensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/DHTSensor.cpp

@@ -0,0 +1,36 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "MeshService.h"
+#include "TelemetrySensor.h"
+#include "DHTSensor.h"
+#include <DHT.h>
+
+DHTSensor::DHTSensor() : TelemetrySensor {} {
+}
+
+int32_t DHTSensor::runOnce() {
+    if (RadioConfig_UserPreferences_TelemetrySensorType_DHT11 || 
+        RadioConfig_UserPreferences_TelemetrySensorType_DHT12) {
+        dht = new DHT(radioConfig.preferences.telemetry_module_sensor_pin, DHT11);
+    }
+    else { 
+        dht = new DHT(radioConfig.preferences.telemetry_module_sensor_pin, DHT22);
+    }
+
+    dht->begin();
+    dht->read();
+    DEBUG_MSG("Telemetry: Opened DHT11/DHT12 on pin: %d\n",
+                radioConfig.preferences.telemetry_module_sensor_pin);
+
+    return (DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool DHTSensor::getMeasurement(Telemetry *measurement) {
+    if (!dht->read(true)) {
+        DEBUG_MSG("Telemetry: FAILED TO READ DATA\n");
+        return false;
+    }
+    measurement->relative_humidity = dht->readHumidity();
+    measurement->temperature = dht->readTemperature();
+    return true;
+}    

src/modules/Telemetry/Sensor/DHTSensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <DHT.h>
+
+#define DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class DHTSensor : virtual public TelemetrySensor {
+private:
+    DHT *dht = NULL;
+
+public:
+    DHTSensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/DallasSensor.cpp

@@ -0,0 +1,31 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "MeshService.h"
+#include "TelemetrySensor.h"
+#include "DallasSensor.h"
+#include <DS18B20.h>
+#include <OneWire.h>
+
+DallasSensor::DallasSensor() : TelemetrySensor {} {
+}
+
+int32_t DallasSensor::runOnce() {
+    oneWire = new OneWire(radioConfig.preferences.telemetry_module_sensor_pin);
+    ds18b20 = new DS18B20(oneWire);
+    ds18b20->begin();
+    ds18b20->setResolution(12);
+    ds18b20->requestTemperatures();
+    DEBUG_MSG("Telemetry: Opened DS18B20 on pin: %d\n",
+                radioConfig.preferences.telemetry_module_sensor_pin);
+    return (DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool DallasSensor::getMeasurement(Telemetry *measurement) {
+    if (ds18b20->isConversionComplete()) {
+        measurement->temperature = ds18b20->getTempC();
+        measurement->relative_humidity = 0;
+        ds18b20->requestTemperatures();
+        return true;
+    } 
+    return false;
+}

src/modules/Telemetry/Sensor/DallasSensor.h

@@ -0,0 +1,17 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <DS18B20.h>
+#include <OneWire.h>
+
+#define DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class DallasSensor : virtual public TelemetrySensor {
+private:
+    OneWire *oneWire = NULL;
+    DS18B20 *ds18b20 = NULL;
+
+public:
+    DallasSensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/MCP9808Sensor.cpp

@@ -0,0 +1,28 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "TelemetrySensor.h"
+#include "MCP9808Sensor.h"
+#include <Adafruit_MCP9808.h>
+
+MCP9808Sensor::MCP9808Sensor() : TelemetrySensor {} {
+}
+
+int32_t MCP9808Sensor::runOnce() {
+    unsigned mcp9808Status;
+    // Default i2c address for MCP9808
+    mcp9808Status = mcp9808.begin(0x18); 
+    if (!mcp9808Status) {
+        DEBUG_MSG("Could not find a valid MCP9808 sensor, check wiring, address, sensor ID!");
+    } else {
+        DEBUG_MSG("TelemetrySensor: Opened MCP9808 on default i2c bus");
+        // Reduce resolution from 0.0625 degrees (precision) to 0.125 degrees (high). 
+        mcp9808.setResolution(2);
+    }
+    return (MCP_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool MCP9808Sensor::getMeasurement(Telemetry *measurement) {
+    measurement->temperature = mcp9808.readTempC();
+
+    return true;
+}    

src/modules/Telemetry/Sensor/MCP9808Sensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_MCP9808.h>
+
+#define MCP_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class MCP9808Sensor : virtual public TelemetrySensor {
+private:
+    Adafruit_MCP9808 mcp9808;
+
+public:
+    MCP9808Sensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/TelemetrySensor.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "../mesh/generated/telemetry.pb.h"
+#define DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class TelemetrySensor {
+protected:
+    TelemetrySensor() { }
+
+public:
+    virtual int32_t runOnce() = 0;
+    virtual bool getMeasurement(Telemetry *measurement)  = 0;
+};

src/modules/Telemetry/Telemetry.cpp

@@ -0,0 +1,299 @@
+#include "Telemetry.h"
+#include "../mesh/generated/telemetry.pb.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
+
+// Sensors
+#include "Sensor/BME280Sensor.h"
+#include "Sensor/BME680Sensor.h"
+#include "Sensor/DHTSensor.h"
+#include "Sensor/DallasSensor.h"
+#include "Sensor/MCP9808Sensor.h"
+
+BME280Sensor bme280Sensor;
+BME680Sensor bme680Sensor;
+DHTSensor dhtSensor;
+DallasSensor dallasSensor;
+MCP9808Sensor mcp9808Sensor;
+
+#define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
+#define DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN true
+
+#ifdef HAS_EINK
+// The screen is bigger so use bigger fonts
+#define FONT_SMALL ArialMT_Plain_16
+#define FONT_MEDIUM ArialMT_Plain_24
+#define FONT_LARGE ArialMT_Plain_24
+#else
+#define FONT_SMALL ArialMT_Plain_10
+#define FONT_MEDIUM ArialMT_Plain_16
+#define FONT_LARGE ArialMT_Plain_24
+#endif
+
+#define fontHeight(font) ((font)[1] + 1) // height is position 1
+
+#define FONT_HEIGHT_SMALL fontHeight(FONT_SMALL)
+#define FONT_HEIGHT_MEDIUM fontHeight(FONT_MEDIUM)
+
+
+int32_t TelemetryPlugin::runOnce()
+{
+#ifndef PORTDUINO
+    /*
+        Uncomment the preferences below if you want to use the plugin
+        without having to configure it from the PythonAPI or WebUI.
+    */
+    /*
+    radioConfig.preferences.telemetry_module_measurement_enabled = 1;
+    radioConfig.preferences.telemetry_module_screen_enabled = 1;
+    radioConfig.preferences.telemetry_module_read_error_count_threshold = 5;
+    radioConfig.preferences.telemetry_module_update_interval = 600;
+    radioConfig.preferences.telemetry_module_recovery_interval = 60;
+    radioConfig.preferences.telemetry_module_display_farenheit = false;
+    radioConfig.preferences.telemetry_module_sensor_pin = 13;
+
+    radioConfig.preferences.telemetry_module_sensor_type =
+        RadioConfig_UserPreferences_TelemetrySensorType::
+            RadioConfig_UserPreferences_TelemetrySensorType_BME280;
+    */
+   
+    if (!(radioConfig.preferences.telemetry_module_measurement_enabled ||
+          radioConfig.preferences.telemetry_module_screen_enabled)) {
+        // If this plugin is not enabled, and the user doesn't want the display screen don't waste any OSThread time on it
+        return (INT32_MAX);
+    }
+
+    if (firstTime) {
+        // This is the first time the OSThread library has called this function, so do some setup
+        firstTime = 0;
+
+        if (radioConfig.preferences.telemetry_module_measurement_enabled) {
+            DEBUG_MSG("Telemetry: Initializing\n");
+            // it's possible to have this plugin enabled, only for displaying values on the screen.
+            // therefore, we should only enable the sensor loop if measurement is also enabled
+            switch (radioConfig.preferences.telemetry_module_sensor_type) {
+
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT11:
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT12:
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT21:
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT22:
+                    return dhtSensor.runOnce();
+                case RadioConfig_UserPreferences_TelemetrySensorType_DS18B20:
+                    return dallasSensor.runOnce();
+                case RadioConfig_UserPreferences_TelemetrySensorType_BME280:
+                    return bme280Sensor.runOnce();
+                case RadioConfig_UserPreferences_TelemetrySensorType_BME680:
+                    return bme680Sensor.runOnce();
+                case RadioConfig_UserPreferences_TelemetrySensorType_MCP9808:
+                    return mcp9808Sensor.runOnce();
+                default:
+                    DEBUG_MSG("Telemetry: Invalid sensor type selected; Disabling plugin");
+                    return (INT32_MAX);
+                    break;
+            }
+        }
+        return (INT32_MAX);
+    } else {
+        // if we somehow got to a second run of this plugin with measurement disabled, then just wait forever
+        if (!radioConfig.preferences.telemetry_module_measurement_enabled)  
+            return (INT32_MAX);
+        // this is not the first time OSThread library has called this function
+        // so just do what we intend to do on the interval
+        if (sensor_read_error_count > radioConfig.preferences.telemetry_module_read_error_count_threshold) {
+            if (radioConfig.preferences.telemetry_module_recovery_interval > 0) {
+                DEBUG_MSG("Telemetry: TEMPORARILY DISABLED; The "
+                          "telemetry_module_read_error_count_threshold has been exceed: %d. Will retry reads in "
+                          "%d seconds\n",
+                          radioConfig.preferences.telemetry_module_read_error_count_threshold,
+                          radioConfig.preferences.telemetry_module_recovery_interval);
+                sensor_read_error_count = 0;
+                return (radioConfig.preferences.telemetry_module_recovery_interval * 1000);
+            }
+            DEBUG_MSG("Telemetry: DISABLED; The telemetry_module_read_error_count_threshold has "
+                      "been exceed: %d. Reads will not be retried until after device reset\n",
+                      radioConfig.preferences.telemetry_module_read_error_count_threshold);
+            return (INT32_MAX);
+
+        } else if (sensor_read_error_count > 0) {
+            DEBUG_MSG("Telemetry: There have been %d sensor read failures. Will retry %d more times\n",
+                      sensor_read_error_count, sensor_read_error_count, sensor_read_error_count,
+                      radioConfig.preferences.telemetry_module_read_error_count_threshold -
+                          sensor_read_error_count);
+        }
+        if (!sendOurTelemetry()) {
+            // if we failed to read the sensor, then try again
+            // as soon as we can according to the maximum polling frequency
+
+            switch (radioConfig.preferences.telemetry_module_sensor_type) {
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT11:
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT12:
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT21:
+                case RadioConfig_UserPreferences_TelemetrySensorType_DHT22:
+                    return (DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+                case RadioConfig_UserPreferences_TelemetrySensorType_DS18B20:
+                    return (DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+                case RadioConfig_UserPreferences_TelemetrySensorType_BME280:
+                case RadioConfig_UserPreferences_TelemetrySensorType_BME680:
+                    return (BME_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+                case RadioConfig_UserPreferences_TelemetrySensorType_MCP9808:
+                    return (MCP_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+                default:
+                    return (DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+            }
+        }
+    }
+    // The return of runOnce is an int32 representing the desired number of
+    // miliseconds until the function should be called again by the
+    // OSThread library.  Multiply the preference value by 1000 to convert seconds to miliseconds
+    return (radioConfig.preferences.telemetry_module_update_interval * 1000);
+#endif
+}
+
+bool TelemetryPlugin::wantUIFrame()
+{
+    return radioConfig.preferences.telemetry_module_screen_enabled;
+}
+
+String GetSenderName(const MeshPacket &mp)
+{
+    String sender;
+
+    auto node = nodeDB.getNode(getFrom(&mp));
+    if (node) {
+        sender = node->user.short_name;
+    } else {
+        sender = "UNK";
+    }
+    return sender;
+}
+
+uint32_t GetTimeSinceMeshPacket(const MeshPacket *mp)
+{
+    uint32_t now = getTime();
+
+    uint32_t last_seen = mp->rx_time;
+    int delta = (int)(now - last_seen);
+    if (delta < 0) // our clock must be slightly off still - not set from GPS yet
+        delta = 0;
+
+    return delta;
+}
+
+float TelemetryPlugin::CelsiusToFarenheit(float c)
+{
+    return (c * 9) / 5 + 32;
+}
+
+void TelemetryPlugin::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_MEDIUM);
+    display->drawString(x, y, "Environment");
+    if (lastMeasurementPacket == nullptr) {
+        display->setFont(FONT_SMALL);
+        display->drawString(x, y += fontHeight(FONT_MEDIUM), "No measurement");
+        return;
+    }
+
+    Telemetry lastMeasurement;
+
+    uint32_t agoSecs = GetTimeSinceMeshPacket(lastMeasurementPacket);
+    String lastSender = GetSenderName(*lastMeasurementPacket);
+
+    auto &p = lastMeasurementPacket->decoded;
+    if (!pb_decode_from_bytes(p.payload.bytes, p.payload.size, Telemetry_fields, &lastMeasurement)) {
+        display->setFont(FONT_SMALL);
+        display->drawString(x, y += fontHeight(FONT_MEDIUM), "Measurement Error");
+        DEBUG_MSG("Telemetry: unable to decode last packet");
+        return;
+    }
+
+    display->setFont(FONT_SMALL);
+    String last_temp = String(lastMeasurement.temperature, 0) + "°C";
+    if (radioConfig.preferences.telemetry_module_display_farenheit) {
+        last_temp = String(CelsiusToFarenheit(lastMeasurement.temperature), 0) + "°F";
+    }
+    display->drawString(x, y += fontHeight(FONT_MEDIUM) - 2, "From: " + lastSender + "(" + String(agoSecs) + "s)");
+    display->drawString(x, y += fontHeight(FONT_SMALL) - 2,"Temp/Hum: " + last_temp + " / " + String(lastMeasurement.relative_humidity, 0) + "%");
+    if (lastMeasurement.barometric_pressure != 0) 
+        display->drawString(x, y += fontHeight(FONT_SMALL),"Press: " + String(lastMeasurement.barometric_pressure, 0) + "hPA");
+}
+
+bool TelemetryPlugin::handleReceivedProtobuf(const MeshPacket &mp, Telemetry *p)
+{
+    if (!(radioConfig.preferences.telemetry_module_measurement_enabled ||
+          radioConfig.preferences.telemetry_module_screen_enabled)) {
+        // If this plugin is not enabled in any capacity, don't handle the packet, and allow other plugins to consume
+        return false;
+    }
+
+    String sender = GetSenderName(mp);
+
+    DEBUG_MSG("Telemetry: Received data from %s\n", sender);
+    DEBUG_MSG("Telemetry->relative_humidity: %f\n", p->relative_humidity);
+    DEBUG_MSG("Telemetry->temperature: %f\n", p->temperature);
+    DEBUG_MSG("Telemetry->barometric_pressure: %f\n", p->barometric_pressure);
+    DEBUG_MSG("Telemetry->gas_resistance: %f\n", p->gas_resistance);
+
+    lastMeasurementPacket = packetPool.allocCopy(mp);
+
+    return false; // Let others look at this message also if they want
+}
+
+bool TelemetryPlugin::sendOurTelemetry(NodeNum dest, bool wantReplies)
+{
+    Telemetry m;
+    m.barometric_pressure = 0;
+    m.gas_resistance = 0;
+    DEBUG_MSG("-----------------------------------------\n");
+
+    DEBUG_MSG("Telemetry: Read data\n");
+
+    switch (radioConfig.preferences.telemetry_module_sensor_type) {
+        case RadioConfig_UserPreferences_TelemetrySensorType_DS18B20:
+            if (!dallasSensor.getMeasurement(&m))
+                sensor_read_error_count++;
+            break;
+        case RadioConfig_UserPreferences_TelemetrySensorType_DHT11:
+        case RadioConfig_UserPreferences_TelemetrySensorType_DHT12:
+        case RadioConfig_UserPreferences_TelemetrySensorType_DHT21:
+        case RadioConfig_UserPreferences_TelemetrySensorType_DHT22:
+            if (!dhtSensor.getMeasurement(&m))
+                sensor_read_error_count++;
+            break;
+        case RadioConfig_UserPreferences_TelemetrySensorType_BME280:
+            bme280Sensor.getMeasurement(&m);
+            break;
+        case RadioConfig_UserPreferences_TelemetrySensorType_BME680:
+            bme680Sensor.getMeasurement(&m);
+            break;
+        case RadioConfig_UserPreferences_TelemetrySensorType_MCP9808:
+            mcp9808Sensor.getMeasurement(&m);
+            break;
+        default:
+            DEBUG_MSG("Telemetry: Invalid sensor type selected; Disabling plugin");
+            return false;
+    }
+
+    DEBUG_MSG("Telemetry->relative_humidity: %f\n", m.relative_humidity);
+    DEBUG_MSG("Telemetry->temperature: %f\n", m.temperature);
+    DEBUG_MSG("Telemetry->barometric_pressure: %f\n", m.barometric_pressure);
+    DEBUG_MSG("Telemetry->gas_resistance: %f\n", m.gas_resistance);
+
+    sensor_read_error_count = 0;
+
+    MeshPacket *p = allocDataProtobuf(m);
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    lastMeasurementPacket = packetPool.allocCopy(*p);
+    DEBUG_MSG("Telemetry: Sending packet to mesh");
+    service.sendToMesh(p);
+    return true;
+}

src/modules/Telemetry/Telemetry.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "../mesh/generated/telemetry.pb.h"
+#include "ProtobufPlugin.h"
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
+
+class TelemetryPlugin : private concurrency::OSThread, public ProtobufPlugin<Telemetry>
+{
+  public:
+    TelemetryPlugin()
+        : concurrency::OSThread("TelemetryPlugin"),
+          ProtobufPlugin("Telemetry", PortNum_TELEMETRY_APP, &Telemetry_msg)
+    {
+        lastMeasurementPacket = nullptr;
+    }
+    virtual bool wantUIFrame() override;
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) override;
+
+  protected:
+    /** Called to handle a particular incoming message
+    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, Telemetry *p) override;
+    virtual int32_t runOnce() override;
+    /**
+     * Send our Telemetry into the mesh
+     */
+    bool sendOurTelemetry(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+  private:
+    float CelsiusToFarenheit(float c);
+    bool firstTime = 1;
+    const MeshPacket *lastMeasurementPacket;
+    uint32_t sensor_read_error_count = 0;
+};