serial console mostly working, but still losing some bytes when transmitting lots.

README.md

     continue # start program
 
 These commands have also been put in the `flash_swd.sh` and `debug_swd.sh` scripts, respectively.
-Call them from the `build_debug` folder where you checked out and built OpenOCD.
+They require the `build_debug` folder where you checked out and built OpenOCD.
+Here are some [general GDB tips](https://beej.us/guide/bggdb/).
 
 ## License
 

debug_swd.sh

 #!/bin/bash
 set -euo pipefail
 
+cd "$(dirname "$0")"
+
 echo Starting OpenOCD in background
-./openocd/src/openocd -s openocd/tcl -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000" -c "cmsis_dap_vid_pid 0x2e8a 0x000c" &
+echo "\n\nstarting new openocd" >> openocd.log
+./build_debug/openocd/src/openocd -s build_debug/openocd/tcl -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000" -c "cmsis_dap_vid_pid 0x2e8a 0x000c" >> openocd.log 2>&1 &
 OPENOCD_PID=$!
 
 # give OpenOCD some time to output stuff
 -ex "set history save" \
 -ex "show print pretty" \
 -ex "target extended-remote localhost:3333" \
--ex "tui new-layout default asm 1 src 2 status 0 cmd 1" \
+-ex "tui new-layout default src 1 status 1 cmd 2" \
 -ex "tui layout default" \
 -ex "tui enable" \
 $1

flash_swd.sh

 #!/bin/bash
 set -euo pipefail
 
-./openocd/src/openocd -s openocd/tcl -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000" -c "cmsis_dap_vid_pid 0x2e8a 0x000c" -c "program $1 verify reset exit"
+cd "$(dirname "$0")"
+
+./build_debug/openocd/src/openocd -s build_debug/openocd/tcl -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000" -c "cmsis_dap_vid_pid 0x2e8a 0x000c" -c "program $1 verify reset exit"

include/console.h

 
 void cnsl_init(void);
 void cnsl_run(void);
-void cnsl_handle_input(const char *buf, uint32_t len);
+void cnsl_handle_input(const uint8_t *buf, size_t len);
 
 #endif // __CONSOLE_H__

include/log.h

 void log_dump_to_uart(void);
 void log_dump_to_disk(void);
 
-void debug_handle_input(char *buff, uint32_t len);
+void debug_handle_input(const uint8_t *buff, size_t len);
 
 #endif // __LOG_H__

include/ring.h

 #define RB_INIT(b, s) { .buffer = b, .size = s, .head = 0, .tail = 0, .full = false }
 
 void rb_add(struct ring_buffer *rb, const uint8_t *data, size_t length);
+#define rb_push(rb, v) rb_add(rb, &v, 1)
 size_t rb_len(struct ring_buffer *rb);
 #define rb_space(rb) ((rb)->size - rb_len(rb))
 void rb_dump(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t));
+void rb_move(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t));
+uint8_t rb_peek(struct ring_buffer *rb);
 uint8_t rb_pop(struct ring_buffer *rb);
 
 #endif // __RING_BUFFER_H__

include/serial.h

 void serial_init(void);
 void serial_write(const uint8_t *buf, size_t count);
 void serial_set_reroute(bool reroute);
+void serial_run(void);
 
 #endif // __SERIAL_H__

src/console.c

 #include "lcd.h"
 #include "image.h"
 #include "volcano.h"
+#include "serial.h"
 
 #define CNSL_BUFF_SIZE 1024
 #define CNSL_REPEAT_MS 500
     }
 }
 
-void cnsl_handle_input(const char *buf, uint32_t len) {
+void cnsl_handle_input(const uint8_t *buf, size_t len) {
     if ((cnsl_buff_pos + len) > CNSL_BUFF_SIZE) {
         debug("error: console input buffer overflow! %lu > %u", cnsl_buff_pos + len, CNSL_BUFF_SIZE);
         cnsl_init();
     memcpy(cnsl_line_buff + cnsl_buff_pos, buf, len);
     cnsl_buff_pos += len;
 
-    // handle backspace
+    // handle backspace and local echo
     for (ssize_t i = cnsl_buff_pos - len; i < (ssize_t)cnsl_buff_pos; i++) {
         if ((cnsl_line_buff[i] == '\b') || (cnsl_line_buff[i] == 0x7F)) {
             if (i > 0) {
             }
 
             usb_cdc_write((const uint8_t *)"\b \b", 3);
+            serial_write((const uint8_t *)"\b \b", 3);
 
             // check for another backspace in this space
             i--;
         } else {
             usb_cdc_write((const uint8_t *)(cnsl_line_buff + i), 1);
+            serial_write((const uint8_t *)(cnsl_line_buff + i), 1);
         }
     }
 

src/log.c

     }
     if ((l > 0) && (l <= (int)sizeof(line_buff))) {
         usb_cdc_write(line_buff, l);
+        serial_write(line_buff, l);
 
         if (log) {
             add_to_log(line_buff, l);
     va_end(args);
 }
 
-void debug_handle_input(char *buff, uint32_t len) {
+void debug_handle_input(const uint8_t *buff, size_t len) {
     (void)buff;
 
     if (len > 0) {
     while (!got_input) {
         watchdog_update();
         usb_run();
+        serial_run();
     }
 
     usb_cdc_set_reroute(false);

src/main.c

 
         heartbeat_run();
         buttons_run();
+
         usb_run();
+        serial_run();
         cnsl_run();
 
         battery_run();

src/ring.c

     }
 }
 
+void rb_move(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t)) {
+    rb_dump(rb, write);
+    rb->head = 0;
+    rb->tail = 0;
+    rb->full = false;
+}
+
+uint8_t rb_peek(struct ring_buffer *rb) {
+    if (rb_len(rb) == 0) {
+        return 0;
+    }
+
+    uint8_t v = rb->buffer[rb->tail];
+    return v;
+}
+
 uint8_t rb_pop(struct ring_buffer *rb) {
     if (rb_len(rb) == 0) {
         return 0;

src/serial.c

 /*
  * serial.c
  *
+ * https://github.com/raspberrypi/pico-examples/blob/master/uart/uart_advanced/uart_advanced.c
+ * https://forums.raspberrypi.com/viewtopic.php?t=343110
+ *
  * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
  *
  * This program is free software: you can redistribute it and/or modify
 #define PARITY UART_PARITY_NONE
 #define STOP_BITS 1
 
-#define UART_HW_FIFO_LEN 32
+#define UART_RX_BUFF_LEN 64
 #define UART_TX_BUFF_LEN 128
 
 #include "hardware/uart.h"
 #include "ring.h"
 #include "serial.h"
 
+static uint8_t rx_buff[UART_RX_BUFF_LEN] = {0};
+static struct ring_buffer rx = RB_INIT(rx_buff, sizeof(rx_buff));
+
 static uint8_t tx_buff[UART_TX_BUFF_LEN] = {0};
 static struct ring_buffer tx = RB_INIT(tx_buff, sizeof(tx_buff));
+
 static bool reroute_serial_debug = false;
+static bool tx_irq_state = false;
 
 static void serial_irq(void) {
-    uint8_t buf[UART_HW_FIFO_LEN];
-    uint16_t count = 0;
-
     // Rx - read from UART FIFO to local buffer
-    while (uart_is_readable(UART_ID)) {
+    while (uart_is_readable(UART_ID) && (rb_space(&rx) > 0)) {
         uint8_t ch = uart_getc(UART_ID);
-        buf[count++] = ch;
+        rb_push(&rx, ch);
+    }
 
-        if (count >= UART_HW_FIFO_LEN) {
+    // Tx - write to UART FIFO if needed
+    while (uart_is_writable(UART_ID)) {
+        if (rb_len(&tx) > 0) {
+            uart_putc_raw(UART_ID, rb_pop(&tx));
+        } else {
+            uart_set_irq_enables(UART_ID, true, false);
+            tx_irq_state = false;
             break;
         }
     }
 
-    // Rx - pass local buffer to further processing
-    if ((count >= 1) && (buf[0] == ENTER_BOOTLOADER_MAGIC)) {
-        reset_to_bootloader();
-    } else if (reroute_serial_debug) {
-        debug_handle_input((char *)buf, count);
-    } else {
-        cnsl_handle_input((char *)buf, count);
-    }
-
-    // Tx - write to UART FIFO if needed
-    while (uart_is_writable(UART_ID) && (rb_len(&tx) > 0)) {
-        uart_putc_raw(UART_ID, rb_pop(&tx));
-    }
 }
 
 void serial_init(void) {
     irq_set_exclusive_handler(UART_IRQ, serial_irq);
     irq_set_enabled(UART_IRQ, true);
 
-    uart_set_irq_enables(UART_ID, true, true);
+    uart_set_irq_enables(UART_ID, true, false);
+    tx_irq_state = false;
 }
 
 void serial_write(const uint8_t *buf, size_t count) {
     uart_set_irq_enables(UART_ID, true, false);
+    tx_irq_state = false;
+
+    while ((rb_len(&tx) == 0) && uart_is_writable(UART_ID) && (count > 0)) {
+        uart_putc_raw(UART_ID, *buf++);
+        count--;
+    }
+
+    if (count == 0) {
+        return;
+    }
 
     size_t off = 0;
 
         off += space;
 
         uart_set_irq_enables(UART_ID, true, true);
+        tx_irq_state = true;
+
         sleep_ms(1);
+
         uart_set_irq_enables(UART_ID, true, false);
+        tx_irq_state = false;
     }
+
 #endif // SERIAL_WRITES_BLOCK_WHEN_BUFFER_FULL
 
     rb_add(&tx, buf + off, count);
 
     uart_set_irq_enables(UART_ID, true, true);
+    tx_irq_state = true;
 }
 
 void serial_set_reroute(bool reroute) {
     reroute_serial_debug = reroute;
 }
+
+void serial_run(void) {
+    uart_set_irq_enables(UART_ID, false, tx_irq_state);
+
+    // Rx - pass local buffer to further processing
+    if (rb_len(&rx) >= 1) {
+        if (rb_peek(&rx) == ENTER_BOOTLOADER_MAGIC) {
+            reset_to_bootloader();
+        } else if (reroute_serial_debug) {
+            rb_move(&rx, debug_handle_input);
+        } else {
+            rb_move(&rx, cnsl_handle_input);
+        }
+    }
+
+    uart_set_irq_enables(UART_ID, true, tx_irq_state);
+}

src/usb_cdc.c

         if ((count >= 1) && (buf[0] == ENTER_BOOTLOADER_MAGIC)) {
             reset_to_bootloader();
         } else if (reroute_cdc_debug) {
-            debug_handle_input(buf, count);
+            debug_handle_input((const uint8_t *)buf, count);
         } else {
-            cnsl_handle_input(buf, count);
+            cnsl_handle_input((const uint8_t *)buf, count);
         }
     }
 }