esp32/machine_pwm.c: Fix lightsleep.

IhorNehrutsa · IhorNehrutsa · commit 117fedc6a186 · 2025-02-20T14:17:23.000+02:00
Rename light_sleep_enable to lightsleep.

Signed-off-by: Ihor Nehrutsa &lt;Ihor.Nehrutsa@gmail.com&gt;
diff --git a/ports/esp32/machine_pwm.c b/ports/esp32/machine_pwm.c
@@ -40,7 +40,7 @@
 #include "esp_clk_tree.h"
 #include "py/mpprint.h"
 
-#define debug_printf(...) // mp_printf(&mp_plat_print, __VA_ARGS__); mp_printf(&mp_plat_print, " | %d at %s\n", __LINE__, __FILE__);
+#define debug_printf(...) mp_printf(&mp_plat_print, __VA_ARGS__); mp_printf(&mp_plat_print, " | %d at %s\n", __LINE__, __FILE__);
 
 #define FADE 0
 
@@ -80,7 +80,7 @@ typedef struct _machine_pwm_obj_t {
     int8_t mode;
     int8_t channel;
     int8_t timer;
-    bool light_sleep_enable;
+    bool lightsleep;
     int32_t freq;
     int8_t duty_scale; // DUTY_10 if duty(), DUTY_16 if duty_u16(), DUTY_NS if duty_ns()
     int duty_ui;       // saved values of UI duty
@@ -90,9 +90,9 @@ typedef struct _machine_pwm_obj_t {
 } machine_pwm_obj_t;
 
 typedef struct _chans_t {
-    int8_t pin;              // Which channel has which GPIO pin assigned? (-1 if not assigned)
-    int8_t timer;            // Which channel has which timer assigned? (-1 if not assigned)
-    bool light_sleep_enable; // Is light sleep enable has been set for this pin
+    int8_t pin;      // Which channel has which GPIO pin assigned? (-1 if not assigned)
+    int8_t timer;    // Which channel has which timer assigned? (-1 if not assigned)
+    bool lightsleep; // Is light sleep enable has been set for this pin
 } chans_t;
 
 // List of PWM channels
@@ -109,33 +109,38 @@ static timers_t timers[LEDC_SPEED_MODE_MAX][LEDC_TIMER_MAX];
 
 // register-unregister channel
 static void register_channel(int mode, int channel, int pin, int timer) {
-    if ((mode >= 0) && (mode < LEDC_SPEED_MODE_MAX) && (channel >= 0) && (channel < LEDC_CHANNEL_MAX)) {
-        chans[mode][channel].pin = pin;
-        chans[mode][channel].timer = timer;
-    }
+    chans[mode][channel].pin = pin;
+    chans[mode][channel].timer = timer;
+}
+
+static void unregister_channel(int mode, int channel) {
+    register_channel(mode, channel, -1, -1);
+    chans[mode][channel].lightsleep = false;
+}
+
+static void unregister_timer(int mode, int timer) {
+    timers[mode][timer].freq = -1; // unused timer freq is -1
+    timers[mode][timer].duty_resolution = 0;
+    timers[mode][timer].clk_cfg = LEDC_AUTO_CLK;
 }
-#define unregister_channel(mode, channel) register_channel(mode, channel, -1, -1)
 
 static void pwm_init(void) {
     for (int mode = 0; mode < LEDC_SPEED_MODE_MAX; ++mode) {
         // Initial condition: no channels assigned
         for (int channel = 0; channel < LEDC_CHANNEL_MAX; ++channel) {
             unregister_channel(mode, channel);
-            chans[mode][channel].light_sleep_enable = false;
         }
         // Initial condition: no timers assigned
         for (int timer = 0; timer < LEDC_TIMER_MAX; ++timer) {
-            timers[mode][timer].freq = -1; // unset timer is -1
-            timers[mode][timer].duty_resolution = 0;
-            timers[mode][timer].clk_cfg = LEDC_AUTO_CLK;
+            unregister_timer(mode, timer);
         }
     }
 }
 
 // Returns true if the timer is in use in addition to current channel
 static bool is_timer_in_use(int mode, int current_channel, int timer) {
     for (int channel = 0; channel < LEDC_CHANNEL_MAX; ++channel) {
-        if ((channel != current_channel) && (chans[mode][channel].timer == timer)) {
+        if ((channel != current_channel) && (chans[mode][channel].timer == timer) && (chans[mode][channel].pin >= 0)) {
             return true;
         }
     }
@@ -156,22 +161,19 @@ static void pwm_deinit(int mode, int channel, int level) {
                     .speed_mode = mode,
                     .timer_num = timer,
                 };
-                check_esp_err(ledc_timer_config(&ledc_timer));
-                // Flag it unused
-                timers[mode][timer].freq = -1;
-                timers[mode][timer].duty_resolution = 0;
-                timers[mode][timer].clk_cfg = LEDC_AUTO_CLK;
+                ledc_timer_config(&ledc_timer);
+                unregister_timer(mode, timer);
             }
         }
 
         int pin = chans[mode][channel].pin;
         if (pin >= 0) {
             // Disable LEDC output, and set idle level
             check_esp_err(ledc_stop(mode, channel, level));
-            if (chans[mode][channel].light_sleep_enable) {
+            if (chans[mode][channel].lightsleep) {
                 // Enable SLP_SEL to change GPIO status automantically in lightsleep.
                 check_esp_err(gpio_sleep_sel_en(pin));
-                chans[mode][channel].light_sleep_enable = false;
+                chans[mode][channel].lightsleep = false;
             }
         }
         unregister_channel(mode, channel);
@@ -216,9 +218,10 @@ static int duty_to_ns(machine_pwm_obj_t *self, int duty) {
     return ((int64_t)duty * 1000000000LL + (int64_t)self->freq * (int64_t)(MAX_16_DUTY / 2)) / ((int64_t)self->freq * (int64_t)MAX_16_DUTY);
 }
 
-// Reconfigure PWM pin output as input/output. This allows to read the pin level.
+// Reconfigure PWM pin output as input/output.
 static void reconfigure_pin(machine_pwm_obj_t *self) {
     #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 0)
+    // This allows to read the pin level.
     gpio_set_direction(self->pin, GPIO_MODE_INPUT_OUTPUT);
     #endif
     esp_rom_gpio_connect_out_signal(self->pin, ledc_periph_signal[self->mode].sig_out0_idx + self->channel, self->output_invert, 0);
@@ -259,10 +262,10 @@ static void apply_duty(machine_pwm_obj_t *self) {
         check_esp_err(ledc_update_duty(self->mode, self->channel));
         #endif
     }
-    if (self->light_sleep_enable) {
+    if (self->lightsleep) {
         // Disable SLP_SEL to change GPIO status automantically in lightsleep.
         check_esp_err(gpio_sleep_sel_dis(self->pin));
-        chans[self->mode][self->channel].light_sleep_enable = true;
+        chans[self->mode][self->channel].lightsleep = true;
     }
     register_channel(self->mode, self->channel, self->pin, self->timer);
 }
@@ -360,6 +363,16 @@ static ledc_clk_cfg_t find_clock_in_use() {
     }
     return LEDC_AUTO_CLK;
 }
+
+// Check if a timer is already set with a different clock source
+static bool is_timer_with_different_clock(int mode, int current_timer, ledc_clk_cfg_t clk_cfg) {
+    for (int timer = 0; timer < LEDC_TIMER_MAX; ++timer) {
+        if ((timer != current_timer) && (clk_cfg != LEDC_AUTO_CLK) && (timers[mode][timer].clk_cfg != LEDC_AUTO_CLK) && (timers[mode][timer].clk_cfg != clk_cfg)) {
+            return true;
+        }
+    }
+    return false;
+}
 #endif
 
 static void check_freq_ranges(machine_pwm_obj_t *self, int freq, int upper_freq) {
@@ -371,9 +384,7 @@ static void check_freq_ranges(machine_pwm_obj_t *self, int freq, int upper_freq)
 // Set timer frequency
 static void set_freq(machine_pwm_obj_t *self, unsigned int freq) {
     self->freq = freq;
-    if (timers[self->mode][self->timer].freq != freq) {
-        timers[self->mode][self->timer].freq = freq;
-
+    if ((timers[self->mode][self->timer].freq != freq) || (self->lightsleep)) {
         ledc_timer_config_t timer = {};
         timer.speed_mode = self->mode;
         timer.timer_num = self->timer;
@@ -382,7 +393,7 @@ static void set_freq(machine_pwm_obj_t *self, unsigned int freq) {
 
         timer.clk_cfg = LEDC_AUTO_CLK;
 
-        if (self->light_sleep_enable) {
+        if (self->lightsleep) {
             timer.clk_cfg = LEDC_USE_RC_FAST_CLK; // 8 or 20 MHz
         } else {
             #if SOC_LEDC_SUPPORT_APB_CLOCK
@@ -402,9 +413,9 @@ static void set_freq(machine_pwm_obj_t *self, unsigned int freq) {
             #endif
         }
         #if !(CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2)
-        // Check for clock source conflic
-        ledc_clk_cfg_t pwm_clk = find_clock_in_use();
-        if ((pwm_clk != LEDC_AUTO_CLK) && (pwm_clk != timer.clk_cfg)) {
+        // Check for clock source conflict
+        ledc_clk_cfg_t clk_cfg = find_clock_in_use();
+        if ((clk_cfg != LEDC_AUTO_CLK) && (clk_cfg != timer.clk_cfg)) {
             mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("one or more active timers use a different clock source, not supported by the current SoC."));
         }
         #endif
@@ -426,6 +437,7 @@ static void set_freq(machine_pwm_obj_t *self, unsigned int freq) {
         if (self->mode == LEDC_LOW_SPEED_MODE) {
             check_esp_err(ledc_timer_rst(self->mode, self->timer));
         }
+        timers[self->mode][self->timer].freq = freq;
         timers[self->mode][self->timer].duty_resolution = timer.duty_resolution;
         timers[self->mode][self->timer].clk_cfg = timer.clk_cfg;
     }
@@ -454,7 +466,7 @@ static void find_channel(machine_pwm_obj_t *self, int *ret_mode, int *ret_channe
     // Try to find self channel first
     for (int mode = 0; mode < LEDC_SPEED_MODE_MAX; ++mode) {
         #if SOC_LEDC_SUPPORT_HS_MODE
-        if (self->light_sleep_enable && (mode == LEDC_HIGH_SPEED_MODE)) {
+        if (self->lightsleep && (mode == LEDC_HIGH_SPEED_MODE)) {
             continue;
         }
         #endif
@@ -469,7 +481,7 @@ static void find_channel(machine_pwm_obj_t *self, int *ret_mode, int *ret_channe
     // Find free channel
     for (int mode = 0; mode < LEDC_SPEED_MODE_MAX; ++mode) {
         #if SOC_LEDC_SUPPORT_HS_MODE
-        if (self->light_sleep_enable && (mode == LEDC_HIGH_SPEED_MODE)) {
+        if (self->lightsleep && (mode == LEDC_HIGH_SPEED_MODE)) {
             continue;
         }
         #endif
@@ -487,7 +499,7 @@ static void find_channel(machine_pwm_obj_t *self, int *ret_mode, int *ret_channe
 static void find_timer(machine_pwm_obj_t *self, int freq, int *ret_mode, int *ret_timer) {
     for (int mode = 0; mode < LEDC_SPEED_MODE_MAX; ++mode) {
         #if SOC_LEDC_SUPPORT_HS_MODE
-        if (self->light_sleep_enable && (mode == LEDC_HIGH_SPEED_MODE)) {
+        if (self->lightsleep && (mode == LEDC_HIGH_SPEED_MODE)) {
             continue;
         }
         #endif
@@ -505,7 +517,7 @@ static void find_timer(machine_pwm_obj_t *self, int freq, int *ret_mode, int *re
 
 // Try to find a timer with the same frequency in the current mode, otherwise in the next mode.
 // If no existing timer and channel was found, then try to find free timer in any mode.
-// If the mode or channel is changed, release the channel and select(bind) a new channel in the next mode.
+// If the mode or channel is changed, release the channel and register a new channel in the next mode.
 static void select_timer(machine_pwm_obj_t *self, int freq) {
     // mode, channel, timer may be -1(not defined) or actual values
     int mode = -1;
@@ -526,16 +538,21 @@ static void select_timer(machine_pwm_obj_t *self, int freq) {
         }
     }
     if (timer < 0) {
-        mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("out of %sPWM timers:%d"), self->light_sleep_enable ? "light sleep capable " : "", self->light_sleep_enable ? LEDC_TIMER_MAX : LEDC_SPEED_MODE_MAX *LEDC_TIMER_MAX);
+        mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("out of %sPWM timers:%d"), self->lightsleep ? "light sleep capable " : "", self->lightsleep ? LEDC_TIMER_MAX : LEDC_SPEED_MODE_MAX *LEDC_TIMER_MAX);
     }
-    // If the timer is found, then bind
+    // If the timer is found, then register
     if (self->timer != timer) {
         unregister_channel(self->mode, self->channel);
-        // Bind the channel to the timer
+        // Rregister the channel to the timer
         self->mode = mode;
         self->timer = timer;
         register_channel(self->mode, self->channel, -1, self->timer);
     }
+    #if !(CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2)
+    if (is_timer_with_different_clock(self->mode, self->timer, timers[self->mode][self->timer].clk_cfg)) {
+        mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("one or more active timers use a different clock source, not supported by the current SoC."));
+    }
+    #endif
 }
 
 static void set_freq_duty(machine_pwm_obj_t *self, unsigned int freq) {
@@ -560,17 +577,47 @@ static void mp_machine_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_p
             mp_printf(print, ", duty_u16=%d", get_duty_u16(self));
         }
         if (self->output_invert) {
-            mp_printf(print, ", invert=%s", self->output_invert ? "True" : "False");
+            mp_printf(print, ", invert=True");
         }
-        if (self->light_sleep_enable) {
-            mp_printf(print, ", light_sleep_enable=True");
+        if (self->lightsleep) {
+            mp_printf(print, ", lightsleep=True");
         }
         mp_printf(print, ")");
 
         #if MICROPY_ERROR_REPORTING > MICROPY_ERROR_REPORTING_NORMAL
         mp_printf(print, "  # duty=%.2f%%", 100.0 * get_duty_u16(self) / MAX_16_DUTY);
         mp_printf(print, ", raw_duty=%d, resolution=%d", ledc_get_duty(self->mode, self->channel), timers[self->mode][self->timer].duty_resolution);
         mp_printf(print, ", mode=%d, timer=%d, channel=%d", self->mode, self->timer, self->channel);
+        int clk_cfg = timers[self->mode][self->timer].clk_cfg;
+        mp_printf(print, ", clk_cfg=%d=", clk_cfg);
+        if (clk_cfg == LEDC_USE_RC_FAST_CLK) {
+            mp_printf(print, "RC_FAST_CLK");
+        }
+        #if SOC_LEDC_SUPPORT_APB_CLOCK
+        else if (clk_cfg == LEDC_USE_APB_CLK) {
+            mp_printf(print, "APB_CLK");
+        }
+        #endif
+        #if SOC_LEDC_SUPPORT_XTAL_CLOCK
+        else if (clk_cfg == LEDC_USE_XTAL_CLK) {
+            mp_printf(print, "XTAL_CLK");
+        }
+        #endif
+        #if SOC_LEDC_SUPPORT_REF_TICK
+        else if (clk_cfg == LEDC_USE_REF_TICK) {
+            mp_printf(print, "REF_TICK");
+        }
+        #endif
+        #if SOC_LEDC_SUPPORT_PLL_DIV_CLOCK
+        else if (clk_cfg == LEDC_USE_PLL_DIV_CLK) {
+            mp_printf(print, "PLL_CLK");
+        }
+        #endif
+        else if (clk_cfg == LEDC_AUTO_CLK) {
+            mp_printf(print, "AUTO_CLK");
+        } else {
+            mp_printf(print, "UNKNOWN");
+        }
         #endif
     } else {
         mp_printf(print, ")");
@@ -587,20 +634,20 @@ static void mp_machine_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_p
 static void mp_machine_pwm_init_helper(machine_pwm_obj_t *self,
     size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
 
-    enum { ARG_freq, ARG_duty, ARG_duty_u16, ARG_duty_ns, ARG_invert, ARG_light_sleep_enable };
+    enum { ARG_freq, ARG_duty, ARG_duty_u16, ARG_duty_ns, ARG_invert, ARG_lightsleep };
     mp_arg_t allowed_args[] = {
         { MP_QSTR_freq, MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_duty, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_duty_u16, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_duty_ns, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_invert, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = self->output_invert} },
-        { MP_QSTR_light_sleep_enable, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = self->light_sleep_enable} },
+        { MP_QSTR_lightsleep, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = self->lightsleep} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args,
         MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    self->light_sleep_enable = args[ARG_light_sleep_enable].u_bool;
+    self->lightsleep = args[ARG_lightsleep].u_bool;
 
     int freq = args[ARG_freq].u_int;
     if (freq != -1) {
@@ -628,7 +675,7 @@ static void mp_machine_pwm_init_helper(machine_pwm_obj_t *self,
     int channel = -1;
     find_channel(self, &mode, &channel, freq);
     if (channel < 0) {
-        mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("out of %sPWM channels:%d"), self->light_sleep_enable ? "light sleep capable " : "", self->light_sleep_enable ? LEDC_CHANNEL_MAX : LEDC_SPEED_MODE_MAX *LEDC_CHANNEL_MAX);
+        mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("out of %sPWM channels:%d"), self->lightsleep ? "light sleep capable " : "", self->lightsleep ? LEDC_CHANNEL_MAX : LEDC_SPEED_MODE_MAX *LEDC_CHANNEL_MAX);
     }
     self->mode = mode;
     self->channel = channel;
@@ -659,7 +706,7 @@ static void self_reset(machine_pwm_obj_t *self) {
     self->channel_duty = -1;
     self->output_invert = false;
     self->output_invert_prev = false;
-    self->light_sleep_enable = false;
+    self->lightsleep = false;
 }
 
 // This called from PWM() constructor
