PWM for nRF52 full debuged.

Author: nvlsianpu

hal/targets/hal/TARGET_NORDIC/TARGET_NRF5/TARGET_MCU_NRF52832/pwmout_api.c

@@ -47,44 +47,51 @@
 #include "app_util_platform.h"
 #include "nrf_drv_pwm.h"
 
+
+#define MAX_PWM_PERIOD_US   (0x7FFF << 3)                       // -> 7FFF (1_us/16) * 128
+#define MAX_PWM_PERIOD_MS   ((MAX_PWM_PERIOD_US / 1000) + 1)    // approximations advance
+#define MAX_PWM_PERIOD_S    ((MAX_PWM_PERIOD_US / 1000000) + 1) // approximations advance
+
 #define PWM_INSTANCE_COUNT  3
 
+///> instances of nRF52 PWM driver
 static nrf_drv_pwm_t m_pwm_driver[PWM_INSTANCE_COUNT] =
-    {
-        NRF_DRV_PWM_INSTANCE(0),
-        NRF_DRV_PWM_INSTANCE(1),
-        NRF_DRV_PWM_INSTANCE(2)
-    };
+{
+    NRF_DRV_PWM_INSTANCE(0),
+    NRF_DRV_PWM_INSTANCE(1),
+    NRF_DRV_PWM_INSTANCE(2)
+};
 
 typedef struct
 {
     uint32_t period_us;
     uint32_t duty_us;
     float    duty;
-} pwm_signal_t;
+} pwm_signal_t; /// PWM signal description type
 
 typedef struct
 {
     nrf_drv_pwm_t * p_pwm_driver;
     pwm_signal_t signal;
-} pwm_t;
+    volatile nrf_pwm_values_common_t seq_values[1];
+} pwm_t; /// internal PWM instance support type
 
 static pwm_t m_pwm[PWM_INSTANCE_COUNT] =
 {
     {.p_pwm_driver = NULL},
     {.p_pwm_driver = NULL},
     {.p_pwm_driver = NULL}
-};
+};  /// Array of internal PWM instances.
 
 typedef struct
 {
-    uint16_t period;
-    uint16_t duty;
+    uint16_t period_hwu;
+    uint16_t duty_hwu;
     nrf_pwm_clk_t  pwm_clk;
-} pulsewidth_set_t;    
+} pulsewidth_set_t; /// helper type for timing calculations
 
 
-static void internal_pwmout_exe(pwmout_t *obj);
+static void internal_pwmout_exe(pwmout_t *obj, bool new_period);
 
 void pwmout_init(pwmout_t *obj, PinName pin)
 {
@@ -95,17 +102,17 @@ void pwmout_init(pwmout_t *obj, PinName pin)
         if (m_pwm[i].p_pwm_driver == NULL) // a driver instance not assigned to the obj?
         {
             obj->pin         = pin;
-            /// @todo obj->pwm_name = 
+            
             obj->pwm_channel = i;
 
             m_pwm[i].p_pwm_driver = &m_pwm_driver[i];
-            m_pwm[i].signal.period_us = 100000; // 0.02 s
-            m_pwm[i].signal.duty_us   = 50000;
+            m_pwm[i].signal.period_us = 200000; // 0.02 s
+            m_pwm[i].signal.duty_us   = 100000;
             m_pwm[i].signal.duty      = (0.5);
 
             obj->pwm_struct  = &m_pwm[i];
 
-            internal_pwmout_exe(obj);
+            internal_pwmout_exe(obj, true);
 
             break;
         }
@@ -119,7 +126,6 @@ void pwmout_free(pwmout_t *obj)
     nrf_drv_pwm_uninit( (nrf_drv_pwm_t*) obj->pwm_struct );
 
     m_pwm[obj->pwm_channel].p_pwm_driver = NULL;
-    /// @todo release gpio
 }
 
 void pwmout_write(pwmout_t *obj, float percent)
@@ -152,54 +158,112 @@ float pwmout_read(pwmout_t *obj)
 
 void pwmout_period(pwmout_t *obj, float seconds)
 {
-    // @todo saturation
+    // raught saturation < 0, quasi-max>
+    if (seconds > MAX_PWM_PERIOD_S)
+    {
+        seconds = MAX_PWM_PERIOD_S;
+    }
+    else if (seconds < 0)
+    {
+        seconds = 0; // f. pwmout_period_us will set period to min. value
+    }
+    
     int us = seconds * 1000000;
 
     pwmout_period_us(obj, us);
 }
 
 void pwmout_period_ms(pwmout_t *obj, int ms)
 {
+    // reught saturation < 0, quasi-max>
+    if (ms > MAX_PWM_PERIOD_MS)
+    {
+        ms = MAX_PWM_PERIOD_MS;
+    }
+    else if (ms < 0)
+    {
+        ms = 0; // f. pwmout_period_us will set period to min. value
+    }
+    
     int us = ms * 1000;
 
     pwmout_period_us(obj, us);
 }
 
+
 void pwmout_period_us(pwmout_t *obj, int us)
 {
     pwm_signal_t * p_pwm_signal = &(((pwm_t*)obj->pwm_struct)->signal);
 
+    // saturation <1, real-max>
+    if (us > MAX_PWM_PERIOD_US)
+    {
+        us = MAX_PWM_PERIOD_US;
+    }
+    else if (us < 1)
+    {
+        us = 1;
+    }
+    
     p_pwm_signal->duty_us = (int)((float)us * p_pwm_signal->duty);
 
     p_pwm_signal->period_us  = us;
 
-    internal_pwmout_exe(obj);
+    internal_pwmout_exe(obj, true);
 }
 
 void pwmout_pulsewidth(pwmout_t *obj, float seconds)
 {
-    // @todo saturation
+    // raught saturation < 0, quasi-max>
+    if (seconds > MAX_PWM_PERIOD_S)
+    {
+        seconds = MAX_PWM_PERIOD_S;
+    }
+    else if (seconds < 0)
+    {
+        seconds = 0;
+    }
+    
     int us = seconds * 1000000;
 
     pwmout_pulsewidth_us(obj,us);
 }
 
 void pwmout_pulsewidth_ms(pwmout_t *obj, int ms)
 {
-    // @todo saturation
+    // raught saturation < 0, quasi-max>
+    if (ms > MAX_PWM_PERIOD_MS)
+    {
+        ms = MAX_PWM_PERIOD_MS;
+    }
+    else if (ms < 0)
+    {
+        ms = 0;
+    }
+    
     int us = ms * 1000;
 
-    pwmout_pulsewidth_us(obj,us);
+    pwmout_pulsewidth_us(obj, us);
 }
 
 void pwmout_pulsewidth_us(pwmout_t *obj, int us)
 {
-    // @todo saturation
+    // saturation <0, real-max>
+    if (us > MAX_PWM_PERIOD_US)
+    {
+        us = MAX_PWM_PERIOD_US;
+    }
+    else if (us < 0)
+    {
+        us = 0;
+    }
+    
     pwm_signal_t * p_pwm_signal = &(((pwm_t*)obj->pwm_struct)->signal);
 
     p_pwm_signal->duty_us  = us;
+    p_pwm_signal->duty     = us / p_pwm_signal->period_us;
 
-    internal_pwmout_exe(obj);
+    internal_pwmout_exe(obj, false);
 }
 
 
@@ -209,15 +273,15 @@ void pwmout_pulsewidth_us(pwmout_t *obj, int us)
 
 static ret_code_t pulsewidth_us_set_get(int period_us, int duty_us, pulsewidth_set_t * const p_settings)
 {
-    uint16_t div;
+    uint16_t      div;
     nrf_pwm_clk_t pwm_clk = NRF_PWM_CLK_16MHz;
 
     for(div = 1; div <= 128 ; div <<= 1) 
     {
         if (0x7FFF >= period_us)
         {
-            p_settings->period  = period_us; // unit [us * div]
-            p_settings->duty = duty_us;       // unit [us * div]
+            p_settings->period_hwu  = period_us; // unit [us/16 * div]
+            p_settings->duty_hwu = duty_us;       // unit [us/16 * div]
             p_settings->pwm_clk   = pwm_clk;
 
             return NRF_SUCCESS;
@@ -231,63 +295,59 @@ static ret_code_t pulsewidth_us_set_get(int period_us, int duty_us, pulsewidth_s
     return NRF_ERROR_INVALID_PARAM;
 }
 
-        static volatile nrf_pwm_values_common_t seq_values[1];
-        
-        static nrf_pwm_sequence_t const seq =
-        {
-            .values.p_common = seq_values,
-            .length          = NRF_PWM_VALUES_LENGTH(seq_values),
-            .repeats         = 0,
-            .end_delay       = 0
-        };
 
-static void internal_pwmout_exe(pwmout_t *obj)
+static void internal_pwmout_exe(pwmout_t *obj, bool new_period)
 {
-    pulsewidth_set_t pulsewidth_set;
-    pwm_signal_t   * p_pwm_signal;
-    nrf_drv_pwm_t *p_pwm_driver;
-    ret_code_t ret_code;
+    pulsewidth_set_t          pulsewidth_set;
+    pwm_signal_t            * p_pwm_signal;
+    nrf_drv_pwm_t           * p_pwm_driver;
+    ret_code_t                ret_code;
 
     p_pwm_signal = &(((pwm_t*)obj->pwm_struct)->signal);
 
     if (NRF_SUCCESS == pulsewidth_us_set_get(p_pwm_signal->period_us * 16,
                                              p_pwm_signal->duty_us * 16,
                                              &pulsewidth_set))
     {
-        //@todo apply pulsewidth_set
         p_pwm_driver = (((pwm_t*)obj->pwm_struct)->p_pwm_driver);
 
-        nrf_drv_pwm_config_t config0 =
+        nrf_pwm_sequence_t seq =
         {
-            .output_pins =
-            {
-                obj->pin,                 // channel 0
-                NRF_DRV_PWM_PIN_NOT_USED, // channel 1
-                NRF_DRV_PWM_PIN_NOT_USED, // channel 2
-                NRF_DRV_PWM_PIN_NOT_USED, // channel 3
-            },
-            .irq_priority = APP_IRQ_PRIORITY_LOW,
-            .base_clock   = pulsewidth_set.pwm_clk,
-            .count_mode   = NRF_PWM_MODE_UP,
-            .top_value    = pulsewidth_set.period,
-            .load_mode    = NRF_PWM_LOAD_COMMON,
-            .step_mode    = NRF_PWM_STEP_AUTO
+            .values.p_common = (nrf_pwm_values_common_t*) (((pwm_t*)obj->pwm_struct)->seq_values),
+            .length          = 1,
+            .repeats         = 0,
+            .end_delay       = 0
         };
 
+        (((pwm_t*)obj->pwm_struct)->seq_values)[0] = pulsewidth_set.duty_hwu | 0x8000;
 
-        //printf("clock = %d, top = %d\r\n", pulsewidth_set.pwm_clk, pulsewidth_set.period);
-        
-        nrf_drv_pwm_uninit(p_pwm_driver);
-        
-        ret_code = nrf_drv_pwm_init( p_pwm_driver, &config0, NULL);
-        
-        MBED_ASSERT(ret_code == NRF_SUCCESS); // assert if free instance was not found.
+        if (new_period)
+        {
+            nrf_drv_pwm_config_t config0 =
+            {
+                .output_pins =
+                {
+                    obj->pin | NRF_DRV_PWM_PIN_INVERTED, // channel 0
+                    NRF_DRV_PWM_PIN_NOT_USED,            // channel 1
+                    NRF_DRV_PWM_PIN_NOT_USED,            // channel 2
+                    NRF_DRV_PWM_PIN_NOT_USED,            // channel 3
+                },
+                .irq_priority = APP_IRQ_PRIORITY_LOW,
+                .base_clock   = pulsewidth_set.pwm_clk,
+                .count_mode   = NRF_PWM_MODE_UP,
+                .top_value    = pulsewidth_set.period_hwu,
+                .load_mode    = NRF_PWM_LOAD_COMMON,
+                .step_mode    = NRF_PWM_STEP_AUTO
+            };
+            
+            nrf_drv_pwm_uninit(p_pwm_driver);
 
-        seq_values[0] = pulsewidth_set.duty;
+            ret_code = nrf_drv_pwm_init( p_pwm_driver, &config0, NULL);
 
-        nrf_drv_pwm_simple_playback(p_pwm_driver, &seq, 0, NRF_DRV_PWM_FLAG_LOOP);
+            MBED_ASSERT(ret_code == NRF_SUCCESS); // assert if free instance was not found.
+        }
 
-        
+        nrf_drv_pwm_simple_playback(p_pwm_driver, &seq, 0, NRF_DRV_PWM_FLAG_LOOP);
     }
     else
     {