Initial pwmout_period implementation

Author: multiplemonomials

targets/TARGET_Ambiq_Micro/TARGET_Apollo3/device/objects_pwm.h

@@ -83,18 +83,24 @@ typedef enum {
 } PWMName;
 
 // Get the CTIMER number of a PWM
-#define APOLLO3_PWMNAME_GET_CTIMER(pwmName) (pwmName >> 2)
+#define APOLLO3_PWMNAME_GET_CTIMER(pwm_name) (pwm_name >> 2)
 
 // Convert from PWM name to AM_HAL_CTIMER_TIMERA/AM_HAL_CTIMER_TIMERB macro
-#define APOLLO3_PWMNAME_GET_SEGMENT(pwmName) (pwmName & 0b10 ? AM_HAL_CTIMER_TIMERB : AM_HAL_CTIMER_TIMERA)
+#define APOLLO3_PWMNAME_GET_SEGMENT(pwm_name) (pwm_name & 0b10 ? AM_HAL_CTIMER_TIMERB : AM_HAL_CTIMER_TIMERA)
 
 // Convert from PWM name to AM_HAL_CTIMER_OUTPUT_NORMAL/AM_HAL_CTIMER_OUTPUT_SECONDARY enum value
-#define APOLLO3_PWMNAME_GET_OUTPUT(pwmName) (pwmName & 0b1 ? AM_HAL_CTIMER_OUTPUT_SECONDARY : AM_HAL_CTIMER_OUTPUT_NORMAL)
+#define APOLLO3_PWMNAME_GET_OUTPUT(pwm_name) (pwm_name & 0b1 ? AM_HAL_CTIMER_OUTPUT_SECONDARY : AM_HAL_CTIMER_OUTPUT_NORMAL)
 
 struct pwmout_s
 {
     // PWM name that this channel is using
-    PWMName pwmName;
+    PWMName pwm_name;
+
+    // Clock period configured on this PWM, in floating point seconds
+    float clock_period;
+
+    // Number of counts that the PWM output will make before a new PWM cycle starts
+    uint32_t top_count;
 };
 
 #ifdef __cplusplus

targets/TARGET_Ambiq_Micro/TARGET_Apollo3/device/pwmout_api.c

@@ -23,6 +23,7 @@
 #include "pinmap.h"
 #include "objects.h"
 #include "mbed_assert.h"
+#include <mbed_error.h>
 
 #include <math.h>
 
@@ -48,8 +49,8 @@ struct pwm_clock_freq {
 // - LFRC - internal low freq RC oscillator, 1.024kHz +-32% (no that's not a typo!)
 // This means we have quite a wide range of base clock frequencies available, though period accuracy will be pretty
 // poor if the LFRC gets selected.
-#define NUM_CLOCK_OPTIONS 16
-static const struct pwm_clock_freq pwm_clocks[NUM_CLOCK_OPTIONS] = {
+#define NUM_CLOCK_SOURCE_OPTIONS 16
+static const struct pwm_clock_freq pwm_clock_sources[NUM_CLOCK_SOURCE_OPTIONS] = {
     {AM_HAL_CTIMER_HFRC_12MHZ, 12000000},
     {AM_HAL_CTIMER_HFRC_3MHZ, 3000000},
     {AM_HAL_CTIMER_HFRC_187_5KHZ, 187500},
@@ -73,63 +74,8 @@ static const struct pwm_clock_freq pwm_clocks[NUM_CLOCK_OPTIONS] = {
 };
 
 /// Largest top count value supported by hardware.  Using this value will provide the highest duty cycle resolution.
-const uint16_t MAX_TOP_COUNT = 65534;
-
-
-
-/// Calculate the effective PWM period (in floating point seconds) based on a divider and top_count value
-static float calc_effective_pwm_period(float divider, uint16_t top_count)
-{
-    // Note: The hardware counts to top_count *inclusively*, so we have to add 1
-    // to get the number of clock cycles that a given top_count value will produce
-    return 1.0f / ((clock_get_hz(clk_sys) / divider) / (top_count + 1));
-}
-
-/// Calculate the best possible top_count value (rounding up) for a divider and a desired pwm period
-static uint16_t calc_top_count_for_period(float divider, float desired_pwm_period)
-{
-    // Derivation:
-    // desired_pwm_period = 1.0f / ((clock_get_hz(clk_sys) / divider) / (top_count + 1))
-    // desired_pwm_period = (top_count + 1) / (clock_get_hz(clk_sys) / divider)
-    // desired_pwm_period * (clock_get_hz(clk_sys) / divider) - 1 = top_count
-
-    long top_count_float = lroundf(desired_pwm_period * (clock_get_hz(clk_sys) / divider) - 1);
-    MBED_ASSERT(top_count_float <= MAX_TOP_COUNT);
-    return (uint16_t)top_count_float;
-}
-
-/// Calculate the best possible floating point divider value for a desired pwm period.
-/// This function assumes that top_count is set to MAX_TOP_COUNT.
-static float calc_divider_for_period(float desired_pwm_period)
-{
-    // Derivation:
-    // (desired_pwm_period * clock_get_hz(clk_sys)) / divider - 1 = top_count
-    // (desired_pwm_period * clock_get_hz(clk_sys)) / divider = top_count + 1
-    // divider = (desired_pwm_period * clock_get_hz(clk_sys)) / (top_count + 1)
-
-    return (desired_pwm_period * clock_get_hz(clk_sys)) / (MAX_TOP_COUNT + 1);
-}
-
-/// Convert PWM divider from floating point to a fixed point number (rounding up).
-/// The divider is returned as an 8.4 bit fixed point number, which is what the Pico registers use.
-static uint16_t pwm_divider_float_to_fixed(float divider_float)
-{
-    // To convert to a fixed point number, multiply by 16 and then round up
-    uint16_t divider_exact = ceil(divider_float * 16);
-
-    // Largest supported divider is 255 and 15/16
-    if(divider_exact > 0xFFF)
-    {
-        divider_exact = 0xFFF;
-    }
-    return divider_exact;
-}
-
-/// Convert PWM divider from the fixed point hardware value (8.4 bits) to a float.
-static float pwm_divider_fixed_to_float(uint16_t divider_fixed)
-{
-    return divider_fixed / 16.0f;
-}
+/// The hardware performs (CMPR register value + 1) counts and it's a 16-bit register, so the actual max top count is 2^16.
+const uint32_t MAX_TOP_COUNT = 65536;
 
 void pwmout_init(pwmout_t *obj, PinName pin)
 {
@@ -139,7 +85,7 @@ void pwmout_init(pwmout_t *obj, PinName pin)
     const PWMName pwmName = pinmap_peripheral(pin, PinMap_PWM_OUT);
 
     /* Populate PWM object with values. */
-    obj->pwmName = pwmName;
+    obj->pwm_name = pwmName;
 
     // Configure the pin
     am_hal_ctimer_output_config(APOLLO3_PWMNAME_GET_CTIMER(pwmName),
@@ -206,87 +152,80 @@ float pwmout_read(pwmout_t *obj)
 void pwmout_period(pwmout_t *obj, const float desired_period)
 {
     // To find the period, we perform the following steps:
-    // - Determine the slowest clock frequency that we can use while still hitting the needed period
+    // - Determine the fastest clock frequency that we can use while still hitting the needed period
     // - Calculate the correct top_count value that will produce as close to the desired period as possible
-
-
-    if(period <= calc_effective_pwm_period(1, MAX_TOP_COUNT))
-    {
-        // Short period.  Leave divider at 1 and reduce top_count to match the expected period
-        obj->clock_divider = 1.0f;
-        obj->cfg.div = PWM_CHn_DIV_1;
-        obj->top_count = calc_top_count_for_period(obj->clock_divider, period);
+    // - Write the new top_count value into the hardware
+
+    size_t clk_source_idx;
+    bool found_clk_source = false;
+    for(clk_source_idx = 0; clk_source_idx < NUM_CLOCK_SOURCE_OPTIONS; ++clk_source_idx) {
+        const float divider_max_period = MAX_TOP_COUNT / (float)pwm_clock_sources[clk_source_idx].frequency;
+        if(divider_max_period >= desired_period) {
+            found_clk_source = true;
+            break;
+        }
+    }
+    if(!found_clk_source) {
+        MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_DRIVER_PWM, MBED_ERROR_CODE_INVALID_ARGUMENT), "Clock frequency too slow!");
     }
-    else
-    {
-        // Long period, need to use divider.
-
-        // Step 1: Calculate exact desired divider such that top_count would equal MAX_TOP_COUNT
-        float desired_divider = calc_divider_for_period(period);
-
-        // Step 2: Round desired divider upwards to the next value the hardware can do.
-        // We go upwards so that the top_count value can be trimmed downwards for the best period accuracy.
-        uint16_t divider_fixed_point = pwm_divider_float_to_fixed(desired_divider);
-        obj->cfg.div = divider_fixed_point;
-
-        // Step 3: Get the divider we'll actually be using as a float
-        obj->clock_divider = pwm_divider_fixed_to_float(divider_fixed_point);
 
-        // Step 4: For best accuracy, recalculate the top_count value using the divider.
-        obj->top_count = calc_top_count_for_period(obj->clock_divider, period);
+    // Now that we have found the best clock source, calculate top_count to hit the desired period
+    obj->clock_period = 1.0f / (float)pwm_clock_sources[clk_source_idx].frequency;
+    obj->top_count = lroundf(desired_period / obj->clock_period);
 
-#if APOLLO3_PWMOUT_DEBUG
-        printf("period = %f, desired_divider = %f\n",
-               period,
-               desired_divider);
-#endif
+    // The hardware cannot support a top_count of less than 2. If that happened than it means the
+    // frequency is too fast.
+    if(obj->top_count < 2) {
+        MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_DRIVER_PWM, MBED_ERROR_CODE_INVALID_ARGUMENT), "Clock frequency too fast!");
     }
 
-    // Save period for later
-    obj->period = period;
-
 #if APOLLO3_PWMOUT_DEBUG
-    printf("obj->clock_divider = %f, obj->cfg.div = %" PRIu32 ", obj->top_count = %" PRIu16 "\n",
-           obj->clock_divider,
-           obj->cfg.div,
+    printf("clk_source_idx = %zu, obj->clock_period = %f, obj->top_count = %" PRIu32 "\n",
+           clk_source_idx,
+           obj->clock_period,
            obj->top_count);
 #endif
 
-    // Set the new divider and top_count values.
-    pwm_config_set_wrap(&(obj->cfg), obj->top_count);
-    pwm_init(obj->slice, &(obj->cfg), false);
+    // Set new clock source. This stops the timer.
+    am_hal_ctimer_config_single(APOLLO3_PWMNAME_GET_CTIMER(obj->pwm_name),
+        APOLLO3_PWMNAME_GET_SEGMENT(obj->pwm_name),
+        AM_HAL_CTIMER_FN_PWM_REPEAT | clk_source_idx);
+
+    // Set new period value. Note that:
+    // - We need to program a value of (top_count - 1) into the HW register
+    // - As part of setting the period we also need to program the duty cycle. For now we program it to zero,
+    //   in anticipation of a future pwmout_write() call
+    if(APOLLO3_PWMNAME_GET_OUTPUT(obj->pwm_name) == AM_HAL_CTIMER_OUTPUT_NORMAL) {
+        am_hal_ctimer_period_set(APOLLO3_PWMNAME_GET_CTIMER(obj->pwm_name),
+            APOLLO3_PWMNAME_GET_SEGMENT(obj->pwm_name),
+            obj->top_count - 1,
+            0);
+    }
+    else {
+        am_hal_ctimer_aux_period_set(APOLLO3_PWMNAME_GET_CTIMER(obj->pwm_name),
+            APOLLO3_PWMNAME_GET_SEGMENT(obj->pwm_name),
+            obj->top_count - 1,
+            0);
+    }
+
+    am_hal_ctimer_start(APOLLO3_PWMNAME_GET_CTIMER(obj->pwm_name), APOLLO3_PWMNAME_GET_SEGMENT(obj->pwm_name));
 }
 
-/** Set the PWM period specified in miliseconds, keeping the duty cycle the same
- *
- * Parameter obj The pwmout object
- * Parameter ms  The milisecond period
- */
 void pwmout_period_ms(pwmout_t *obj, int period)
 {
     /* Set new period. */
     pwmout_period(obj, period / 1000.0f);
 }
 
-/** Set the PWM period specified in microseconds, keeping the duty cycle the same
- *
- * Parameter obj The pwmout object
- * Parameter us  The microsecond period
- */
 void pwmout_period_us(pwmout_t *obj, int period)
 {
     /* Set new period. */
     pwmout_period(obj, period / 1000000.0f);
 }
 
-/** Read the PWM period specified in microseconds
- *
- * @param obj The pwmout object
- * @return A int output period
- */
 int pwmout_read_period_us(pwmout_t *obj)
 {
-    return lroundf(1000000 * calc_effective_pwm_period(obj->clock_divider, obj->top_count));
+    return lroundf(1000000 * obj->top_count * obj->clock_period);
 }
 
 /** Set the PWM pulsewidth specified in seconds, keeping the period the same.