Merge branch 'master' into NextHopRouter

src/modules/AdminModule.cpp

@@ -182,6 +182,12 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
         }
         break;
     }
+    case meshtastic_AdminMessage_remove_by_nodenum_tag: {
+        LOG_INFO("Client is receiving a remove_nodenum command.\n");
+        nodeDB.removeNodeByNum(r->remove_by_nodenum);
+        reboot(DEFAULT_REBOOT_SECONDS);
+        break;
+    }
 #ifdef ARCH_PORTDUINO
     case meshtastic_AdminMessage_exit_simulator_tag:
         LOG_INFO("Exiting simulator\n");
@@ -378,6 +384,11 @@ void AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
         moduleConfig.has_detection_sensor = true;
         moduleConfig.detection_sensor = c.payload_variant.detection_sensor;
         break;
+    case meshtastic_ModuleConfig_ambient_lighting_tag:
+        LOG_INFO("Setting module config: Ambient Lighting\n");
+        moduleConfig.has_ambient_lighting = true;
+        moduleConfig.ambient_lighting = c.payload_variant.ambient_lighting;
+        break;
     }
 
     saveChanges(SEGMENT_MODULECONFIG);
@@ -523,6 +534,11 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_detection_sensor_tag;
             res.get_module_config_response.payload_variant.detection_sensor = moduleConfig.detection_sensor;
             break;
+        case meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG:
+            LOG_INFO("Getting module config: Ambient Lighting\n");
+            res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_ambient_lighting_tag;
+            res.get_module_config_response.payload_variant.ambient_lighting = moduleConfig.ambient_lighting;
+            break;
         }
 
         // NOTE: The phone app needs to know the ls_secsvalue so it can properly expect sleep behavior.

src/modules/DetectionSensorModule.cpp

@@ -28,6 +28,12 @@ int32_t DetectionSensorModule::runOnce()
         return disable();
 
     if (firstTime) {
+
+#ifdef DETECTION_SENSOR_EN
+        pinMode(DETECTION_SENSOR_EN, OUTPUT);
+        digitalWrite(DETECTION_SENSOR_EN, HIGH);
+#endif
+
         // This is the first time the OSThread library has called this function, so do some setup
         firstTime = false;
         if (moduleConfig.detection_sensor.monitor_pin > 0) {

src/modules/ExternalNotificationModule.cpp

@@ -8,7 +8,7 @@
  * handle the module's behavior.
  *
  * Documentation:
- * https://meshtastic.org/docs/settings/moduleconfig/external-notification
+ * https://meshtastic.org/docs/configuration/module/external-notification
  *
  * @author Jm Casler & Meshtastic Team
  * @date [Insert Date]
@@ -31,6 +31,10 @@
 uint8_t red = 0;
 uint8_t green = 0;
 uint8_t blue = 0;
+uint8_t colorState = 1;
+uint8_t brightnessIndex = 0;
+uint8_t brightnessValues[] = {0, 10, 20, 30, 50, 90, 160, 170}; // blue gets multiplied by 1.5
+bool ascending = true;
 #endif
 
 #ifndef PIN_BUZZER
@@ -39,7 +43,7 @@ uint8_t blue = 0;
 
 /*
     Documentation:
-        https://meshtastic.org/docs/settings/moduleconfig/external-notification
+        https://meshtastic.org/docs/configuration/module/external-notification
 */
 
 // Default configurations
@@ -100,11 +104,26 @@ int32_t ExternalNotificationModule::runOnce()
             }
 #ifdef HAS_NCP5623
             if (rgb_found.type == ScanI2C::NCP5623) {
-                green = (green + 50) % 255;
-                red = abs(red - green) % 255;
-                blue = abs(blue / red) % 255;
-
+                red = (colorState & 4) ? brightnessValues[brightnessIndex] : 0;          // Red enabled on colorState = 4,5,6,7
+                green = (colorState & 2) ? brightnessValues[brightnessIndex] : 0;        // Green enabled on colorState = 2,3,6,7
+                blue = (colorState & 1) ? (brightnessValues[brightnessIndex] * 1.5) : 0; // Blue enabled on colorState = 1,3,5,7
                 rgb.setColor(red, green, blue);
+
+                if (ascending) { // fade in
+                    brightnessIndex++;
+                    if (brightnessIndex == (sizeof(brightnessValues) - 1)) {
+                        ascending = false;
+                    }
+                } else {
+                    brightnessIndex--; // fade out
+                }
+                if (brightnessIndex == 0) {
+                    ascending = true;
+                    colorState++; // next color
+                    if (colorState > 7) {
+                        colorState = 1;
+                    }
+                }
             }
 #endif
 

src/modules/Modules.cpp

@@ -24,6 +24,9 @@
 #include "modules/Telemetry/AirQualityTelemetry.h"
 #include "modules/Telemetry/EnvironmentTelemetry.h"
 #endif
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
+#include "modules/Telemetry/PowerTelemetry.h"
+#endif
 #ifdef ARCH_ESP32
 #include "modules/esp32/AudioModule.h"
 #include "modules/esp32/StoreForwardModule.h"
@@ -92,6 +95,9 @@ void setupModules()
             new AirQualityTelemetryModule();
         }
 #endif
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
+        new PowerTelemetryModule();
+#endif
 #if (defined(ARCH_ESP32) || defined(ARCH_NRF52) || defined(ARCH_RP2040)) && !defined(CONFIG_IDF_TARGET_ESP32S2) &&               \
     !defined(CONFIG_IDF_TARGET_ESP32C3)
         new SerialModule();

src/modules/Telemetry/PowerTelemetry.cpp

@@ -0,0 +1,240 @@
+#include "PowerTelemetry.h"
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "PowerFSM.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+#include "power.h"
+#include "sleep.h"
+#include "target_specific.h"
+
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
+#include "Sensor/INA3221Sensor.h"
+INA3221Sensor ina3221Sensor;
+#endif
+
+#define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
+#define DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN true
+
+#if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ST7735_CS) || defined(ST7789_CS)) &&                                \
+    !defined(DISPLAY_FORCE_SMALL_FONTS)
+
+// 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 PowerTelemetryModule::runOnce()
+{
+    if (sleepOnNextExecution == true) {
+        sleepOnNextExecution = false;
+        uint32_t nightyNightMs = getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval);
+        LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.\n", nightyNightMs);
+        doDeepSleep(nightyNightMs, true);
+    }
+
+    uint32_t result = UINT32_MAX;
+    /*
+        Uncomment the preferences below if you want to use the module
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    // moduleConfig.telemetry.power_measurement_enabled = 1;
+    // moduleConfig.telemetry.power_screen_enabled = 1;
+    // moduleConfig.telemetry.power_update_interval = 45;
+
+    if (!(moduleConfig.telemetry.power_measurement_enabled)) {
+        // If this module is not enabled, and the user doesn't want the display screen don't waste any OSThread time on it
+        return disable();
+    }
+
+    if (firstTime) {
+        // This is the first time the OSThread library has called this function, so do some setup
+        firstTime = 0;
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
+        if (moduleConfig.telemetry.power_measurement_enabled) {
+            LOG_INFO("Power Telemetry: Initializing\n");
+            // it's possible to have this module enabled, only for displaying values on the screen.
+            // therefore, we should only enable the sensor loop if measurement is also enabled
+            if (ina219Sensor.hasSensor() && !ina219Sensor.isInitialized())
+                result = ina219Sensor.runOnce();
+            if (ina260Sensor.hasSensor() && !ina260Sensor.isInitialized())
+                result = ina260Sensor.runOnce();
+            if (ina3221Sensor.hasSensor() && !ina3221Sensor.isInitialized())
+                result = ina3221Sensor.runOnce();
+        }
+        return result;
+#else
+        return disable();
+#endif
+    } else {
+        // if we somehow got to a second run of this module with measurement disabled, then just wait forever
+        if (!moduleConfig.telemetry.power_measurement_enabled)
+            return disable();
+
+        uint32_t now = millis();
+        if (((lastSentToMesh == 0) ||
+             ((now - lastSentToMesh) >= getConfiguredOrDefaultMs(moduleConfig.telemetry.power_update_interval))) &&
+            airTime->isTxAllowedAirUtil()) {
+            sendTelemetry();
+            lastSentToMesh = now;
+        } else if (((lastSentToPhone == 0) || ((now - lastSentToPhone) >= sendToPhoneIntervalMs)) &&
+                   (service.isToPhoneQueueEmpty())) {
+            // Just send to phone when it's not our time to send to mesh yet
+            // Only send while queue is empty (phone assumed connected)
+            sendTelemetry(NODENUM_BROADCAST, true);
+            lastSentToPhone = now;
+        }
+    }
+    return min(sendToPhoneIntervalMs, result);
+}
+bool PowerTelemetryModule::wantUIFrame()
+{
+    return moduleConfig.telemetry.power_screen_enabled;
+}
+
+uint32_t GetTimeyWimeySinceMeshPacket(const meshtastic_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;
+}
+
+void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_MEDIUM);
+    display->drawString(x, y, "Power Telemetry");
+    if (lastMeasurementPacket == nullptr) {
+        display->setFont(FONT_SMALL);
+        display->drawString(x, y += fontHeight(FONT_MEDIUM), "No measurement");
+        return;
+    }
+
+    meshtastic_Telemetry lastMeasurement;
+
+    uint32_t agoSecs = GetTimeyWimeySinceMeshPacket(lastMeasurementPacket);
+    const char *lastSender = getSenderShortName(*lastMeasurementPacket);
+
+    auto &p = lastMeasurementPacket->decoded;
+    if (!pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &lastMeasurement)) {
+        display->setFont(FONT_SMALL);
+        display->drawString(x, y += fontHeight(FONT_MEDIUM), "Measurement Error");
+        LOG_ERROR("Unable to decode last packet");
+        return;
+    }
+
+    display->setFont(FONT_SMALL);
+    String last_temp = String(lastMeasurement.variant.environment_metrics.temperature, 0) + "°C";
+    display->drawString(x, y += fontHeight(FONT_MEDIUM) - 2, "From: " + String(lastSender) + "(" + String(agoSecs) + "s)");
+    if (lastMeasurement.variant.power_metrics.ch1_voltage != 0) {
+        display->drawString(x, y += fontHeight(FONT_SMALL),
+                            "Ch 1 Volt/Cur: " + String(lastMeasurement.variant.power_metrics.ch1_voltage, 0) + "V / " +
+                                String(lastMeasurement.variant.power_metrics.ch1_current, 0) + "mA");
+        display->drawString(x, y += fontHeight(FONT_SMALL),
+                            "Ch 2 Volt/Cur: " + String(lastMeasurement.variant.power_metrics.ch2_voltage, 0) + "V / " +
+                                String(lastMeasurement.variant.power_metrics.ch2_current, 0) + "mA");
+        display->drawString(x, y += fontHeight(FONT_SMALL),
+                            "Ch 3 Volt/Cur: " + String(lastMeasurement.variant.power_metrics.ch3_voltage, 0) + "V / " +
+                                String(lastMeasurement.variant.power_metrics.ch3_current, 0) + "mA");
+    }
+}
+
+bool PowerTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
+{
+    if (t->which_variant == meshtastic_Telemetry_power_metrics_tag) {
+#ifdef DEBUG_PORT
+        const char *sender = getSenderShortName(mp);
+
+        LOG_INFO("(Received from %s): ch1_voltage=%f, ch1_current=%f, ch2_voltage=%f, ch2_current=%f, "
+                 "ch3_voltage=%f, ch3_current=%f\n",
+                 sender, t->variant.power_metrics.ch1_voltage, t->variant.power_metrics.ch1_current,
+                 t->variant.power_metrics.ch2_voltage, t->variant.power_metrics.ch2_current, t->variant.power_metrics.ch3_voltage,
+                 t->variant.power_metrics.ch3_current);
+#endif
+        // release previous packet before occupying a new spot
+        if (lastMeasurementPacket != nullptr)
+            packetPool.release(lastMeasurementPacket);
+
+        lastMeasurementPacket = packetPool.allocCopy(mp);
+    }
+
+    return false; // Let others look at this message also if they want
+}
+
+bool PowerTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
+{
+    meshtastic_Telemetry m;
+    bool valid = false;
+    m.time = getTime();
+    m.which_variant = meshtastic_Telemetry_power_metrics_tag;
+
+    m.variant.power_metrics.ch1_voltage = 0;
+    m.variant.power_metrics.ch1_current = 0;
+    m.variant.power_metrics.ch2_voltage = 0;
+    m.variant.power_metrics.ch2_current = 0;
+    m.variant.power_metrics.ch3_voltage = 0;
+    m.variant.power_metrics.ch3_current = 0;
+#if HAS_TELEMETRY && !defined(ARCH_PORTDUINO)
+    if (ina219Sensor.hasSensor())
+        valid = ina219Sensor.getMetrics(&m);
+    if (ina260Sensor.hasSensor())
+        valid = ina260Sensor.getMetrics(&m);
+    if (ina3221Sensor.hasSensor())
+        valid = ina3221Sensor.getMetrics(&m);
+#endif
+
+    if (valid) {
+        LOG_INFO("(Sending): ch1_voltage=%f, ch1_current=%f, ch2_voltage=%f, ch2_current=%f, "
+                 "ch3_voltage=%f, ch3_current=%f\n",
+                 m.variant.power_metrics.ch1_voltage, m.variant.power_metrics.ch1_current, m.variant.power_metrics.ch2_voltage,
+                 m.variant.power_metrics.ch2_current, m.variant.power_metrics.ch3_voltage, m.variant.power_metrics.ch3_current);
+
+        sensor_read_error_count = 0;
+
+        meshtastic_MeshPacket *p = allocDataProtobuf(m);
+        p->to = dest;
+        p->decoded.want_response = false;
+        if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR)
+            p->priority = meshtastic_MeshPacket_Priority_RELIABLE;
+        else
+            p->priority = meshtastic_MeshPacket_Priority_MIN;
+        // release previous packet before occupying a new spot
+        if (lastMeasurementPacket != nullptr)
+            packetPool.release(lastMeasurementPacket);
+
+        lastMeasurementPacket = packetPool.allocCopy(*p);
+        if (phoneOnly) {
+            LOG_INFO("Sending packet to phone\n");
+            service.sendToPhone(p);
+        } else {
+            LOG_INFO("Sending packet to mesh\n");
+            service.sendToMesh(p, RX_SRC_LOCAL, true);
+
+            if (config.device.role == meshtastic_Config_DeviceConfig_Role_SENSOR && config.power.is_power_saving) {
+                LOG_DEBUG("Starting next execution in 5 seconds and then going to sleep.\n");
+                sleepOnNextExecution = true;
+                setIntervalFromNow(5000);
+            }
+        }
+    }
+    return valid;
+}

src/modules/Telemetry/PowerTelemetry.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "NodeDB.h"
+#include "ProtobufModule.h"
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
+
+class PowerTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
+{
+  public:
+    PowerTelemetryModule()
+        : concurrency::OSThread("PowerTelemetryModule"),
+          ProtobufModule("PowerTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
+    {
+        lastMeasurementPacket = nullptr;
+        setIntervalFromNow(10 * 1000);
+    }
+    virtual bool wantUIFrame() override;
+#if !HAS_SCREEN
+    void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+#else
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) override;
+#endif
+
+  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 meshtastic_MeshPacket &mp, meshtastic_Telemetry *p) override;
+    virtual int32_t runOnce() override;
+    /**
+     * Send our Telemetry into the mesh
+     */
+    bool sendTelemetry(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+  private:
+    bool firstTime = 1;
+    meshtastic_MeshPacket *lastMeasurementPacket;
+    uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute
+    uint32_t lastSentToMesh = 0;
+    uint32_t lastSentToPhone = 0;
+    uint32_t sensor_read_error_count = 0;
+};

src/modules/Telemetry/Sensor/INA3221Sensor.cpp

@@ -0,0 +1,43 @@
+#include "INA3221Sensor.h"
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include "configuration.h"
+#include <INA3221.h>
+
+INA3221Sensor::INA3221Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_INA3221, "INA3221"){};
+
+int32_t INA3221Sensor::runOnce()
+{
+    LOG_INFO("Init sensor: %s\n", sensorName);
+    if (!hasSensor()) {
+        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    }
+    if (!status) {
+        ina3221.setAddr(INA3221_ADDR42_SDA);
+        ina3221.begin();
+        status = true;
+    } else {
+        status = true;
+    }
+    return initI2CSensor();
+};
+
+void INA3221Sensor::setup() {}
+
+bool INA3221Sensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.environment_metrics.voltage = ina3221.getVoltage(INA3221_CH1);
+    measurement->variant.environment_metrics.current = ina3221.getCurrent(INA3221_CH1);
+    measurement->variant.power_metrics.ch1_voltage = ina3221.getVoltage(INA3221_CH1);
+    measurement->variant.power_metrics.ch1_current = ina3221.getCurrent(INA3221_CH1);
+    measurement->variant.power_metrics.ch2_voltage = ina3221.getVoltage(INA3221_CH2);
+    measurement->variant.power_metrics.ch2_current = ina3221.getCurrent(INA3221_CH2);
+    measurement->variant.power_metrics.ch3_voltage = ina3221.getVoltage(INA3221_CH3);
+    measurement->variant.power_metrics.ch3_current = ina3221.getCurrent(INA3221_CH3);
+    return true;
+}
+
+uint16_t INA3221Sensor::getBusVoltageMv()
+{
+    return lround(ina3221.getVoltage(INA3221_CH1) * 1000);
+}

src/modules/Telemetry/Sensor/INA3221Sensor.h

@@ -0,0 +1,16 @@
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <INA3221.h>
+
+class INA3221Sensor : public TelemetrySensor
+{
+  public:
+    INA3221Sensor();
+    int32_t runOnce() override;
+    void setup() override;
+    bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual uint16_t getBusVoltageMv();
+
+  private:
+    INA3221 ina3221 = INA3221(INA3221_ADDR42_SDA);
+};