MycilaDimmer.h

// SPDX-License-Identifier: MIT
/*
 * Copyright (C) 2023-2025 Mathieu Carbou
 */
#pragma once
 
#define MYCILA_DIMMER_VERSION          "2.1.0"
#define MYCILA_DIMMER_VERSION_MAJOR    2
#define MYCILA_DIMMER_VERSION_MINOR    1
#define MYCILA_DIMMER_VERSION_REVISION 0
 
#ifdef MYCILA_JSON_SUPPORT
  #include <ArduinoJson.h>
#endif
 
#include <assert.h>
#include <esp32-hal-gpio.h>
 
namespace Mycila {
  class Dimmer {
    public:
      virtual ~Dimmer() {};
 
      virtual void begin() = 0;
      virtual void end() = 0;
      virtual const char* type() const = 0;

      // DIMMER CONFIG //

      void setDutyCycleLimit(float limit) {
        _dutyCycleLimit = _contrain(limit, 0, 1);
        if (_dutyCycle > _dutyCycleLimit)
          setDutyCycle(_dutyCycleLimit);
      }

      void setDutyCycleMin(float min) {
        _dutyCycleMin = _contrain(min, 0, _dutyCycleMax);
        setDutyCycle(_dutyCycle);
      }

      void setDutyCycleMax(float max) {
        _dutyCycleMax = _contrain(max, _dutyCycleMin, 1);
        setDutyCycle(_dutyCycle);
      }

      float getDutyCycleLimit() const { return _dutyCycleLimit; }

      float getDutyCycleMin() const { return _dutyCycleMin; }

      float getDutyCycleMax() const { return _dutyCycleMax; }

      // POWER LUT //

      void enablePowerLUT(bool enable, uint16_t semiPeriod = 0) {
        if (!enable) {
          _powerLUTEnabled = false;
          return;
        }
        // Enabling the LUT
        if (semiPeriod > 0) {
          // A semi-period is provided, use it
          _semiPeriod = semiPeriod;
        } else {
          // semiPeriod == 0, use already set semi-period, must be >0
          if (_semiPeriod == 0) {
            ESP_LOGE("MycilaDimmer", "enablePowerLUT: semiPeriod must be provided or must be already set when enabling power LUT");
          }
          assert(_semiPeriod > 0);
        }
        _powerLUTEnabled = true;
      }

      bool isPowerLUTEnabled() const { return _powerLUTEnabled; }

      uint16_t getPowerLUTSemiPeriod() const { return _powerLUTEnabled ? _semiPeriod : 0; }

      // DIMMER STATES //

      bool isEnabled() const { return _enabled; }

      bool isOnline() const { return _enabled && _online; }

      void setOnline(bool online) {
        _online = online;
        if (!_online) {
          _dutyCycleFire = 0.0f;
          if (_enabled)
            _apply();
        } else {
          setDutyCycle(_dutyCycle);
        }
      }

      // DIMMER CONTROL //

      void on() { setDutyCycle(1); }

      void off() { setDutyCycle(0); }

      bool isOff() const { return !isOn(); }

      bool isOn() const { return isOnline() && _dutyCycle; }

      bool isOnAtFullPower() const { return _dutyCycle >= _dutyCycleMax; }

      bool setDutyCycle(float dutyCycle) {
        // Apply limit and save the wanted duty cycle.
        // It will only be applied when dimmer will be on.
        _dutyCycle = _contrain(dutyCycle, 0, _dutyCycleLimit);
 
        const float mapped = getDutyCycleMapped();
 
        if (_powerLUTEnabled) {
          if (mapped == 0) {
            _dutyCycleFire = 0.0f;
          } else if (mapped == 1) {
            _dutyCycleFire = 1.0f;
          } else {
            _dutyCycleFire = 1.0f - static_cast<float>(_lookupFiringDelay(mapped, _semiPeriod)) / static_cast<float>(_semiPeriod);
          }
        } else {
          _dutyCycleFire = mapped;
        }
 
        return isOnline() && _apply();
      }

      // DUTY CYCLE //

      float getDutyCycle() const { return _dutyCycle; }

      float getDutyCycleMapped() const { return _dutyCycleMin + _dutyCycle * (_dutyCycleMax - _dutyCycleMin); }

      float getDutyCycleFire() const { return isOnline() ? _dutyCycleFire : 0.0f; }

      // HARMONICS //
 
      // Calculate harmonics based on dimmer firing angle for resistive loads
      // array[0] = H1 (fundamental), array[1] = H3, array[2] = H5, array[3] = H7, etc.
      // Only odd harmonics are calculated (even harmonics are negligible for symmetric dimmers)
      // Returns true if harmonics were calculated, false if dimmer is not active
      bool readHarmonics(float* array, size_t n) const {
        if (array == nullptr || n == 0)
          return false;
 
        // Check if dimmer is active and routing
        if (!isOnline())
          return false;
 
        if (_dutyCycleFire <= 0.0f) {
          for (size_t i = 0; i < n; i++) {
            array[i] = 0.0f; // No power, no harmonics
          }
          return true;
        }
 
        if (_dutyCycleFire >= 1.0f) {
          array[0] = 100.0f; // H1 (fundamental) = 100% reference
          for (size_t i = 1; i < n; i++) {
            array[i] = 0.0f; // No harmonics at full power
          }
          return true;
        }
 
        // Initialize all values to NAN
        for (size_t i = 0; i < n; i++) {
          array[i] = NAN;
        }
 
        // getDutyCycleFire() returns the conduction angle normalized (0-1)
        // Convert to firing angle: α = π × (1 - conduction)
        const float firingAngle = M_PI * (1.0f - _dutyCycleFire);
        const float sin_2a = sinf(2.0f * firingAngle);
 
        // RMS of fundamental component: I1_rms = (1/π) × √[2(π - α + ½sin(2α))]
        const float i1_rms = sqrtf((2.0f / M_PI) * (M_PI - firingAngle + 0.5f * sin_2a));
 
        if (i1_rms <= 0.001f)
          return false;
 
        array[0] = 100.0f; // H1 (fundamental) = 100% reference
 
        // Pre-compute constant values
        static constexpr float inv_pi_2 = 2.0f / M_PI;
        static constexpr float inv_sqrt2 = 0.70710678f; // 1/√2
        const float scale_factor = inv_pi_2 * inv_sqrt2 * 100.0f / i1_rms;
 
        // Calculate odd harmonics (H3, H5, H7, ...)
        // Formula: Hn% = (2/π√2) × |cos((n-1)α)/(n-1) - cos((n+1)α)/(n+1)| / I1_rms × 100
        for (size_t i = 1; i < n; i++) {
          const float n_f = static_cast<float>(2 * i + 1); // 3, 5, 7, 9, ...
          const float n_minus_1 = n_f - 1.0f;
          const float n_plus_1 = n_f + 1.0f;
 
          // Compute Fourier coefficient
          const float coeff = cosf(n_minus_1 * firingAngle) / n_minus_1 -
                              cosf(n_plus_1 * firingAngle) / n_plus_1;
 
          // Convert to percentage of fundamental
          array[i] = fabsf(coeff) * scale_factor;
        }
 
        return true;
      }
 
#ifdef MYCILA_JSON_SUPPORT
      virtual void toJson(const JsonObject& root) const {
        root["type"] = type();
        root["enabled"] = _enabled;
        root["online"] = _online;
        root["state"] = isOn() ? "on" : "off";
        root["duty_cycle"] = _dutyCycle;
        root["duty_cycle_mapped"] = getDutyCycleMapped();
        root["duty_cycle_fire"] = _dutyCycleFire;
        root["duty_cycle_limit"] = _dutyCycleLimit;
        root["duty_cycle_min"] = _dutyCycleMin;
        root["duty_cycle_max"] = _dutyCycleMax;
        root["power_lut"] = _powerLUTEnabled;
        root["power_lut_semi_period"] = _semiPeriod;
      }
#endif
 
    protected:
      bool _enabled = false;
      bool _online = false;
 
      float _dutyCycle = 0.0f;
      float _dutyCycleFire = 0.0f;
      float _dutyCycleLimit = 1.0f;
      float _dutyCycleMin = 0.0f;
      float _dutyCycleMax = 1.0f;
 
      bool _powerLUTEnabled = false;
      uint16_t _semiPeriod = 0;
 
      static uint16_t _lookupFiringDelay(float dutyCycle, uint16_t semiPeriod);
 
      virtual bool _apply() = 0;
 
      static inline float _contrain(float amt, float low, float high) {
        return (amt < low) ? low : ((amt > high) ? high : amt);
      }
  };
 
  class VirtualDimmer : public Dimmer {
    public:
      virtual ~VirtualDimmer() { end(); }
 
      virtual void begin() { _enabled = true; }
      virtual void end() { _enabled = false; }
      virtual const char* type() const { return "virtual"; }
 
    protected:
      virtual bool _apply() { return true; }
  };
} // namespace Mycila
 
#include "MycilaDimmerDFRobot.h"
#include "MycilaDimmerPWM.h"
#include "MycilaDimmerThyristor.h"