Mirrors/pico-uart-bridge
1
0
Fork 0
mirror of https://github.com/Noltari/pico-uart-bridge.git synced 2025-05-14 08:12:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Cleanup of PR #24

Browse source
This commit is contained in:
Menci 2024-08-01 16:56:06 +08:00
parent cc42c66af4
commit 552e61fd50
1 changed files with 258 additions and 312 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

220
uart-bridge.c
View file

@ -17,22 +17,15 @@
#define MIN(a, b) ((a > b) ? b : a) #define MIN(a, b) ((a > b) ? b : a)
#endif /* MIN */ #endif /* MIN */
#define SYS_LED_ACTIVE 25 #define LED_PIN 25
#define BUFFER_SIZE 2560 #define BUFFER_SIZE 2560
#define LED_TIMEOUT 10 #define UART0_TX 16
#define UART0_RX 17
#define UART0_TX 0
#define UART0_RX 1
#define UART0_LED_TX 19 // not used for UDPI
#define UART0_LED_RX 18
#define UART1_TX 4 #define UART1_TX 4
#define UART1_RX 5 #define UART1_RX 5
#define UART1_LED_TX 17
#define UART1_LED_RX 16
#define DEF_BIT_RATE 115200 #define DEF_BIT_RATE 115200
#define DEF_STOP_BITS 1 #define DEF_STOP_BITS 1
@ -40,13 +33,11 @@
#define DEF_DATA_BITS 8 #define DEF_DATA_BITS 8
typedef struct { typedef struct {
uart_inst_t * const inst; uart_inst_t *const inst;
uint irq; uint irq;
void *irq_fn; void *irq_fn;
uint8_t tx_pin; uint8_t tx_pin;
uint8_t rx_pin; uint8_t rx_pin;
uint8_t tx_led;
uint8_t rx_led;
} uart_id_t; } uart_id_t;
typedef struct { typedef struct {
@ -59,10 +50,6 @@ typedef struct {
uint8_t usb_buffer[BUFFER_SIZE]; uint8_t usb_buffer[BUFFER_SIZE];
uint32_t usb_pos; uint32_t usb_pos;
mutex_t usb_mtx; mutex_t usb_mtx;
volatile uint8_t countdown_LED_TX;
volatile uint8_t countdown_LED_RX;
critical_section_t spinlock_LED_TX;
critical_section_t spinlock_LED_RX;
} uart_data_t; } uart_data_t;
void uart0_irq_fn(void); void uart0_irq_fn(void);
@ -75,32 +62,21 @@ const uart_id_t UART_ID[CFG_TUD_CDC] = {
.irq_fn = &uart0_irq_fn, .irq_fn = &uart0_irq_fn,
.tx_pin = UART0_TX, .tx_pin = UART0_TX,
.rx_pin = UART0_RX, .rx_pin = UART0_RX,
.tx_led = UART0_LED_TX, }, {
.rx_led = UART0_LED_RX,
},
{
.inst = uart1, .inst = uart1,
.irq = UART1_IRQ, .irq = UART1_IRQ,
.irq_fn = &uart1_irq_fn, .irq_fn = &uart1_irq_fn,
.tx_pin = UART1_TX, .tx_pin = UART1_TX,
.rx_pin = UART1_RX, .rx_pin = UART1_RX,
.tx_led = UART1_LED_TX,
.rx_led = UART1_LED_RX,
} }
}; };
uart_data_t UART_DATA[CFG_TUD_CDC]; uart_data_t UART_DATA[CFG_TUD_CDC];
struct repeating_timer stimulate;
volatile bool ready = false; volatile bool ready = false;
void init_led(uint8_t p) { static inline uint databits_usb2uart(uint8_t data_bits)
gpio_init(p); {
gpio_set_dir(p, GPIO_OUT); switch (data_bits) {
gpio_put(p, 0);
}
static inline uint databits_usb2uart(uint8_t data_bits) {
switch(data_bits) {
case 5: case 5:
return 5; return 5;
case 6: case 6:
@ -112,8 +88,9 @@ static inline uint databits_usb2uart(uint8_t data_bits) {
} }
} }
static inline uart_parity_t parity_usb2uart(uint8_t usb_parity) { static inline uart_parity_t parity_usb2uart(uint8_t usb_parity)
switch(usb_parity) { {
switch (usb_parity) {
case 1: case 1:
return UART_PARITY_ODD; return UART_PARITY_ODD;
case 2: case 2:
@ -123,8 +100,9 @@ static inline uart_parity_t parity_usb2uart(uint8_t usb_parity) {
} }
} }
static inline uint stopbits_usb2uart(uint8_t stop_bits) { static inline uint stopbits_usb2uart(uint8_t stop_bits)
switch(stop_bits) { {
switch (stop_bits) {
case 2: case 2:
return 2; return 2;
default: default:
@ -132,19 +110,25 @@ static inline uint stopbits_usb2uart(uint8_t stop_bits) {
} }
} }
void update_uart_cfg(uint8_t itf) { void update_uart_cfg(uint8_t itf)
{
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
mutex_enter_blocking(&ud->lc_mtx); mutex_enter_blocking(&ud->lc_mtx);
if(ud->usb_lc.bit_rate != ud->uart_lc.bit_rate) { if (ud->usb_lc.bit_rate != ud->uart_lc.bit_rate) {
uart_set_baudrate(ui->inst, ud->usb_lc.bit_rate); uart_set_baudrate(ui->inst, ud->usb_lc.bit_rate);
ud->uart_lc.bit_rate = ud->usb_lc.bit_rate; ud->uart_lc.bit_rate = ud->usb_lc.bit_rate;
} }
if((ud->usb_lc.stop_bits != ud->uart_lc.stop_bits) || (ud->usb_lc.parity != ud->uart_lc.parity) || (ud->usb_lc.data_bits != ud->uart_lc.data_bits)) { if ((ud->usb_lc.stop_bits != ud->uart_lc.stop_bits) ||
uart_set_format(ui->inst, databits_usb2uart(ud->usb_lc.data_bits), stopbits_usb2uart(ud->usb_lc.stop_bits), parity_usb2uart(ud->usb_lc.parity)); (ud->usb_lc.parity != ud->uart_lc.parity) ||
(ud->usb_lc.data_bits != ud->uart_lc.data_bits)) {
uart_set_format(ui->inst,
databits_usb2uart(ud->usb_lc.data_bits),
stopbits_usb2uart(ud->usb_lc.stop_bits),
parity_usb2uart(ud->usb_lc.parity));
ud->uart_lc.data_bits = ud->usb_lc.data_bits; ud->uart_lc.data_bits = ud->usb_lc.data_bits;
ud->uart_lc.parity = ud->usb_lc.parity; ud->uart_lc.parity = ud->usb_lc.parity;
ud->uart_lc.stop_bits = ud->usb_lc.stop_bits; ud->uart_lc.stop_bits = ud->usb_lc.stop_bits;
@ -153,14 +137,17 @@ void update_uart_cfg(uint8_t itf) {
mutex_exit(&ud->lc_mtx); mutex_exit(&ud->lc_mtx);
} }
void usb_read_bytes(uint8_t itf) { void usb_read_bytes(uint8_t itf)
{
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
uint32_t len = tud_cdc_n_available(itf); uint32_t len = tud_cdc_n_available(itf);
if(len && mutex_try_enter(&ud->usb_mtx, NULL)) { if (len &&
mutex_try_enter(&ud->usb_mtx, NULL)) {
len = MIN(len, BUFFER_SIZE - ud->usb_pos); len = MIN(len, BUFFER_SIZE - ud->usb_pos);
if(len) { if (len) {
uint32_t count; uint32_t count;
count = tud_cdc_n_read(itf, &ud->usb_buffer[ud->usb_pos], len); count = tud_cdc_n_read(itf, &ud->usb_buffer[ud->usb_pos], len);
ud->usb_pos += count; ud->usb_pos += count;
} }
@ -169,35 +156,37 @@ void usb_read_bytes(uint8_t itf) {
} }
} }
void usb_write_bytes(uint8_t itf) { void usb_write_bytes(uint8_t itf)
{
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
if(ud->uart_pos) { if (ud->uart_pos) {
if(mutex_try_enter(&ud->uart_mtx, NULL)) { if (mutex_try_enter(&ud->uart_mtx, NULL)) {
uint32_t count = tud_cdc_n_write(itf, ud->uart_buffer, ud->uart_pos); uint32_t count = tud_cdc_n_write(itf, ud->uart_buffer, ud->uart_pos);
// horrible! should use ring buffers!! // horrible! should use ring buffers!!
if(count < ud->uart_pos) { if (count < ud->uart_pos) {
memmove(ud->uart_buffer, &ud->uart_buffer[count], ud->uart_pos - count); memmove(ud->uart_buffer, &ud->uart_buffer[count], ud->uart_pos - count);
} }
ud->uart_pos -= count; ud->uart_pos -= count;
mutex_exit(&ud->uart_mtx); mutex_exit(&ud->uart_mtx);
if(count) if (count)
tud_cdc_n_write_flush(itf); tud_cdc_n_write_flush(itf);
} }
} }
} }
void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms) { void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms)
{
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
// is mutex for tx even needed?? // is mutex for tx even needed??
//mutex_enter_blocking(&ud->lc_mtx); //mutex_enter_blocking(&ud->lc_mtx);
if(duration_ms == 0xffff) { if (duration_ms == 0xffff) {
uart_set_break(ui->inst, true); uart_set_break(ui->inst, true);
} else if(duration_ms == 0x0000) { } else if (duration_ms == 0x0000) {
uart_set_break(ui->inst, false); uart_set_break(ui->inst, false);
} else { } else {
// should be correct for non-compliant stacks? // should be correct for non-compliant stacks?
@ -208,7 +197,8 @@ void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms) {
//mutex_exit(&ud->lc_mtx); //mutex_exit(&ud->lc_mtx);
} }
void usb_cdc_process(uint8_t itf) { void usb_cdc_process(uint8_t itf)
{
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
mutex_enter_blocking(&ud->lc_mtx); mutex_enter_blocking(&ud->lc_mtx);
@ -219,73 +209,38 @@ void usb_cdc_process(uint8_t itf) {
usb_write_bytes(itf); usb_write_bytes(itf);
} }
void core1_entry(void) { void core1_entry(void)
{
tusb_init(); tusb_init();
ready = true; ready = true;
while(1) { while (1) {
int itf; int itf;
int con = 0;
tud_task(); tud_task();
if(tud_ready()) { // we need to ignore DTR on the CDC side if (tud_ready()) { // we need to ignore DTR on the CDC side
gpio_put(SYS_LED_ACTIVE, 1); for (itf = 0; itf < CFG_TUD_CDC; itf++) {
for(itf = 0; itf < CFG_TUD_CDC; itf++) { if (tud_cdc_n_connected(itf)) {
con = 1;
usb_cdc_process(itf); usb_cdc_process(itf);
} }
} else {
gpio_put(SYS_LED_ACTIVE, 0);
} }
} }
gpio_put(LED_PIN, con);
}
} }
void stimulate_status(uint8_t itf) { static inline void uart_read_bytes(uint8_t itf)
const uart_id_t *ui = &UART_ID[itf]; {
uart_data_t *ud = &UART_DATA[itf];
critical_section_enter_blocking(&ud->spinlock_LED_RX);
if(ud->countdown_LED_RX == LED_TIMEOUT) {
gpio_put(ui->rx_led, 1);
}
if(ud->countdown_LED_RX != 0) {
ud->countdown_LED_RX--;
if(ud->countdown_LED_RX == 0) {
gpio_put(ui->rx_led, 0);
}
}
critical_section_exit(&ud->spinlock_LED_RX);
critical_section_enter_blocking(&ud->spinlock_LED_TX);
if(ud->countdown_LED_TX == LED_TIMEOUT) {
gpio_put(ui->tx_led, 1);
}
if(ud->countdown_LED_TX != 0) {
ud->countdown_LED_TX--;
if(ud->countdown_LED_TX == 0) {
gpio_put(ui->tx_led, 0);
}
}
critical_section_exit(&ud->spinlock_LED_TX);
}
bool update_status(struct repeating_timer *t) {
for(uint8_t itf = 0; itf < CFG_TUD_CDC; itf++) {
stimulate_status(itf);
}
return true;
}
static inline void uart_read_bytes(uint8_t itf) {
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
if(uart_is_readable(ui->inst)) { if (uart_is_readable(ui->inst)) {
critical_section_enter_blocking(&ud->spinlock_LED_RX);
ud->countdown_LED_RX = LED_TIMEOUT;
critical_section_exit(&ud->spinlock_LED_RX);
mutex_enter_blocking(&ud->uart_mtx); mutex_enter_blocking(&ud->uart_mtx);
if(ud->uart_pos < BUFFER_SIZE) { if (ud->uart_pos < BUFFER_SIZE) {
ud->uart_buffer[ud->uart_pos] = uart_getc(ui->inst); ud->uart_buffer[ud->uart_pos] = uart_getc(ui->inst);
ud->uart_pos++; ud->uart_pos++;
} else { } else {
@ -295,19 +250,27 @@ static inline void uart_read_bytes(uint8_t itf) {
} }
} }
void uart_write_bytes(uint8_t itf) { void uart0_irq_fn(void)
{
uart_read_bytes(0);
}
void uart1_irq_fn(void)
{
uart_read_bytes(1);
}
void uart_write_bytes(uint8_t itf)
{
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
if(ud->usb_pos && mutex_try_enter(&ud->usb_mtx, NULL)) { if (ud->usb_pos && mutex_try_enter(&ud->usb_mtx, NULL)) {
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
// horrible! should use ring buffers!! // horrible! should use ring buffers!!
if(uart_is_writable(ui->inst)) { // && count < ud->usb_pos) { if (uart_is_writable(ui->inst)) { // && count < ud->usb_pos) {
critical_section_enter_blocking(&ud->spinlock_LED_TX);
ud->countdown_LED_TX = LED_TIMEOUT;
critical_section_exit(&ud->spinlock_LED_TX);
uart_putc_raw(ui->inst, ud->usb_buffer[0]); uart_putc_raw(ui->inst, ud->usb_buffer[0]);
if(ud->usb_pos > 1) { if (ud->usb_pos > 1) {
memmove(ud->usb_buffer, &ud->usb_buffer[1], ud->usb_pos - 1); memmove(ud->usb_buffer, &ud->usb_buffer[1], ud->usb_pos - 1);
} }
ud->usb_pos--; ud->usb_pos--;
@ -316,25 +279,11 @@ void uart_write_bytes(uint8_t itf) {
} }
} }
void uart0_irq_fn(void) { void init_uart_data(uint8_t itf)
uart_read_bytes(0); {
}
void uart1_irq_fn(void) {
uart_read_bytes(1);
}
void init_uart_data(uint8_t itf) {
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
uart_data_t *ud = &UART_DATA[itf]; uart_data_t *ud = &UART_DATA[itf];
init_led(ui->tx_led);
init_led(ui->rx_led);
ud->countdown_LED_TX = 0;
ud->countdown_LED_RX = 0;
critical_section_init(&ud->spinlock_LED_TX);
critical_section_init(&ud->spinlock_LED_RX);
/* Pinmux */ /* Pinmux */
gpio_set_function(ui->tx_pin, GPIO_FUNC_UART); gpio_set_function(ui->tx_pin, GPIO_FUNC_UART);
gpio_set_function(ui->rx_pin, GPIO_FUNC_UART); gpio_set_function(ui->rx_pin, GPIO_FUNC_UART);
@ -375,15 +324,12 @@ void init_uart_data(uint8_t itf) {
void start_uarts() { void start_uarts() {
uint8_t itf; uint8_t itf;
for(itf = 0; itf < CFG_TUD_CDC; itf++) { for (itf = 0; itf < CFG_TUD_CDC; itf++) {
init_uart_data(itf); init_uart_data(itf);
} }
// init led stimulator
add_repeating_timer_ms(1, update_status, NULL, &stimulate);
// enable ISRs // enable ISRs
for(itf = 0; itf < CFG_TUD_CDC; itf++) { for (itf = 0; itf < CFG_TUD_CDC; itf++) {
const uart_id_t *ui = &UART_ID[itf]; const uart_id_t *ui = &UART_ID[itf];
irq_set_enabled(ui->irq, true); irq_set_enabled(ui->irq, true);
uart_set_irq_enables(ui->inst, true, false); uart_set_irq_enables(ui->inst, true, false);
@ -393,23 +339,23 @@ void start_uarts() {
int main(void) { int main(void) {
int itf; int itf;
set_sys_clock_khz(125000, false);
multicore_reset_core1(); multicore_reset_core1();
init_led(SYS_LED_ACTIVE);
usbd_serial_init(); usbd_serial_init();
start_uarts(); start_uarts();
gpio_init(LED_PIN);
gpio_set_dir(LED_PIN, GPIO_OUT);
multicore_launch_core1(core1_entry); multicore_launch_core1(core1_entry);
do { do {
sleep_us(1); sleep_us(1);
} while(!ready); } while (!ready);
while(1) { while (1) {
if(tud_ready()) { if (tud_ready()) {
for(itf = 0; itf < CFG_TUD_CDC; itf++) { for (itf = 0; itf < CFG_TUD_CDC; itf++) {
update_uart_cfg(itf); update_uart_cfg(itf);
uart_write_bytes(itf); uart_write_bytes(itf);
} }