Merge branch 'ESPWortuhr:main' into Add-options-for-vertical,-extra-led-and-meander-layout

Author: BastiMu

include/EEPROMAnything.h

@@ -76,8 +76,9 @@ void read() {
     Serial.printf("MQTT_Port    : %u\n", G.mqtt.port);
 
     Serial.printf("autoBrightEnabled    : %u\n", G.autoBrightEnabled);
-    Serial.printf("autoBrightOffset    : %u\n", G.autoBrightOffset);
-    Serial.printf("autoBrightSlope    : %u\n", G.autoBrightSlope);
+    Serial.printf("autoBrightMin    : %u\n", G.autoBrightMin);
+    Serial.printf("autoBrightMax    : %u\n", G.autoBrightMax);
+    Serial.printf("autoBrightPeak    : %u\n", G.autoBrightPeak);
     Serial.printf("Uhrtype    : %u\n", G.transitionDuration);
     Serial.printf("transitionType    : %u\n", G.transitionType);
     Serial.printf("transitionDuration    : %u\n", G.transitionSpeed);

include/Uhr.h

@@ -137,8 +137,9 @@ struct GLOBAL {
     OpenWeatherMapData openWeatherMap;
 
     uint8_t autoBrightEnabled;
-    uint8_t autoBrightOffset;
-    uint8_t autoBrightSlope;
+    uint8_t autoBrightMin;
+    uint8_t autoBrightMax;
+    uint16_t autoBrightPeak;
     uint8_t transitionType;
     uint8_t transitionDuration;
     uint8_t transitionSpeed;
@@ -155,7 +156,7 @@ struct GLOBAL {
 GLOBAL G = {};
 
 // LDR
-float ledGain = 100;
+float ledGain = DEFAULT_BRIGHTNESS;
 
 uint8_t _second = 0;
 uint8_t _secondFrame = 0;

include/clockWork.h

@@ -6,22 +6,12 @@ class ClockWork {
 private:
     uint16_t countMillisSpeed = 0;
     uint32_t previousMillis = 0;
-    enum class stateBH1750Type {
-        toBeInitialized = 0,
-        Initialized = 1,
-        cannotBeInitialized = 2,
-    };
-    stateBH1750Type stateBH1750 = stateBH1750Type::toBeInitialized;
-    float lux = 0.0;
-    uint16_t adcValue0Lux =
-        10; // Hier wird der niedrigste LDR-ADC Wert getrackt,
-            // für eine dynamische offset korrektur bei 0 LUX
+    uint32_t lux = 0;
 
 private:
     //------------------------------------------------------------------------------
     // Helper Functions
     //------------------------------------------------------------------------------
-    void initBH1750Logic();
     void loopAutoBrightLogic();
     uint32_t num32BitWithOnesAccordingToColumns();
     bool isRomanLanguage();

include/clockWork.hpp

@@ -5,84 +5,100 @@
 #include "clockWork.h"
 #include "openwmap.h"
 #include <Arduino.h>
+#if AUTOBRIGHT_USE_BH1750
 #include <BH1750.h>
+BH1750 lightMeter(0x23);
+bool bh1750Initialized;
+#endif
 
 OpenWMap weather;
-BH1750 lightMeter(0x23);
 
 //------------------------------------------------------------------------------
 // Helper Functions
 //------------------------------------------------------------------------------
 
-// Automatic Brightness Control (enabled/dieabled by G.autoBrightEnabled)
-// 1. Measure ambient light with high resolution sensor BH1750, if available. If
-// not, use legacy LDR.
+// Automatic Brightness Control (enabled/disabled by G.autoBrightEnabled)
+// 1. Measure ambient light with high resolution sensor BH1750, if available.
+//    If not, use legacy LDR.
 // 2. Derive the ledGain for the LEDs 0.0 - 100.0%
-// 3. When ledGain changed, execute led.set()
-// Inputs: autoBrightSlope, autoBrightOffset 0-255
+// 3. When ledGain changed, set parametersChanged = true
+// Inputs:
+//   G.autoBrightEnabled, G.autoBrightMin, G.autoBrightMax, G.autoBrightPeak
+//   AUTOBRIGHT_LDR_RESBRIGHT, AUTOBRIGHT_LDR_RESDARK, AUTOBRIGHT_LDR_RESDIVIDER
 // Outputs:
 //  lux = Ambient light [LUX]
 //  ledGain = gain for the the LEDs: 0.0-100.0% (Gain means n % of the
-//  configured brightness: effectBri)
+//    configured brightness: effectBri)
 void ClockWork::loopAutoBrightLogic() {
+    if (G.autoBrightEnabled != 1)
+        return;
+
+    if (G.autoBrightMin == G.autoBrightMax) {
+        // If min and max are identical, nothing needs to be measured...
+        // Besides: map() would crash with division by zero in this case
+        ledGain = G.autoBrightMax;
+        return;
+    }
+
     float ledGainOld = ledGain;
-    if (stateBH1750 == stateBH1750Type::toBeInitialized) {
-        initBH1750Logic();
-    }
-    if (G.autoBrightEnabled) {
-        if (stateBH1750 == stateBH1750Type::Initialized) {
-            // Using BH1750 for ambient light measurement which directly
-            // provides the LUX value with high resolution!
-            if (lightMeter.measurementReady())
-                lux = lightMeter.readLightLevel(); // 0.0-54612.5 LUX
-        } else {
-            // Using legacy LDR for ambient light measurement
-            // Electrical circuit = voltage divider: 3.3V--LDR-->ADC<--220
-            // Ohm--GND
-            uint16_t adcValue = analogRead(
-                A0); // Read out ADC, pin TOUT = 0.0V - 1.0V = adcValue 0-1023
-            // Track lowest ADC value for offest correction at 0 LUX
-            if (adcValue < adcValue0Lux)
-                adcValue0Lux = adcValue;
-            float ldrValue = adcValue - adcValue0Lux;
-            // Derive LUX value from ldrValue via a second degree polinomial.
-            // The polinomial was derived using an Excel trend line, see
-            // LDR-Calibration.xlsx
-            const float x2 = 0.0427;
-            const float x1 = 2.679;
-            const float x0 = 10.857;
-            lux = x2 * ldrValue * ldrValue + x1 * ldrValue + x0;
+    float luxNow = -1.0;
+
+#if AUTOBRIGHT_USE_BH1750
+    if (bh1750Initialized && lightMeter.measurementReady()) {
+        luxNow = lightMeter.readLightLevel(); // 0.0-54612.5 LUX
+    }
+#endif
+
+#if AUTOBRIGHT_USE_LDR
+    // only use LDR, if no value from BH1750 is available
+    if (luxNow < 0) {
+        uint16_t adcValue = analogRead(A0); // Range 0-1023 (1024 on overflow)
+
+        // The lux value is considerably misrepresented upwards at ADC values
+        // above 980. As 980 with an LDR5528 corresponds to approx. 1500 lux,
+        // but usually no more than 1000 lux are reached indoors even on sunny
+        // days, a fixed upper measurement limit of 980 is set here.
+        // Regardless of this, a maximum value of 1023 has to be applied in
+        // any case in order to avoid division by zero (analogRead is 0-1024)!
+        if (adcValue > 980) {
+            adcValue = 980;
         }
 
-        // Based on the LUX value derive the gain for the LEDs 0.0 - 100.0%
-        // Interpretation of autoBrightSlope+1=aBS: aBS=1 -> slope=1/16x, aBS=16
-        // -> slope=1x, aBS=256 -> slope=16x, When autoBrightOffset=0, and
-        // aBS=16 then ledGain should reach 100.0% at 500.0 LUX.
-        ledGain = (lux * (float)(G.autoBrightSlope + 1)) / 80.0;
-        // Add autoBrightOffset 0-255
-        ledGain +=
-            ((uint16_t)100 * (uint16_t)G.autoBrightOffset) / (uint16_t)255;
-        if (ledGain > 100.0)
-            ledGain = 100.0;
+        luxNow = (adcValue * AUTOBRIGHT_LDR_RESDARK * 10) /
+                 (AUTOBRIGHT_LDR_RESBRIGHT * AUTOBRIGHT_LDR_RESDIVIDER *
+                  (1024 - adcValue));
     }
-    if (ledGainOld != ledGain) {
-        parametersChanged = true;
+#endif
+
+    // If luxNow is still negative, no data could be retrieved from BH1750 or
+    // LDR. We return to preserve the previous ledGain (potentially default).
+    // Otherwise we may end up in a blinking light...
+    if (luxNow < 0) {
+        return;
     }
-}
 
-// Ambient Light Sensor BH1750
-// Initialize the I2C bus using SCL and SDA pins
-// (BH1750 library doesn't do this automatically)
-void ClockWork::initBH1750Logic() {
-    // begin returns a boolean that can be used to detect setup problems.
-    if (lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
-        Serial.println("BH1750 initialized. Using this sensor for ambient "
-                       "light measurement.");
-        stateBH1750 = stateBH1750Type::Initialized;
-    } else {
-        Serial.println("BH1750 initialisation error. Using legacy LDR for "
-                       "ambient light measurement");
-        stateBH1750 = stateBH1750Type::cannotBeInitialized;
+    // Even in HIGH_RES_MODE, the BH1750 only has a precision of 1 lux. The
+    // decimal point values supplied by the library should therefore be
+    // considered as 'noise' and their use makes little to no sense.
+    // Also: in order to not trigger parametersChanged more often than
+    // necessary, the value gets rounded.
+    lux = round(luxNow);
+
+    ledGain = map(lux, 0, G.autoBrightPeak, G.autoBrightMin, G.autoBrightMax);
+
+    // Ensure ledGain meets the defined limits.
+    uint16_t minimum = min(G.autoBrightMin, G.autoBrightMax);
+    uint16_t maximum = max(G.autoBrightMin, G.autoBrightMax);
+
+    if (ledGain >= maximum) {
+        ledGain = maximum;
+    }
+    if (ledGain <= minimum) {
+        ledGain = minimum;
+    }
+
+    if (ledGainOld != ledGain) {
+        parametersChanged = true;
     }
 }
 
@@ -1124,7 +1140,7 @@ void ClockWork::loop(struct tm &tm) {
         //--------------------------------------------
         // Auto Brightness Logic
         //--------------------------------------------
-        if (G.autoBrightEnabled) {
+        if (G.autoBrightEnabled == 1) {
             loopAutoBrightLogic();
         }
 
@@ -1304,13 +1320,12 @@ void ClockWork::loop(struct tm &tm) {
         config["command"] = "autoBright";
         if (G.param1 == 0) {
             config["autoBrightEnabled"] = G.autoBrightEnabled;
-            config["autoBrightOffset"] = G.autoBrightOffset;
-            config["autoBrightSlope"] = G.autoBrightSlope;
+            config["autoBrightMin"] = G.autoBrightMin;
+            config["autoBrightMax"] = G.autoBrightMax;
+            config["autoBrightPeak"] = G.autoBrightPeak;
         }
-        // Original: config["autoBrightSensor"] = map(analogRead(A0), 0, 1023,
-        // 0, 255);
-        config["autoBrightSensor"] = (int)lux;
-        config["autoBrightGain"] = (int)ledGain;
+        config["autoBrightSensor"] = (uint32_t)lux;
+        config["autoBrightGain"] = (uint8_t)ledGain;
         serializeJson(config, str);
         webSocket.sendTXT(G.client_nr, str, strlen(str));
         break;

include/config.h

@@ -178,15 +178,18 @@
  * NeutralWhite (4300K) or ColdWhite (6500K)), in the case of RGB just leave it
  * at NeutralWhite. With DEFAULT_HUE it is possible to define the hue value
  * of the default color scheme. Use https://colorizer.org to get a hue value
- * of your choice.
+ * of your choice. DEFAULT_BRIGHTNESS defines the default brightness (percent)
+ * of the LEDs, if no other value is defined yet.
  *
  * Valid values for DEFAULT_LEDTYPE [Brg, Grb, Rgb, Rbg, Gbr, Grbw]
  * Valid values for WHITE_LEDTYPE [WarmWhite, NeutralWhite, ColdWhite]
  * Valid values for DEFAULT_HUE [integer 0-255]
+ * Valid values for DEFAULT_BRIGHTNESS [one of these: 0, 20, 40, 60, 80, 100]
  */
 #define DEFAULT_LEDTYPE Brg
 #define WHITE_LEDTYPE WhiteType::NeutralWhite
 #define DEFAULT_HUE 120
+#define DEFAULT_BRIGHTNESS 100
 
 //--------------------------------------------------------------------------
 // Define Build Type
@@ -210,6 +213,46 @@
  */
 #define DEFAULT_BUILDTYPE BuildTypeDef::Normal
 
+//--------------------------------------------------------------------------
+// Specify settings for automatic brightness control
+//--------------------------------------------------------------------------
+/*
+ * The wordclock offers the option to automatically adjust the LED
+ * brightness to the ambient light. Either an LDR or a BH1750 module is
+ * used for this purpose. If both measurement methods are activated and the
+ * corresponding hardware is available and functional, the BH1750 is the
+ * preferred choice.
+ *
+ * By setting AUTOBRIGHT_USE_LDR or AUTOBRIGHT_USE_BH1750 to false, the
+ * respective variant will be disabled and the program code on the
+ * microcontroller can thus be reduced. If both modes are deactivated,
+ * the option for automatic brightness control in the web interface is no
+ * longer available.
+ *
+ * For the LDR variant, a voltage divider with an LDR (R1) and a resistor R2
+ * is used. As LDR a type 5528 and as R2 a 10k resistor is recommended. In
+ * case of a different configuration, it is necessary to adjust these
+ * values accordingly:
+ * AUTOBRIGHT_LDR_RESBRIGHT resistance of the LDR in bright environment
+ *   (10 lux) in KΩ
+ * AUTOBRIGHT_LDR_RESDARK resistance of the LDR in a dark environment
+ *   (0 lux) in KΩ
+ * AUTOBRIGHT_LDR_RESDIVIDER resistance of the divider resistor (R2) in KΩ
+ *
+ * Valid values:
+ * AUTOBRIGHT_USE_BH1750 [true, false]
+ * AUTOBRIGHT_USE_LDR [true, false]
+ * AUTOBRIGHT_LDR_RESBRIGHT [number]
+ * AUTOBRIGHT_LDR_RESDARK [number]
+ * AUTOBRIGHT_LDR_RESDIVIDER [number]
+ */
+#define AUTOBRIGHT_USE_BH1750 true
+#define AUTOBRIGHT_USE_LDR true
+
+#define AUTOBRIGHT_LDR_RESBRIGHT 15
+#define AUTOBRIGHT_LDR_RESDARK 1000
+#define AUTOBRIGHT_LDR_RESDIVIDER 10
+
 //--------------------------------------------------------------------------
 // Define External Realtime Clock
 //--------------------------------------------------------------------------

include/led.hpp

@@ -146,7 +146,7 @@ uint8_t Led::getCurrentManualBrightnessSetting() {
     } else if (_hour < 24) {
         return G.h22;
     } else {
-        return 100;
+        return DEFAULT_BRIGHTNESS;
     }
 }
 
@@ -155,7 +155,7 @@ uint8_t Led::getCurrentManualBrightnessSetting() {
 HsbColor Led::getColorbyPositionWithAppliedBrightness(ColorPosition position) {
     HsbColor color = G.color[position];
 
-    if (G.autoBrightEnabled) {
+    if (G.autoBrightEnabled == 1) {
         color.B = setBrightnessAuto(color.B);
     } else {
         color.B *= getCurrentManualBrightnessSetting() / 100.f;

include/webPageAdapter.h

@@ -296,7 +296,6 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t *payload,
             G.transitionSpeed = split(payload, 9);
             G.transitionColorize = split(payload, 12);
             G.transitionDemo = split(payload, 15);
-            ;
             break;
         }
 
@@ -362,8 +361,23 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t *payload,
 
         case COMMAND_SET_AUTO_BRIGHT: {
             G.autoBrightEnabled = split(payload, 3);
-            G.autoBrightOffset = split(payload, 6);
-            G.autoBrightSlope = split(payload, 9);
+            G.autoBrightMin = split(payload, 6);
+            G.autoBrightMax = split(payload, 9);
+            G.autoBrightPeak = split(payload, 12, 4);
+
+            if (G.autoBrightMin < 0)
+                G.autoBrightMin = 0;
+            if (G.autoBrightMin > 100)
+                G.autoBrightMin = 100;
+            if (G.autoBrightMax < 10)
+                G.autoBrightMax = 10;
+            if (G.autoBrightMax > 100)
+                G.autoBrightMax = 100;
+            if (G.autoBrightPeak < 10)
+                G.autoBrightPeak = 10;
+            if (G.autoBrightPeak > 1500)
+                G.autoBrightPeak = 1500;
+
             break;
         }