shared/tinyusb: Add USBD_CDC class to access usb serial port.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

extmod/modmachine.c

@@ -32,6 +32,10 @@
 #include "extmod/modmachine.h"
 #include "shared/runtime/pyexec.h"
 
+#if MICROPY_HW_USB_CDC
+#include "shared/tinyusb/mp_usbd_cdc.h"
+#endif
+
 #if MICROPY_PY_MACHINE_DHT_READINTO
 #include "drivers/dht/dht.h"
 #endif

extmod/os_dupterm.c

@@ -53,6 +53,7 @@ void mp_os_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc) {
     if (nlr_push(&nlr) == 0) {
         mp_stream_close(term);
         const mp_stream_p_t *stream_p = mp_get_stream_raise(term, MP_STREAM_OP_IOCTL);
+        int errcode = 0;
         stream_p->ioctl(term, MP_STREAM_REPL_ATTACHED, 0, &errcode);
         nlr_pop();
     } else {

shared/tinyusb/mp_usbd.h

@@ -34,6 +34,7 @@
 #include "py/obj.h"
 #include "py/objarray.h"
 #include "py/runtime.h"
+#include "mp_usbd_cdc.h"
 
 #ifndef NO_QSTR
 #include "tusb.h"
@@ -45,6 +46,10 @@ static inline void mp_usbd_init_tud(void) {
     tusb_init();
     tud_cdc_configure_fifo_t cfg = { .rx_persistent = 0, .tx_persistent = 1 };
     tud_cdc_configure_fifo(&cfg);
+
+    #if MICROPY_HW_USB_CDC
+    machine_usbd_cdc_init0();
+    #endif
 }
 
 // Run the TinyUSB device task

shared/tinyusb/mp_usbd_cdc.c

@@ -28,6 +28,7 @@
 #include "py/mphal.h"
 #include "py/stream.h"
 #include "extmod/modmachine.h"
+#include "shared/runtime/mpirq.h"
 
 #include "mp_usbd.h"
 #include "mp_usbd_cdc.h"
@@ -38,6 +39,12 @@ static uint8_t cdc_itf_pending; // keep track of cdc interfaces which need atten
 static int8_t cdc_connected_flush_delay = 0;
 static void usbd_cdc_rx_event_callback(void);
 
+// Constants for USBD_CDC.irq trigger.
+#define USBD_CDC_IRQ_RX (1)
+
+#ifndef UNUSED
+#define UNUSED(X) (void)X      /* To avoid gcc/g++ warnings */
+#endif
 
 uintptr_t mp_usbd_cdc_poll_interfaces(uintptr_t poll_flags) {
     uintptr_t ret = 0;
@@ -70,12 +77,12 @@ uintptr_t mp_usbd_cdc_poll_interfaces(uintptr_t poll_flags) {
     return ret;
 }
 
-mp_uint_t mp_usbd_cdc_rx_strn(const char *buf, mp_uint_t len) {
+mp_uint_t mp_usbd_cdc_rx_strn(char *buf, mp_uint_t len) {
     return tud_cdc_read(buf, len);
 }
 
 void tud_cdc_rx_cb(uint8_t itf) {
-    #if 0
+    #if !MICROPY_PY_OS_DUPTERM
     // consume pending USB data immediately to free usb buffer and keep the endpoint from stalling.
     // in case the ringbuffer is full, mark the CDC interface that need attention later on for polling
     cdc_itf_pending &= ~(1 << itf);
@@ -229,28 +236,30 @@ const machine_usbd_cdc_obj_t machine_usbd_cdc_obj = {{&machine_usbd_cdc_type}};/
 
 
 static bool machine_usbd_cdc_irq_scheduled;// [MICROPY_HW_USB_CDC_NUM];
+static void machine_usbd_cdc_attach_to_repl(const machine_usbd_cdc_obj_t *self, bool attached);
 
-static void machine_usbd_cdc_init0(void) {
+void machine_usbd_cdc_init0(void) {
     // for (size_t i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
     MP_STATE_PORT(machine_usbd_cdc_irq) = mp_const_none;
     machine_usbd_cdc_irq_scheduled = false;
     // }
 
+    #if MICROPY_PY_OS_DUPTERM
     // #if MICROPY_HW_USB_CDC_REPL
     // Activate USB_CDC(0) on dupterm slot 1 for the REPL
     // todo auto detect appropriate slot
     MP_STATE_VM(dupterm_objs[1]) = MP_OBJ_FROM_PTR(&machine_usbd_cdc_obj);
-    usb_vcp_attach_to_repl(&machine_usbd_cdc_obj, true);
-    // #endif
+    machine_usbd_cdc_attach_to_repl(&machine_usbd_cdc_obj, true);
+    #endif
 
 }
 
 static mp_obj_t machine_usbd_cdc_irq_run(mp_obj_t self_in) {
-    machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    // machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(self_in);
     // uint8_t idx = self->cdc_idx;
     mp_obj_t callback = MP_STATE_PORT(machine_usbd_cdc_irq);
     machine_usbd_cdc_irq_scheduled = false;
-    if (callback != mp_const_none && usbd_cdc_rx_num(self)) {
+    if (callback != mp_const_none && tud_cdc_available()) {
         mp_call_function_1(callback, self_in);
     }
     return mp_const_none;
@@ -267,11 +276,12 @@ void usbd_cdc_rx_event_callback(void) {
 }
 
 static void machine_usbd_cdc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    int id = ((machine_usbd_cdc_obj_t *)MP_OBJ_TO_PTR(self_in))->cdc_itf->cdc_idx;
-    mp_printf(print, "USBD_CDC(%u)", id);
+    // int id = ((machine_usbd_cdc_obj_t *)MP_OBJ_TO_PTR(self_in))->cdc_itf->cdc_idx;
+    mp_printf(print, "USBD_CDC()");
 }
 
-void machine_usbd_cdc_attach_to_repl(const machine_usbd_cdc_obj_t *self, bool attached) {
+static void machine_usbd_cdc_attach_to_repl(const machine_usbd_cdc_obj_t *self, bool attached) {
+    UNUSED(self);
     // self->attached_to_repl = attached;
     if (attached) {
         // Default behavior is non-blocking when attached to repl
@@ -321,7 +331,7 @@ static mp_obj_t machine_usbd_cdc_init(size_t n_args, const mp_obj_t *pos_args, m
 
     // parse args
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-    machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    // machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     // flow control
@@ -349,7 +359,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(machine_usbd_cdc_isconnected_obj, machine_usbd_
 /// Return `True` if any characters waiting, else `False`.
 static mp_obj_t machine_usbd_cdc_any(mp_obj_t self_in) {
     UNUSED(self_in);
-    if (ringbuf_peek(&stdin_ringbuf) != -1) {
+    if (tud_cdc_available()) {
         return mp_const_true;
     } else {
         return mp_const_false;
@@ -429,7 +439,7 @@ static mp_obj_t machine_usbd_cdc_irq(size_t n_args, const mp_obj_t *pos_args, mp
         { MP_QSTR_trigger, MP_ARG_INT, {.u_int = USBD_CDC_IRQ_RX} },
         { MP_QSTR_hard, MP_ARG_BOOL, {.u_bool = false} },
     };
-    machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    // machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
@@ -480,16 +490,17 @@ static const mp_rom_map_elem_t machine_usbd_cdc_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&mp_stream___exit___obj) },
 
     // class constants
-    { MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(USBD_CDC_FLOWCONTROL_RTS) },
-    { MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(USBD_CDC_FLOWCONTROL_CTS) },
+    // { MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(USBD_CDC_FLOWCONTROL_RTS) },
+    // { MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(USBD_CDC_FLOWCONTROL_CTS) },
     { MP_ROM_QSTR(MP_QSTR_IRQ_RX), MP_ROM_INT(USBD_CDC_IRQ_RX) },
 };
 
 static MP_DEFINE_CONST_DICT(machine_usbd_cdc_locals_dict, machine_usbd_cdc_locals_dict_table);
 
 static mp_uint_t machine_usbd_cdc_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
-    machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    int ret = usbd_cdc_rx(self, (byte *)buf, size, 0);
+    UNUSED(self_in);
+    // machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    int ret = mp_usbd_cdc_rx_strn((char *)buf, size);
     if (ret == 0) {
         // return EAGAIN error to indicate non-blocking
         *errcode = MP_EAGAIN;
@@ -499,7 +510,7 @@ static mp_uint_t machine_usbd_cdc_read(mp_obj_t self_in, void *buf, mp_uint_t si
 }
 
 static mp_uint_t machine_usbd_cdc_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
-    machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    UNUSED(self_in);
     int ret = mp_usbd_cdc_tx_strn((const char *)buf, size);
     if (ret == 0) {
         // return EAGAIN error to indicate non-blocking
@@ -514,17 +525,11 @@ static mp_uint_t machine_usbd_cdc_ioctl(mp_obj_t self_in, mp_uint_t request, uin
     machine_usbd_cdc_obj_t *self = MP_OBJ_TO_PTR(self_in);
     if (request == MP_STREAM_POLL) {
         uintptr_t flags = arg;
-        ret = 0;
-        if ((flags & MP_STREAM_POLL_RD) && usbd_cdc_rx_num(self) > 0) {
-            ret |= MP_STREAM_POLL_RD;
-        }
-        if ((flags & MP_STREAM_POLL_WR) && usbd_cdc_tx_half_empty(self)) {
-            ret |= MP_STREAM_POLL_WR;
-        }
+        ret = mp_usbd_cdc_poll_interfaces(flags);
     } else if (request == MP_STREAM_CLOSE) {
         ret = 0;
     } else if (request == MP_STREAM_REPL_ATTACHED) {
-        machine_usbd_cdc_attach_to_repl(arg);
+        machine_usbd_cdc_attach_to_repl(self, arg);
         ret = 0;
     } else {
         *errcode = MP_EINVAL;

shared/tinyusb/mp_usbd_cdc.h

@@ -37,6 +37,7 @@
 #define MICROPY_HW_USB_CDC_DTR_RTS_BOOTLOADER (0)
 #endif
 
+void machine_usbd_cdc_init0(void);
 // extern const mp_obj_type_t pyb_usb_vcp_type;
 extern const mp_obj_type_t machine_usbd_cdc_type;
 // extern void machine_usbd_cdc_attach_to_repl(const machine_usbd_cdc_obj_t *self, bool attached);
@@ -45,6 +46,6 @@ extern const mp_obj_type_t machine_usbd_cdc_type;
 uintptr_t mp_usbd_cdc_poll_interfaces(uintptr_t poll_flags);
 // void tud_cdc_rx_cb(uint8_t itf);
 mp_uint_t mp_usbd_cdc_tx_strn(const char *str, mp_uint_t len);
-mp_uint_t mp_usbd_cdc_rx_strn(const char *buf, mp_uint_t len);
+mp_uint_t mp_usbd_cdc_rx_strn(char *buf, mp_uint_t len);
 
 #endif // MICROPY_INCLUDED_SHARED_TINYUSB_MP_USBD_CDC_H