Merge b42a340b40 into de89b516dc

Merge branch '0_15' of https://github.com/aircoookie/WLED into 0_15
Antialiased line & circle
2024-05-10 05:31:27 +03:00 · 2024-05-10 00:04:43 +02:00 · 2024-05-10 00:02:28 +02:00 · 2024-05-09 23:58:58 +02:00 · 2024-05-07 23:38:19 +02:00 · 2024-05-07 16:34:15 +02:00
--- a/pio-scripts/obj-dump.py
+++ b/pio-scripts/obj-dump.py
@ -1,9 +1,24 @@
 # Little convenience script to get an object dump
+#   You may add "-S" to the objdump commandline (i.e. replace "-D -C " with "-d -S -C ") 
+#   to get source code intermixed with disassembly (SLOW !)

 Import('env')

 def obj_dump_after_elf(source, target, env):
+    platform = env.PioPlatform()
+    board = env.BoardConfig()
+    mcu = board.get("build.mcu", "esp32")
+
    print("Create firmware.asm")
-    env.Execute("xtensa-lx106-elf-objdump "+ "-D " + str(target[0]) + " > "+ "${PROGNAME}.asm")
-    
+    if mcu == "esp8266":
+        env.Execute("xtensa-lx106-elf-objdump "+ "-D -C " + str(target[0]) + " > "+ "$BUILD_DIR/${PROGNAME}.asm")
+    if mcu == "esp32":
+        env.Execute("xtensa-esp32-elf-objdump "+ "-D -C " + str(target[0]) + " > "+ "$BUILD_DIR/${PROGNAME}.asm")
+    if mcu == "esp32s2":
+        env.Execute("xtensa-esp32s2-elf-objdump "+ "-D -C " + str(target[0]) + " > "+ "$BUILD_DIR/${PROGNAME}.asm")
+    if mcu == "esp32s3":
+        env.Execute("xtensa-esp32s3-elf-objdump "+ "-D -C " + str(target[0]) + " > "+ "$BUILD_DIR/${PROGNAME}.asm")
+    if mcu == "esp32c3":
+        env.Execute("riscv32-esp-elf-objdump "+ "-D -C " + str(target[0]) + " > "+ "$BUILD_DIR/${PROGNAME}.asm")
+
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.elf", [obj_dump_after_elf])
--- a/pio-scripts/output_bins.py
+++ b/pio-scripts/output_bins.py
@ -36,6 +36,8 @@ def create_release(source):
 def bin_rename_copy(source, target, env):
    _create_dirs()
    variant = env["PIOENV"]
+    builddir = os.path.join(env["PROJECT_BUILD_DIR"],  variant)
+    source_map = os.path.join(builddir, env["PROGNAME"] + ".map")

    # create string with location and file names based on variant
    map_file = "{}map{}{}.map".format(OUTPUT_DIR, os.path.sep, variant)
@ -44,7 +46,11 @@ def bin_rename_copy(source, target, env):

    # copy firmware.map to map/<variant>.map
    if os.path.isfile("firmware.map"):
-        shutil.move("firmware.map", map_file)
+        print("Found linker mapfile firmware.map")
+        shutil.copy("firmware.map", map_file)
+    if os.path.isfile(source_map):
+        print(f"Found linker mapfile {source_map}")
+        shutil.copy(source_map, map_file)

 def bin_gzip(source, target):
    # only create gzip for esp8266
--- a/platformio.ini
+++ b/platformio.ini
@ -115,6 +115,7 @@ extra_scripts =
  post:pio-scripts/strip-floats.py
  pre:pio-scripts/user_config_copy.py
  pre:pio-scripts/build_ui.py
+  ; post:pio-scripts/obj-dump.py  ;; convenience script to create a disassembly dump of the firmware (hardcore debugging)

 # ------------------------------------------------------------------------------
 # COMMON SETTINGS:
--- a/usermods/Battery/UMBattery.h
+++ b/usermods/Battery/UMBattery.h
@ -0,0 +1,160 @@
+#ifndef UMBBattery_h
+#define UMBBattery_h
+
+#include "battery_defaults.h"
+
+/**
+ *  Battery base class
+ *  all other battery classes should inherit from this
+ */
+class UMBattery
+{
+    private:
+
+    protected:
+        float minVoltage;
+        float maxVoltage;
+        float voltage;
+        int8_t level = 100;
+        float calibration; // offset or calibration value to fine tune the calculated voltage
+        float voltageMultiplier; // ratio for the voltage divider
+        
+        float linearMapping(float v, float min, float max, float oMin = 0.0f, float oMax = 100.0f)
+        {
+            return (v-min) * (oMax-oMin) / (max-min) + oMin;
+        }
+
+    public:
+        UMBattery()
+        {
+            this->setVoltageMultiplier(USERMOD_BATTERY_VOLTAGE_MULTIPLIER);
+            this->setCalibration(USERMOD_BATTERY_CALIBRATION);
+        }
+
+        virtual void update(batteryConfig cfg)
+        {
+            if(cfg.minVoltage) this->setMinVoltage(cfg.minVoltage);
+            if(cfg.maxVoltage) this->setMaxVoltage(cfg.maxVoltage);
+            if(cfg.level) this->setLevel(cfg.level);
+            if(cfg.calibration) this->setCalibration(cfg.calibration);
+            if(cfg.voltageMultiplier) this->setVoltageMultiplier(cfg.voltageMultiplier);
+        }
+
+        /**
+         * Corresponding battery curves
+         * calculates the level in % (0-100) with given voltage and possible voltage range
+         */
+        virtual float mapVoltage(float v, float min, float max) = 0;
+        // { 
+        //     example implementation, linear mapping
+        //     return (v-min) * 100 / (max-min);
+        // };
+
+        virtual void calculateAndSetLevel(float voltage) = 0;
+
+
+
+        /*
+         *
+         * Getter and Setter
+         *
+         */
+
+        /*
+        * Get lowest configured battery voltage
+        */
+        virtual float getMinVoltage()
+        {
+            return this->minVoltage;
+        }
+
+        /*
+         * Set lowest battery voltage
+         * can't be below 0 volt
+         */
+        virtual void setMinVoltage(float voltage)
+        {
+            this->minVoltage = max(0.0f, voltage);
+        }
+
+        /*
+         * Get highest configured battery voltage
+         */
+        virtual float getMaxVoltage()
+        {
+            return this->maxVoltage;
+        }
+
+        /*
+         * Set highest battery voltage
+         * can't be below minVoltage
+         */
+        virtual void setMaxVoltage(float voltage)
+        {
+            this->maxVoltage = max(getMinVoltage()+.5f, voltage);
+        }
+
+        float getVoltage()
+        {
+            return this->voltage;
+        }
+
+        /**
+         * check if voltage is within specified voltage range, allow 10% over/under voltage
+         */
+        void setVoltage(float voltage)
+        {
+            // this->voltage = ( (voltage < this->getMinVoltage() * 0.85f) || (voltage > this->getMaxVoltage() * 1.1f) ) 
+            //     ? -1.0f 
+            //     : voltage;
+            this->voltage = voltage;
+        }
+
+        float getLevel()
+        {
+            return this->level;
+        }
+
+        void setLevel(float level)
+        {
+            this->level = constrain(level, 0.0f, 110.0f);
+        }
+
+        /*
+         * Get the configured calibration value
+         * a offset value to fine-tune the calculated voltage.
+         */
+        virtual float getCalibration()
+        {
+            return calibration;
+        }
+
+        /*
+         * Set the voltage calibration offset value
+         * a offset value to fine-tune the calculated voltage.
+         */
+        virtual void setCalibration(float offset)
+        {
+            calibration = offset;
+        }
+
+        /*
+         * Get the configured calibration value
+         * a value to set the voltage divider ratio
+         */
+        virtual float getVoltageMultiplier()
+        {
+            return voltageMultiplier;
+        }
+
+        /*
+         * Set the voltage multiplier value
+         * a value to set the voltage divider ratio.
+         */
+        virtual void setVoltageMultiplier(float multiplier)
+        {
+            voltageMultiplier = multiplier;
+        }
+};
+
+#endif
--- a/usermods/Battery/battery_defaults.h
+++ b/usermods/Battery/battery_defaults.h
@ -1,3 +1,8 @@
+#ifndef UMBDefaults_h
+#define UMBDefaults_h
+
+#include "wled.h"
+
 // pin defaults
 // for the esp32 it is best to use the ADC1: GPIO32 - GPIO39
 // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/adc.html
@ -14,19 +19,55 @@
  #define USERMOD_BATTERY_MEASUREMENT_INTERVAL 30000
 #endif

-// default for 18650 battery
-// https://batterybro.com/blogs/18650-wholesale-battery-reviews/18852515-when-to-recycle-18650-batteries-and-how-to-start-a-collection-center-in-your-vape-shop
-// Discharge voltage: 2.5 volt + .1 for personal safety
-#ifndef USERMOD_BATTERY_MIN_VOLTAGE
-  #ifdef USERMOD_BATTERY_USE_LIPO
-    // LiPo "1S" Batteries should not be dischared below 3V !!
-    #define USERMOD_BATTERY_MIN_VOLTAGE 3.2f
-  #else
-    #define USERMOD_BATTERY_MIN_VOLTAGE 2.6f
-  #endif
+
+/* Default Battery Type
+ * 0 = unkown
+ * 1 = Lipo
+ * 2 = Lion
+ */
+#ifndef USERMOD_BATTERY_DEFAULT_TYPE
+  #define USERMOD_BATTERY_DEFAULT_TYPE 0
+#endif
+/*
+ *
+ *  Unkown 'Battery' defaults
+ *
+ */
+#ifndef USERMOD_BATTERY_UNKOWN_MIN_VOLTAGE
+  // Extra save defaults
+  #define USERMOD_BATTERY_UNKOWN_MIN_VOLTAGE 3.3f
+#endif
+#ifndef USERMOD_BATTERY_UNKOWN_MAX_VOLTAGE
+  #define USERMOD_BATTERY_UNKOWN_MAX_VOLTAGE 4.2f
 #endif

-//the default ratio for the voltage divider
+/*
+ *
+ *  Lithium polymer (Li-Po) defaults
+ *
+ */
+#ifndef USERMOD_BATTERY_LIPO_MIN_VOLTAGE
+  // LiPo "1S" Batteries should not be dischared below 3V !!
+  #define USERMOD_BATTERY_LIPO_MIN_VOLTAGE 3.2f
+#endif
+#ifndef USERMOD_BATTERY_LIPO_MAX_VOLTAGE
+  #define USERMOD_BATTERY_LIPO_MAX_VOLTAGE 4.2f
+#endif
+
+/*
+ *
+ *  Lithium-ion (Li-Ion) defaults
+ *
+ */
+#ifndef USERMOD_BATTERY_LION_MIN_VOLTAGE
+  // default for 18650 battery
+  #define USERMOD_BATTERY_LION_MIN_VOLTAGE 2.6f
+#endif
+#ifndef USERMOD_BATTERY_LION_MAX_VOLTAGE
+  #define USERMOD_BATTERY_LION_MAX_VOLTAGE 4.2f
+#endif
+
+// the default ratio for the voltage divider
 #ifndef USERMOD_BATTERY_VOLTAGE_MULTIPLIER
  #ifdef ARDUINO_ARCH_ESP32
    #define USERMOD_BATTERY_VOLTAGE_MULTIPLIER 2.0f
@ -35,13 +76,8 @@
  #endif
 #endif

-#ifndef USERMOD_BATTERY_MAX_VOLTAGE
-  #define USERMOD_BATTERY_MAX_VOLTAGE 4.2f
-#endif
-
-// a common capacity for single 18650 battery cells is between 2500 and 3600 mAh
-#ifndef USERMOD_BATTERY_TOTAL_CAPACITY
-  #define USERMOD_BATTERY_TOTAL_CAPACITY 3100
+#ifndef USERMOD_BATTERY_AVERAGING_ALPHA
+  #define USERMOD_BATTERY_AVERAGING_ALPHA 0.1f
 #endif

 // offset or calibration value to fine tune the calculated voltage
@ -49,11 +85,6 @@
  #define USERMOD_BATTERY_CALIBRATION 0
 #endif

-// calculate remaining time / the time that is left before the battery runs out of power
-// #ifndef USERMOD_BATTERY_CALCULATE_TIME_LEFT_ENABLED
-//   #define USERMOD_BATTERY_CALCULATE_TIME_LEFT_ENABLED false
-// #endif
-
 // auto-off feature
 #ifndef USERMOD_BATTERY_AUTO_OFF_ENABLED
  #define USERMOD_BATTERY_AUTO_OFF_ENABLED true
@ -78,4 +109,26 @@

 #ifndef USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION
  #define USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION 5
+#endif
+
+// battery types
+typedef enum
+{
+  unknown=0,
+  lipo=1,
+  lion=2
+} batteryType;
+
+// used for initial configuration after boot 
+typedef struct bconfig_t 
+{
+  batteryType type;
+  float minVoltage;
+  float maxVoltage;
+  float voltage;          // current voltage
+  int8_t level;           // current level
+  float calibration;      // offset or calibration value to fine tune the calculated voltage
+  float voltageMultiplier;
+} batteryConfig;
+
 #endif
--- a/usermods/Battery/readme.md
+++ b/usermods/Battery/readme.md
@ -36,13 +36,12 @@ define `USERMOD_BATTERY` in `wled00/my_config.h`
 | Name                                            | Unit        | Description                                                                           |
 | ----------------------------------------------- | ----------- |-------------------------------------------------------------------------------------- |
 | `USERMOD_BATTERY`                               |             | define this (in `my_config.h`) to have this usermod included wled00\usermods_list.cpp |
-| `USERMOD_BATTERY_USE_LIPO`                      |             | define this (in `my_config.h`) if you use LiPo rechargeables (1S)                     |
 | `USERMOD_BATTERY_MEASUREMENT_PIN`               |             | defaults to A0 on ESP8266 and GPIO35 on ESP32                                         |
 | `USERMOD_BATTERY_MEASUREMENT_INTERVAL`          | ms          | battery check interval. defaults to 30 seconds                                        |
-| `USERMOD_BATTERY_MIN_VOLTAGE`                   | v           | minimum battery voltage. default is 2.6 (18650 battery standard)                      |
-| `USERMOD_BATTERY_MAX_VOLTAGE`                   | v           | maximum battery voltage. default is 4.2 (18650 battery standard)                      |
-| `USERMOD_BATTERY_TOTAL_CAPACITY`                | mAh         | the capacity of all cells in parallel summed up                                       |
-| `USERMOD_BATTERY_CALIBRATION`                   |             | offset / calibration number, fine tune the measured voltage by the microcontroller    |
+| `USERMOD_BATTERY_{TYPE}_MIN_VOLTAGE`            | v           | minimum battery voltage. default is 2.6 (18650 battery standard)                      |
+| `USERMOD_BATTERY_{TYPE}_MAX_VOLTAGE`            | v           | maximum battery voltage. default is 4.2 (18650 battery standard)                      |
+| `USERMOD_BATTERY_{TYPE}_TOTAL_CAPACITY`         | mAh         | the capacity of all cells in parallel summed up                                       |
+| `USERMOD_BATTERY_{TYPE}_CALIBRATION`            |             | offset / calibration number, fine tune the measured voltage by the microcontroller    |
 | Auto-Off                                        | ---         | ---                                                                                   |
 | `USERMOD_BATTERY_AUTO_OFF_ENABLED`              | true/false  | enables auto-off                                                                      |
 | `USERMOD_BATTERY_AUTO_OFF_THRESHOLD`            | % (0-100)   | when this threshold is reached master power turns off                                 |
@ -54,6 +53,13 @@ define `USERMOD_BATTERY` in `wled00/my_config.h`

 All parameters can be configured at runtime via the Usermods settings page.

+**NOTICE:** Each Battery type can be pre-configured individualy (in `my_config.h`)
+
+| Name            | Alias         | `my_config.h` example                 |
+| --------------- | ------------- | ------------------------------------- |
+| Lithium Polymer | lipo (Li-Po)  | `USERMOD_BATTERY_lipo_MIN_VOLTAGE`    |
+| Lithium Ionen   | lion (Li-Ion) | `USERMOD_BATTERY_lion_TOTAL_CAPACITY` |
+
 ## ⚠️ Important

 - Make sure you know your battery specifications! All batteries are **NOT** the same!
@ -80,6 +86,11 @@ Specification from:  [Molicel INR18650-M35A, 3500mAh 10A Lithium-ion battery, 3.

 ## 📝 Change Log

+2024-04-30
+
+- integrate factory pattern to make it easier to add other / custom battery types
+- update readme
+
 2023-01-04

 - basic support for LiPo rechargeable batteries ( `-D USERMOD_BATTERY_USE_LIPO`)
--- a/usermods/Battery/types/LionUMBattery.h
+++ b/usermods/Battery/types/LionUMBattery.h
@ -0,0 +1,38 @@
+#ifndef UMBLion_h
+#define UMBLion_h
+
+#include "../battery_defaults.h"
+#include "../UMBattery.h"
+
+/**
+ *  LiOn Battery
+ * 
+ */
+class LionUMBattery : public UMBattery
+{
+    private:
+
+    public:
+        LionUMBattery() : UMBattery()
+        {
+            this->setMinVoltage(USERMOD_BATTERY_LION_MIN_VOLTAGE);
+            this->setMaxVoltage(USERMOD_BATTERY_LION_MAX_VOLTAGE);
+        }
+
+        float mapVoltage(float v, float min, float max) override
+        {
+            return this->linearMapping(v, min, max); // basic mapping
+        };
+
+        void calculateAndSetLevel(float voltage) override
+        {
+            this->setLevel(this->mapVoltage(voltage, this->getMinVoltage(), this->getMaxVoltage()));
+        };
+
+        virtual void setMaxVoltage(float voltage) override
+        {
+            this->maxVoltage = max(getMinVoltage()+1.0f, voltage);
+        }
+};
+
+#endif
--- a/usermods/Battery/types/LipoUMBattery.h
+++ b/usermods/Battery/types/LipoUMBattery.h
@ -0,0 +1,54 @@
+#ifndef UMBLipo_h
+#define UMBLipo_h
+
+#include "../battery_defaults.h"
+#include "../UMBattery.h"
+
+/**
+ *  LiPo Battery
+ * 
+ */
+class LipoUMBattery : public UMBattery
+{
+    private:
+
+    public:
+        LipoUMBattery() : UMBattery()
+        {
+            this->setMinVoltage(USERMOD_BATTERY_LIPO_MIN_VOLTAGE);
+            this->setMaxVoltage(USERMOD_BATTERY_LIPO_MAX_VOLTAGE);
+        }
+
+        /**
+         * LiPo batteries have a differnt discharge curve, see 
+         * https://blog.ampow.com/lipo-voltage-chart/
+         */
+        float mapVoltage(float v, float min, float max) override 
+        {
+            float lvl = 0.0f;
+            lvl = this->linearMapping(v, min, max); // basic mapping
+
+            if (lvl < 40.0f) 
+                lvl = this->linearMapping(lvl, 0, 40, 0, 12);       // last 45% -> drops very quickly
+            else {
+            if (lvl < 90.0f)
+                lvl = this->linearMapping(lvl, 40, 90, 12, 95);     // 90% ... 40% -> almost linear drop
+            else // level >  90%
+                lvl = this->linearMapping(lvl, 90, 105, 95, 100);   // highest 15% -> drop slowly
+            }
+
+            return lvl;
+        };
+
+        void calculateAndSetLevel(float voltage) override
+        {
+            this->setLevel(this->mapVoltage(voltage, this->getMinVoltage(), this->getMaxVoltage()));
+        };
+
+        virtual void setMaxVoltage(float voltage) override
+        {
+            this->maxVoltage = max(getMinVoltage()+0.7f, voltage);
+        }
+};
+
+#endif
--- a/usermods/Battery/types/UnkownUMBattery.h
+++ b/usermods/Battery/types/UnkownUMBattery.h
@ -0,0 +1,39 @@
+#ifndef UMBUnkown_h
+#define UMBUnkown_h
+
+#include "../battery_defaults.h"
+#include "../UMBattery.h"
+
+/**
+ *  Unkown / Default Battery
+ * 
+ */
+class UnkownUMBattery : public UMBattery
+{
+    private:
+
+    public:
+        UnkownUMBattery() : UMBattery()
+        {
+            this->setMinVoltage(USERMOD_BATTERY_UNKOWN_MIN_VOLTAGE);
+            this->setMaxVoltage(USERMOD_BATTERY_UNKOWN_MAX_VOLTAGE);
+        }
+
+        void update(batteryConfig cfg)
+        {
+            if(cfg.minVoltage) this->setMinVoltage(cfg.minVoltage); else this->setMinVoltage(USERMOD_BATTERY_UNKOWN_MIN_VOLTAGE);
+            if(cfg.maxVoltage) this->setMaxVoltage(cfg.maxVoltage); else this->setMaxVoltage(USERMOD_BATTERY_UNKOWN_MAX_VOLTAGE);
+        }
+
+        float mapVoltage(float v, float min, float max) override
+        {
+            return this->linearMapping(v, min, max); // basic mapping
+        };
+
+        void calculateAndSetLevel(float voltage) override
+        {
+            this->setLevel(this->mapVoltage(voltage, this->getMinVoltage(), this->getMaxVoltage()));
+        };
+};
+
+#endif
--- a/usermods/Battery/usermod_v2_Battery.h
+++ b/usermods/Battery/usermod_v2_Battery.h
@ -2,12 +2,15 @@

 #include "wled.h"
 #include "battery_defaults.h"
+#include "UMBattery.h"
+#include "types/UnkownUMBattery.h"
+#include "types/LionUMBattery.h"
+#include "types/LiPoUMBattery.h"

 /*
 * Usermod by Maximilian Mewes
- * Mail: mewes.maximilian@gmx.de
- * GitHub: itCarl
- * Date: 25.12.2022
+ * E-mail: mewes.maximilian@gmx.de
+ * Created at: 25.12.2022
 * If you have any questions, please feel free to contact me.
 */
 class UsermodBattery : public Usermod 
@ -15,47 +18,32 @@ class UsermodBattery : public Usermod
  private:
    // battery pin can be defined in my_config.h
    int8_t batteryPin = USERMOD_BATTERY_MEASUREMENT_PIN;
+    
+    UMBattery* bat = new UnkownUMBattery();
+    batteryConfig cfg;
+
    // how often to read the battery voltage
    unsigned long readingInterval = USERMOD_BATTERY_MEASUREMENT_INTERVAL;
    unsigned long nextReadTime = 0;
    unsigned long lastReadTime = 0;
-    // battery min. voltage
-    float minBatteryVoltage = USERMOD_BATTERY_MIN_VOLTAGE;
-    // battery max. voltage
-    float maxBatteryVoltage = USERMOD_BATTERY_MAX_VOLTAGE;
-    // all battery cells summed up
-    unsigned int totalBatteryCapacity = USERMOD_BATTERY_TOTAL_CAPACITY;
-    // raw analog reading 
-    float rawValue = 0.0f;
-    // calculated voltage            
-    float voltage = maxBatteryVoltage;
    // between 0 and 1, to control strength of voltage smoothing filter
-    float alpha = 0.05f;
-    // multiplier for the voltage divider that is in place between ADC pin and battery, default will be 2 but might be adapted to readout voltages over ~5v ESP32 or ~6.6v ESP8266
-    float voltageMultiplier = USERMOD_BATTERY_VOLTAGE_MULTIPLIER;
-    // mapped battery level based on voltage
-    int8_t batteryLevel = 100;
-    // offset or calibration value to fine tune the calculated voltage
-    float calibration = USERMOD_BATTERY_CALIBRATION;
-    
-    // time left estimation feature
-    // bool calculateTimeLeftEnabled = USERMOD_BATTERY_CALCULATE_TIME_LEFT_ENABLED;
-    // float estimatedTimeLeft = 0.0;
+    float alpha = USERMOD_BATTERY_AVERAGING_ALPHA;

    // auto shutdown/shutoff/master off feature
    bool autoOffEnabled = USERMOD_BATTERY_AUTO_OFF_ENABLED;
-    int8_t autoOffThreshold = USERMOD_BATTERY_AUTO_OFF_THRESHOLD;
+    uint8_t autoOffThreshold = USERMOD_BATTERY_AUTO_OFF_THRESHOLD;

    // low power indicator feature
    bool lowPowerIndicatorEnabled = USERMOD_BATTERY_LOW_POWER_INDICATOR_ENABLED;
-    int8_t lowPowerIndicatorPreset = USERMOD_BATTERY_LOW_POWER_INDICATOR_PRESET;
-    int8_t lowPowerIndicatorThreshold = USERMOD_BATTERY_LOW_POWER_INDICATOR_THRESHOLD;
-    int8_t lowPowerIndicatorReactivationThreshold = lowPowerIndicatorThreshold+10;
-    int8_t lowPowerIndicatorDuration = USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION;
+    uint8_t lowPowerIndicatorPreset = USERMOD_BATTERY_LOW_POWER_INDICATOR_PRESET;
+    uint8_t lowPowerIndicatorThreshold = USERMOD_BATTERY_LOW_POWER_INDICATOR_THRESHOLD;
+    uint8_t lowPowerIndicatorReactivationThreshold = lowPowerIndicatorThreshold+10;
+    uint8_t lowPowerIndicatorDuration = USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION;
    bool lowPowerIndicationDone = false;
    unsigned long lowPowerActivationTime = 0; // used temporary during active time
-    int8_t lastPreset = 0;
+    uint8_t lastPreset = 0;

+    //
    bool initDone = false;
    bool initializing = true;

@ -67,22 +55,17 @@ class UsermodBattery : public Usermod
    static const char _preset[];
    static const char _duration[];
    static const char _init[];
-    
-
-    // custom map function
-    // https://forum.arduino.cc/t/floating-point-using-map-function/348113/2
-    double mapf(double x, double in_min, double in_max, double out_min, double out_max) 
-    {
-      return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-    }

+    /**
+     * Helper for rounding floating point values 
+     */
    float dot2round(float x) 
    {
      float nx = (int)(x * 100 + .5);
      return (float)(nx / 100);
    }

-    /*
+    /**
     * Turn off all leds
     */
    void turnOff()
@ -91,15 +74,15 @@ class UsermodBattery : public Usermod
      stateUpdated(CALL_MODE_DIRECT_CHANGE);
    }

-    /*
+    /**
     * Indicate low power by activating a configured preset for a given time and then switching back to the preset that was selected previously
     */
    void lowPowerIndicator()
    {
      if (!lowPowerIndicatorEnabled) return;
      if (batteryPin < 0) return;  // no measurement
-      if (lowPowerIndicationDone && lowPowerIndicatorReactivationThreshold <= batteryLevel) lowPowerIndicationDone = false;
-      if (lowPowerIndicatorThreshold <= batteryLevel) return;
+      if (lowPowerIndicationDone && lowPowerIndicatorReactivationThreshold <= bat->getLevel()) lowPowerIndicationDone = false;
+      if (lowPowerIndicatorThreshold <= bat->getLevel()) return;
      if (lowPowerIndicationDone) return;
      if (lowPowerActivationTime <= 1) {
        lowPowerActivationTime = millis();
@ -114,26 +97,39 @@ class UsermodBattery : public Usermod
      }      
    }

+    /**
+     * read the battery voltage in different ways depending on the architecture 
+     */
    float readVoltage()
    {
      #ifdef ARDUINO_ARCH_ESP32
        // use calibrated millivolts analogread on esp32 (150 mV ~ 2450 mV default attentuation) and divide by 1000 to get from milivolts to volts and multiply by voltage multiplier and apply calibration value
-        return (analogReadMilliVolts(batteryPin) / 1000.0f) * voltageMultiplier  + calibration;
+        return (analogReadMilliVolts(batteryPin) / 1000.0f) * bat->getVoltageMultiplier()  + bat->getCalibration();
      #else
        // use analog read on esp8266 ( 0V ~ 1V no attenuation options) and divide by ADC precision 1023 and multiply by voltage multiplier and apply calibration value
-        return (analogRead(batteryPin) / 1023.0f) * voltageMultiplier + calibration;
+        return (analogRead(batteryPin) / 1023.0f) * bat->getVoltageMultiplier() + bat->getCalibration();
      #endif
    }

  public:
    //Functions called by WLED

-    /*
+    /**
     * setup() is called once at boot. WiFi is not yet connected at this point.
     * You can use it to initialize variables, sensors or similar.
     */
    void setup() 
    {
+      // plug in the right battery type
+      if(cfg.type == (batteryType)lipo) {
+        bat = new LipoUMBattery();
+      } else if(cfg.type == (batteryType)lion) {
+        bat = new LionUMBattery();
+      }
+
+      // update the choosen battery type with configured values
+      bat->update(cfg);
+
      #ifdef ARDUINO_ARCH_ESP32
        bool success = false;
        DEBUG_PRINTLN(F("Allocating battery pin..."));
@ -141,7 +137,7 @@ class UsermodBattery : public Usermod
          if (pinManager.allocatePin(batteryPin, false, PinOwner::UM_Battery)) {
            DEBUG_PRINTLN(F("Battery pin allocation succeeded."));
            success = true;
-            voltage = readVoltage();
+            bat->setVoltage(readVoltage());
          }

        if (!success) {
@ -152,7 +148,7 @@ class UsermodBattery : public Usermod
        }
      #else //ESP8266 boards have only one analog input pin A0
        pinMode(batteryPin, INPUT);
-        voltage = readVoltage();
+        bat->setVoltage(readVoltage());
      #endif

      nextReadTime = millis() + readingInterval;
@ -162,7 +158,7 @@ class UsermodBattery : public Usermod
    }


-    /*
+    /**
     * connected() is called every time the WiFi is (re)connected
     * Use it to initialize network interfaces
     */
@ -191,43 +187,17 @@ class UsermodBattery : public Usermod
      if (batteryPin < 0) return;  // nothing to read

      initializing = false;
+      float rawValue = readVoltage();

-      rawValue = readVoltage();
      // filter with exponential smoothing because ADC in esp32 is fluctuating too much for a good single readout
-      voltage = voltage + alpha * (rawValue - voltage);
-
-      // check if voltage is within specified voltage range, allow 10% over/under voltage - removed cause this just makes it hard for people to troubleshoot as the voltage in the web gui will say invalid instead of displaying a voltage
-      //voltage = ((voltage < minBatteryVoltage * 0.85f) || (voltage > maxBatteryVoltage * 1.1f)) ? -1.0f : voltage;
+      float filteredVoltage = bat->getVoltage() + alpha * (rawValue - bat->getVoltage());

+      bat->setVoltage(filteredVoltage);
      // translate battery voltage into percentage
-      /*
-        the standard "map" function doesn't work
-        https://www.arduino.cc/reference/en/language/functions/math/map/  notes and warnings at the bottom
-      */
-      #ifdef USERMOD_BATTERY_USE_LIPO
-        batteryLevel = mapf(voltage, minBatteryVoltage, maxBatteryVoltage, 0, 100); // basic mapping
-        // LiPo batteries have a differnt dischargin curve, see 
-        //  https://blog.ampow.com/lipo-voltage-chart/
-        if (batteryLevel < 40.0f) 
-          batteryLevel = mapf(batteryLevel, 0, 40, 0, 12);       // last 45% -> drops very quickly
-        else {
-          if (batteryLevel < 90.0f)
-            batteryLevel = mapf(batteryLevel, 40, 90, 12, 95);   // 90% ... 40% -> almost linear drop
-          else // level >  90%
-            batteryLevel = mapf(batteryLevel, 90, 105, 95, 100); // highest 15% -> drop slowly
-        }
-      #else
-        batteryLevel = mapf(voltage, minBatteryVoltage, maxBatteryVoltage, 0, 100);
-      #endif
-      if (voltage > -1.0f) batteryLevel = constrain(batteryLevel, 0.0f, 110.0f);
-
-      // if (calculateTimeLeftEnabled) {
-      //   float currentBatteryCapacity = totalBatteryCapacity;
-      //   estimatedTimeLeft = (currentBatteryCapacity/strip.currentMilliamps)*60;
-      // }
+      bat->calculateAndSetLevel(filteredVoltage);

      // Auto off -- Master power off
-      if (autoOffEnabled && (autoOffThreshold >= batteryLevel))
+      if (autoOffEnabled && (autoOffThreshold >= bat->getLevel()))
        turnOff();

 #ifndef WLED_DISABLE_MQTT
@ -236,13 +206,13 @@ class UsermodBattery : public Usermod
      if (WLED_MQTT_CONNECTED) {
        char buf[64]; // buffer for snprintf()
        snprintf_P(buf, 63, PSTR("%s/voltage"), mqttDeviceTopic);
-        mqtt->publish(buf, 0, false, String(voltage).c_str());
+        mqtt->publish(buf, 0, false, String(bat->getVoltage()).c_str());
      }
 #endif

    }

-    /*
+    /**
     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
     * Below it is shown how this could be used for e.g. a light sensor
@ -262,16 +232,6 @@ class UsermodBattery : public Usermod
      // info modal display names
      JsonArray infoPercentage = user.createNestedArray(F("Battery level"));
      JsonArray infoVoltage = user.createNestedArray(F("Battery voltage"));
-      // if (calculateTimeLeftEnabled)
-      // {
-      //   JsonArray infoEstimatedTimeLeft = user.createNestedArray(F("Estimated time left"));
-      //   if (initializing) {
-      //     infoEstimatedTimeLeft.add(FPSTR(_init));
-      //   } else {
-      //     infoEstimatedTimeLeft.add(estimatedTimeLeft);
-      //     infoEstimatedTimeLeft.add(F(" min"));
-      //   }
-      // }
      JsonArray infoNextUpdate = user.createNestedArray(F("Next update"));

      infoNextUpdate.add((nextReadTime - millis()) / 1000);
@ -283,46 +243,104 @@ class UsermodBattery : public Usermod
        return;
      }

-      if (batteryLevel < 0) {
+      if (bat->getLevel() < 0) {
        infoPercentage.add(F("invalid"));
      } else {
-        infoPercentage.add(batteryLevel);
+        infoPercentage.add(bat->getLevel());
      }
      infoPercentage.add(F(" %"));

-      if (voltage < 0) {
+      if (bat->getVoltage() < 0) {
        infoVoltage.add(F("invalid"));
      } else {
-        infoVoltage.add(dot2round(voltage));
+        infoVoltage.add(dot2round(bat->getVoltage()));
      }
      infoVoltage.add(F(" V"));
    }

+    void addBatteryToJsonObject(JsonObject& battery, bool forJsonState)
+    {
+      if(forJsonState) { battery[F("type")] = cfg.type; } else {battery[F("type")] = (String)cfg.type; }  // has to be a String otherwise it won't get converted to a Dropdown
+      battery[F("min-voltage")] = bat->getMinVoltage();
+      battery[F("max-voltage")] = bat->getMaxVoltage();
+      battery[F("calibration")] = bat->getCalibration();
+      battery[F("voltage-multiplier")] = bat->getVoltageMultiplier();
+      battery[FPSTR(_readInterval)] = readingInterval;

-    /*
+      JsonObject ao = battery.createNestedObject(F("auto-off"));  // auto off section
+      ao[FPSTR(_enabled)] = autoOffEnabled;
+      ao[FPSTR(_threshold)] = autoOffThreshold;
+
+      JsonObject lp = battery.createNestedObject(F("indicator")); // low power section
+      lp[FPSTR(_enabled)] = lowPowerIndicatorEnabled;
+      lp[FPSTR(_preset)] = lowPowerIndicatorPreset; // dropdown trickery (String)lowPowerIndicatorPreset; 
+      lp[FPSTR(_threshold)] = lowPowerIndicatorThreshold;
+      lp[FPSTR(_duration)] = lowPowerIndicatorDuration;
+    }
+
+    void getUsermodConfigFromJsonObject(JsonObject& battery)
+    {
+      getJsonValue(battery[F("type")], cfg.type);
+      getJsonValue(battery[F("min-voltage")], cfg.minVoltage);
+      getJsonValue(battery[F("max-voltage")], cfg.maxVoltage);
+      getJsonValue(battery[F("calibration")], cfg.calibration);
+      getJsonValue(battery[F("voltage-multiplier")], cfg.voltageMultiplier);
+    
+      setReadingInterval(battery[FPSTR(_readInterval)] | readingInterval);
+
+      JsonObject ao = battery[F("auto-off")];
+      setAutoOffEnabled(ao[FPSTR(_enabled)] | autoOffEnabled);
+      setAutoOffThreshold(ao[FPSTR(_threshold)] | autoOffThreshold);
+
+      JsonObject lp = battery[F("indicator")];
+      setLowPowerIndicatorEnabled(lp[FPSTR(_enabled)] | lowPowerIndicatorEnabled);
+      setLowPowerIndicatorPreset(lp[FPSTR(_preset)] | lowPowerIndicatorPreset);
+      setLowPowerIndicatorThreshold(lp[FPSTR(_threshold)] | lowPowerIndicatorThreshold);
+      lowPowerIndicatorReactivationThreshold = lowPowerIndicatorThreshold+10;
+      setLowPowerIndicatorDuration(lp[FPSTR(_duration)] | lowPowerIndicatorDuration);
+      
+      if(initDone) 
+        bat->update(cfg);
+    }
+
+    /**
     * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
     * Values in the state object may be modified by connected clients
     */
-    /*
    void addToJsonState(JsonObject& root)
    {
+      JsonObject battery = root.createNestedObject(FPSTR(_name));

+      if (battery.isNull())
+        battery = root.createNestedObject(FPSTR(_name));
+      
+      addBatteryToJsonObject(battery, true);
+      
+      DEBUG_PRINTLN(F("Battery state exposed in JSON API."));
    }
-    */


-    /*
+    /**
     * readFromJsonState() can be used to receive data clients send to the /json/state part of the JSON API (state object).
     * Values in the state object may be modified by connected clients
     */
    /*
    void readFromJsonState(JsonObject& root)
    {
+      if (!initDone) return;  // prevent crash on boot applyPreset()
+
+      JsonObject battery = root[FPSTR(_name)];
+
+      if (!battery.isNull()) {
+        getUsermodConfigFromJsonObject(battery);
+      
+        DEBUG_PRINTLN(F("Battery state read from JSON API."));
+      }
    }
    */


-    /*
+    /**
     * addToConfig() can be used to add custom persistent settings to the cfg.json file in the "um" (usermod) object.
     * It will be called by WLED when settings are actually saved (for example, LED settings are saved)
     * If you want to force saving the current state, use serializeConfig() in your loop().
@ -359,47 +377,41 @@ class UsermodBattery : public Usermod
     */
    void addToConfig(JsonObject& root)
    {
-      JsonObject battery = root.createNestedObject(FPSTR(_name));           // usermodname
+      JsonObject battery = root.createNestedObject(FPSTR(_name));
+      
+      if (battery.isNull()) {
+        battery = root.createNestedObject(FPSTR(_name));
+      }
+
      #ifdef ARDUINO_ARCH_ESP32
        battery[F("pin")] = batteryPin;
      #endif
-
-      // battery[F("time-left")] = calculateTimeLeftEnabled;
-      battery[F("min-voltage")] = minBatteryVoltage;
-      battery[F("max-voltage")] = maxBatteryVoltage;
-      battery[F("capacity")] = totalBatteryCapacity;
-      battery[F("calibration")] = calibration;
-      battery[F("voltage-multiplier")] = voltageMultiplier;
-      battery[FPSTR(_readInterval)] = readingInterval;
      
-      JsonObject ao = battery.createNestedObject(F("auto-off"));               // auto off section
-      ao[FPSTR(_enabled)] = autoOffEnabled;
-      ao[FPSTR(_threshold)] = autoOffThreshold;
-
-      JsonObject lp = battery.createNestedObject(F("indicator"));    // low power section
-      lp[FPSTR(_enabled)] = lowPowerIndicatorEnabled;
-      lp[FPSTR(_preset)] = lowPowerIndicatorPreset; // dropdown trickery (String)lowPowerIndicatorPreset; 
-      lp[FPSTR(_threshold)] = lowPowerIndicatorThreshold;
-      lp[FPSTR(_duration)] = lowPowerIndicatorDuration;
+      addBatteryToJsonObject(battery, false);

      // read voltage in case calibration or voltage multiplier changed to see immediate effect
-      voltage = readVoltage();
+      bat->setVoltage(readVoltage());

      DEBUG_PRINTLN(F("Battery config saved."));
    }

    void appendConfigData()
    {
-      oappend(SET_F("addInfo('Battery:min-voltage', 1, 'v');"));
-      oappend(SET_F("addInfo('Battery:max-voltage', 1, 'v');"));
-      oappend(SET_F("addInfo('Battery:capacity', 1, 'mAh');"));
-      oappend(SET_F("addInfo('Battery:interval', 1, 'ms');"));
-      oappend(SET_F("addInfo('Battery:auto-off:threshold', 1, '%');"));
-      oappend(SET_F("addInfo('Battery:indicator:threshold', 1, '%');"));
-      oappend(SET_F("addInfo('Battery:indicator:duration', 1, 's');"));
+      // Total: 462 Bytes
+      oappend(SET_F("td=addDropdown('Battery', 'type');"));               // 35 Bytes
+      oappend(SET_F("addOption(td, 'Unkown', '0');"));                    // 30 Bytes
+      oappend(SET_F("addOption(td, 'LiPo', '1');"));                      // 28 Bytes
+      oappend(SET_F("addOption(td, 'LiOn', '2');"));                      // 28 Bytes
+      oappend(SET_F("addInfo('Battery:type',1,'<small style=\"color:orange\">requires reboot</small>');")); // 81 Bytes
+      oappend(SET_F("addInfo('Battery:min-voltage', 1, 'v');"));          // 40 Bytes
+      oappend(SET_F("addInfo('Battery:max-voltage', 1, 'v');"));          // 40 Bytes
+      oappend(SET_F("addInfo('Battery:interval', 1, 'ms');"));            // 38 Bytes
+      oappend(SET_F("addInfo('Battery:auto-off:threshold', 1, '%');"));   // 47 Bytes
+      oappend(SET_F("addInfo('Battery:indicator:threshold', 1, '%');"));  // 48 Bytes
+      oappend(SET_F("addInfo('Battery:indicator:duration', 1, 's');"));   // 47 Bytes
      
-      // cannot quite get this mf to work. its exeeding some buffer limit i think
-      // what i wanted is a list of all presets to select one from
+      // this option list would exeed the oappend() buffer
+      // a list of all presets to select one from
      // oappend(SET_F("bd=addDropdown('Battery:low-power-indicator', 'preset');"));
      // the loop generates: oappend(SET_F("addOption(bd, 'preset name', preset id);"));
      // for(int8_t i=1; i < 42; i++) {
@ -412,7 +424,7 @@ class UsermodBattery : public Usermod
    }


-    /*
+    /**
     * readFromConfig() can be used to read back the custom settings you added with addToConfig().
     * This is called by WLED when settings are loaded (currently this only happens immediately after boot, or after saving on the Usermod Settings page)
     * 
@ -445,25 +457,13 @@ class UsermodBattery : public Usermod
        newBatteryPin     = battery[F("pin")] | newBatteryPin;
      #endif
      // calculateTimeLeftEnabled = battery[F("time-left")] | calculateTimeLeftEnabled;
-      setMinBatteryVoltage(battery[F("min-voltage")] | minBatteryVoltage);
-      setMaxBatteryVoltage(battery[F("max-voltage")] | maxBatteryVoltage);
-      setTotalBatteryCapacity(battery[F("capacity")] | totalBatteryCapacity);
-      setCalibration(battery[F("calibration")] | calibration);
-      setVoltageMultiplier(battery[F("voltage-multiplier")] | voltageMultiplier);
+      setMinBatteryVoltage(battery[F("min-voltage")] | bat->getMinVoltage());
+      setMaxBatteryVoltage(battery[F("max-voltage")] | bat->getMaxVoltage());
+      setCalibration(battery[F("calibration")] | bat->getCalibration());
+      setVoltageMultiplier(battery[F("voltage-multiplier")] | bat->getVoltageMultiplier());
      setReadingInterval(battery[FPSTR(_readInterval)] | readingInterval);

-      JsonObject ao = battery[F("auto-off")];
-      setAutoOffEnabled(ao[FPSTR(_enabled)] | autoOffEnabled);
-      setAutoOffThreshold(ao[FPSTR(_threshold)] | autoOffThreshold);
-
-      JsonObject lp = battery[F("indicator")];
-      setLowPowerIndicatorEnabled(lp[FPSTR(_enabled)] | lowPowerIndicatorEnabled);
-      setLowPowerIndicatorPreset(lp[FPSTR(_preset)] | lowPowerIndicatorPreset); // dropdown trickery (int)lp["preset"]
-      setLowPowerIndicatorThreshold(lp[FPSTR(_threshold)] | lowPowerIndicatorThreshold);
-      lowPowerIndicatorReactivationThreshold = lowPowerIndicatorThreshold+10;
-      setLowPowerIndicatorDuration(lp[FPSTR(_duration)] | lowPowerIndicatorDuration);
-
-      DEBUG_PRINT(FPSTR(_name));
+      getUsermodConfigFromJsonObject(battery);

      #ifdef ARDUINO_ARCH_ESP32
        if (!initDone) 
@ -491,8 +491,9 @@ class UsermodBattery : public Usermod
      return !battery[FPSTR(_readInterval)].isNull();
    }

-    /*
-     * Generate a preset sample for low power indication 
+    /**
+     * TBD: Generate a preset sample for low power indication
+     * a button on the config page would be cool, currently not possible
     */
    void generateExamplePreset()
    {
@ -529,7 +530,7 @@ class UsermodBattery : public Usermod
     *
     */

-    /*
+    /**
     * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
     * This could be used in the future for the system to determine whether your usermod is installed.
     */
@ -538,13 +539,23 @@ class UsermodBattery : public Usermod
      return USERMOD_ID_BATTERY;
    }

+    /**
+     * get currently active battery type
+     */
+    batteryType getBatteryType()
+    {
+      return cfg.type;
+    }

+    /**
+     * 
+     */
    unsigned long getReadingInterval()
    {
      return readingInterval;
    }

-    /*
+    /**
     * minimum repetition is 3000ms (3s) 
     */
    void setReadingInterval(unsigned long newReadingInterval)
@ -552,105 +563,84 @@ class UsermodBattery : public Usermod
      readingInterval = max((unsigned long)3000, newReadingInterval);
    }

-
-    /*
+    /**
     * Get lowest configured battery voltage
     */
    float getMinBatteryVoltage()
    {
-      return minBatteryVoltage;
+      return bat->getMinVoltage();
    }

-    /*
+    /**
     * Set lowest battery voltage
     * can't be below 0 volt
     */
    void setMinBatteryVoltage(float voltage)
    {
-      minBatteryVoltage = max(0.0f, voltage);
+      bat->setMinVoltage(voltage);
    }

-    /*
+    /**
     * Get highest configured battery voltage
     */
    float getMaxBatteryVoltage()
    {
-      return maxBatteryVoltage;
+      return bat->getMaxVoltage();
    }
    
-    /*
+    /**
     * Set highest battery voltage
     * can't be below minBatteryVoltage
     */
    void setMaxBatteryVoltage(float voltage)
    {
-      #ifdef USERMOD_BATTERY_USE_LIPO
-        maxBatteryVoltage = max(getMinBatteryVoltage()+0.7f, voltage);
-      #else
-        maxBatteryVoltage = max(getMinBatteryVoltage()+1.0f, voltage);
-      #endif
+      bat->setMaxVoltage(voltage);
    }


-    /*
-     * Get the capacity of all cells in parralel sumed up
-     * unit: mAh
-     */
-    unsigned int getTotalBatteryCapacity()
-    {
-      return totalBatteryCapacity;
-    }
-
-    void setTotalBatteryCapacity(unsigned int capacity)
-    {
-      totalBatteryCapacity = capacity;
-    }
-
-
-
-    /*
+    /**
     * Get the calculated voltage
     * formula: (adc pin value / adc precision * max voltage) + calibration
     */
    float getVoltage()
    {
-      return voltage;
+      return bat->getVoltage();
    }

-    /*
+    /**
     * Get the mapped battery level (0 - 100) based on voltage
     * important: voltage can drop when a load is applied, so its only an estimate
     */
    int8_t getBatteryLevel()
    {
-      return batteryLevel;
+      return bat->getLevel();
    }

-    /*
+    /**
     * Get the configured calibration value
     * a offset value to fine-tune the calculated voltage.
     */
    float getCalibration()
    {
-      return calibration;
+      return bat->getCalibration();
    }

-    /*
+    /**
     * Set the voltage calibration offset value
     * a offset value to fine-tune the calculated voltage.
     */
    void setCalibration(float offset)
    {
-      calibration = offset;
+      bat->setCalibration(offset);
    }

-    /*
+    /**
     * Set the voltage multiplier value
     * A multiplier that may need adjusting for different voltage divider setups
     */
    void setVoltageMultiplier(float multiplier)
    {
-      voltageMultiplier = multiplier;
+      bat->setVoltageMultiplier(multiplier);
    }

    /*
@ -659,10 +649,10 @@ class UsermodBattery : public Usermod
     */
    float getVoltageMultiplier()
    {
-      return voltageMultiplier;
+      return bat->getVoltageMultiplier();
    }

-    /*
+    /**
     * Get auto-off feature enabled status
     * is auto-off enabled, true/false
     */
@ -671,7 +661,7 @@ class UsermodBattery : public Usermod
      return autoOffEnabled;
    }

-    /*
+    /**
     * Set auto-off feature status 
     */
    void setAutoOffEnabled(bool enabled)
@ -679,7 +669,7 @@ class UsermodBattery : public Usermod
      autoOffEnabled = enabled;
    }
    
-    /*
+    /**
     * Get auto-off threshold in percent (0-100)
     */
    int8_t getAutoOffThreshold()
@ -687,7 +677,7 @@ class UsermodBattery : public Usermod
      return autoOffThreshold;
    }

-    /*
+    /**
     * Set auto-off threshold in percent (0-100) 
     */
    void setAutoOffThreshold(int8_t threshold)
@ -697,8 +687,7 @@ class UsermodBattery : public Usermod
      autoOffThreshold  = lowPowerIndicatorEnabled /*&& autoOffEnabled*/ ? min(lowPowerIndicatorThreshold-1, (int)autoOffThreshold) : autoOffThreshold;
    }

-
-    /*
+    /**
     * Get low-power-indicator feature enabled status
     * is the low-power-indicator enabled, true/false
     */
@ -707,7 +696,7 @@ class UsermodBattery : public Usermod
      return lowPowerIndicatorEnabled;
    }

-    /*
+    /**
     * Set low-power-indicator feature status 
     */
    void setLowPowerIndicatorEnabled(bool enabled)
@ -715,7 +704,7 @@ class UsermodBattery : public Usermod
      lowPowerIndicatorEnabled = enabled;
    }

-    /*
+    /**
     * Get low-power-indicator preset to activate when low power is detected
     */
    int8_t getLowPowerIndicatorPreset()
@ -723,7 +712,7 @@ class UsermodBattery : public Usermod
      return lowPowerIndicatorPreset;
    }

-    /* 
+    /** 
     * Set low-power-indicator preset to activate when low power is detected
     */
    void setLowPowerIndicatorPreset(int8_t presetId)
@ -741,7 +730,7 @@ class UsermodBattery : public Usermod
      return lowPowerIndicatorThreshold;
    }

-    /*
+    /**
     * Set low-power-indicator threshold in percent (0-100)
     */
    void setLowPowerIndicatorThreshold(int8_t threshold)
@ -751,7 +740,7 @@ class UsermodBattery : public Usermod
      lowPowerIndicatorThreshold  = autoOffEnabled /*&& lowPowerIndicatorEnabled*/ ? max(autoOffThreshold+1, (int)lowPowerIndicatorThreshold) : max(5, (int)lowPowerIndicatorThreshold);
    }

-    /*
+    /**
     * Get low-power-indicator duration in seconds
     */
    int8_t getLowPowerIndicatorDuration()
@ -759,7 +748,7 @@ class UsermodBattery : public Usermod
      return lowPowerIndicatorDuration;
    }

-    /*
+    /**
     * Set low-power-indicator duration in seconds
     */
    void setLowPowerIndicatorDuration(int8_t duration)
@ -767,9 +756,8 @@ class UsermodBattery : public Usermod
      lowPowerIndicatorDuration = duration;
    }

-
-    /*
-     * Get low-power-indicator status when the indication is done thsi returns true
+    /**
+     * Get low-power-indicator status when the indication is done this returns true
     */
    bool getLowPowerIndicatorDone()
    {
--- a/usermods/audioreactive/audio_reactive.h
+++ b/usermods/audioreactive/audio_reactive.h
@ -282,6 +282,7 @@ void FFTcode(void * parameter)
      //FFT.windowing(FFTWindow::Blackman_Harris, FFTDirection::Forward);  // Weigh data using "Blackman- Harris" window - sharp peaks due to excellent sideband rejection
      FFT.compute( FFTDirection::Forward );                       // Compute FFT
      FFT.complexToMagnitude();                                   // Compute magnitudes
+      vReal[0] = 0;   // The remaining DC offset on the signal produces a strong spike on position 0 that should be eliminated to avoid issues.

      FFT.majorPeak(&FFT_MajorPeak, &FFT_Magnitude);                // let the effects know which freq was most dominant
      FFT_MajorPeak = constrain(FFT_MajorPeak, 1.0f, 11025.0f);   // restrict value to range expected by effects
--- a/wled00/FX.cpp
+++ b/wled00/FX.cpp
@ -2506,7 +2506,7 @@ uint16_t ripple_base()
        uint16_t cx = rippleorigin >> 8;
        uint16_t cy = rippleorigin & 0xFF;
        uint8_t mag = scale8(sin8((propF>>2)), amp);
-        if (propI > 0) SEGMENT.draw_circle(cx, cy, propI, color_blend(SEGMENT.getPixelColorXY(cx + propI, cy), col, mag));
+        if (propI > 0) SEGMENT.drawCircle(cx, cy, propI, color_blend(SEGMENT.getPixelColorXY(cx + propI, cy), col, mag), true);
      } else
      #endif
      {
@ -6056,7 +6056,7 @@ uint16_t mode_2Dfloatingblobs(void) {
      }
    }
    uint32_t c = SEGMENT.color_from_palette(blob->color[i], false, false, 0);
-    if (blob->r[i] > 1.f) SEGMENT.fill_circle(roundf(blob->x[i]), roundf(blob->y[i]), roundf(blob->r[i]), c);
+    if (blob->r[i] > 1.f) SEGMENT.fillCircle(roundf(blob->x[i]), roundf(blob->y[i]), roundf(blob->r[i]), c);
    else                  SEGMENT.setPixelColorXY((int)roundf(blob->x[i]), (int)roundf(blob->y[i]), c);
    // move x
    if (blob->x[i] + blob->r[i] >= cols - 1) blob->x[i] += (blob->sX[i] * ((cols - 1 - blob->x[i]) / blob->r[i] + 0.005f));
@ -6643,7 +6643,6 @@ static const char _data_FX_MODE_GRAVIMETER[] PROGMEM = "Gravimeter@Rate of fall,
 //   * JUGGLES      //
 //////////////////////
 uint16_t mode_juggles(void) {                   // Juggles. By Andrew Tuline.
-  if (SEGLEN == 1) return mode_static();
  um_data_t *um_data;
  if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) {
    // add support for no audio
@ -6655,12 +6654,13 @@ uint16_t mode_juggles(void) {                   // Juggles. By Andrew Tuline.
  uint16_t my_sampleAgc = fmax(fmin(volumeSmth, 255.0), 0);

  for (size_t i=0; i<SEGMENT.intensity/32+1U; i++) {
+    // if SEGLEN equals 1, we will always set color to the first and only pixel, but the effect is still good looking
    SEGMENT.setPixelColor(beatsin16(SEGMENT.speed/4+i*2,0,SEGLEN-1), color_blend(SEGCOLOR(1), SEGMENT.color_from_palette(strip.now/4+i*2, false, PALETTE_SOLID_WRAP, 0), my_sampleAgc));
  }

  return FRAMETIME;
 } // mode_juggles()
-static const char _data_FX_MODE_JUGGLES[] PROGMEM = "Juggles@!,# of balls;!,!;!;1v;m12=0,si=0"; // Pixels, Beatsin
+static const char _data_FX_MODE_JUGGLES[] PROGMEM = "Juggles@!,# of balls;!,!;!;01v;m12=0,si=0"; // Pixels, Beatsin


 //////////////////////
@ -6761,7 +6761,7 @@ uint16_t mode_noisefire(void) {                 // Noisefire. By Andrew Tuline.

  return FRAMETIME;
 } // mode_noisefire()
-static const char _data_FX_MODE_NOISEFIRE[] PROGMEM = "Noisefire@!,!;;;1v;m12=2,si=0"; // Circle, Beatsin
+static const char _data_FX_MODE_NOISEFIRE[] PROGMEM = "Noisefire@!,!;;;01v;m12=2,si=0"; // Circle, Beatsin


 ///////////////////////
@ -6871,7 +6871,7 @@ uint16_t mode_plasmoid(void) {                  // Plasmoid. By Andrew Tuline.

  return FRAMETIME;
 } // mode_plasmoid()
-static const char _data_FX_MODE_PLASMOID[] PROGMEM = "Plasmoid@Phase,# of pixels;!,!;!;1v;sx=128,ix=128,m12=0,si=0"; // Pixels, Beatsin
+static const char _data_FX_MODE_PLASMOID[] PROGMEM = "Plasmoid@Phase,# of pixels;!,!;!;01v;sx=128,ix=128,m12=0,si=0"; // Pixels, Beatsin


 ///////////////////////
@ -7026,7 +7026,7 @@ static const char _data_FX_MODE_BLURZ[] PROGMEM = "Blurz@Fade rate,Blur;!,Color
 //   ** DJLight        //
 /////////////////////////
 uint16_t mode_DJLight(void) {                   // Written by ??? Adapted by Will Tatam.
-  if (SEGLEN == 1) return mode_static();
+  // No need to prevent from executing on single led strips, only mid will be set (mid = 0)
  const int mid = SEGLEN / 2;

  um_data_t *um_data;
@ -7047,13 +7047,14 @@ uint16_t mode_DJLight(void) {                   // Written by ??? Adapted by Wil
    CRGB color = CRGB(fftResult[15]/2, fftResult[5]/2, fftResult[0]/2); // 16-> 15 as 16 is out of bounds
    SEGMENT.setPixelColor(mid, color.fadeToBlackBy(map(fftResult[4], 0, 255, 255, 4)));     // TODO - Update

+    // if SEGLEN equals 1 these loops won't execute
    for (int i = SEGLEN - 1; i > mid; i--)   SEGMENT.setPixelColor(i, SEGMENT.getPixelColor(i-1)); // move to the left
    for (int i = 0; i < mid; i++)            SEGMENT.setPixelColor(i, SEGMENT.getPixelColor(i+1)); // move to the right
  }

  return FRAMETIME;
 } // mode_DJLight()
-static const char _data_FX_MODE_DJLIGHT[] PROGMEM = "DJ Light@Speed;;;1f;m12=2,si=0"; // Circle, Beatsin
+static const char _data_FX_MODE_DJLIGHT[] PROGMEM = "DJ Light@Speed;;;01f;m12=2,si=0"; // Circle, Beatsin


 ////////////////////
@ -7097,7 +7098,7 @@ static const char _data_FX_MODE_FREQMAP[] PROGMEM = "Freqmap@Fade rate,Starting
 //   ** Freqmatrix   //
 ///////////////////////
 uint16_t mode_freqmatrix(void) {                // Freqmatrix. By Andreas Pleschung.
-  if (SEGLEN == 1) return mode_static();
+  // No need to prevent from executing on single led strips, we simply change pixel 0 each time and avoid the shift
  um_data_t *um_data;
  if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) {
    // add support for no audio
@ -7140,12 +7141,13 @@ uint16_t mode_freqmatrix(void) {                // Freqmatrix. By Andreas Plesch

    // shift the pixels one pixel up
    SEGMENT.setPixelColor(0, color);
+    // if SEGLEN equals 1 this loop won't execute
    for (int i = SEGLEN - 1; i > 0; i--) SEGMENT.setPixelColor(i, SEGMENT.getPixelColor(i-1)); //move to the left
  }

  return FRAMETIME;
 } // mode_freqmatrix()
-static const char _data_FX_MODE_FREQMATRIX[] PROGMEM = "Freqmatrix@Speed,Sound effect,Low bin,High bin,Sensitivity;;;1f;m12=3,si=0"; // Corner, Beatsin
+static const char _data_FX_MODE_FREQMATRIX[] PROGMEM = "Freqmatrix@Speed,Sound effect,Low bin,High bin,Sensitivity;;;01f;m12=3,si=0"; // Corner, Beatsin


 //////////////////////
@ -7202,7 +7204,7 @@ static const char _data_FX_MODE_FREQPIXELS[] PROGMEM = "Freqpixels@Fade rate,Sta
 // As a compromise between speed and accuracy we are currently sampling with 10240Hz, from which we can then determine with a 512bin FFT our max frequency is 5120Hz.
 // Depending on the music stream you have you might find it useful to change the frequency mapping.
 uint16_t mode_freqwave(void) {                  // Freqwave. By Andreas Pleschung.
-  if (SEGLEN == 1) return mode_static();
+  // As before, this effect can also work on single pixels, we just lose the shifting effect
  um_data_t *um_data;
  if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) {
    // add support for no audio
@ -7246,13 +7248,14 @@ uint16_t mode_freqwave(void) {                  // Freqwave. By Andreas Pleschun
    SEGMENT.setPixelColor(SEGLEN/2, color);

    // shift the pixels one pixel outwards
+    // if SEGLEN equals 1 these loops won't execute
    for (int i = SEGLEN - 1; i > SEGLEN/2; i--)   SEGMENT.setPixelColor(i, SEGMENT.getPixelColor(i-1)); //move to the left
    for (int i = 0; i < SEGLEN/2; i++)            SEGMENT.setPixelColor(i, SEGMENT.getPixelColor(i+1)); // move to the right
  }

  return FRAMETIME;
 } // mode_freqwave()
-static const char _data_FX_MODE_FREQWAVE[] PROGMEM = "Freqwave@Speed,Sound effect,Low bin,High bin,Pre-amp;;;1f;m12=2,si=0"; // Circle, Beatsin
+static const char _data_FX_MODE_FREQWAVE[] PROGMEM = "Freqwave@Speed,Sound effect,Low bin,High bin,Pre-amp;;;01f;m12=2,si=0"; // Circle, Beatsin


 ///////////////////////
@ -7311,7 +7314,6 @@ static const char _data_FX_MODE_GRAVFREQ[] PROGMEM = "Gravfreq@Rate of fall,Sens
 //   ** Noisemove   //
 //////////////////////
 uint16_t mode_noisemove(void) {                 // Noisemove.    By: Andrew Tuline
-  if (SEGLEN == 1) return mode_static();
  um_data_t *um_data;
  if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) {
    // add support for no audio
@ -7325,20 +7327,20 @@ uint16_t mode_noisemove(void) {                 // Noisemove.    By: Andrew Tuli
  uint8_t numBins = map(SEGMENT.intensity,0,255,0,16);    // Map slider to fftResult bins.
  for (int i=0; i<numBins; i++) {                         // How many active bins are we using.
    uint16_t locn = inoise16(strip.now*SEGMENT.speed+i*50000, strip.now*SEGMENT.speed);   // Get a new pixel location from moving noise.
+    // if SEGLEN equals 1 locn will be always 0, hence we set the first pixel only
    locn = map(locn, 7500, 58000, 0, SEGLEN-1);           // Map that to the length of the strand, and ensure we don't go over.
    SEGMENT.setPixelColor(locn, color_blend(SEGCOLOR(1), SEGMENT.color_from_palette(i*64, false, PALETTE_SOLID_WRAP, 0), fftResult[i % 16]*4));
  }

  return FRAMETIME;
 } // mode_noisemove()
-static const char _data_FX_MODE_NOISEMOVE[] PROGMEM = "Noisemove@Speed of perlin movement,Fade rate;!,!;!;1f;m12=0,si=0"; // Pixels, Beatsin
+static const char _data_FX_MODE_NOISEMOVE[] PROGMEM = "Noisemove@Speed of perlin movement,Fade rate;!,!;!;01f;m12=0,si=0"; // Pixels, Beatsin


 //////////////////////
 //   ** Rocktaves   //
 //////////////////////
 uint16_t mode_rocktaves(void) {                 // Rocktaves. Same note from each octave is same colour.    By: Andrew Tuline
-  if (SEGLEN == 1) return mode_static();
  um_data_t *um_data;
  if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) {
    // add support for no audio
@ -7366,12 +7368,13 @@ uint16_t mode_rocktaves(void) {                 // Rocktaves. Same note from eac
  frTemp  = fabsf(frTemp * 2.1f);                         // Fudge factors to compress octave range starting at 0 and going to 255;

  uint16_t i = map(beatsin8(8+octCount*4, 0, 255, 0, octCount*8), 0, 255, 0, SEGLEN-1);
+  // i will be always constrained between 0 and 0 if SEGLEN equals 1
  i = constrain(i, 0, SEGLEN-1);
  SEGMENT.addPixelColor(i, color_blend(SEGCOLOR(1), SEGMENT.color_from_palette((uint8_t)frTemp, false, PALETTE_SOLID_WRAP, 0), volTemp));

  return FRAMETIME;
 } // mode_rocktaves()
-static const char _data_FX_MODE_ROCKTAVES[] PROGMEM = "Rocktaves@;!,!;!;1f;m12=1,si=0"; // Bar, Beatsin
+static const char _data_FX_MODE_ROCKTAVES[] PROGMEM = "Rocktaves@;!,!;!;01f;m12=1,si=0"; // Bar, Beatsin


 ///////////////////////
@ -7379,8 +7382,8 @@ static const char _data_FX_MODE_ROCKTAVES[] PROGMEM = "Rocktaves@;!,!;!;1f;m12=1
 ///////////////////////
 // Combines peak detection with FFT_MajorPeak and FFT_Magnitude.
 uint16_t mode_waterfall(void) {                   // Waterfall. By: Andrew Tuline
-  if (SEGLEN == 1) return mode_static();
-
+  // effect can work on single pixels, we just lose the shifting effect
+  
  um_data_t *um_data;
  if (!usermods.getUMData(&um_data, USERMOD_ID_AUDIOREACTIVE)) {
    // add support for no audio
@ -7417,12 +7420,13 @@ uint16_t mode_waterfall(void) {                   // Waterfall. By: Andrew Tulin
    } else {
      SEGMENT.setPixelColor(SEGLEN-1, color_blend(SEGCOLOR(1), SEGMENT.color_from_palette(pixCol+SEGMENT.intensity, false, PALETTE_SOLID_WRAP, 0), (int)my_magnitude));
    }
+    // loop will not execute if SEGLEN equals 1
    for (int i = 0; i < SEGLEN-1; i++) SEGMENT.setPixelColor(i, SEGMENT.getPixelColor(i+1)); // shift left
  }

  return FRAMETIME;
 } // mode_waterfall()
-static const char _data_FX_MODE_WATERFALL[] PROGMEM = "Waterfall@!,Adjust color,Select bin,Volume (min);!,!;!;1f;c2=0,m12=2,si=0"; // Circles, Beatsin
+static const char _data_FX_MODE_WATERFALL[] PROGMEM = "Waterfall@!,Adjust color,Select bin,Volume (min);!,!;!;01f;c2=0,m12=2,si=0"; // Circles, Beatsin


 #ifndef WLED_DISABLE_2D
--- a/wled00/FX.h
+++ b/wled00/FX.h
@ -106,6 +106,10 @@
 #define PURPLE     (uint32_t)0x400080
 #define ORANGE     (uint32_t)0xFF3000
 #define PINK       (uint32_t)0xFF1493
+#define GREY       (uint32_t)0x808080
+#define GRAY       GREY
+#define DARKGREY   (uint32_t)0x333333
+#define DARKGRAY   DARKGREY
 #define ULTRAWHITE (uint32_t)0xFFFFFFFF
 #define DARKSLATEGRAY (uint32_t)0x2F4F4F
 #define DARKSLATEGREY DARKSLATEGRAY
@ -605,6 +609,7 @@ typedef struct Segment {
    inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c)               { setPixelColorXY(int(x), int(y), c); }
    inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); }
    inline void setPixelColorXY(int x, int y, CRGB c)                             { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); }
+    inline void setPixelColorXY(unsigned x, unsigned y, CRGB c)                   { setPixelColorXY(int(x), int(y), RGBW32(c.r,c.g,c.b,0)); }
    #ifdef WLED_USE_AA_PIXELS
    void setPixelColorXY(float x, float y, uint32_t c, bool aa = true);
    inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColorXY(x, y, RGBW32(r,g,b,w), aa); }
@ -624,24 +629,25 @@ typedef struct Segment {
    void moveX(int8_t delta, bool wrap = false);
    void moveY(int8_t delta, bool wrap = false);
    void move(uint8_t dir, uint8_t delta, bool wrap = false);
-    void draw_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c);
-    void fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c);
-    void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c);
-    inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, CRGB c) { drawLine(x0, y0, x1, y1, RGBW32(c.r,c.g,c.b,0)); } // automatic inline
+    void drawCircle(uint16_t cx, uint16_t cy, uint8_t radius, uint32_t c, bool soft = false);
+    inline void drawCircle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c, bool soft = false) { drawCircle(cx, cy, radius, RGBW32(c.r,c.g,c.b,0), soft); }
+    void fillCircle(uint16_t cx, uint16_t cy, uint8_t radius, uint32_t c, bool soft = false);
+    inline void fillCircle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c, bool soft = false) { fillCircle(cx, cy, radius, RGBW32(c.r,c.g,c.b,0), soft); }
+    void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c, bool soft = false);
+    inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, CRGB c, bool soft = false) { drawLine(x0, y0, x1, y1, RGBW32(c.r,c.g,c.b,0), soft); } // automatic inline
    void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, uint32_t color, uint32_t col2 = 0, int8_t rotate = 0);
    inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB c) { drawCharacter(chr, x, y, w, h, RGBW32(c.r,c.g,c.b,0)); } // automatic inline
    inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB c, CRGB c2, int8_t rotate = 0) { drawCharacter(chr, x, y, w, h, RGBW32(c.r,c.g,c.b,0), RGBW32(c2.r,c2.g,c2.b,0), rotate); } // automatic inline
    void wu_pixel(uint32_t x, uint32_t y, CRGB c);
-    void blur1d(fract8 blur_amount); // blur all rows in 1 dimension
    inline void blur2d(fract8 blur_amount) { blur(blur_amount); }
    inline void fill_solid(CRGB c) { fill(RGBW32(c.r,c.g,c.b,0)); }
-    void nscale8(uint8_t scale);
  #else
    inline uint16_t XY(uint16_t x, uint16_t y)                                    { return x; }
    inline void setPixelColorXY(int x, int y, uint32_t c)                         { setPixelColor(x, c); }
    inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c)               { setPixelColor(int(x), c); }
    inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColor(x, RGBW32(r,g,b,w)); }
    inline void setPixelColorXY(int x, int y, CRGB c)                             { setPixelColor(x, RGBW32(c.r,c.g,c.b,0)); }
+    inline void setPixelColorXY(unsigned x, unsigned y, CRGB c)                   { setPixelColor(int(x), RGBW32(c.r,c.g,c.b,0)); }
    #ifdef WLED_USE_AA_PIXELS
    inline void setPixelColorXY(float x, float y, uint32_t c, bool aa = true)     { setPixelColor(x, c, aa); }
    inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColor(x, RGBW32(r,g,b,w), aa); }
@ -660,9 +666,12 @@ typedef struct Segment {
    inline void moveX(int8_t delta, bool wrap = false) {}
    inline void moveY(int8_t delta, bool wrap = false) {}
    inline void move(uint8_t dir, uint8_t delta, bool wrap = false) {}
-    inline void fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c) {}
-    inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c) {}
-    inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, CRGB c) {}
+    inline void drawCircle(uint16_t cx, uint16_t cy, uint8_t radius, uint32_t c, bool soft = false) {}
+    inline void drawCircle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c, bool soft = false) {}
+    inline void fillCircle(uint16_t cx, uint16_t cy, uint8_t radius, uint32_t c, bool soft = false) {}
+    inline void fillCircle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c, bool soft = false) {}
+    inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c, bool soft = false) {}
+    inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, CRGB c, bool soft = false) {}
    inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, uint32_t color, uint32_t = 0, int8_t = 0) {}
    inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB color) {}
    inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB c, CRGB c2, int8_t rotate = 0) {}
--- a/wled00/FX_2Dfcn.cpp
+++ b/wled00/FX_2Dfcn.cpp
@ -342,55 +342,36 @@ void Segment::blurCol(uint32_t col, fract8 blur_amount, bool smear) {
 // 1D Box blur (with added weight - blur_amount: [0=no blur, 255=max blur])
 void Segment::box_blur(uint16_t i, bool vertical, fract8 blur_amount) {
  if (!isActive() || blur_amount == 0) return; // not active
-  const unsigned cols = virtualWidth();
-  const unsigned rows = virtualHeight();
-  const unsigned dim1 = vertical ? rows : cols;
-  const unsigned dim2 = vertical ? cols : rows;
+  const int cols = virtualWidth();
+  const int rows = virtualHeight();
+  const int dim1 = vertical ? rows : cols;
+  const int dim2 = vertical ? cols : rows;
  if (i >= dim2) return;
  const float seep = blur_amount/255.f;
  const float keep = 3.f - 2.f*seep;
  // 1D box blur
-  CRGB tmp[dim1];
-  for (unsigned j = 0; j < dim1; j++) {
-    unsigned x = vertical ? i : j;
-    unsigned y = vertical ? j : i;
-    int xp = vertical ? x : x-1;  // "signed" to prevent underflow
-    int yp = vertical ? y-1 : y;  // "signed" to prevent underflow
-    unsigned xn = vertical ? x : x+1;
-    unsigned yn = vertical ? y+1 : y;
-    CRGB curr = getPixelColorXY(x,y);
-    CRGB prev = (xp<0 || yp<0) ? CRGB::Black : getPixelColorXY(xp,yp);
-    CRGB next = ((vertical && yn>=dim1) || (!vertical && xn>=dim1)) ? CRGB::Black : getPixelColorXY(xn,yn);
-    unsigned r, g, b;
-    r = (curr.r*keep + (prev.r + next.r)*seep) / 3;
-    g = (curr.g*keep + (prev.g + next.g)*seep) / 3;
-    b = (curr.b*keep + (prev.b + next.b)*seep) / 3;
-    tmp[j] = CRGB(r,g,b);
+  uint32_t out[dim1], in[dim1];
+  for (int j = 0; j < dim1; j++) {
+    int x = vertical ? i : j;
+    int y = vertical ? j : i;
+    in[j] = getPixelColorXY(x, y);
  }
-  for (unsigned j = 0; j < dim1; j++) {
-    unsigned x = vertical ? i : j;
-    unsigned y = vertical ? j : i;
-    setPixelColorXY(x, y, tmp[j]);
+  for (int j = 0; j < dim1; j++) {
+    uint32_t curr = in[j];
+    uint32_t prev = j > 0      ? in[j-1] : BLACK;
+    uint32_t next = j < dim1-1 ? in[j+1] : BLACK;
+    uint8_t r, g, b, w;
+    r = (R(curr)*keep + (R(prev) + R(next))*seep) / 3;
+    g = (G(curr)*keep + (G(prev) + G(next))*seep) / 3;
+    b = (B(curr)*keep + (B(prev) + B(next))*seep) / 3;
+    w = (W(curr)*keep + (W(prev) + W(next))*seep) / 3;
+    out[j] = RGBW32(r,g,b,w);
+  }
+  for (int j = 0; j < dim1; j++) {
+    int x = vertical ? i : j;
+    int y = vertical ? j : i;
+    setPixelColorXY(x, y, out[j]);
  }
-}
-
-// blur1d: one-dimensional blur filter. Spreads light to 2 line neighbors.
-// blur2d: two-dimensional blur filter. Spreads light to 8 XY neighbors.
-//
-//           0 = no spread at all
-//          64 = moderate spreading
-//         172 = maximum smooth, even spreading
-//
-//         173..255 = wider spreading, but increasing flicker
-//
-//         Total light is NOT entirely conserved, so many repeated
-//         calls to 'blur' will also result in the light fading,
-//         eventually all the way to black; this is by design so that
-//         it can be used to (slowly) clear the LEDs to black.
-
-void Segment::blur1d(fract8 blur_amount) {
-  const unsigned rows = virtualHeight();
-  for (unsigned y = 0; y < rows; y++) blurRow(y, blur_amount);
 }

 void Segment::moveX(int8_t delta, bool wrap) {
@ -447,33 +428,67 @@ void Segment::move(uint8_t dir, uint8_t delta, bool wrap) {
  }
 }

-void Segment::draw_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB col) {
+void Segment::drawCircle(uint16_t cx, uint16_t cy, uint8_t radius, uint32_t col, bool soft) {
  if (!isActive() || radius == 0) return; // not active
-  // Bresenham’s Algorithm
-  int d = 3 - (2*radius);
-  int y = radius, x = 0;
-  while (y >= x) {
-    setPixelColorXY(cx+x, cy+y, col);
-    setPixelColorXY(cx-x, cy+y, col);
-    setPixelColorXY(cx+x, cy-y, col);
-    setPixelColorXY(cx-x, cy-y, col);
-    setPixelColorXY(cx+y, cy+x, col);
-    setPixelColorXY(cx-y, cy+x, col);
-    setPixelColorXY(cx+y, cy-x, col);
-    setPixelColorXY(cx-y, cy-x, col);
-    x++;
-    if (d > 0) {
-      y--;
-      d += 4 * (x - y) + 10;
-    } else {
-      d += 4 * x + 6;
+  if (soft) {
+    // Xiaolin Wu’s algorithm
+    int rsq = radius*radius;
+    int x = 0;
+    int y = radius;
+    unsigned oldFade = 0;
+    while (x < y) {
+      float yf = sqrtf(float(rsq - x*x)); // needs to be floating point
+      unsigned fade = float(0xFFFF) * (ceilf(yf) - yf); // how much color to keep
+      if (oldFade > fade) y--;
+      oldFade = fade;
+      setPixelColorXY(cx+x, cy+y, color_blend(col, getPixelColorXY(cx+x, cy+y), fade, true));
+      setPixelColorXY(cx-x, cy+y, color_blend(col, getPixelColorXY(cx-x, cy+y), fade, true));
+      setPixelColorXY(cx+x, cy-y, color_blend(col, getPixelColorXY(cx+x, cy-y), fade, true));
+      setPixelColorXY(cx-x, cy-y, color_blend(col, getPixelColorXY(cx-x, cy-y), fade, true));
+      setPixelColorXY(cx+y, cy+x, color_blend(col, getPixelColorXY(cx+y, cy+x), fade, true));
+      setPixelColorXY(cx-y, cy+x, color_blend(col, getPixelColorXY(cx-y, cy+x), fade, true));
+      setPixelColorXY(cx+y, cy-x, color_blend(col, getPixelColorXY(cx+y, cy-x), fade, true));
+      setPixelColorXY(cx-y, cy-x, color_blend(col, getPixelColorXY(cx-y, cy-x), fade, true));
+      setPixelColorXY(cx+x, cy+y-1, color_blend(getPixelColorXY(cx+x, cy+y-1), col, fade, true));
+      setPixelColorXY(cx-x, cy+y-1, color_blend(getPixelColorXY(cx-x, cy+y-1), col, fade, true));
+      setPixelColorXY(cx+x, cy-y+1, color_blend(getPixelColorXY(cx+x, cy-y+1), col, fade, true));
+      setPixelColorXY(cx-x, cy-y+1, color_blend(getPixelColorXY(cx-x, cy-y+1), col, fade, true));
+      setPixelColorXY(cx+y-1, cy+x, color_blend(getPixelColorXY(cx+y-1, cy+x), col, fade, true));
+      setPixelColorXY(cx-y+1, cy+x, color_blend(getPixelColorXY(cx-y+1, cy+x), col, fade, true));
+      setPixelColorXY(cx+y-1, cy-x, color_blend(getPixelColorXY(cx+y-1, cy-x), col, fade, true));
+      setPixelColorXY(cx-y+1, cy-x, color_blend(getPixelColorXY(cx-y+1, cy-x), col, fade, true));
+      x++;
+    }
+  } else {
+    // Bresenham’s Algorithm
+    int d = 3 - (2*radius);
+    int y = radius, x = 0;
+    while (y >= x) {
+      setPixelColorXY(cx+x, cy+y, col);
+      setPixelColorXY(cx-x, cy+y, col);
+      setPixelColorXY(cx+x, cy-y, col);
+      setPixelColorXY(cx-x, cy-y, col);
+      setPixelColorXY(cx+y, cy+x, col);
+      setPixelColorXY(cx-y, cy+x, col);
+      setPixelColorXY(cx+y, cy-x, col);
+      setPixelColorXY(cx-y, cy-x, col);
+      x++;
+      if (d > 0) {
+        y--;
+        d += 4 * (x - y) + 10;
+      } else {
+        d += 4 * x + 6;
+      }
    }
  }
 }

 // by stepko, taken from https://editor.soulmatelights.com/gallery/573-blobs
-void Segment::fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB col) {
+void Segment::fillCircle(uint16_t cx, uint16_t cy, uint8_t radius, uint32_t col, bool soft) {
  if (!isActive() || radius == 0) return; // not active
+  // draw soft bounding circle
+  if (soft) drawCircle(cx, cy, radius, col, soft);
+  // fill it
  const int cols = virtualWidth();
  const int rows = virtualHeight();
  for (int y = -radius; y <= radius; y++) {
@ -486,30 +501,58 @@ void Segment::fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB col) {
  }
 }

-void Segment::nscale8(uint8_t scale) {
-  if (!isActive()) return; // not active
-  const unsigned cols = virtualWidth();
-  const unsigned rows = virtualHeight();
-  for (unsigned y = 0; y < rows; y++) for (unsigned x = 0; x < cols; x++) {
-    setPixelColorXY(x, y, CRGB(getPixelColorXY(x, y)).nscale8(scale));
-  }
-}
-
 //line function
-void Segment::drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c) {
+void Segment::drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c, bool soft) {
  if (!isActive()) return; // not active
-  const unsigned cols = virtualWidth();
-  const unsigned rows = virtualHeight();
+  const int cols = virtualWidth();
+  const int rows = virtualHeight();
  if (x0 >= cols || x1 >= cols || y0 >= rows || y1 >= rows) return;
-  const int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
-  const int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
-  int err = (dx>dy ? dx : -dy)/2, e2;
-  for (;;) {
-    setPixelColorXY(x0,y0,c);
-    if (x0==x1 && y0==y1) break;
-    e2 = err;
-    if (e2 >-dx) { err -= dy; x0 += sx; }
-    if (e2 < dy) { err += dx; y0 += sy; }
+
+  const int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1; // x distance & step
+  const int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1; // y distance & step
+
+  // single pixel (line length == 0)
+  if (dx+dy == 0) {
+    setPixelColorXY(x0, y0, c);
+    return;
+  }
+
+  if (soft) {
+    // Xiaolin Wu’s algorithm
+    const bool steep = dy > dx;
+    if (steep) {
+      // we need to go along longest dimension
+      std::swap(x0,y0);
+      std::swap(x1,y1);
+    }
+    if (x0 > x1) {
+      // we need to go in increasing fashion
+      std::swap(x0,x1);
+      std::swap(y0,y1);
+    }
+    float gradient = x1-x0 == 0 ? 1.0f : float(y1-y0) / float(x1-x0);
+    float intersectY = y0;
+    for (int x = x0; x <= x1; x++) {
+      unsigned keep = float(0xFFFF) * (intersectY-int(intersectY)); // how much color to keep
+      unsigned seep = 0xFFFF - keep; // how much background to keep
+      int y = int(intersectY);
+      if (steep) std::swap(x,y);  // temporaryly swap if steep
+      // pixel coverage is determined by fractional part of y co-ordinate
+      setPixelColorXY(x, y, color_blend(c, getPixelColorXY(x, y), keep, true));
+      setPixelColorXY(x+int(steep), y+int(!steep), color_blend(c, getPixelColorXY(x+int(steep), y+int(!steep)), seep, true));
+      intersectY += gradient;
+      if (steep) std::swap(x,y);  // restore if steep
+    }
+  } else {
+    // Bresenham's algorithm
+    int err = (dx>dy ? dx : -dy)/2;   // error direction
+    for (;;) {
+      setPixelColorXY(x0, y0, c);
+      if (x0==x1 && y0==y1) break;
+      int e2 = err;
+      if (e2 >-dx) { err -= dy; x0 += sx; }
+      if (e2 < dy) { err += dx; y0 += sy; }
+    }
  }
 }

--- a/wled00/fcn_declare.h
+++ b/wled00/fcn_declare.h
@ -409,14 +409,14 @@ void clearEEPROM();
  float fmod_t(float num, float denom);
 #else
  #include <math.h>
-  #define sin_t sin
-  #define cos_t cos
-  #define tan_t tan
-  #define asin_t asin
-  #define acos_t acos
-  #define atan_t atan
-  #define fmod_t fmod
-  #define floor_t floor
+  #define sin_t sinf
+  #define cos_t cosf
+  #define tan_t tanf
+  #define asin_t asinf
+  #define acos_t acosf
+  #define atan_t atanf
+  #define fmod_t fmodf
+  #define floor_t floorf
 #endif

 //wled_serial.cpp
--- a/wled00/wled_serial.cpp
+++ b/wled00/wled_serial.cpp
@ -123,7 +123,10 @@ void handleSerial()
            releaseJSONBufferLock();
            return;
          }
-          verboseResponse = deserializeState(pDoc->as<JsonObject>());
+          JsonObject root = pDoc->as<JsonObject>();
+          verboseResponse = deserializeState(root);
+          //if JSON contains networking key then initiate saving of config
+          if (root.containsKey("nw")) doSerializeConfig = true;
          //only send response if TX pin is unused for other purposes
          if (verboseResponse && (!pinManager.isPinAllocated(hardwareTX) || pinManager.getPinOwner(hardwareTX) == PinOwner::DebugOut)) {
            pDoc->clear();
--- a/wled00/ws.cpp
+++ b/wled00/ws.cpp
@ -206,9 +206,12 @@ bool sendLiveLedsWs(uint32_t wsClient)
    uint8_t g = G(c);
    uint8_t b = B(c);
    uint8_t w = W(c);
-    buffer[pos++] = scale8(qadd8(w, r), strip.getBrightness()); //R, add white channel to RGB channels as a simple RGBW -> RGB map
-    buffer[pos++] = scale8(qadd8(w, g), strip.getBrightness()); //G
-    buffer[pos++] = scale8(qadd8(w, b), strip.getBrightness()); //B
+    //buffer[pos++] = scale8(qadd8(w, r), strip.getBrightness()); //R, add white channel to RGB channels as a simple RGBW -> RGB map
+    //buffer[pos++] = scale8(qadd8(w, g), strip.getBrightness()); //G
+    //buffer[pos++] = scale8(qadd8(w, b), strip.getBrightness()); //B
+    buffer[pos++] = qadd8(w, r); //R, add white channel to RGB channels as a simple RGBW -> RGB map
+    buffer[pos++] = qadd8(w, g); //G
+    buffer[pos++] = qadd8(w, b); //B
  }

  wsc->binary(std::move(wsBuf));
Autor	SHA1	Wiadomość	Data
JonnyTech	8e1b2ad4f7	Merge `b42a340b40` into `de89b516dc`	2024-05-10 05:31:27 +03:00
Blaz Kristan	de89b516dc	Merge branch '0_15' of https://github.com/aircoookie/WLED into 0_15	2024-05-10 00:04:43 +02:00
Blaz Kristan	4dbe9a7015	Antialiased line & circle	2024-05-10 00:02:28 +02:00
Blaz Kristan	a320f16404	Real math fix	2024-05-09 23:58:58 +02:00
Frank	b88c300d04	audioreactive: workaround for ArduinoFFT bug 93 This fix works around a problem that was solved in upstream ArduinoFFT 2.0.2	2024-05-07 23:38:19 +02:00
Blaz Kristan	88372cd516	Brighter peek (ignore strip brightness)	2024-05-07 16:34:15 +02:00
Blaž Kristan	b3206121cc	Merge pull request #3942 from gaaat98/audioreactive-analog Enabled some audioreactive effects for single pixel strips/segments	2024-05-07 07:35:46 +02:00
gaaat98	5bccb5fc42	removed commented checks	2024-05-07 00:31:37 +02:00
Blaž Kristan	47e1cbdaff	Merge pull request #3003 from itCarl/usermod-battery-update2023 Usermod Battery 🔋 Added Support for different battery types, Optimized file structure	2024-05-06 20:41:00 +02:00
Maximilian Mewes	52020cbe26	CP fix	2024-05-06 17:46:26 +02:00
Maximilian Mewes	d33651c25b	Update setup method	2024-05-06 17:45:02 +02:00
Maximilian Mewes	18e9f9c304	Rename Battery classes	2024-05-06 17:39:40 +02:00
Frank	2607c44fbb	make objdump work Script update based on latest version from Tasmota * add support for all esp32 variants * add "-C" : Decode (demangle) low-level symbol names into user-level C++ names.	2024-05-06 11:00:41 +02:00
Frank	a6e536189c	output_bin.py : fix for mapfile copy The build script was not looking into the right place, so there was never a .map file dropped into build_output/map/ Builds with the newer arduino-esp32 v2.0.x framework actually generate a .map file that is placed directly next to firmware.bin	2024-05-05 21:56:01 +02:00
Maximilian Mewes	05a8c692f2	read initial voltage correctly	2024-04-30 18:11:18 +02:00
Maximilian Mewes	35d26afcb4	Merge remote-tracking branch 'upstream/0_15' into usermod-battery-update2023	2024-04-30 17:12:08 +02:00
Maximilian Mewes	2245ee6fce	bugfixes	2024-04-30 17:02:57 +02:00
Maximilian Mewes	a13f1a9bee	bug fixes	2024-04-30 15:24:02 +02:00
Maximilian Mewes	3cc60fa4d4	Merge branch 'main' into usermod-battery-update2023	2024-04-30 15:01:23 +02:00
Maximilian Mewes	bd69c24231	intermediate update	2024-04-30 14:54:53 +02:00
gaaat	74bc159a52	enabled some audioreactive effects for single pixel strips/segments	2024-04-29 20:19:10 +02:00
JonnyTech	b42a340b40	WIP: enhance Serial API JSON The Serial API for JSON currently does not support writing to cfg.json - this is an attempt to add it with code taken from wled_server.cpp - feedback and guidance is needed please because as I non-developer there is something wrong with my implementation that I cannot figure out	2024-04-29 11:47:21 +04:00
Maximilian Mewes	a9d6a15924	Update Classes	2023-09-09 21:50:30 +02:00
Maximilian Mewes	b8c61b5236	Move battery types to a separate folder 📁	2023-09-09 21:01:55 +02:00
Maximilian Mewes	b77e1eb94b	Merge remote-tracking branch 'origin/main' into usermod-battery-update2023	2023-09-08 23:17:23 +02:00
Maximilian Mewes	f78f8b6b12	Exposing the Battery state to JSON API - Part 2	2023-01-21 01:44:50 +01:00
Maximilian Mewes	f97b79bc16	Exposing the Battery state to JSON API - Part 1	2023-01-21 00:39:51 +01:00
Maximilian Mewes	42c8a77755	Merge branch 'main' into usermod-battery-update2023	2023-01-20 23:25:13 +01:00
Maximilian Mewes	bb82bf762f	Update Readme, my_config type config options with examples	2023-01-12 21:50:46 +01:00
Maximilian Mewes	d16f9efeec	Added forgotten file 😥	2023-01-06 19:09:12 +01:00
Maximilian Mewes	8ba5dfe447	Another Bugfx 🧑‍🔧	2023-01-06 19:07:39 +01:00
Maximilian Mewes	3759071449	Fix previous bug again 🐛, Add Type Dropdown to config page	2023-01-06 17:00:29 +01:00
Maximilian Mewes	85d59945a0	runtime exception fix 🐛	2023-01-06 00:19:16 +01:00
Maximilian Mewes	4c8b490c89	minor changes	2023-01-05 20:38:55 +01:00
Maximilian Mewes	8dd1745149	Add base battery 🔋 class, Add Lipo, Lion class	2023-01-05 19:48:53 +01:00