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
This commit is contained in:
Ardi Loot 2022-11-30 10:15:07 +02:00 committed by GitHub
parent 9f1a7a1c20
commit bd601ad2da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 260 additions and 1 deletions

View File

@ -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},
...
}
}
```

View File

@ -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";

View File

@ -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

View File

@ -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");

View File

@ -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
}