reintroduced RX buffer to implement available/peek/read methods

Note that due to not being interrupt driven, the private method fillRxBuffer() is frequently called to see if there is new data to be added to the buffer.
It attempts to read for a few ms, to prevent underruns. Note however that this may have unwanted delays as a side effect.

Author: maxint-rd

cores/arduino/HardwareSerial.cpp

@@ -140,30 +140,105 @@ void HardwareSerial::begin(unsigned long baud, byte config)
   uart_init(&_serial, (uint32_t)baud, databits, parity, stopbits);
 }
 
+// MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+void HardwareSerial::fillRxBuffer(void)    // private method: read all characters that can be read
+{
+  // Fill RX buffer during read/available calls
+  // Newly received characters are added to the buffer
+  // _rx_buffer_head is the location of the new character
+  // _rx_buffer_tail is the location of the oldest character that is not read yet
+  unsigned char c;
+/*
+  while(uart_getc(&_serial, &c) == 0)
+  {
+    _rx_buffer[_rx_buffer_head]=c;
+    _rx_buffer_head = (rx_buffer_index_t)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
+  }
+*/
+  // To avoid buffer underruns, we try to read during at least a few millis.
+  // Perhaps there is a better way, but for now it works.
+  // Maybe we should also do something to handle disruption of interrupts
+/*
+  #define SERIAL_WAIT_FOR_RX 5000L
+  uint32_t uStart=micros();
+  while((micros()-uStart)<SERIAL_WAIT_FOR_RX)
+*/
+  #define SERIAL_WAIT_FOR_RX 3
+  uint32_t uStart=millis();
+  while((millis()-uStart)<SERIAL_WAIT_FOR_RX)
+  {
+    if(uart_getc(&_serial, &c) == 0)
+    {
+/*
+      _rx_buffer[_rx_buffer_head]=c;
+      _rx_buffer_head = (rx_buffer_index_t)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
+/**/
+      rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
+  
+      // if we should be storing the received character into the location
+      // just before the tail (meaning that the head would advance to the
+      // current location of the tail), we're about to overflow the buffer
+      // and so we don't write the character or advance the head.
+      if (i != _rx_buffer_tail) {
+        _rx_buffer[_rx_buffer_head] = c;
+        _rx_buffer_head = i;
+      }
+/**/
+    }
+  }
+}
+
 void HardwareSerial::end()
 {
+  // MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+  // clear any received data
+  _rx_buffer_head = _rx_buffer_tail;
+
   uart_deinit(&_serial);
 }
 
 int HardwareSerial::available(void)
 {
-  return -1;
+  // MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+  //return -1;
+  fillRxBuffer();
+  return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
 }
 
 int HardwareSerial::peek(void)
 {
-   return -1;
+  // MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+   //return -1;
+  fillRxBuffer();	// MMOLE 240316: Serial.parseInt() uses peek() with timeout to see if more data is available
+  if (_rx_buffer_head == _rx_buffer_tail) {
+    return -1;
+  } else {
+    return _rx_buffer[_rx_buffer_tail];
+  }
 }
 
 int HardwareSerial::read(void)
 {
-
   unsigned char c;
+  // MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+/*
   if(uart_getc(&_serial, &c) == 0){
     return c;
   }else{
     return -1;
   }
+*/
+  // Fill RX buffer during read/available calls
+  fillRxBuffer();
+
+  // if the head isn't ahead of the tail, we don't have any characters
+  if (_rx_buffer_head == _rx_buffer_tail) {
+    return -1;
+  } else {
+    unsigned char c = _rx_buffer[_rx_buffer_tail];
+    _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
+    return c;
+  }
 }
 
 

cores/arduino/HardwareSerial.h

@@ -20,6 +20,7 @@
   Modified 14 August 2012 by Alarus
   Modified 3 December 2013 by Matthijs Kooijman
   Modified 1 may 2023 by TempersLee
+  Modified 13 October 2023 by Maxint R&D
 */
 
 #ifndef HardwareSerial_h
@@ -109,6 +110,17 @@ class HardwareSerial : public Stream {
     {
       begin(baud, SERIAL_8N1);     //SERIAL_9E1_5  SERIAL_8N1
     }
+    // MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+    volatile rx_buffer_index_t _rx_buffer_head;
+    volatile rx_buffer_index_t _rx_buffer_tail;
+    //volatile tx_buffer_index_t _tx_buffer_head;
+    //volatile tx_buffer_index_t _tx_buffer_tail;
+
+    // Don't put any members after these buffers, since only the first
+    // 32 bytes of this struct can be accessed quickly using the ldd
+    // instruction.
+    unsigned char _rx_buffer[SERIAL_RX_BUFFER_SIZE];
+    //unsigned char _tx_buffer[SERIAL_TX_BUFFER_SIZE];
     void begin(unsigned long, uint8_t);
     void end();
 
@@ -159,6 +171,9 @@ class HardwareSerial : public Stream {
     uint8_t _config;
     unsigned long _baud;
     void init(PinName _rx, PinName _tx, PinName _rts = NC, PinName _cts = NC);
+
+    // MMOLE: reintroduced RX buffer to properly implement read/available/peek methods
+    void fillRxBuffer(void);    // read all characters that can be read
 };
 
 #if defined(USART1)