adds onReceive() parameter

In order to allow the user to choose if onReceive() call back will be called only when UART Rx timeout happens or also when UART FIFO gets 120 bytes, 
a new parameter has been added to onReceive() with the default behavior based on timeout.

    void onReceive(OnReceiveCb function, bool onlyOnTimeout = true);

   onReceive will setup a callback that will be called whenever an UART interruption occurs (UART_INTR_RXFIFO_FULL or UART_INTR_RXFIFO_TOUT)
   UART_INTR_RXFIFO_FULL interrupt triggers at UART_FULL_THRESH_DEFAULT bytes received (defined as 120 bytes by default in IDF)
   UART_INTR_RXFIFO_TOUT interrupt triggers at UART_TOUT_THRESH_DEFAULT symbols passed without any reception (defined as 10 symbos by default in IDF)
   onlyOnTimeout parameter will define how onReceive will behave:
   Default: true -- The callback will only be called when RX Timeout happens. 
                           Whole stream of bytes will be ready for being read on the callback function at once.
                           This option may lead to Rx Overflow depending on the Rx Buffer Size and number of bytes received in the streaming
            false --    The callback will be called when FIFO reaches 120 bytes and also on RX Timeout.
                           The stream of incommig bytes will be "split" into blocks of 120 bytes on each callback.
                           This option avoid any sort of Rx Overflow, but leaves the UART packet reassembling work to the Application.

Author: SuGlider

cores/esp32/HardwareSerial.cpp

@@ -129,7 +129,7 @@ _uart_nr(uart_nr),
 _uart(NULL), 
 _rxBufferSize(256), 
 _onReceiveCB(NULL),
-_rxTimeout(10),
+_onReceiveTimeout(true),
 _onReceiveErrorCB(NULL),
 _eventTask(NULL)
 #if !CONFIG_DISABLE_HAL_LOCKS
@@ -187,11 +187,12 @@ void HardwareSerial::onReceiveError(OnReceiveErrorCb function)
     HSERIAL_MUTEX_UNLOCK();
 }
 
-void HardwareSerial::onReceive(OnReceiveCb function)
+void HardwareSerial::onReceive(OnReceiveCb function, bool onlyOnTimeout)
 {
     HSERIAL_MUTEX_LOCK();
     // function may be NULL to cancel onReceive() from its respective task 
     _onReceiveCB = function;
+    _onReceiveTimeout = onlyOnTimeout;
 
     // this can be called after Serial.begin(), therefore it shall create the event task
     if (function != NULL && _uart != NULL && _eventTask == NULL) {
@@ -200,20 +201,12 @@ void HardwareSerial::onReceive(OnReceiveCb function)
     HSERIAL_MUTEX_UNLOCK();
 }
 
-void HardwareSerial::setRxTimeout(uint8_t symbols_timeout)
-{
-    HSERIAL_MUTEX_LOCK();
-    
-    _rxTimeout = symbols_timeout;
-
-    if(_uart != NULL) uart_set_rx_timeout(_uart_nr, _rxTimeout); // Set new timeout
-    
-    HSERIAL_MUTEX_UNLOCK();
-}
-
 void HardwareSerial::eventQueueReset()
 {
     QueueHandle_t uartEventQueue = NULL;
+    if (_uart == NULL) {
+	    return;
+    }
     uartGetEventQueue(_uart, &uartEventQueue);
     if (uartEventQueue != NULL) {
         xQueueReset(uartEventQueue);
@@ -232,14 +225,16 @@ void HardwareSerial::_uartEventTask(void *args)
             if(xQueueReceive(uartEventQueue, (void * )&event, (portTickType)portMAX_DELAY)) {
                 switch(event.type) {
                     case UART_DATA:
-                        if(uart->_onReceiveCB && uart->available() > 0) uart->_onReceiveCB(event.timeout_flag);
+                        if(uart->_onReceiveCB && uart->available() > 0 && 
+                            ((uart->_onReceiveTimeout && event.timeout_flag) || !uart->_onReceiveTimeout) ) 
+                                uart->_onReceiveCB();
                         break;
                     case UART_FIFO_OVF:
                         log_w("UART%d FIFO Overflow. Consider adding Hardware Flow Control to your Application.", uart->_uart_nr);
                         if(uart->_onReceiveErrorCB) uart->_onReceiveErrorCB(UART_FIFO_OVF_ERROR);
                         break;
                     case UART_BUFFER_FULL:
-                        log_w("UART%d Buffer Full. Consider encreasing your buffer size of your Application.", uart->_uart_nr);
+                        log_w("UART%d Buffer Full. Consider increasing your buffer size of your Application.", uart->_uart_nr);
                         if(uart->_onReceiveErrorCB) uart->_onReceiveErrorCB(UART_BUFFER_FULL_ERROR);
                         break;
                     case UART_BREAK:
@@ -343,11 +338,6 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
         _createEventTask(this);
     }
 
-    // Set UART RX timeout
-    if (_uart != NULL) {
-        uart_set_rx_timeout(_uart_nr, _rxTimeout);
-    }
-    
     HSERIAL_MUTEX_UNLOCK();
 }