psoc6: Machine class func renames and pwm improvements.

Signed-off-by: jaenrig-ifx <[email protected]>

Author: jaenrig-ifx

ports/psoc6/machine_adcblock.c

@@ -314,7 +314,7 @@ static mp_obj_t machine_adcblock_connect(size_t n_pos_args, const mp_obj_t *pos_
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(machine_adcblock_connect_obj, 2, machine_adcblock_connect);
 
-void mod_adcblock_deinit(void) {
+void machine_adcblock_deinit_all(void) {
     for (uint8_t i = 0; i < MAX_BLOCKS; i++) {
         if (adc_block[i] != NULL) {
             machine_adcblock_deinit(adc_block[i]);

ports/psoc6/machine_adcblock.h

@@ -54,5 +54,5 @@ typedef struct
     uint32_t pin;
 }adc_block_channel_pin_map_t;
 
-void mod_adcblock_deinit(void);
+void machine_adcblock_deinit_all(void);
 #endif // MICROPY_INCLUDED_MACHINE_ADCBLOCK_H

ports/psoc6/machine_i2c.c

@@ -319,7 +319,7 @@ static mp_obj_t machine_i2c_slave_irq_disable(mp_obj_t self_in) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_slave_irq_disable_obj, machine_i2c_slave_irq_disable);
 
-void mod_i2c_deinit() {
+void machine_i2c_deinit_all() {
     for (uint8_t i = 0; i < MAX_I2C; i++) {
         if (i2c_obj[i] != NULL) {
             machine_i2c_deinit((mp_obj_base_t *)(i2c_obj[i]));

ports/psoc6/machine_pin.c

@@ -469,7 +469,7 @@ static mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_irq_obj, 1, machine_pin_irq);
 
-void mod_pin_deinit() {
+void machine_pin_deinit_all() {
     for (uint8_t i = 0; i < machine_pin_num_of_cpu_pins; i++) {
         if (pin_io[i] != NULL) {
             machine_pin_obj_deinit(pin_io[i]);

ports/psoc6/machine_pwm.c

@@ -24,13 +24,17 @@
  * THE SOFTWARE.
  */
 
-#include "py/runtime.h"
-#include "py/mphal.h"
-#include "modmachine.h"
+ #include "py/runtime.h"
+ #include "py/mphal.h"
+ #include "modmachine.h"
 
 // port-specific includes
-#include "machine_pin_phy.h"
-#include "mplogger.h"
+ #include "machine_pin_phy.h"
+ #include "mplogger.h"
+
+ #define pwm_assert_raise_val(msg, ret)   if (ret != CY_RSLT_SUCCESS) { \
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT(msg), ret); \
+}
 
 typedef struct _machine_pwm_obj_t {
     mp_obj_base_t base;
@@ -39,14 +43,12 @@ typedef struct _machine_pwm_obj_t {
     uint32_t fz;
     uint8_t duty_type;
     mp_int_t duty;
-    // bool invert;
 } machine_pwm_obj_t;
 
 static machine_pwm_obj_t *pwm_obj[MAX_PWM_OBJS] = { NULL };
 
 static inline machine_pwm_obj_t *pwm_obj_alloc() {
-    for (uint8_t i = 0; i < MAX_PWM_OBJS; i++)
-    {
+    for (uint8_t i = 0; i < MAX_PWM_OBJS; i++) {
         if (pwm_obj[i] == NULL) {
             pwm_obj[i] = mp_obj_malloc(machine_pwm_obj_t, &machine_pwm_type);
             return pwm_obj[i];
@@ -57,8 +59,7 @@ static inline machine_pwm_obj_t *pwm_obj_alloc() {
 }
 
 static inline void pwm_obj_free(machine_pwm_obj_t *pwm_obj_ptr) {
-    for (uint8_t i = 0; i < MAX_PWM_OBJS; i++)
-    {
+    for (uint8_t i = 0; i < MAX_PWM_OBJS; i++) {
         if (pwm_obj[i] == pwm_obj_ptr) {
             pwm_obj[i] = NULL;
         }
@@ -72,74 +73,83 @@ enum {
     DUTY_NS
 };
 
-static void mp_machine_pwm_freq_set(machine_pwm_obj_t *self, mp_int_t freq);
+/* Unit conversion macros */
+ #define pwm_duty_cycle_ns_to_u16(duty_ns, fz)       ((int)(((float)(duty_ns * fz) / (float)1000000000) * (float)65536) - 1)
+ #define pwm_duty_cycle_u16_to_ns(duty_u16, fz)      ((int)(((float)(duty_u16 + 1) / (float)65536) * ((float)1000000000 / (float)fz)))
+ #define pwm_duty_cycle_u16_to_percent(duty_u16)     ((float)((duty_u16) * 100) / (float)65535)
+ #define pwm_freq_to_period_us(fz)                   ((uint32_t)(1000000 / fz))
+ #define pwm_period_ns_to_us(period_ns)              ((uint32_t)(period_ns / 1000))
+
+static void pwm_duty_ns_assert(mp_int_t duty_ns, uint32_t fz) {
+    if (duty_ns > (int)(1000000000 / fz)) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM duty in ns is larger than the period %d ns"), (int)(1000000000 / fz));
+    }
+}
 
-static cy_rslt_t pwm_freq_duty_set(cyhal_pwm_t *pwm_obj, uint32_t fz, float duty_cycle) {
-    return cyhal_pwm_set_duty_cycle(pwm_obj, duty_cycle * 100, fz); // duty_cycle in percentage
+static inline void pwm_freq_duty_set(cyhal_pwm_t *pwm_obj, uint32_t fz, mp_int_t duty_cycle) {
+    cy_rslt_t ret = cyhal_pwm_set_duty_cycle(pwm_obj, pwm_duty_cycle_u16_to_percent(duty_cycle), fz);
+    pwm_assert_raise_val("PWM frequency and duty cycle set failed with return code %lx !", ret);
 }
 
-static inline cy_rslt_t pwm_duty_set_ns(cyhal_pwm_t *pwm_obj, uint32_t fz, uint32_t pulse_width) {
-    return cyhal_pwm_set_period(pwm_obj, 1000000 / fz, pulse_width / 1000); // !# * --> /
+static void pwm_duty_set_ns(cyhal_pwm_t *pwm_obj, uint32_t fz, uint32_t pulse_width) {
+    cy_rslt_t ret = cyhal_pwm_set_period(pwm_obj, pwm_freq_to_period_us(fz), pwm_period_ns_to_us(pulse_width));
+    pwm_assert_raise_val("PWM period set failed with return code %lx !", ret);
 }
 
-/*STATIC inline cy_rslt_t pwm_advanced_init(machine_pwm_obj_t *machine_pwm_obj) {
-    return cyhal_pwm_init_adv(&machine_pwm_obj->pwm_obj, machine_pwm_obj->pin, NC, CYHAL_PWM_LEFT_ALIGN, true, 0, true, NULL); // complimentary pin set as not connected
-}*/
+static void pwm_config(machine_pwm_obj_t *self) {
+    if (self->duty_type == DUTY_U16) {
+        pwm_freq_duty_set(&self->pwm_obj, self->fz, self->duty);
+    } else {
+        pwm_duty_set_ns(&self->pwm_obj, self->fz, self->duty);
+    }
+}
 
 static void mp_machine_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     machine_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_printf(print, "frequency=%u duty_cycle=%f", self->fz, (double)self->duty);
+    mp_obj_t pin = mp_obj_new_int(self->pin);
+    const char *pin_name = mp_obj_str_get_str(pin_name_by_addr(pin));
+    mp_printf(print, "PWM(\"%s\",freq=%u, duty_u16=%f)", pin_name, self->fz, (double)self->duty);
 }
 
 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_u16, ARG_duty_ns};
-    // enum { ARG_freq, ARG_duty_u16, ARG_duty_ns, ARG_invert };
+
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_freq,     MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
+        { MP_QSTR_freq, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
         { MP_QSTR_duty_u16, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
         { MP_QSTR_duty_ns,  MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
-        // { MP_QSTR_invert,   MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = VALUE_NOT_SET} },
     };
 
     // Parse the arguments.
     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->active = 1;
 
     if ((args[ARG_freq].u_int != VALUE_NOT_SET)) {
-        // pwm_freq_duty_set(&self->pwm_obj, args[ARG_freq].u_int, self->duty);
         self->fz = args[ARG_freq].u_int;
     }
 
-    if ((args[ARG_duty_u16].u_int != VALUE_NOT_SET)) {
-        float val = (float)(args[ARG_duty_u16].u_int) / (float)65535;
-        pwm_freq_duty_set(&self->pwm_obj, self->fz, val);
-        self->duty = args[ARG_duty_u16].u_int;
-        self->duty_type = DUTY_U16;
+    if ((args[ARG_duty_u16].u_int != VALUE_NOT_SET) &&
+        (args[ARG_duty_ns].u_int != VALUE_NOT_SET)) {
+        mp_raise_ValueError(MP_ERROR_TEXT("PWM duty should be specified only in one format"));
     }
 
-    if (args[ARG_duty_ns].u_int != VALUE_NOT_SET) {
-        pwm_duty_set_ns(&self->pwm_obj, self->fz, args[ARG_duty_ns].u_int);
+    if ((args[ARG_duty_u16].u_int != VALUE_NOT_SET)) {
+        self->duty = args[ARG_duty_u16].u_int > 65535 ? 65535 : args[ARG_duty_u16].u_int;
+        self->duty_type = DUTY_U16;
+    } else if (args[ARG_duty_ns].u_int != VALUE_NOT_SET) {
+        pwm_duty_ns_assert(args[ARG_duty_ns].u_int, self->fz);
         self->duty = args[ARG_duty_ns].u_int;
         self->duty_type = DUTY_NS;
+    } else {
+        mp_raise_ValueError(MP_ERROR_TEXT("PWM duty should be specified in either ns or u16"));
     }
 
-    // inverts the respective output if the value is True
-    /*if (args[ARG_invert].u_int != VALUE_NOT_SET) {
-        self->invert = args[ARG_invert].u_int;
-        if (self->invert == 1) {
-            cyhal_pwm_free(&self->pwm_obj);
-            cy_rslt_t result = pwm_advanced_init(self);
-            if (result != CY_RSLT_SUCCESS) {
-                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM initialisation failed with return code %lx ! and invert output is not available"), result);
-            }
-            self->duty_type = DUTY_U16;
-            self->duty = ((1) - ((self->duty) / 65535)) * 65535;
-        }
-    }*/
-    cyhal_pwm_start(&self->pwm_obj);
+    pwm_config(self);
+
+    cy_rslt_t result = cyhal_pwm_start(&self->pwm_obj);
+    pwm_assert_raise_val("PWM start failed with return code %lx !", result);
 }
 
 static mp_obj_t mp_machine_pwm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
@@ -151,16 +161,10 @@ static mp_obj_t mp_machine_pwm_make_new(const mp_obj_type_t *type, size_t n_args
     self->pin = pin_addr_by_name(all_args[0]);
     self->duty_type = DUTY_NOT_SET;
     self->fz = -1;
-    // self->invert = -1;
 
-    // Initialize PWM
     cy_rslt_t result = cyhal_pwm_init(&self->pwm_obj, self->pin, NULL);
-
-    // To check whether PWM init is successful
-    if (result != CY_RSLT_SUCCESS) {
-        assert_pin_phy_used(result);
-        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM initialisation failed with return code %lx !"), result);
-    }
+    assert_pin_phy_used(result);
+    pwm_assert_raise_val("PWM initialisation failed with return code %lx !", result);
 
     // Process the remaining parameters.
     mp_map_t kw_args;
@@ -171,17 +175,17 @@ static mp_obj_t mp_machine_pwm_make_new(const mp_obj_type_t *type, size_t n_args
 }
 
 static void mp_machine_pwm_deinit(machine_pwm_obj_t *self) {
-    cyhal_pwm_stop(&self->pwm_obj);
+    cy_rslt_t result = cyhal_pwm_stop(&self->pwm_obj);
+    pwm_assert_raise_val("PWM stop failed with return code %lx !", result);
     cyhal_pwm_free(&self->pwm_obj);
     pwm_obj_free(self);
 }
 
 static mp_obj_t mp_machine_pwm_duty_get_u16(machine_pwm_obj_t *self) {
     if (self->duty_type == DUTY_NS) {
-        // duty_cycle = pulsewidth(ns)*freq(hz);
-        return mp_obj_new_float(((self->duty) * (self->fz) * 65535) / 1000000000 - 1);
+        return mp_obj_new_int(pwm_duty_cycle_ns_to_u16(self->duty, self->fz));
     } else {
-        return mp_obj_new_float(self->duty);
+        return mp_obj_new_int(self->duty);
     }
 }
 
@@ -190,39 +194,38 @@ static void mp_machine_pwm_duty_set_u16(machine_pwm_obj_t *self, mp_int_t duty_u
     // Check the value is more than the max value
     self->duty = duty_u16 > 65535 ? 65535 : duty_u16;
     self->duty_type = DUTY_U16;
-    pwm_freq_duty_set(&self->pwm_obj, self->fz, (float)(self->duty) / (float)65535); // s conversion of duty_u16 into dutyu16/65535
+    pwm_config(self);
 }
 
 static mp_obj_t mp_machine_pwm_duty_get_ns(machine_pwm_obj_t *self) {
     if (self->duty_type == DUTY_U16) {
-        return mp_obj_new_float(((self->duty) * 1000000000) / ((self->fz) * 65535));   // pw (ns) = duty_cycle*10^9/fz
+        return mp_obj_new_int(pwm_duty_cycle_u16_to_ns(self->duty, self->fz));
     } else {
-        return mp_obj_new_float(self->duty);
+        return mp_obj_new_int(self->duty);
     }
 }
 
 // sets the pulse width in nanoseconds
 static void mp_machine_pwm_duty_set_ns(machine_pwm_obj_t *self, mp_int_t duty_ns) {
+    pwm_duty_ns_assert(duty_ns, self->fz);
     self->duty = duty_ns;
     self->duty_type = DUTY_NS;
-    pwm_duty_set_ns(&self->pwm_obj, self->fz, duty_ns);
+    pwm_config(self);
 }
 
 static mp_obj_t mp_machine_pwm_freq_get(machine_pwm_obj_t *self) {
     return MP_OBJ_NEW_SMALL_INT(self->fz);
-
 }
 
 static void mp_machine_pwm_freq_set(machine_pwm_obj_t *self, mp_int_t freq) {
-    self->fz = freq;
-    pwm_freq_duty_set(&self->pwm_obj, freq, self->duty);
     if (self->duty_type == DUTY_NS) {
-        self->duty = ((self->duty) * (self->fz) * 65535) / 1000000000;
-        mp_machine_pwm_duty_set_ns(self, self->duty);
+        pwm_duty_ns_assert(self->duty, freq);
     }
+    self->fz = freq;
+    pwm_config(self);
 }
 
-void mod_pwm_deinit() {
+void machine_pwm_deinit_all() {
     for (uint8_t i = 0; i < MAX_PWM_OBJS; i++) {
         if (pwm_obj[i] != NULL) {
             mp_machine_pwm_deinit(pwm_obj[i]);

ports/psoc6/machine_rtc.c

@@ -87,12 +87,12 @@ bool rtc_memory_write_enabled() {
 }
 
 /* This function is run from main.c to init the RTC at boot time. This will set the RTC to PSoC default time: 1st Jan 2000*/
-void mod_rtc_init(void) {
+void machine_rtc_init_all(void) {
     cy_rslt_t result = cyhal_rtc_init(&psoc6_rtc);
     rtc_assert_raise("cyhal_rtc_init failed !", result);
 }
 
-void mod_rtc_deinit() {
+void machine_rtc_deinit_all() {
     if (rtc_memory_write_enabled() == false) {
         cyhal_rtc_free(&psoc6_rtc);
     }

ports/psoc6/machine_sdcard.c

@@ -315,7 +315,7 @@ static mp_obj_t machine_sdcard_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t
 static MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_ioctl_obj, machine_sdcard_ioctl);
 
 
-void mod_sdcard_deinit() {
+void machine_sdcard_deinit_all() {
     for (uint8_t i = 0; i < MAX_SDHC_SLOT; i++) {
         if (sdhc_obj[i] != NULL) {
             machine_sdcard_deinit(MP_OBJ_FROM_PTR(sdhc_obj[i]));

ports/psoc6/machine_spi.c

@@ -419,7 +419,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
 
 #endif
 
-void mod_spi_deinit() {
+void machine_spi_deinit_all() {
     for (uint8_t i = 0; i < MAX_SPI; i++) {
         if (spi_obj[i] != NULL) {
             machine_spi_deinit((mp_obj_base_t *)(spi_obj[i]));

ports/psoc6/machine_timer.c

@@ -246,7 +246,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
     );
 
 
-void mod_timer_deinit() {
+void machine_timer_deinit_all() {
     for (uint8_t i = 0; i < MAX_TIMER; i++) {
         if (timer_obj[i] != NULL) {
             machine_timer_deinit((mp_obj_base_t *)(timer_obj[i]));

ports/psoc6/machine_uart.c

@@ -483,7 +483,7 @@ static mp_uint_t mp_machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, uint
     return ret;
 }
 
-void mod_uart_deinit() {
+void machine_uart_deinit_all() {
     for (uint8_t i = 0; i < MAX_UART; i++) {
         if (uart_obj[i] != NULL) {
             mp_machine_uart_deinit(uart_obj[i]);