Esp32Ledc.hxx

Go to the documentation of this file.

 
#ifndef _DRIVERS_ESP32LEDC_HXX_
#define _DRIVERS_ESP32LEDC_HXX_
 
#include "freertos_drivers/common/PWM.hxx"
#include "utils/logging.h"
#include "utils/macros.h"
#include "utils/Uninitialized.hxx"
 
#include <driver/ledc.h>
 
namespace openmrn_arduino
{
 
class Esp32Ledc
{
public:
    Esp32Ledc(const std::initializer_list<uint8_t> &pins,
              const ledc_channel_t first_channel = LEDC_CHANNEL_0,
              const ledc_timer_bit_t timer_resolution = LEDC_TIMER_12_BIT,
              const uint32_t timer_hz = 5000,
              const ledc_timer_t timer_num = LEDC_TIMER_0,
              const ledc_mode_t timer_mode = LEDC_LOW_SPEED_MODE,
              const ledc_clk_cfg_t timer_clock = LEDC_AUTO_CLK)
        : firstChannel_(first_channel)
        , pins_(pins)
    {
        // Ensure the pin count is valid and within range of usable channels.
        HASSERT(pins_.size() > 0 &&
                pins_.size() <= (LEDC_CHANNEL_MAX - first_channel));
        memset(&timerConfig_, 0, sizeof(ledc_timer_config_t));
        // timerConfig_.speed_mode will be assigned the SOC default mode, which
        // is either HIGH speed or LOW speed depending on the hardware support.
        timerConfig_.duty_resolution = timer_resolution;
        timerConfig_.freq_hz = timer_hz;
        timerConfig_.speed_mode = timer_mode;
        timerConfig_.timer_num = timer_num;
        timerConfig_.clk_cfg = timer_clock;
    }
 
    void hw_init()
    {
        LOG(INFO,
            "[Esp32Ledc:%d] Configuring timer (resolution:%d, frequency:%"
            PRIu32 ")",
            timerConfig_.timer_num,
            (1 << (uint8_t)timerConfig_.duty_resolution) - 1,
            timerConfig_.freq_hz);
        ESP_ERROR_CHECK(ledc_timer_config(&timerConfig_));
        size_t count = 0;
        for (uint8_t pin : pins_)
        {
            HASSERT(GPIO_IS_VALID_OUTPUT_GPIO(pin));
 
            ledc_channel_t led_channel =
                static_cast<ledc_channel_t>(firstChannel_ + count);
            LOG(INFO, "[Esp32Ledc:%d] Configuring LEDC channel %d on GPIO %d",
                timerConfig_.timer_num, led_channel, pin);
            ledc_channel_config_t config;
            memset(&config, 0, sizeof(ledc_channel_config_t));
            config.gpio_num = pin;
            config.speed_mode = timerConfig_.speed_mode;
            config.channel = led_channel;
            config.timer_sel = timerConfig_.timer_num;
            ESP_ERROR_CHECK(ledc_channel_config(&config));
            channels_[count].emplace(this, led_channel, pin);
            count++;
        }
    }
 
    PWM *get_channel(unsigned id)
    {
        HASSERT(id <= (LEDC_CHANNEL_MAX - firstChannel_));
        return &*channels_[id];
    }
 
    void fade_channel_over_time(unsigned id, uint32_t target_duty = 0,
                                uint32_t fade_period = 1000,
                                ledc_fade_mode_t fade_mode = LEDC_FADE_NO_WAIT)
    {
        HASSERT(id <= (LEDC_CHANNEL_MAX - firstChannel_));
        ledc_channel_t channel =
            static_cast<ledc_channel_t>(firstChannel_ + id);
        HASSERT(0 == pthread_once(&ledcFadeOnce_, &Esp32Ledc::ledc_fade_setup));
        ESP_ERROR_CHECK(
            ledc_set_fade_time_and_start(timerConfig_.speed_mode, channel,
                 target_duty, fade_period, fade_mode));
    }
 
    static void ledc_fade_setup()
    {
        // allocate the interrupt as low/medium priority (C code supported) and
        // the interrupt can be shared with other usages (if necessary).
        const int INTR_MODE_FLAGS =
            ESP_INTR_FLAG_LOWMED | ESP_INTR_FLAG_SHARED;
        LOG(VERBOSE, "[Esp32Ledc] Initializing LED Fade ISR");
        ESP_ERROR_CHECK(ledc_fade_func_install(INTR_MODE_FLAGS));
    }
private:
    class Channel : public PWM
    {
    public:
        Channel(Esp32Ledc *parent, ledc_channel_t channel, uint8_t pin)
            : parent_(parent)
            , channel_(channel)
        {
        }
 
        void set_period(uint32_t counts) override
        {
            parent_->set_period(counts);
        }
 
        uint32_t get_period() override
        {
            return parent_->get_period();
        }
 
        void set_duty(uint32_t counts) override
        {
            parent_->set_duty(channel_, counts);
        }
 
        uint32_t get_duty() override
        {
            return parent_->get_duty(channel_);
        }
 
        uint32_t get_period_max() override
        {
            return parent_->get_period_max();
        }
 
        uint32_t get_period_min() override
        {
            return parent_->get_period_min();
        }
    private:
        Esp32Ledc *parent_;
        ledc_channel_t channel_;
    };
 
    void set_period(uint32_t counts)
    {
        ESP_ERROR_CHECK(
            ledc_set_freq(timerConfig_.speed_mode, timerConfig_.timer_num,
                counts));
    }
 
    uint32_t get_period()
    {
        return ledc_get_freq(timerConfig_.speed_mode, timerConfig_.timer_num);
    }
 
    void set_duty(ledc_channel_t channel, uint32_t counts)
    {
        ESP_ERROR_CHECK(
            ledc_set_duty(timerConfig_.speed_mode, channel, counts));
        ESP_ERROR_CHECK(ledc_update_duty(timerConfig_.speed_mode, channel));
    }
 
    uint32_t get_duty(ledc_channel_t channel)
    {
        return ledc_get_duty(timerConfig_.speed_mode, channel);
    }
 
    uint32_t get_period_max()
    {
        return ((1 << (uint8_t)timerConfig_.duty_resolution) - 1);
    }
 
    uint32_t get_period_min()
    {
        return 0;
    }
 
    const ledc_channel_t firstChannel_;
 
    ledc_timer_config_t timerConfig_;
 
    static pthread_once_t ledcFadeOnce_;
 
    uninitialized<Channel> channels_[LEDC_CHANNEL_MAX];
 
    std::vector<uint8_t> pins_;
 
    DISALLOW_COPY_AND_ASSIGN(Esp32Ledc);
};
 
} // namespace openmrn_arduino
 
using openmrn_arduino::Esp32Ledc;
 
#endif // _DRIVERS_ESP32LEDC_HXX_