Enable showing the console on a debug uart

Author: k0d

main.c

@@ -430,6 +430,9 @@ int __attribute__((used)) main(void) {
     // displays init after filesystem, since they could share the flash SPI
     board_init();
 
+    // Start the debug serial
+    serial_early_init();
+
     // Reset everything and prep MicroPython to run boot.py.
     reset_port();
     reset_board();

ports/stm/boards/nucleo_f746zg/mpconfigboard.h

@@ -34,3 +34,6 @@
 #define FLASH_PAGE_SIZE             (0x4000)
 
 #define BOARD_OSC_DIV (8)
+
+#define DEBUG_UART_TX (&pin_PD08)
+#define DEBUG_UART_RX (&pin_PD09)

ports/stm/common-hal/busio/UART.c

@@ -28,6 +28,7 @@
 #include "shared-bindings/busio/UART.h"
 
 #include "mpconfigport.h"
+#include "lib/mp-readline/readline.h"
 #include "lib/utils/interrupt_char.h"
 #include "py/gc.h"
 #include "py/mperrno.h"
@@ -39,6 +40,7 @@
 
 //arrays use 0 based numbering: UART1 is stored at index 0
 STATIC bool reserved_uart[MAX_UART];
+STATIC bool never_reset_uart[MAX_UART];
 int errflag; //Used to restart read halts
 
 STATIC void uart_clock_enable(uint16_t mask);
@@ -61,11 +63,16 @@ STATIC USART_TypeDef * assign_uart_or_throw(busio_uart_obj_t* self, bool pin_eva
 }
 
 void uart_reset(void) {
+    uint16_t never_reset_mask = 0x00;
     for (uint8_t i = 0; i < MAX_UART; i++) {
-        reserved_uart[i] = false;
-        MP_STATE_PORT(cpy_uart_obj_all)[i] = NULL;
+        if (!never_reset_uart[i]) {
+            reserved_uart[i] = false;
+            MP_STATE_PORT(cpy_uart_obj_all)[i] = NULL;
+        } else {
+            never_reset_mask |= 1 << i;
+        }
     }
-    uart_clock_disable(ALL_UARTS);
+    uart_clock_disable(ALL_UARTS & ~(never_reset_mask));
 }
 
 void common_hal_busio_uart_construct(busio_uart_obj_t *self,
@@ -209,8 +216,10 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
 
     // Init buffer for rx and claim pins
     if (self->rx != NULL) {
-        if (!ringbuf_alloc(&self->ringbuf, receiver_buffer_size, true)) {
-            mp_raise_ValueError(translate("UART Buffer allocation error"));
+         if (self->ringbuf.buf == NULL) {
+            if (!ringbuf_alloc(&self->ringbuf, receiver_buffer_size, true)) {
+                mp_raise_ValueError(translate("UART Buffer allocation error"));
+            }
         }
         claim_pin(rx);
     }
@@ -234,6 +243,17 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
     errflag = HAL_OK;
 }
 
+void common_hal_busio_uart_never_reset(busio_uart_obj_t *self) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(mcu_uart_banks); i++) {
+        if (mcu_uart_banks[i] == self->handle.Instance) {
+            never_reset_uart[i] = true;
+            never_reset_pin_number(self->tx->pin->port, self->tx->pin->number);
+            never_reset_pin_number(self->rx->pin->port, self->rx->pin->number);
+            break;
+        }
+    }
+}
+
 bool common_hal_busio_uart_deinited(busio_uart_obj_t *self) {
     return self->tx->pin == NULL;
 }
@@ -289,7 +309,8 @@ size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data,
     bool write_err = false; //write error shouldn't disable interrupts
 
     HAL_NVIC_DisableIRQ(self->irq);
-    if (HAL_UART_Transmit(&self->handle, (uint8_t*)data, len, HAL_MAX_DELAY) != HAL_OK) {
+    HAL_StatusTypeDef ret = HAL_UART_Transmit(&self->handle, (uint8_t*)data, len, HAL_MAX_DELAY);
+    if (ret != HAL_OK) {
         write_err = true;
     }
     HAL_UART_Receive_IT(&self->handle, &self->rx_char, 1);
@@ -313,6 +334,10 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *handle)
             }
             ringbuf_put_n(&context->ringbuf, &context->rx_char, 1);
             errflag = HAL_UART_Receive_IT(handle, &context->rx_char, 1);
+            if (context->rx_char == CHAR_CTRL_C) {
+                common_hal_busio_uart_clear_rx_buffer(context);
+                mp_keyboard_interrupt();
+            }
 
             return;
         }

shared-bindings/busio/UART.h

@@ -29,6 +29,7 @@
 
 #include "common-hal/microcontroller/Pin.h"
 #include "common-hal/busio/UART.h"
+#include "py/ringbuf.h"
 
 extern const mp_obj_type_t busio_uart_type;
 
@@ -66,4 +67,6 @@ extern uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *
 extern void common_hal_busio_uart_clear_rx_buffer(busio_uart_obj_t *self);
 extern bool common_hal_busio_uart_ready_to_tx(busio_uart_obj_t *self);
 
+extern void common_hal_busio_uart_never_reset(busio_uart_obj_t *self);
+
 #endif  // MICROPY_INCLUDED_SHARED_BINDINGS_BUSIO_UART_H

supervisor/serial.h

@@ -38,6 +38,7 @@
 FIL* boot_output_file;
 #endif
 
+void serial_early_init(void);
 void serial_init(void);
 void serial_write(const char* text);
 // Only writes up to given length. Does not check for null termination at all.

supervisor/shared/serial.c

@@ -32,26 +32,68 @@
 #include "shared-bindings/terminalio/Terminal.h"
 #include "supervisor/serial.h"
 #include "supervisor/usb.h"
+#include "shared-bindings/microcontroller/Pin.h"
 
 #include "tusb.h"
 
+#if defined(DEBUG_UART_TX) && defined(DEBUG_UART_RX)
+#include "shared-bindings/busio/UART.h"
+busio_uart_obj_t debug_uart;
+byte buf_array[64];
+#endif
+
+void serial_early_init(void) {
+#if defined(DEBUG_UART_TX) && defined(DEBUG_UART_RX)
+    debug_uart.ringbuf = (ringbuf_t){ buf_array, sizeof(buf_array) };
+    debug_uart.base.type = &busio_uart_type;
+
+    const mcu_pin_obj_t* rx = MP_OBJ_TO_PTR(DEBUG_UART_RX);
+    const mcu_pin_obj_t* tx = MP_OBJ_TO_PTR(DEBUG_UART_TX);
+
+    common_hal_busio_uart_construct(&debug_uart, tx, rx, NULL, NULL, NULL, false,
+                                    115200, 8, PARITY_NONE, 1, 1.0f, 64);
+    common_hal_busio_uart_never_reset(&debug_uart);
+#endif
+}
+
 void serial_init(void) {
     usb_init();
 }
 
 bool serial_connected(void) {
+#if defined(DEBUG_UART_TX) && defined(DEBUG_UART_RX)
+    return true;
+#else
     return tud_cdc_connected();
+#endif
 }
 
 char serial_read(void) {
+#if defined(DEBUG_UART_TX) && defined(DEBUG_UART_RX)
+    if (tud_cdc_connected() && tud_cdc_available() > 0) {
+        return (char) tud_cdc_read_char();
+    }
+    int uart_errcode;
+    char text;
+    common_hal_busio_uart_read(&debug_uart, (uint8_t*) &text, 1, &uart_errcode);
+    return text;
+#else
     return (char) tud_cdc_read_char();
+#endif
 }
 
 bool serial_bytes_available(void) {
+#if defined(DEBUG_UART_TX) && defined(DEBUG_UART_RX)
+    return common_hal_busio_uart_rx_characters_available(&debug_uart) || (tud_cdc_available() > 0);
+#else
     return tud_cdc_available() > 0;
+#endif
 }
 
 void serial_write_substring(const char* text, uint32_t length) {
+    if (length == 0) { // TODO(mark) this is needed because of 'lib/mp-readline/readline.c:71'
+        return;
+    }
 #if CIRCUITPY_DISPLAYIO
     int errcode;
     common_hal_terminalio_terminal_write(&supervisor_terminal, (const uint8_t*) text, length, &errcode);
@@ -62,6 +104,11 @@ void serial_write_substring(const char* text, uint32_t length) {
         count += tud_cdc_write(text + count, length - count);
         usb_background();
     }
+
+#if defined(DEBUG_UART_TX) && defined(DEBUG_UART_RX)
+    int uart_errcode;
+    common_hal_busio_uart_write(&debug_uart, (const uint8_t*) text, length, &uart_errcode);
+#endif
 }
 
 void serial_write(const char* text) {

supervisor/stub/serial.c

@@ -26,6 +26,10 @@
 
 #include "supervisor/serial.h"
 
+void serial_early_init(void) {
+
+}
+
 void serial_init(void) {
 
 }