MycilaDimmerPWM.h

// SPDX-License-Identifier: MIT
/*
 * Copyright (C) 2023-2025 Mathieu Carbou
 */
#pragma once
 
#include "MycilaDimmer.h"
 
#define MYCILA_DIMMER_PWM_RESOLUTION 12   // 12 bits resolution => 0-4095 watts
#define MYCILA_DIMMER_PWM_FREQUENCY  1000 // 1 kHz
 
namespace Mycila {
  class PWMDimmer : public Dimmer {
    public:
      virtual ~PWMDimmer() { end(); }

      void setPin(gpio_num_t pin) { _pin = pin; }

      gpio_num_t getPin() const { return _pin; }

      void setFrequency(uint32_t frequency) { this->_frequency = frequency; }

      uint32_t getFrequency() const { return _frequency; }

      void setResolution(uint8_t resolution) { this->_resolution = resolution; }

      uint8_t getResolution() const { return _resolution; }

      void begin() override;

      void end() override;
 
      const char* type() const override { return "pwm"; }
 
      bool calculateMetrics(Metrics& metrics, float gridVoltage, float loadResistance) const override {
        return isOnline() && _calculatePhaseControlMetrics(metrics, _dutyCycleFire, gridVoltage, loadResistance);
      }
 
#ifdef MYCILA_JSON_SUPPORT
      void toJson(const JsonObject& root) const override {
        Dimmer::toJson(root);
        root["pwm_pin"] = static_cast<int>(_pin);
        root["pwm_frequency"] = _frequency;
        root["pwm_resolution"] = _resolution;
      }
#endif
 
    protected:
      bool _apply() override {
        if (!_online) {
          return ledcWrite(_pin, 0);
        }
        uint32_t duty = _dutyCycleFire * ((1 << _resolution) - 1);
        return ledcWrite(_pin, duty);
      }
 
      bool _calculateHarmonics(float* array, size_t n) const override {
        return _calculatePhaseControlHarmonics(_dutyCycleFire, array, n);
      }
 
    private:
      gpio_num_t _pin = GPIO_NUM_NC;
      uint32_t _frequency = MYCILA_DIMMER_PWM_FREQUENCY;
      uint8_t _resolution = MYCILA_DIMMER_PWM_RESOLUTION;
  };
} // namespace Mycila