Fix Serial RX and add option for FIFO Full Threshold in Serial.begin

me-no-dev · me-no-dev · commit 371f382db7dd · 2021-04-08T15:29:53.000+03:00
Fixes: espressif#5005
diff --git a/cores/esp32/HardwareSerial.cpp b/cores/esp32/HardwareSerial.cpp
@@ -50,7 +50,7 @@ HardwareSerial Serial2(2);
 
 HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL){}
 
-void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)
+void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms, uint8_t rxfifo_full_thrhd)
{
 if(0 > _uart_nr || _uart_nr > 2){
 log_e("Serial number is invalid, please use 0, 1 or 2");
@@ -78,7 +78,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 txPin = TX2;
 }
 #endif
- _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
+ _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
 _tx_pin = txPin;
 _rx_pin = rxPin;
 
@@ -94,7 +94,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 
 if(detectedBaudRate){
 delay(100); // Give some time...
- _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert);
+ _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
 } else{
 log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
 _uart = NULL;
diff --git a/cores/esp32/HardwareSerial.h b/cores/esp32/HardwareSerial.h
@@ -55,7 +55,7 @@ class HardwareSerial: public Stream
 public:
 HardwareSerial(int uart_nr);
 
- void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsigned long timeout_ms = 20000UL);
+ void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsigned long timeout_ms = 20000UL, uint8_t rxfifo_full_thrhd = 112);
 void end();
 void updateBaudRate(unsigned long baud);
 int available(void);
diff --git a/cores/esp32/esp32-hal-tinyusb.c b/cores/esp32/esp32-hal-tinyusb.c
@@ -48,8 +48,6 @@ typedef struct{
 bool external_phy;
 } tinyusb_config_t;
 
-static TaskHandle_t s_tusb_tskh;
-
 static void configure_pins(usb_hal_context_t *usb)
{
 for (const usb_iopin_dsc_t *iopin = usb_periph_iopins; iopin->pin != -1; ++iopin){
@@ -74,7 +72,6 @@ static void configure_pins(usb_hal_context_t *usb)
 
 esp_err_t tinyusb_driver_install(const tinyusb_config_t *config)
{
- int res;
 log_i("Driver installation...");
 
 // Hal init
diff --git a/cores/esp32/esp32-hal-uart.c b/cores/esp32/esp32-hal-uart.c
@@ -130,10 +130,10 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
 }
 }
 
-void uartEnableInterrupt(uart_t* uart)
+static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
{
 UART_MUTEX_LOCK();
- uart->dev->conf1.rxfifo_full_thrhd = 112;
+ uart->dev->conf1.rxfifo_full_thrhd = rxfifo_full_thrhd;
 #if CONFIG_IDF_TARGET_ESP32
 uart->dev->conf1.rx_tout_thrhd = 2;
 #else
@@ -149,7 +149,7 @@ void uartEnableInterrupt(uart_t* uart)
 UART_MUTEX_UNLOCK();
 }
 
-void uartDisableInterrupt(uart_t* uart)
+static void uartDisableInterrupt(uart_t* uart)
{
 UART_MUTEX_LOCK();
 uart->dev->conf1.val = 0;
@@ -162,7 +162,7 @@ void uartDisableInterrupt(uart_t* uart)
 UART_MUTEX_UNLOCK();
 }
 
-void uartDetachRx(uart_t* uart, uint8_t rxPin)
+static void uartDetachRx(uart_t* uart, uint8_t rxPin)
{
 if(uart == NULL){
 return;
@@ -171,25 +171,25 @@ void uartDetachRx(uart_t* uart, uint8_t rxPin)
 uartDisableInterrupt(uart);
 }
 
-void uartDetachTx(uart_t* uart, uint8_t txPin)
+static void uartDetachTx(uart_t* uart, uint8_t txPin)
{
 if(uart == NULL){
 return;
 }
 pinMatrixOutDetach(txPin, false, false);
 }
 
-void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
+static void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted, uint8_t rxfifo_full_thrhd)
{
 if(uart == NULL || rxPin >= GPIO_PIN_COUNT){
 return;
 }
 pinMode(rxPin, INPUT);
- uartEnableInterrupt(uart);
+ uartEnableInterrupt(uart, rxfifo_full_thrhd);
 pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);
 }
 
-void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
+static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
{
 if(uart == NULL || txPin >= GPIO_PIN_COUNT){
 return;
@@ -198,7 +198,7 @@ void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 pinMatrixOutAttach(txPin, UART_TXD_IDX(uart->num), inverted, false);
 }
 
-uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted)
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd)
{
 if(uart_nr >= UART_PORTS_NUM){
 return NULL;
@@ -256,7 +256,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
 UART_MUTEX_UNLOCK();
 
 if(rxPin != -1){
- uartAttachRx(uart, rxPin, inverted);
+ uartAttachRx(uart, rxPin, inverted, rxfifo_full_thrhd);
 }
 
 if(txPin != -1){
@@ -322,7 +322,11 @@ uint32_t uartAvailable(uart_t* uart)
 if(uart == NULL || uart->queue == NULL){
 return 0;
 }
+#ifdef UART_READ_RX_FIFO
 return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
+#else
+ return uxQueueMessagesWaiting(uart->queue);
+#endif
 }
 
 uint32_t uartAvailableForWrite(uart_t* uart)
@@ -333,6 +337,7 @@ uint32_t uartAvailableForWrite(uart_t* uart)
 return 0x7f - uart->dev->status.txfifo_cnt;
 }
 
+#ifdef UART_READ_RX_FIFO
 void uartRxFifoToQueue(uart_t* uart)
{
 	uint8_t c;
@@ -357,17 +362,20 @@ void uartRxFifoToQueue(uart_t* uart)
 	uart->dev->int_clr.val = 0xffffffff;
 UART_MUTEX_UNLOCK();
 }
+#endif
 
 uint8_t uartRead(uart_t* uart)
{
 if(uart == NULL || uart->queue == NULL){
 return 0;
 }
 uint8_t c;
+#ifdef UART_READ_RX_FIFO
 if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
{
 	uartRxFifoToQueue(uart);
 }
+#endif
 if(xQueueReceive(uart->queue, &c, 0)){
 return c;
 }
@@ -380,10 +388,12 @@ uint8_t uartPeek(uart_t* uart)
 return 0;
 }
 uint8_t c;
+#ifdef UART_READ_RX_FIFO
 if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
{
 	uartRxFifoToQueue(uart);
 }
+#endif
 if(xQueuePeek(uart->queue, &c, 0)){
 return c;
 }
diff --git a/cores/esp32/esp32-hal-uart.h b/cores/esp32/esp32-hal-uart.h
@@ -51,7 +51,7 @@ extern "C"{
 struct uart_struct_t;
 typedef struct uart_struct_t uart_t;
 
-uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted);
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd);
 void uartEnd(uart_t* uart, uint8_t rxPin, uint8_t txPin);
 
 uint32_t uartAvailable(uart_t* uart);

-Original file line number
+Diff line change
 public:
 HardwareSerial(int uart_nr);
 -voidbegin(unsignedlong baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsignedlong timeout_ms = 20000UL);
 +voidbegin(unsignedlong baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsignedlong timeout_ms = 20000UL, uint8_t rxfifo_full_thrhd = 112);
 voidend();
 voidupdateBaudRate(unsignedlong baud);
 intavailable(void);
Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,6 @@ typedef struct{`
`48`	`48`	`boolexternal_phy;`
`49`	`49`	`} tinyusb_config_t;`
`50`	`50`
`51`		`-staticTaskHandle_ts_tusb_tskh;`
`52`		`-`
`53`	`51`	`staticvoidconfigure_pins(usb_hal_context_t*usb)`
`54`	`52`	`{`
`55`	`53`	`for (constusb_iopin_dsc_t*iopin=usb_periph_iopins; iopin->pin!=-1; ++iopin){`
`@@ -74,7 +72,6 @@ static void configure_pins(usb_hal_context_t *usb)`
`74`	`72`
`75`	`73`	`esp_err_ttinyusb_driver_install(consttinyusb_config_t*config)`
`76`	`74`	`{`
`77`		`-intres;`
`78`	`75`	`log_i("Driver installation...");`
`79`	`76`
`80`	`77`	`// Hal init`
Original file line number	Diff line number	Diff line change
`@@ -130,10 +130,10 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`-voiduartEnableInterrupt(uart_t*uart)`
	`133`	`+staticvoiduartEnableInterrupt(uart_t*uart, uint8_trxfifo_full_thrhd)`
`134`	`134`	`{`
`135`	`135`	`UART_MUTEX_LOCK();`
`136`		`-uart->dev->conf1.rxfifo_full_thrhd=112;`
	`136`	`+uart->dev->conf1.rxfifo_full_thrhd=rxfifo_full_thrhd;`
`137`	`137`	`#ifCONFIG_IDF_TARGET_ESP32`
`138`	`138`	`uart->dev->conf1.rx_tout_thrhd=2;`
`139`	`139`	`#else`
`@@ -149,7 +149,7 @@ void uartEnableInterrupt(uart_t* uart)`
`149`	`149`	`UART_MUTEX_UNLOCK();`
`150`	`150`	`}`
`151`	`151`
`152`		`-voiduartDisableInterrupt(uart_t*uart)`
	`152`	`+staticvoiduartDisableInterrupt(uart_t*uart)`
`153`	`153`	`{`
`154`	`154`	`UART_MUTEX_LOCK();`
`155`	`155`	`uart->dev->conf1.val=0;`
`@@ -162,7 +162,7 @@ void uartDisableInterrupt(uart_t* uart)`
`162`	`162`	`UART_MUTEX_UNLOCK();`
`163`	`163`	`}`
`164`	`164`
`165`		`-voiduartDetachRx(uart_t*uart, uint8_trxPin)`
	`165`	`+staticvoiduartDetachRx(uart_t*uart, uint8_trxPin)`
`166`	`166`	`{`
`167`	`167`	`if(uart==NULL){`
`168`	`168`	`return;`
`@@ -171,25 +171,25 @@ void uartDetachRx(uart_t* uart, uint8_t rxPin)`
`171`	`171`	`uartDisableInterrupt(uart);`
`172`	`172`	`}`
`173`	`173`
`174`		`-voiduartDetachTx(uart_t*uart, uint8_ttxPin)`
	`174`	`+staticvoiduartDetachTx(uart_t*uart, uint8_ttxPin)`
`175`	`175`	`{`
`176`	`176`	`if(uart==NULL){`
`177`	`177`	`return;`
`178`	`178`	`}`
`179`	`179`	`pinMatrixOutDetach(txPin, false, false);`
`180`	`180`	`}`
`181`	`181`
`182`		`-voiduartAttachRx(uart_t*uart, uint8_trxPin, boolinverted)`
	`182`	`+staticvoiduartAttachRx(uart_t*uart, uint8_trxPin, boolinverted, uint8_trxfifo_full_thrhd)`
`183`	`183`	`{`
`184`	`184`	`if(uart==NULL\|\|rxPin >= GPIO_PIN_COUNT){`
`185`	`185`	`return;`
`186`	`186`	`}`
`187`	`187`	`pinMode(rxPin, INPUT);`
`188`		`-uartEnableInterrupt(uart);`
	`188`	`+uartEnableInterrupt(uart, rxfifo_full_thrhd);`
`189`	`189`	`pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);`
`190`	`190`	`}`
`191`	`191`
`192`		`-voiduartAttachTx(uart_t*uart, uint8_ttxPin, boolinverted)`
	`192`	`+staticvoiduartAttachTx(uart_t*uart, uint8_ttxPin, boolinverted)`
`193`	`193`	`{`
`194`	`194`	`if(uart==NULL\|\|txPin >= GPIO_PIN_COUNT){`
`195`	`195`	`return;`
`@@ -198,7 +198,7 @@ void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)`
`198`	`198`	`pinMatrixOutAttach(txPin, UART_TXD_IDX(uart->num), inverted, false);`
`199`	`199`	`}`
`200`	`200`
`201`		`-uart_t*uartBegin(uint8_tuart_nr, uint32_tbaudrate, uint32_tconfig, int8_trxPin, int8_ttxPin, uint16_tqueueLen, boolinverted)`
	`201`	`+uart_t*uartBegin(uint8_tuart_nr, uint32_tbaudrate, uint32_tconfig, int8_trxPin, int8_ttxPin, uint16_tqueueLen, boolinverted, uint8_trxfifo_full_thrhd)`
`202`	`202`	`{`
`203`	`203`	`if(uart_nr >= UART_PORTS_NUM){`
`204`	`204`	`returnNULL;`
`@@ -256,7 +256,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx`
`256`	`256`	`UART_MUTEX_UNLOCK();`
`257`	`257`
`258`	`258`	`if(rxPin!=-1){`
`259`		`-uartAttachRx(uart, rxPin, inverted);`
	`259`	`+uartAttachRx(uart, rxPin, inverted, rxfifo_full_thrhd);`
`260`	`260`	`}`
`261`	`261`
`262`	`262`	`if(txPin!=-1){`
`@@ -322,7 +322,11 @@ uint32_t uartAvailable(uart_t* uart)`
`322`	`322`	`if(uart==NULL\|\|uart->queue==NULL){`
`323`	`323`	`return0;`
`324`	`324`	`}`
	`325`	`+#ifdefUART_READ_RX_FIFO`
`325`	`326`	`return (uxQueueMessagesWaiting(uart->queue) +uart->dev->status.rxfifo_cnt) ;`
	`327`	`+#else`
	`328`	`+returnuxQueueMessagesWaiting(uart->queue);`
	`329`	`+#endif`
`326`	`330`	`}`
`327`	`331`
`328`	`332`	`uint32_tuartAvailableForWrite(uart_t*uart)`
`@@ -333,6 +337,7 @@ uint32_t uartAvailableForWrite(uart_t* uart)`
`333`	`337`	`return0x7f-uart->dev->status.txfifo_cnt;`
`334`	`338`	`}`
`335`	`339`
	`340`	`+#ifdefUART_READ_RX_FIFO`
`336`	`341`	`voiduartRxFifoToQueue(uart_t*uart)`
`337`	`342`	`{`
`338`	`343`	`uint8_tc;`
`@@ -357,17 +362,20 @@ void uartRxFifoToQueue(uart_t* uart)`
`357`	`362`	`uart->dev->int_clr.val=0xffffffff;`
`358`	`363`	`UART_MUTEX_UNLOCK();`
`359`	`364`	`}`
	`365`	`+#endif`
`360`	`366`
`361`	`367`	`uint8_tuartRead(uart_t*uart)`
`362`	`368`	`{`
`363`	`369`	`if(uart==NULL\|\|uart->queue==NULL){`
`364`	`370`	`return0;`
`365`	`371`	`}`
`366`	`372`	`uint8_tc;`
	`373`	`+#ifdefUART_READ_RX_FIFO`
`367`	`374`	`if ((uxQueueMessagesWaiting(uart->queue) ==0) && (uart->dev->status.rxfifo_cnt>0))`
`368`	`375`	`{`
`369`	`376`	`uartRxFifoToQueue(uart);`
`370`	`377`	`}`
	`378`	`+#endif`
`371`	`379`	`if(xQueueReceive(uart->queue, &c, 0)){`
`372`	`380`	`returnc;`
`373`	`381`	`}`
`@@ -380,10 +388,12 @@ uint8_t uartPeek(uart_t* uart)`
`380`	`388`	`return0;`
`381`	`389`	`}`
`382`	`390`	`uint8_tc;`
	`391`	`+#ifdefUART_READ_RX_FIFO`
`383`	`392`	`if ((uxQueueMessagesWaiting(uart->queue) ==0) && (uart->dev->status.rxfifo_cnt>0))`
`384`	`393`	`{`
`385`	`394`	`uartRxFifoToQueue(uart);`
`386`	`395`	`}`
	`396`	`+#endif`
`387`	`397`	`if(xQueuePeek(uart->queue, &c, 0)){`
`388`	`398`	`returnc;`
`389`	`399`	`}`
-Original file line number
+Diff line change
 structuart_struct_t;
 typedefstructuart_struct_tuart_t;
 -uart_t*uartBegin(uint8_tuart_nr, uint32_tbaudrate, uint32_tconfig, int8_trxPin, int8_ttxPin, uint16_tqueueLen, boolinverted);
 +uart_t*uartBegin(uint8_tuart_nr, uint32_tbaudrate, uint32_tconfig, int8_trxPin, int8_ttxPin, uint16_tqueueLen, boolinverted, uint8_trxfifo_full_thrhd);
 voiduartEnd(uart_t*uart, uint8_trxPin, uint8_ttxPin);
 uint32_tuartAvailable(uart_t*uart);