Skip to content

Commit f90e5b6

Browse files
GrumpyOldPizzaGrumpyOldPizza
committed
CDC/Uart: avoid overfetch on ::read(), increase Uart RX/TX buffer size to 128
1 parent 913a911 commit f90e5b6

File tree

4 files changed

+87
-91
lines changed

4 files changed

+87
-91
lines changed

‎cores/stm32l4/CDC.cpp‎

Lines changed: 49 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -133,34 +133,38 @@ int CDC::read()
133133

134134
size_t CDC::read(uint8_t *buffer, size_t size)
135135
{
136-
unsigned int rx_read, rx_count;
137-
size_t count;
136+
unsigned int rx_read, rx_count;
137+
size_t count;
138138

139-
count = 0;
139+
count = 0;
140140

141-
while (count < size) {
141+
while (count < size) {
142142

143-
rx_count = _rx_count;
143+
rx_count = _rx_count;
144144

145-
if (rx_count == 0) {
146-
break;
147-
}
145+
if (rx_count == 0) {
146+
break;
147+
}
148148

149-
rx_read = _rx_read;
149+
rx_read = _rx_read;
150150

151-
if (rx_count > (UART_RX_BUFFER_SIZE - rx_read)) {
152-
rx_count = (UART_RX_BUFFER_SIZE - rx_read);
153-
}
151+
if (rx_count > (CDC_RX_BUFFER_SIZE - rx_read)) {
152+
rx_count = (CDC_RX_BUFFER_SIZE - rx_read);
153+
}
154154

155-
memcpy(&buffer[count], &_rx_data[rx_read], rx_count);
156-
count += rx_count;
155+
if (rx_count > (size - count)) {
156+
rx_count = (size - count);
157+
}
158+
159+
memcpy(&buffer[count], &_rx_data[rx_read], rx_count);
160+
count += rx_count;
157161

158-
_rx_read = (rx_read + rx_count) & (CDC_RX_BUFFER_SIZE -1);
162+
_rx_read = (rx_read + rx_count) & (CDC_RX_BUFFER_SIZE -1);
159163

160-
armv7m_atomic_sub(&_rx_count, rx_count);
161-
}
164+
armv7m_atomic_sub(&_rx_count, rx_count);
165+
}
162166

163-
return count;
167+
return count;
164168
}
165169

166170
void CDC::flush()
@@ -286,7 +290,7 @@ size_t CDC::write(const uint8_t *buffer, size_t size)
286290
return count;
287291
}
288292

289-
void CDC::onReceive(void(*callback)(int))
293+
void CDC::onReceive(void(*callback)(void))
290294
{
291295
_receiveCallback = callback;
292296
}
@@ -308,42 +312,36 @@ void CDC::EventCallback(uint32_t events)
308312
bool empty;
309313

310314
if (events & USBD_CDC_EVENT_RECEIVE) {
311-
while (_rx_count != CDC_RX_BUFFER_SIZE) {
312-
empty = (_rx_count == 0);
313-
314-
count = 0;
315-
316-
do {
317-
rx_size = 0;
318-
rx_count = CDC_RX_BUFFER_SIZE - _rx_count;
315+
empty = (_rx_count == 0);
319316

320-
if (rx_count == 0) {
321-
break;
322-
}
323-
324-
rx_write = _rx_write;
317+
count = 0;
325318

326-
if (rx_count > (CDC_RX_BUFFER_SIZE - rx_write)) {
327-
rx_count = (CDC_RX_BUFFER_SIZE - rx_write);
328-
}
329-
330-
rx_size = stm32l4_usbd_cdc_receive(_usbd_cdc, &_rx_data[rx_write], rx_count);
331-
332-
_rx_write = (rx_write + rx_size) & (CDC_RX_BUFFER_SIZE -1);
333-
334-
armv7m_atomic_add(&_rx_count, rx_size);
335-
336-
count += rx_size;
337-
338-
} while (rx_size);
339-
340-
if (empty && _receiveCallback) {
341-
(*_receiveCallback)(count);
342-
}
343-
344-
if (!rx_size) {
319+
do {
320+
rx_size = 0;
321+
rx_count = CDC_RX_BUFFER_SIZE - _rx_count;
322+
323+
if (rx_count == 0) {
345324
break;
346325
}
326+
327+
rx_write = _rx_write;
328+
329+
if (rx_count > (CDC_RX_BUFFER_SIZE - rx_write)) {
330+
rx_count = (CDC_RX_BUFFER_SIZE - rx_write);
331+
}
332+
333+
rx_size = stm32l4_usbd_cdc_receive(_usbd_cdc, &_rx_data[rx_write], rx_count);
334+
335+
_rx_write = (rx_write + rx_size) & (CDC_RX_BUFFER_SIZE -1);
336+
337+
armv7m_atomic_add(&_rx_count, rx_size);
338+
339+
count += rx_size;
340+
341+
} while (rx_size);
342+
343+
if (empty && count && _receiveCallback) {
344+
armv7m_pendsv_enqueue((armv7m_pendsv_routine_t)_receiveCallback, NULL, 0);
347345
}
348346
}
349347

‎cores/stm32l4/USBAPI.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ class CDC : public HardwareSerial
101101
size_t read(uint8_t *buffer, size_t size);
102102

103103
// STM32L4 EXTENSTION: asynchronous receive
104-
void onReceive(void(*callback)(int));
104+
void onReceive(void(*callback)(void));
105105

106106
// STM32L4 EXTENSTION: enable/disabe blocking writes
107107
void blockOnOverrun(bool enable);
@@ -122,7 +122,7 @@ class CDC : public HardwareSerial
122122
volatile uint32_t _tx_count;
123123
volatile uint32_t _tx_size;
124124

125-
void (*_receiveCallback)(int);
125+
void (*_receiveCallback)(void);
126126

127127
static void _event_callback(void *context, uint32_t events);
128128
void EventCallback(uint32_t events);

‎cores/stm32l4/Uart.cpp‎

Lines changed: 32 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -142,8 +142,12 @@ size_t Uart::read(uint8_t *buffer, size_t size)
142142
rx_count = (UART_RX_BUFFER_SIZE - rx_read);
143143
}
144144

145+
if (rx_count > (size - count)) {
146+
rx_count = (size - count);
147+
}
148+
145149
memcpy(&buffer[count], &_rx_data[rx_read], rx_count);
146-
count += rx_count;
150+
count += rx_count;
147151

148152
_rx_read = (rx_read + rx_count) & (UART_RX_BUFFER_SIZE -1);
149153

@@ -268,7 +272,7 @@ size_t Uart::write(const uint8_t *buffer, size_t size)
268272
return count;
269273
}
270274

271-
void Uart::onReceive(void(*callback)(int))
275+
void Uart::onReceive(void(*callback)(void))
272276
{
273277
_receiveCallback = callback;
274278
}
@@ -290,42 +294,36 @@ void Uart::EventCallback(uint32_t events)
290294
bool empty;
291295

292296
if (events & UART_EVENT_RECEIVE) {
293-
while (_rx_count != UART_RX_BUFFER_SIZE) {
294-
empty = (_rx_count == 0);
295-
296-
count = 0;
297+
empty = (_rx_count == 0);
297298

298-
do {
299-
rx_size = 0;
300-
rx_count = UART_RX_BUFFER_SIZE - _rx_count;
299+
count = 0;
301300

302-
if (rx_count == 0) {
303-
break;
304-
}
305-
306-
rx_write = _rx_write;
307-
308-
if (rx_count > (UART_RX_BUFFER_SIZE - rx_write)) {
309-
rx_count = (UART_RX_BUFFER_SIZE - rx_write);
310-
}
311-
312-
rx_size = stm32l4_uart_receive(_uart, &_rx_data[rx_write], rx_count);
313-
314-
_rx_write = (rx_write + rx_size) & (UART_RX_BUFFER_SIZE -1);
315-
316-
armv7m_atomic_add(&_rx_count, rx_size);
317-
318-
count += rx_size;
319-
320-
} while (rx_size);
321-
322-
if (empty && _receiveCallback) {
323-
(*_receiveCallback)(count);
324-
}
325-
326-
if (!rx_size) {
301+
do {
302+
rx_size = 0;
303+
rx_count = UART_RX_BUFFER_SIZE - _rx_count;
304+
305+
if (rx_count == 0) {
327306
break;
328307
}
308+
309+
rx_write = _rx_write;
310+
311+
if (rx_count > (UART_RX_BUFFER_SIZE - rx_write)) {
312+
rx_count = (UART_RX_BUFFER_SIZE - rx_write);
313+
}
314+
315+
rx_size = stm32l4_uart_receive(_uart, &_rx_data[rx_write], rx_count);
316+
317+
_rx_write = (rx_write + rx_size) & (UART_RX_BUFFER_SIZE -1);
318+
319+
armv7m_atomic_add(&_rx_count, rx_size);
320+
321+
count += rx_size;
322+
323+
} while (rx_size);
324+
325+
if (empty && count && _receiveCallback) {
326+
armv7m_pendsv_enqueue((armv7m_pendsv_routine_t)_receiveCallback, NULL, 0);
329327
}
330328
}
331329

‎cores/stm32l4/Uart.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -30,8 +30,8 @@
3030

3131
#include "HardwareSerial.h"
3232

33-
#define UART_RX_BUFFER_SIZE 64
34-
#define UART_TX_BUFFER_SIZE 64
33+
#define UART_RX_BUFFER_SIZE 128
34+
#define UART_TX_BUFFER_SIZE 128
3535

3636
class Uart : public HardwareSerial
3737
{
@@ -55,7 +55,7 @@ class Uart : public HardwareSerial
5555
size_t read(uint8_t *buffer, size_t size);
5656

5757
// STM32L4 EXTENSTION: asynchronous receive
58-
void onReceive(void(*callback)(int));
58+
void onReceive(void(*callback)(void));
5959

6060
// STM32L4 EXTENSTION: enable/disabe blocking writes
6161
void blockOnOverrun(bool block);
@@ -77,7 +77,7 @@ class Uart : public HardwareSerial
7777
volatile uint32_t _tx_count;
7878
volatile uint32_t _tx_size;
7979

80-
void (*_receiveCallback)(int);
80+
void (*_receiveCallback)(void);
8181

8282
static void _event_callback(void *context, uint32_t events);
8383
void EventCallback(uint32_t events);

0 commit comments

Comments
 (0)