[USB CDC] Bulk read fixed, added bulk read until

Author: makarenya

cores/arduino/Stream.h

@@ -99,7 +99,7 @@ class Stream : public Print
   // terminates if length characters have been read or timeout (see setTimeout)
   // returns the number of characters placed in the buffer (0 means no valid data found)
 
-  size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character
+  virtual size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character
   size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
   // terminates if length characters have been read, timeout, or if the terminator character  detected
   // returns the number of characters placed in the buffer (0 means no valid data found)

cores/arduino/USBSerial.cpp

@@ -99,15 +99,39 @@ int USBSerial::read(void) {
 }
 
 size_t USBSerial::readBytes(char *buffer, size_t length) {
+  uint16_t read;
   auto rest = static_cast<uint16_t>(length);
   _startMillis = millis();
   do {
-    rest -= CDC_ReceiveQueue_Read(&ReceiveQueue, reinterpret_cast<uint8_t*>(buffer), rest);
+    read = CDC_ReceiveQueue_Read(&ReceiveQueue, reinterpret_cast<uint8_t*>(buffer), rest);
+    CDC_resume_receive();
+    rest -= read;
+    buffer += read;
     if (rest == 0) return length;
   } while(millis() - _startMillis < _timeout);
   return length - rest;
 }
 
+size_t USBSerial::readBytesUntil(char terminator, char *buffer, size_t length) {
+  uint16_t read;
+  auto rest = static_cast<uint16_t>(length);
+  _startMillis = millis();
+  do {
+    bool found = CDC_ReceiveQueue_ReadUntil(&ReceiveQueue, static_cast<uint8_t>(terminator),
+            reinterpret_cast<uint8_t*>(buffer), rest, &read);
+    CDC_resume_receive();
+    rest -= read;
+    buffer += read;
+    if (found) {
+      return length - rest;
+    }
+    if (rest == 0) {
+      return length;
+    }
+  } while(millis() - _startMillis < _timeout);
+  return length - rest;
+}
+
 int USBSerial::peek(void)
 {
   // Peek one symbol, it can't change receive avaiablity

cores/arduino/USBSerial.h

@@ -37,6 +37,7 @@ class USBSerial : public Stream {
     virtual int peek(void);
     virtual int read(void);
     virtual size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer
+    virtual size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character
     virtual void flush(void);
     virtual size_t write(uint8_t);
     virtual size_t write(const uint8_t *buffer, size_t size);

cores/arduino/stm32/usb/cdc/cdc_queue.c

@@ -116,6 +116,9 @@ void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue, uint16_t size
   if (queue->write >= queue->length) {
     queue->length = CDC_RECEIVE_QUEUE_BUFFER_SIZE;
   }
+  if (queue->write >= CDC_RECEIVE_QUEUE_BUFFER_SIZE) {
+    queue->write = 0;
+  }
 }
 
 // Determine size, available for read
@@ -145,18 +148,70 @@ int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue) {
 
 uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue, uint8_t *buffer, uint16_t size) {
   volatile uint16_t write = queue->write;
+  volatile uint16_t length = queue->length;
   uint16_t available;
+  while(write != queue->write || length != queue->length) {
+    write = queue->write;
+    length = queue->length;
+  }
+
   if (write >= queue->read) {
     available = write - queue->read;
   } else {
-    available = CDC_RECEIVE_QUEUE_BUFFER_SIZE - queue->read;
+    available = length - queue->read;
   }
   if (available < size) {
     size = available;
   }
+
   memcpy(buffer, &queue->buffer[queue->read], size);
-  queue->read = (queue->read + size) % CDC_RECEIVE_QUEUE_BUFFER_SIZE;
+  queue->read = queue->read + size;
+  if (queue->read >= length) {
+    queue->read = 0;
+  }
   return size;
 }
+
+bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue, uint8_t terminator, uint8_t *buffer,
+        uint16_t size, uint16_t* fetched) {
+  volatile uint16_t write = queue->write;
+  volatile uint16_t length = queue->length;
+  uint16_t available;
+  while(write != queue->write || length != queue->length) {
+      write = queue->write;
+      length = queue->length;
+  }
+
+  if (write >= queue->read) {
+    available = write - queue->read;
+  } else {
+    available = length - queue->read;
+  }
+  if (available < size) {
+    size = available;
+  }
+
+  uint8_t* start = &queue->buffer[queue->read];
+  for(uint16_t i = 0; i < size; i++) {
+    uint8_t ch = start[i];
+    if (ch == terminator) {
+      queue->read += (uint16_t)(i + 1);
+      if (queue->read >= length) {
+        queue->read = 0;
+      }
+      *fetched = i;
+      return true;
+    } else {
+      buffer[i] = ch;
+    }
+  }
+
+  *fetched = size;
+  queue->read += size;
+  if (queue->read >= length) {
+      queue->read = 0;
+  }
+  return false;
+}
 #endif /* USBD_USE_CDC */
 #endif /* USBCON */

cores/arduino/stm32/usb/cdc/cdc_queue.h

@@ -81,6 +81,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef* queue);
 int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef* queue);
 int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef* queue);
 uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef* queue, uint8_t* buffer, uint16_t size);
+bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef* queue, uint8_t terminator, uint8_t* buffer,
+        uint16_t size, uint16_t* fetched);
 uint8_t* CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef* queue);
 void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef* queue, uint16_t size);
 

cores/arduino/stm32/usb/cdc/usbd_cdc_if.c

@@ -40,7 +40,7 @@ USBD_HandleTypeDef hUSBD_Device_CDC;
 CDC_TransmitQueue_TypeDef TransmitQueue;
 CDC_ReceiveQueue_TypeDef ReceiveQueue;
 __IO uint32_t lineState = 0;
-__IO bool receivePended = false;
+__IO bool receivePended = true;
 
 
 /** USBD_CDC Private Function Prototypes */