3131#include "py/runtime.h"
3232#include "supervisor/shared/tick.h"
3333#include "lib/utils/interrupt_char.h"
34+ #include "common-hal/microcontroller/Pin.h"
3435
36+ #include "src/rp2_common/hardware_irq/include/hardware/irq.h"
3537#include "src/rp2_common/hardware_gpio/include/hardware/gpio.h"
3638
3739#define NO_PIN 0xff
3840
3941#define UART_INST (uart ) (((uart) ? uart1 : uart0))
4042
41- #define TX 0
42- #define RX 1
43- #define CTS 2
44- #define RTS 3
45-
4643typedef enum {
4744 STATUS_FREE = 0 ,
4845 STATUS_IN_USE ,
@@ -51,7 +48,7 @@ typedef enum {
5148
5249static uart_status_t uart_status [2 ];
5350
54- void uart_reset (void ) {
51+ void reset_uart (void ) {
5552 for (uint8_t num = 0 ; num < 2 ; num ++ ) {
5653 if (uart_status [num ] == STATUS_IN_USE ) {
5754 uart_status [num ] = STATUS_FREE ;
@@ -71,7 +68,7 @@ static uint8_t get_free_uart() {
7168 break ;
7269 }
7370 if (num ) {
74- mp_raise_RuntimeError (translate ("All UART peripherals in use" ));
71+ mp_raise_RuntimeError (translate ("All UART peripherals are in use" ));
7572 }
7673 }
7774 return num ;
@@ -84,10 +81,21 @@ static uint8_t pin_init(const uint8_t uart, const mcu_pin_obj_t * pin, const uin
8481 if (!(((pin -> number & 3 ) == pin_type ) && ((((pin -> number + 4 ) & 8 ) >> 3 ) == uart ))) {
8582 mp_raise_ValueError (translate ("Invalid pins" ));
8683 }
84+ claim_pin (pin );
8785 gpio_set_function (pin -> number , GPIO_FUNC_UART );
8886 return pin -> number ;
8987}
9088
89+ static ringbuf_t ringbuf [2 ];
90+
91+ static void uart0_callback (void ) {
92+ while (uart_is_readable (uart0 ) && !ringbuf_put (& ringbuf [0 ], (uint8_t )uart_get_hw (uart0 )-> dr )) {}
93+ }
94+
95+ static void uart1_callback (void ) {
96+ while (uart_is_readable (uart1 ) && !ringbuf_put (& ringbuf [1 ], (uint8_t )uart_get_hw (uart1 )-> dr )) {}
97+ }
98+
9199void common_hal_busio_uart_construct (busio_uart_obj_t * self ,
92100 const mcu_pin_obj_t * tx , const mcu_pin_obj_t * rx ,
93101 const mcu_pin_obj_t * rts , const mcu_pin_obj_t * cts ,
@@ -96,25 +104,56 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
96104 mp_float_t timeout , uint16_t receiver_buffer_size , byte * receiver_buffer ,
97105 bool sigint_enabled ) {
98106
107+ if (bits > 8 ) {
108+ mp_raise_ValueError (translate ("Invalid word/bit length" ));
109+ }
110+
111+ if (receiver_buffer_size == 0 ) {
112+ mp_raise_ValueError (translate ("Invalid buffer size" ));
113+ }
114+
99115 if ((rs485_dir != NULL ) || (rs485_invert )) {
100- mp_raise_NotImplementedError (translate ("RS485 is not supported on this board " ));
116+ mp_raise_NotImplementedError (translate ("RS485 Not yet supported on this device " ));
101117 }
102118
103119 uint8_t uart_id = get_free_uart ();
104120
105- self -> tx_pin = pin_init (uart_id , tx , TX );
106- self -> rx_pin = pin_init (uart_id , rx , RX );
107- self -> cts_pin = pin_init (uart_id , cts , CTS );
108- self -> rts_pin = pin_init (uart_id , rts , RTS );
121+ self -> tx_pin = pin_init (uart_id , tx , 0 );
122+ self -> rx_pin = pin_init (uart_id , rx , 1 );
123+ self -> cts_pin = pin_init (uart_id , cts , 2 );
124+ self -> rts_pin = pin_init (uart_id , rts , 3 );
109125
110126 self -> uart = UART_INST (uart_id );
127+ self -> uart_id = uart_id ;
111128 self -> baudrate = baudrate ;
112129 self -> timeout_ms = timeout * 1000 ;
113130
114131 uart_init (self -> uart , self -> baudrate );
115- uart_set_fifo_enabled (self -> uart , true );
132+ uart_set_fifo_enabled (self -> uart , false );
116133 uart_set_format (self -> uart , bits , stop , parity );
117134 uart_set_hw_flow (self -> uart , (cts != NULL ), (rts != NULL ));
135+
136+ if (rx != NULL ) {
137+ // Initially allocate the UART's buffer in the long-lived part of the
138+ // heap. UARTs are generally long-lived objects, but the "make long-
139+ // lived" machinery is incapable of moving internal pointers like
140+ // self->buffer, so do it manually. (However, as long as internal
141+ // pointers like this are NOT moved, allocating the buffer
142+ // in the long-lived pool is not strictly necessary)
143+ // (This is a macro.)
144+ if (!ringbuf_alloc (& ringbuf [uart_id ], receiver_buffer_size , true)) {
145+ mp_raise_msg (& mp_type_MemoryError , translate ("Failed to allocate RX buffer" ));
146+ }
147+ if (uart_id ) {
148+ self -> uart_irq_id = UART1_IRQ ;
149+ irq_set_exclusive_handler (self -> uart_irq_id , uart1_callback );
150+ } else {
151+ self -> uart_irq_id = UART0_IRQ ;
152+ irq_set_exclusive_handler (self -> uart_irq_id , uart0_callback );
153+ }
154+ irq_set_enabled (self -> uart_irq_id , true);
155+ uart_set_irq_enables (self -> uart , true, false);
156+ }
118157}
119158
120159bool common_hal_busio_uart_deinited (busio_uart_obj_t * self ) {
@@ -126,6 +165,7 @@ void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
126165 return ;
127166 }
128167 uart_deinit (self -> uart );
168+ ringbuf_free (& ringbuf [self -> uart_id ]);
129169 reset_pin_number (self -> tx_pin );
130170 reset_pin_number (self -> rx_pin );
131171 reset_pin_number (self -> cts_pin );
@@ -169,36 +209,25 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
169209 size_t total_read = 0 ;
170210 uint64_t start_ticks = supervisor_ticks_ms64 ();
171211
172- // Busy-wait until timeout or until we've read enough chars.
173- while (supervisor_ticks_ms64 () - start_ticks <= self -> timeout_ms ) {
174- if (uart_is_readable (self -> uart )) {
175- // Read and advance.
176- * data ++ = uart_get_hw (self -> uart )-> dr ;
177-
178- // Decrease how many chars left to read.
179- len -- ;
180- total_read ++ ;
181-
182- // Reset the timeout on every character read.
212+ // Busy-wait for all bytes received or timeout
213+ while (len > 0 && (supervisor_ticks_ms64 () - start_ticks < self -> timeout_ms )) {
214+ // Reset the timeout on every character read.
215+ if (ringbuf_num_filled (& ringbuf [self -> uart_id ])) {
216+ // Prevent conflict with uart irq.
217+ irq_set_enabled (self -> uart_irq_id , false);
218+ // Copy as much received data as available, up to len bytes.
219+ size_t num_read = ringbuf_get_n (& ringbuf [self -> uart_id ], data , len );
220+ // Re-enable irq.
221+ irq_set_enabled (self -> uart_irq_id , true);
222+ len -= num_read ;
223+ data += num_read ;
224+ total_read += num_read ;
183225 start_ticks = supervisor_ticks_ms64 ();
184226 }
185-
186227 RUN_BACKGROUND_TASKS ;
187-
188228 // Allow user to break out of a timeout with a KeyboardInterrupt.
189229 if (mp_hal_is_interrupted ()) {
190- break ;
191- }
192-
193- // Don't need to read any more: data buf is full.
194- if (len == 0 ) {
195- break ;
196- }
197-
198- // If we are zero timeout, make sure we don't loop again (in the event
199- // we read in under 1ms)
200- if (self -> timeout_ms == 0 ) {
201- break ;
230+ return 0 ;
202231 }
203232 }
204233
@@ -228,12 +257,16 @@ void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeou
228257}
229258
230259uint32_t common_hal_busio_uart_rx_characters_available (busio_uart_obj_t * self ) {
231- return uart_is_readable ( self -> uart );
260+ return ringbuf_num_filled ( & ringbuf [ self -> uart_id ] );
232261}
233262
234- void common_hal_busio_uart_clear_rx_buffer (busio_uart_obj_t * self ) {}
263+ void common_hal_busio_uart_clear_rx_buffer (busio_uart_obj_t * self ) {
264+ // Prevent conflict with uart irq.
265+ irq_set_enabled (self -> uart_irq_id , false);
266+ ringbuf_clear (& ringbuf [self -> uart_id ]);
267+ irq_set_enabled (self -> uart_irq_id , true);
268+ }
235269
236- // True if there are no characters still to be written.
237270bool common_hal_busio_uart_ready_to_tx (busio_uart_obj_t * self ) {
238271 if (self -> tx_pin == NO_PIN ) {
239272 return false;
0 commit comments