zephyr: Add finalizer. Allow reconfiguration. Use py/ringbuf.h.

danicampora · danicampora · commit fe2bec785fed · 2025-07-06T00:35:27.000+02:00
Signed-off-by: Daniel Campora &lt;danicampora@gmail.com&gt;
diff --git a/ports/zephyr/machine_uart.c b/ports/zephyr/machine_uart.c
@@ -31,16 +31,27 @@
 
 #include <zephyr/kernel.h>
 #include <zephyr/drivers/uart.h>
-#include <zephyr/sys/ring_buffer.h>
 
 #include "py/mperrno.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "py/ringbuf.h"
 #include "zephyr_device.h"
+#include "extmod/modmachine.h"
 
-// The UART class doesn't have any constants for this port.
-#define MICROPY_PY_MACHINE_UART_CLASS_CONSTANTS
 
-#define UART_RX_RING_BUF_DEF_SIZE                  128
-#define UART_TX_RING_BUF_DEF_SIZE                  128
+#define MACHINE_UART_RTS                            1
+#define MACHINE_UART_CTS                            2
+
+// This class needs a finalizer, so we add it here
+#define MICROPY_PY_MACHINE_UART_CLASS_CONSTANTS \
+    { MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(MACHINE_UART_RTS) }, \
+    { MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(MACHINE_UART_CTS) }, \
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_uart_deinit_obj) },
+
+#define UART_RX_RING_BUF_DEF_SIZE                   128
+#define UART_TX_RING_BUF_DEF_SIZE                   128
 
 static void uart_interrupt_handler(const struct device *dev, void *user_data);
 
@@ -49,12 +60,8 @@ typedef struct _machine_uart_obj_t {
     const struct device *dev;
     uint16_t timeout;       // timeout waiting for first char (in ms)
     uint16_t timeout_char;  // timeout waiting between chars (in ms)
-    uint16_t txbuf_size;
-    uint16_t rxbuf_size;
-    uint8_t *rx_buffer;
-    struct ring_buf rx_ringbuffer;
-    uint8_t *tx_buffer;
-    struct ring_buf tx_ringbuffer;
+    ringbuf_t rx_ringbuffer;
+    ringbuf_t tx_ringbuffer;
 } machine_uart_obj_t;
 
 static const char *_parity_name[] = {"None", "Odd", "Even", "Mark", "Space"};
@@ -73,27 +80,84 @@ static void mp_machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_
 }
 
 static void mp_machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_txbuf, ARG_rxbuf, ARG_timeout, ARG_timeout_char };
+    enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_txbuf, ARG_rxbuf, ARG_timeout, ARG_timeout_char, ARG_flow };
     static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 115200} },
+        { MP_QSTR_bits, MP_ARG_INT, {.u_int = 8} },
+        { MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_stop, MP_ARG_INT, {.u_int = 1} },
         { MP_QSTR_txbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_RX_RING_BUF_DEF_SIZE} },
         { MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_TX_RING_BUF_DEF_SIZE} },
         { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
     };
 
     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->txbuf_size = args[ARG_txbuf].u_int;
-    self->rxbuf_size = args[ARG_rxbuf].u_int;
     self->timeout = args[ARG_timeout].u_int;
     self->timeout_char = args[ARG_timeout_char].u_int;
 
-    self->tx_buffer = m_tracked_calloc(self->txbuf_size, sizeof(uint8_t));
-    ring_buf_init(&self->tx_ringbuffer, self->txbuf_size, self->tx_buffer);
+    uint8_t data_bits;
+    if (args[ARG_bits].u_int == 5) {
+        data_bits = UART_CFG_DATA_BITS_5;
+    } else if (args[ARG_bits].u_int == 6) {
+        data_bits = UART_CFG_DATA_BITS_6;
+    } else if (args[ARG_bits].u_int == 7) {
+        data_bits = UART_CFG_DATA_BITS_7;
+    } else if (args[ARG_bits].u_int == 8) {
+        data_bits = UART_CFG_DATA_BITS_8;
+    } else if (args[ARG_bits].u_int == 9) {
+        data_bits = UART_CFG_DATA_BITS_9;
+    } else {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid data bits"));
+    }
+
+    uint8_t parity;
+    if (args[ARG_parity].u_obj == mp_const_none) {
+        parity = UART_CFG_PARITY_NONE;
+    } else if (mp_obj_get_int(args[ARG_parity].u_obj) == 0) {
+        parity = UART_CFG_PARITY_EVEN;
+    } else if (mp_obj_get_int(args[ARG_parity].u_obj) == 1) {
+        parity = UART_CFG_PARITY_ODD;
+    } else {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid parity"));
+    }
 
-    self->rx_buffer = m_tracked_calloc(self->rxbuf_size, sizeof(uint8_t));
-    ring_buf_init(&self->rx_ringbuffer, self->rxbuf_size, self->rx_buffer);
+    uint8_t stop_bits;
+    if (args[ARG_stop].u_int == 1) {
+        stop_bits = UART_CFG_STOP_BITS_1;
+    } else if (args[ARG_stop].u_int == 2) {
+        data_bits = UART_CFG_STOP_BITS_2;
+    } else {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid stop bits"));
+    }
+
+    uint8_t flow_ctrl;
+    if (args[ARG_flow].u_obj == mp_const_none) {
+        flow_ctrl = UART_CFG_FLOW_CTRL_NONE;
+    } else if (mp_obj_get_int(args[ARG_flow].u_obj) == (MACHINE_UART_RTS | MACHINE_UART_RTS)) {
+        flow_ctrl = UART_CFG_FLOW_CTRL_RTS_CTS;
+    } else {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid flow control"));
+    }
+
+    const struct uart_config cfg = {
+        .baudrate = args[ARG_baudrate].u_int,
+        .parity = parity,
+        .stop_bits = args[ARG_stop].u_int,
+        .data_bits = data_bits,
+        .flow_ctrl = flow_ctrl
+    };
+
+    int ret = uart_configure(self->dev, &cfg);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+
+    ringbuf_alloc(&self->tx_ringbuffer, args[ARG_txbuf].u_int);
+    ringbuf_alloc(&self->rx_ringbuffer, args[ARG_rxbuf].u_int);
 
     uart_irq_callback_user_data_set(self->dev, uart_interrupt_handler, (void *)self);
     uart_irq_rx_enable(self->dev);
@@ -102,7 +166,7 @@ static void mp_machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args,
 static mp_obj_t mp_machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
 
-    machine_uart_obj_t *self = mp_obj_malloc(machine_uart_obj_t, &machine_uart_type);
+    machine_uart_obj_t *self = mp_obj_malloc_with_finaliser(machine_uart_obj_t, &machine_uart_type);
     self->dev = zephyr_device_find(args[0]);
 
     mp_map_t kw_args;
@@ -113,19 +177,16 @@ static mp_obj_t mp_machine_uart_make_new(const mp_obj_type_t *type, size_t n_arg
 }
 
 static void mp_machine_uart_deinit(machine_uart_obj_t *self) {
-    m_tracked_free(self->tx_buffer);
-    m_tracked_free(self->rx_buffer);
+    uart_irq_rx_disable(self->dev);
+    uart_irq_tx_disable(self->dev);
 }
 
 static mp_int_t mp_machine_uart_any(machine_uart_obj_t *self) {
-    return ring_buf_size_get(&self->rx_ringbuffer);
+    return ringbuf_avail(&self->rx_ringbuffer);
 }
 
 static bool mp_machine_uart_txdone(machine_uart_obj_t *self) {
-    if (ring_buf_is_empty(&self->tx_ringbuffer)) {
-        return true;
-    }
-    return false;
+    return ringbuf_avail(&self->tx_ringbuffer) ? false : true;
 }
 
 static mp_uint_t mp_machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
@@ -136,8 +197,9 @@ static mp_uint_t mp_machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t
     size_t time_to_wait = self->timeout;
 
     do {
-        int _rx_len = ring_buf_get(&self->rx_ringbuffer, &buffer[bytes_read], size - bytes_read);
+        int _rx_len = MIN(ringbuf_avail(&self->rx_ringbuffer), size - bytes_read);
         if (_rx_len > 0) {
+            ringbuf_get_bytes(&self->rx_ringbuffer, &buffer[bytes_read], _rx_len);
             bytes_read += _rx_len;
             elapsed_ms = 0;
             time_to_wait = self->timeout_char;
@@ -160,7 +222,7 @@ static mp_uint_t mp_machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_
     }
 
     int _ex_size = 0;
-    int _free_space = ring_buf_space_get(&self->tx_ringbuffer);
+    int _free_space = ringbuf_free(&self->tx_ringbuffer);
     if (size > _free_space) {
         _ex_size = size - _free_space;
     }
@@ -170,7 +232,7 @@ static mp_uint_t mp_machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_
         uart_poll_out(self->dev, buffer[i]);
     }
 
-    ring_buf_put(&self->tx_ringbuffer, &buffer[_ex_size], size - _ex_size);
+    ringbuf_put_bytes(&self->tx_ringbuffer, &buffer[_ex_size], size - _ex_size);
     uart_irq_tx_enable(self->dev);
 
     return size;
@@ -206,7 +268,7 @@ static void uart_interrupt_handler(const struct device *dev, void *user_data) {
     while (uart_irq_update(dev) && uart_irq_is_pending(dev)) {
         if (uart_irq_rx_ready(dev)) {
             uint8_t _rx_buffer[32];
-            size_t _free_space = MIN(ring_buf_space_get(&self->rx_ringbuffer), sizeof(_rx_buffer));
+            size_t _free_space = MIN(ringbuf_free(&self->rx_ringbuffer), sizeof(_rx_buffer));
 
             // empty the uart fifo even if we can't store bytes anymore
             // otherwise we will never exit this interrupt handler
@@ -215,17 +277,20 @@ static void uart_interrupt_handler(const struct device *dev, void *user_data) {
                 continue;
             }
 
-            ring_buf_put(&self->rx_ringbuffer, _rx_buffer, rcv_len);
+            ringbuf_put_bytes(&self->rx_ringbuffer, _rx_buffer, rcv_len);
         }
 
-        int _max_tx_len = uart_irq_tx_ready(dev);
-        if (_max_tx_len > 0) {
+        int _max_uart_tx_len = uart_irq_tx_ready(dev);
+        if (_max_uart_tx_len > 0) {
             uint8_t _tx_buffer[32];
-            size_t _tx_len = MIN(_max_tx_len, sizeof(_tx_buffer));
-
-            _tx_len = ring_buf_get(&self->tx_ringbuffer, _tx_buffer, _tx_len);
-            if (_tx_len > 0) {
-                uart_fifo_fill(dev, _tx_buffer, _tx_len);
+            size_t _buffer_tx_len;
+
+            _max_uart_tx_len = MIN(_max_uart_tx_len, sizeof(_tx_buffer));
+            _buffer_tx_len = ringbuf_avail(&self->tx_ringbuffer);
+            if (_buffer_tx_len > 0) {
+                _buffer_tx_len = MIN(_max_uart_tx_len, _buffer_tx_len);
+                ringbuf_get_bytes(&self->tx_ringbuffer, _tx_buffer, _buffer_tx_len);
+                uart_fifo_fill(dev, _tx_buffer, _buffer_tx_len);
             } else {
                 uart_irq_tx_disable(dev);
             }
diff --git a/ports/zephyr/mpconfigport.h b/ports/zephyr/mpconfigport.h
@@ -110,8 +110,6 @@
 #define MICROPY_FATFS_RPATH            (2)
 #define MICROPY_FATFS_NORTC            (1)
 
-#define MICROPY_TRACKED_ALLOC          (1)
-
 // Saving extra crumbs to make sure binary fits in 128K
 #define MICROPY_COMP_CONST_FOLDING  (0)
 #define MICROPY_COMP_CONST (0)
diff --git a/ports/zephyr/prj.conf b/ports/zephyr/prj.conf
@@ -83,7 +83,6 @@ CONFIG_WATCHDOG=y
 CONFIG_WDT_DISABLE_AT_BOOT=y
 
 CONFIG_SERIAL=y
-CONFIG_RING_BUFFER=y
 CONFIG_UART_INTERRUPT_DRIVEN=y
 CONFIG_UART_LINE_CTRL=y
 CONFIG_UART_USE_RUNTIME_CONFIGURE=y
