PWM outputs usermod (#2912)

* first commit of PWM outputs

* fix pin deallocation issue

* refactoring

* removed debug prints

* fix compile error

* added readme

* added compile error for ESP8266

* added overloaded SetDuty method

* convert state to separate nested object

* Revert "added overloaded SetDuty method"

This reverts commit e8ea32f577.

* move constant strings to flash

* reworked json info and config

* bugfixes

* more bugfixes

* updated readme

* use C strings instead of String

* added uint8 and uint16 overloads for SetDuty

* removed ambiguous overload

usermods/pwm_outputs/readme.md

@@ -0,0 +1,27 @@
+# PWM outputs
+
+v2 Usermod to add generic PWM outputs to WLED. Usermode could be used to control servo motors, LED brightness or any other device controlled by PWM signal.
+
+## Installation
+
+Add the compile-time option `-D USERMOD_PWM_OUTPUTS` to your `platformio.ini` (or `platformio_override.ini`). By default upt to 3 PWM outputs could be configured, to increase that limit add build argument `-D USERMOD_PWM_OUTPUT_PINS=10` (replace 10 by desired amount).
+
+Currently only ESP32 is supported.
+
+## Configuration
+
+By default PWM outputs are disabled, navigate to Usermods settings and configure desired PWM pins and frequencies.
+
+## Usage
+
+If PWM output is configured, it starts to publish its duty cycle value (0-1) both to state JSON and to info JSON (visible in UI info panel). To set PWM duty cycle, use JSON api (over HTTP or over Serial)
+
+```json
+{
+    "pwm": {
+        "0": {"duty": 0.1},
+        "1": {"duty": 0.2},
+        ...
+    }
+}
+```

usermods/pwm_outputs/usermod_pwm_outputs.h

@@ -0,0 +1,221 @@
+#pragma once
+#include "wled.h"
+
+#ifndef ESP32
+  #error This usermod does not support the ESP8266.
+#endif
+
+#ifndef USERMOD_PWM_OUTPUT_PINS
+  #define USERMOD_PWM_OUTPUT_PINS 3
+#endif
+
+
+class PwmOutput {
+  public:
+
+    void open(int8_t pin, uint32_t freq) {
+
+      if (enabled_) {
+        if (pin == pin_ && freq == freq_) {
+          return;  // PWM output is already open
+        } else {
+          close();  // Config has changed, close and reopen
+        }
+      }
+
+      pin_ = pin;
+      freq_ = freq;
+      if (pin_ < 0)
+        return;
+
+      DEBUG_PRINTF("pwm_output[%d]: setup to freq %d\n", pin_, freq_);
+      if (!pinManager.allocatePin(pin_, true, PinOwner::UM_PWM_OUTPUTS))
+        return;
+      
+      channel_ = pinManager.allocateLedc(1);
+      if (channel_ == 255) {
+        DEBUG_PRINTF("pwm_output[%d]: failed to quire ledc\n", pin_);
+        pinManager.deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
+        return;
+      }
+
+      ledcSetup(channel_, freq_, bit_depth_);
+      ledcAttachPin(pin_, channel_);
+      DEBUG_PRINTF("pwm_output[%d]: init successful\n", pin_);
+      enabled_ = true;
+    }
+
+    void close() {
+      DEBUG_PRINTF("pwm_output[%d]: close\n", pin_);
+      if (!enabled_)
+        return;
+      pinManager.deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
+      if (channel_ != 255)
+        pinManager.deallocateLedc(channel_, 1);
+      channel_ = 255;
+      duty_ = 0.0f;
+      enabled_ = false;
+    }
+
+    void setDuty(const float duty) {
+      DEBUG_PRINTF("pwm_output[%d]: set duty %f\n", pin_, duty);
+      if (!enabled_)
+        return;
+      duty_ = min(1.0f, max(0.0f, duty));
+      const uint32_t value = static_cast<uint32_t>((1 << bit_depth_) * duty_);
+      ledcWrite(channel_, value);
+    }
+
+    void setDuty(const uint16_t duty) {
+      setDuty(static_cast<float>(duty) / 65535.0f);
+    }
+
+    bool isEnabled() const {
+      return enabled_;
+    }
+
+    void addToJsonState(JsonObject& pwmState) const {
+      pwmState[F("duty")] = duty_;
+    }
+
+    void readFromJsonState(JsonObject& pwmState) {
+      if (pwmState.isNull()) {
+        return;
+      }
+      float duty;
+      if (getJsonValue(pwmState[F("duty")], duty)) {
+        setDuty(duty);
+      }
+    }
+
+    void addToJsonInfo(JsonObject& user) const {
+      if (!enabled_)
+        return;
+      char buffer[12];
+      sprintf_P(buffer, PSTR("PWM pin %d"), pin_);
+      JsonArray data = user.createNestedArray(buffer);
+      data.add(1e2f * duty_);
+      data.add(F("%"));
+    }
+
+    void addToConfig(JsonObject& pwmConfig) const {
+      pwmConfig[F("pin")] = pin_;
+      pwmConfig[F("freq")] = freq_;
+    }
+
+    bool readFromConfig(JsonObject& pwmConfig) {
+      if (pwmConfig.isNull())
+        return false;
+        
+      bool configComplete = true;
+      int8_t newPin = pin_;
+      uint32_t newFreq = freq_;
+      configComplete &= getJsonValue(pwmConfig[F("pin")], newPin);  
+      configComplete &= getJsonValue(pwmConfig[F("freq")], newFreq);
+
+      open(newPin, newFreq);
+
+      return configComplete;
+    }
+
+  private:
+    int8_t pin_ {-1};
+    uint32_t freq_ {50};
+    static const uint8_t bit_depth_ {12};
+    uint8_t channel_ {255};
+    float duty_ {0.0f};
+    bool enabled_ {false};
+};
+
+
+class PwmOutputsUsermod : public Usermod {
+  public:
+
+    static const char USERMOD_NAME[];
+    static const char PWM_STATE_NAME[];
+
+    void setup() {
+      // By default all PWM outputs are disabled, no setup do be done
+    }
+
+    void loop() {
+    }
+
+    void addToJsonState(JsonObject& root) {
+      JsonObject pwmStates = root.createNestedObject(PWM_STATE_NAME);
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        const PwmOutput& pwm = pwms_[i];
+        if (!pwm.isEnabled())
+          continue;
+        char buffer[4];
+        sprintf_P(buffer, PSTR("%d"), i);
+        JsonObject pwmState = pwmStates.createNestedObject(buffer);
+        pwm.addToJsonState(pwmState);
+      }
+    }
+
+    void readFromJsonState(JsonObject& root) {
+      JsonObject pwmStates = root[PWM_STATE_NAME];
+      if (pwmStates.isNull())
+        return;
+
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        PwmOutput& pwm = pwms_[i];
+        if (!pwm.isEnabled())
+          continue;
+        char buffer[4];
+        sprintf_P(buffer, PSTR("%d"), i);
+        JsonObject pwmState = pwmStates[buffer];
+        pwm.readFromJsonState(pwmState);
+      }
+    }
+
+    void addToJsonInfo(JsonObject& root) {
+      JsonObject user = root[F("u")];
+      if (user.isNull())
+        user = root.createNestedObject(F("u"));
+
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        const PwmOutput& pwm = pwms_[i];
+        pwm.addToJsonInfo(user);
+      }
+    }
+
+    void addToConfig(JsonObject& root) {
+      JsonObject top = root.createNestedObject(USERMOD_NAME);
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        const PwmOutput& pwm = pwms_[i];
+        char buffer[8];
+        sprintf_P(buffer, PSTR("PWM %d"), i);
+        JsonObject pwmConfig = top.createNestedObject(buffer);
+        pwm.addToConfig(pwmConfig);
+      }
+    }
+
+    bool readFromConfig(JsonObject& root) {
+      JsonObject top = root[USERMOD_NAME];
+      if (top.isNull())
+        return false;
+
+      bool configComplete = true;
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        PwmOutput& pwm = pwms_[i];
+        char buffer[8];
+        sprintf_P(buffer, PSTR("PWM %d"), i);
+        JsonObject pwmConfig = top[buffer];
+        configComplete &= pwm.readFromConfig(pwmConfig);
+      }
+      return configComplete;
+    }
+
+    uint16_t getId() {
+      return USERMOD_ID_PWM_OUTPUTS;
+    }
+
+  private:
+    PwmOutput pwms_[USERMOD_PWM_OUTPUT_PINS];
+
+};
+
+const char PwmOutputsUsermod::USERMOD_NAME[] PROGMEM = "PwmOutputs";
+const char PwmOutputsUsermod::PWM_STATE_NAME[] PROGMEM = "pwm";

wled00/const.h

@@ -98,6 +98,7 @@
 #define USERMOD_ID_PING_PONG_CLOCK       34     //Usermod "usermod_v2_ping_pong_clock.h"
 #define USERMOD_ID_ADS1115               35     //Usermod "usermod_ads1115.h"
 #define USERMOD_ID_SD_CARD               37     //Usermod "usermod_sd_card.h"
+#define USERMOD_ID_PWM_OUTPUTS           38     //Usermod "usermod_pwm_outputs.h
 
 //Access point behavior
 #define AP_BEHAVIOR_BOOT_NO_CONN          0     //Open AP when no connection after boot

wled00/pin_manager.h

@@ -58,7 +58,8 @@ enum struct PinOwner : uint8_t {
   UM_BME280            = USERMOD_ID_BME280,             // 0x18 // Usermod "usermod_bme280.h -- Uses "standard" HW_I2C pins
   UM_BH1750            = USERMOD_ID_BH1750,             // 0x19 // Usermod "usermod_bme280.h -- Uses "standard" HW_I2C pins
   UM_Audioreactive     = USERMOD_ID_AUDIOREACTIVE,      // 0x1E // Usermod "audio_reactive.h"
-  UM_SdCard            = USERMOD_ID_SD_CARD             // 0x24 // Usermod "usermod_sd_card.h"
+  UM_SdCard            = USERMOD_ID_SD_CARD,            // 0x24 // Usermod "usermod_sd_card.h"
+  UM_PWM_OUTPUTS       = USERMOD_ID_PWM_OUTPUTS         // 0x21 // Usermod "usermod_pwm_outputs.h"
 };
 static_assert(0u == static_cast<uint8_t>(PinOwner::None), "PinOwner::None must be zero, so default array initialization works as expected");
 

wled00/usermods_list.cpp

@@ -172,6 +172,11 @@
   #include "../usermods/sd_card/usermod_sd_card.h"
 #endif
 
+#ifdef USERMOD_PWM_OUTPUTS
+#include "../usermods/pwm_outputs/usermod_pwm_outputs.h"
+#endif
+
+
 void registerUsermods()
 {
 /*
@@ -323,4 +328,8 @@ void registerUsermods()
   #ifdef SD_ADAPTER
   usermods.add(new UsermodSdCard());
   #endif
+  
+  #ifdef USERMOD_PWM_OUTPUTS
+  usermods.add(new PwmOutputsUsermod());
+  #endif
 }