PoC: Generic Sensor Handling

usermods/DHT/DHT.cpp

@@ -57,13 +57,15 @@
 
 DHT_nonblocking dht_sensor(DHTPIN, DHTTYPE);
 
-class UsermodDHT : public Usermod {
+class UsermodDHT : public Usermod, public Sensor {
   private:
+    static const char _name[];
     unsigned long nextReadTime = 0;
     unsigned long lastReadTime = 0;
-    float humidity, temperature = 0;
+    float tempC = 0, humidity = 0, temperature = 0;
     bool initializing = true;
     bool disabled = false;
+    bool isSensorReady = false;
     #ifdef USERMOD_DHT_MQTT
     char dhtMqttTopic[64];
     size_t dhtMqttTopicLen;
@@ -79,6 +81,8 @@ class UsermodDHT : public Usermod {
     #endif
 
   public:
+    UsermodDHT() : Sensor{_name, 2} {}
+
     void setup() {
       nextReadTime = millis() + USERMOD_DHT_FIRST_MEASUREMENT_AT;
       lastReadTime = millis();
@@ -112,13 +116,13 @@ class UsermodDHT : public Usermod {
       }
       #endif
 
-      float tempC;
       if (dht_sensor.measure(&tempC, &humidity)) {
         #ifdef USERMOD_DHT_CELSIUS
         temperature = tempC;
         #else
         temperature = tempC * 9 / 5 + 32;
         #endif
+        isSensorReady = true;
 
         #ifdef USERMOD_DHT_MQTT
         // 10^n where n is number of decimal places to display in mqtt message. Please adjust buff size together with this constant
@@ -168,6 +172,7 @@ class UsermodDHT : public Usermod {
 
       if (((millis() - lastReadTime) > 10*USERMOD_DHT_MEASUREMENT_INTERVAL)) {
         disabled = true;
+        isSensorReady = false;
       }
     }
 
@@ -242,8 +247,18 @@ class UsermodDHT : public Usermod {
       return USERMOD_ID_DHT;
     }
 
+    uint8_t getSensorCount() override { return 1; }
+    Sensor *getSensor(uint8_t) override { return this; }
+
+  private:
+    bool do_isSensorReady() override { return isSensorReady; }
+    SensorValue do_getSensorChannelValue(uint8_t index) override { return index == 0 ? humidity : tempC; }
+    const SensorChannelProps &do_getSensorChannelProperties(uint8_t index) override { return _channelProps[index]; }
+    const SensorChannelPropsArray<2> _channelProps = { makeChannelProps_Humidity(), makeChannelProps_Temperature() };
 };
 
+const char UsermodDHT::_name[] PROGMEM = "DHT";
+
 
 static UsermodDHT dht;
-REGISTER_USERMOD(dht);
+REGISTER_USERMOD(dht);

usermods/Internal_Temperature_v2/Internal_Temperature_v2.cpp

@@ -1,6 +1,6 @@
 #include "wled.h"
 
-class InternalTemperatureUsermod : public Usermod
+class InternalTemperatureUsermod : public Usermod, public Sensor
 {
 
 private:
@@ -22,10 +22,17 @@ class InternalTemperatureUsermod : public Usermod
   static const char _activationThreshold[];
   static const char _presetToActivate[];
 
+  const SensorChannelProps sensorProps = makeChannelProps_Temperature("on-chip", 0.0f, 80.0f);
+  bool do_isSensorReady() override { return isEnabled && temperature >= 0.0f; }
+  SensorValue do_getSensorChannelValue(uint8_t) override { return temperature; }
+  const SensorChannelProps &do_getSensorChannelProperties(uint8_t) override { return sensorProps; }
+
   // any private methods should go here (non-inline method should be defined out of class)
   void publishMqtt(const char *state, bool retain = false); // example for publishing MQTT message
 
 public:
+  InternalTemperatureUsermod() : Sensor{"CPU", 1} {}
+
   void setup()
   {
   }
@@ -171,6 +178,9 @@ class InternalTemperatureUsermod : public Usermod
   {
     return USERMOD_ID_INTERNAL_TEMPERATURE;
   }
+
+  uint8_t getSensorCount() override { return 1; }
+  Sensor *getSensor(uint8_t) override { return this; }
 };
 
 const char InternalTemperatureUsermod::_name[] PROGMEM = "Internal Temperature";
@@ -194,4 +204,4 @@ void InternalTemperatureUsermod::publishMqtt(const char *state, bool retain)
 }
 
 static InternalTemperatureUsermod internal_temperature_v2;
-REGISTER_USERMOD(internal_temperature_v2);
+REGISTER_USERMOD(internal_temperature_v2);

usermods/Temperature/Temperature.cpp

@@ -165,11 +165,15 @@ void UsermodTemperature::loop() {
   if (now - lastTemperaturesRequest >= 750 /* 93.75ms per the datasheet but can be up to 750ms */) {
     readTemperature();
     if (getTemperatureC() < -100.0f) {
-      if (++errorCount > 10) sensorFound = 0;
+      if (++errorCount > 10) {
+        sensorFound = 0;
+        temperatureSensor.suspendSensor();
+      }
       lastMeasurement = now - readingInterval + 300; // force new measurement in 300ms
       return;
     }
     errorCount = 0;
+    temperatureSensor = temperature;
 
 #ifndef WLED_DISABLE_MQTT
     if (WLED_MQTT_CONNECTED) {
@@ -379,4 +383,4 @@ static void mode_temperature() {
 
 
 static UsermodTemperature temperature;
-REGISTER_USERMOD(temperature);
+REGISTER_USERMOD(temperature);

usermods/Temperature/UsermodTemperature.h

@@ -50,6 +50,8 @@ class UsermodTemperature : public Usermod {
     int16_t idx = -1;   // Domoticz virtual sensor idx
     uint8_t resolution = 0; // 9bits=0, 10bits=1, 11bits=2, 12bits=3
 
+    EasySensor temperatureSensor{_name, makeChannelProps_Temperature()};
+
     // strings to reduce flash memory usage (used more than twice)
     static const char _name[];
     static const char _enabled[];
@@ -106,5 +108,8 @@ class UsermodTemperature : public Usermod {
     bool readFromConfig(JsonObject &root) override;
 
     void appendConfigData() override;
+
+    uint8_t getSensorCount() override { return 1; }
+    Sensor *getSensor(uint8_t) override { return &temperatureSensor; }
 };
 

usermods/UM_SensorDummy/README.md

@@ -0,0 +1,5 @@
+# Dummy usermod to simulate random sensor readings.
+
+Use `UM_SensorInfo` and `UM_SensorDummy` together as an example for how sensors are implemented,
+and how its data can be retrieved. The generated sensor data can be processed by effects and other
+usermods - without directly knowing the sensor and its specific type of data.

usermods/UM_SensorDummy/UM_SensorDummy.cpp

@@ -0,0 +1,105 @@
+/**
+ * (c) 2026 Joachim Dick
+ * Licensed under the EUPL v. 1.2 or later
+ */
+
+#include "wled.h"
+
+//--------------------------------------------------------------------------------------------------
+
+/** Dummy usermod implementation that simulates random sensor readings.
+ */
+class UM_SensorDummy : public Usermod, public Sensor
+{
+public:
+  UM_SensorDummy() : Sensor{"SEF", 4} {}
+
+  // ----- usermod functions -----
+
+  void setup() override {}
+
+  void loop() override
+  {
+    const auto now = millis();
+    if (now < _nextUpdateTime)
+      return;
+    readWeatherStation();
+    _nextUpdateTime = now + 20; // 50 sensor updates per second
+  }
+
+  uint8_t getSensorCount() override { return 2; }
+
+  Sensor *getSensor(uint8_t index) override
+  {
+    if (index == 0)
+      return &_sensorArray;
+    return this;
+  }
+
+  bool do_isSensorReady() override { return true; }
+  SensorValue do_getSensorChannelValue(uint8_t channelIndex) override { return readSEF(channelIndex); }
+  const SensorChannelProps &do_getSensorChannelProperties(uint8_t channelIndex) override { return _localSensorProps[channelIndex]; }
+
+  // ----- internal processing functions -----
+
+  void readWeatherStation()
+  {
+    _sensorArray.set(0, 1012.34f);
+    _sensorArray.set(1, readTemperature());
+    _sensorArray.set(2, readHumidity());
+#if (0) // Battery is empty :-(
+    _sensorArray.set(3, readTemperature() - 3.0f);
+    _sensorArray.set(4, readHumidity() - 5.0f);
+#endif
+  }
+
+  /// The dummy implementation to simulate temperature values (based on perlin noise).
+  float readTemperature()
+  {
+    const int32_t raw = perlin16(strip.now * 8) - 0x8000;
+    // simulate some random temperature around 20°C
+    return 20.0f + raw / 65535.0f * 30.0f;
+  }
+
+  /// The dummy implementation to simulate humidity values (a sine wave).
+  float readHumidity()
+  {
+    const int32_t raw = beatsin16_t(1);
+    // simulate some random humidity between 10% and 90%
+    return 10.0f + raw / 65535.0f * 80.0f;
+  }
+
+  float readSEF(uint8_t index)
+  {
+    if (index >= 3)
+    {
+      const int32_t raw = abs(beat16(20) - 0x8000);
+      return raw / 32767.0f * 100.0f;
+    }
+    const int32_t raw = beatsin16_t(40, 0, 0xFFFF, 0, (index * 0xFFFF) / 3);
+    return 90.0f + raw / 65535.0f * 90.0f;
+  }
+
+  // ----- member variables -----
+
+  uint32_t _nextUpdateTime = 0;
+
+  const SensorChannelPropsArray<4> _localSensorProps =
+      {{makeChannelProps_Float("deltaX", {"offset", "°rad"}, 0.0f, 360.0f),
+        makeChannelProps_Float("deltaY", {"offset", "°rad"}, 0.0f, 360.0f),
+        makeChannelProps_Float("deltaZ", {"offset", "°rad"}, 0.0f, 360.0f),
+        makeChannelProps_Float("deltaT", {"jitter", "µs"}, -1000.0f, 1000.0f)}};
+
+  EasySensorArray<5> _sensorArray{"Weather Station",
+                                  {{SensorChannelProps{"Barometer",
+                                                       SensorQuantity::AirPressure(), 950.0f, 1050.0f},
+                                    makeChannelProps_Temperature("Indoor Temp."),
+                                    makeChannelProps_Humidity("Indoor Hum."),
+                                    makeChannelProps_Temperature("Outdoor Temp."),
+                                    makeChannelProps_Humidity("Outdoor Hum.")}}};
+};
+
+//--------------------------------------------------------------------------------------------------
+
+static UM_SensorDummy um_SensorDummy;
+REGISTER_USERMOD(um_SensorDummy);

usermods/UM_SensorDummy/library.json

@@ -0,0 +1,4 @@
+{
+  "name": "UM_SensorDummy",
+  "build": { "libArchive": false }
+}

usermods/UM_SensorInfo/README.md

@@ -0,0 +1,5 @@
+# Examples for working with sensors.
+
+Use `UM_SensorInfo` and `UM_SensorDummy` together as an example for how sensors are implemented,
+and how its data can be retrieved. The generated sensor data can be processed by effects and other
+usermods - without directly knowing the sensor and its specific type of data.