[USB CDC] Remove timer and buffer usage

Signed-off-by: Alexey Makarenya <[email protected]>

Author: makarenya

cores/arduino/USBSerial.cpp

@@ -27,123 +27,97 @@
 #define USB_TIMEOUT 50
 /* USB Device Core handle declaration */
 extern USBD_HandleTypeDef hUSBD_Device_CDC;
-extern __IO  uint32_t device_connection_status;
 extern __IO  uint32_t lineState;
-extern __IO uint8_t UserTxBuffer[APP_TX_DATA_SIZE];
-extern __IO uint8_t UserRxBuffer[APP_RX_DATA_SIZE];
-extern __IO uint32_t UserTxBufPtrIn;
-extern __IO uint32_t UserTxBufPtrOut;
-extern __IO uint32_t UserRxBufPtrIn;
-extern __IO uint32_t UserRxBufPtrOut;
 
 USBSerial SerialUSB;
 void serialEventUSB() __attribute__((weak));
 
+void USBSerial::begin(void) {
+  CDC_init();
+}
+
 void USBSerial::begin(uint32_t /* baud_count */) {
   // uart config is ignored in USB-CDC
+  begin();
 }
 
 void USBSerial::begin(uint32_t /* baud_count */, uint8_t /* config */) {
   // uart config is ignored in USB-CDC
+  begin();
 }
 
-void USBSerial::end(void) {
-
-  USBD_LL_DeInit(&hUSBD_Device_CDC);
+void USBSerial::end() {
+  CDC_deInit();
 }
 
-int USBSerial::availableForWrite(void)
+int USBSerial::availableForWrite()
 {
-  int ret_val;
-
-  /* UserTxBufPtrOut can be modified by TIM ISR, so in order to be sure that the */
-  /* value that we read is correct, we need to disable TIM Interrupt.            */
-  CDC_disable_TIM_Interrupt();
-
-  if (UserTxBufPtrIn >= UserTxBufPtrOut) {
-    ret_val = (APP_TX_DATA_SIZE - 1 - UserTxBufPtrIn + UserTxBufPtrOut);
-  } else {
-    ret_val = (UserTxBufPtrOut - UserTxBufPtrIn - 1);
-  }
-
-  CDC_enable_TIM_Interrupt();
-
-  return ret_val;
+  // Just transmit queue size, available for write
+  return static_cast<int>(CDC_TransmitQueue_WriteSize(&TransmitQueue));
 }
 
 size_t USBSerial::write(uint8_t ch) {
-
-  /* UserTxBufPtrOut can be modified by TIM ISR, so in order to be sure that the */
-  /* value that we read is correct, we need to disable TIM Interrupt.            */
-  CDC_disable_TIM_Interrupt();
-
-  if (((UserTxBufPtrIn + 1) % APP_TX_DATA_SIZE) == UserTxBufPtrOut) {
-    // Buffer full!!! Force a flush to not loose data and go on
-    CDC_flush();
-  }
-  UserTxBuffer[UserTxBufPtrIn] = ch;
-  UserTxBufPtrIn = ((UserTxBufPtrIn + 1) % APP_TX_DATA_SIZE);
-
-  CDC_enable_TIM_Interrupt();
-
-  return 1;
+  // Just write single-byte buffer.
+  return write(&ch, 1);
 }
 
 size_t USBSerial::write(const uint8_t *buffer, size_t size){
-  size_t i = 0;
-  for (i=0; i < size; i++) {
-    if (write(buffer[i]) != 1) {
-      break;
-	}
+  size_t rest = size;
+  while(rest > 0) {
+    // Determine buffer size available for write
+    auto portion = (size_t)CDC_TransmitQueue_WriteSize(&TransmitQueue);
+    // Truncate it to content size (if rest is greater)
+    if (rest < portion) {
+      portion = rest;
+    }
+    if (portion > 0) {
+      // Only if some space in the buffer exists.
+      // TS: Only main thread calls write and writeSize methods,
+      // it's thread-safe since IRQ does not affects
+      // TransmitQueue write position
+      CDC_TransmitQueue_Enqueue(&TransmitQueue, buffer, portion);
+      rest -= portion;
+      buffer += portion;
+      // After storing data, start transmitting process
+      CDC_continue_transmit();
+    }
   }
-  return i;
+  return size;
 }
 
 int USBSerial::available(void) {
-  return ((APP_RX_DATA_SIZE + (UserRxBufPtrIn - UserRxBufPtrOut)) % APP_RX_DATA_SIZE);
+  // Just ReceiveQueue size, available for reading
+  return static_cast<int>(CDC_ReceiveQueue_ReadSize(&ReceiveQueue));
 }
 
 int USBSerial::read(void) {
-  if (UserRxBufPtrOut == UserRxBufPtrIn) {
+  // Empty ReceiveQueue - nothing to return
+  if (CDC_ReceiveQueue_ReadSize(&ReceiveQueue) <= 0) {
     return -1;
-  } else {
-    unsigned char c = UserRxBuffer[UserRxBufPtrOut];
-    UserRxBufPtrOut = ((UserRxBufPtrOut + 1) % APP_RX_DATA_SIZE);
-    CDC_resume_receive();
-    return c;
   }
+  // Dequeue only one char from queue
+  // TS: it safe, because only main thread affects ReceiveQueue->read pos
+  char ch = CDC_ReceiveQueue_Dequeue(&ReceiveQueue);
+  // Resume receive process, if possible
+  CDC_resume_receive();
+  return ch;
 }
 
 int USBSerial::peek(void)
 {
-  if (UserRxBufPtrOut == UserRxBufPtrIn) {
+  // Empty ReceiveQueue - nothing to return
+  if (CDC_ReceiveQueue_ReadSize(&ReceiveQueue) <= 0) {
     return -1;
-  } else {
-    unsigned char c = UserRxBuffer[UserRxBufPtrOut];
-    return c;
   }
+  // Peek one symbol, it can't change receive avaiablity
+  return CDC_ReceiveQueue_Peek(&ReceiveQueue);
 }
 
 void USBSerial::flush(void)
 {
-  /* UserTxBufPtrOut can be modified by TIM ISR, so in order to be sure that the */
-  /* value that we read is correct, we need to disable TIM Interrupt.            */
-  CDC_disable_TIM_Interrupt();
-  CDC_flush();
-  CDC_enable_TIM_Interrupt();
-}
-
-uint8_t USBSerial::pending(void) {
-  return 0;
-}
-
-uint8_t USBSerial::isConnected(void) {
-
-  if (device_connection_status == 1) {
-    return 1;
-  } else {
-    return 0;
-  }
+  // Wait for TransmitQueue read size becomes zero
+  // TS: safe, because it not be stopped while receive 0
+  while(CDC_TransmitQueue_ReadSize(&TransmitQueue) > 0) {}
 }
 
 uint32_t USBSerial::baud() {

cores/arduino/USBSerial.h

@@ -27,8 +27,7 @@
 // Serial over CDC
 class USBSerial : public Stream {
 public:
-    USBSerial(void) {};
-
+    void begin(void);
     void begin(uint32_t);
 	void begin(uint32_t, uint8_t);
     void end(void);
@@ -64,9 +63,6 @@ class USBSerial : public Stream {
       MARK_PARITY = 3,
       SPACE_PARITY = 4,
     };
-
-	uint8_t isConnected();
-    uint8_t pending();
 };
 
 extern USBSerial SerialUSB;

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

@@ -678,6 +678,7 @@ static uint8_t  USBD_CDC_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
 {
   USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*)pdev->pClassData;
   PCD_HandleTypeDef *hpcd = pdev->pData;
+  USBD_CDC_ItfTypeDef* ctrl = (USBD_CDC_ItfTypeDef *)pdev->pUserData;
 
   if(pdev->pClassData != NULL)
   {
@@ -692,6 +693,10 @@ static uint8_t  USBD_CDC_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
     else
     {
       hcdc->TxState = 0U;
+      if (ctrl->Transferred)
+      {
+        ctrl->Transferred();
+      }
     }
     return USBD_OK;
   }

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

@@ -104,6 +104,7 @@ typedef struct _USBD_CDC_Itf
   int8_t (* DeInit)        (void);
   int8_t (* Control)       (uint8_t cmd, uint8_t* pbuf, uint16_t length);
   int8_t (* Receive)       (uint8_t* Buf, uint32_t *Len);
+  int8_t (* Transferred)   (void);
 
 }USBD_CDC_ItfTypeDef;