STSW-STLKT01: Projects/SensorTile/Applications/DataLog/Src/usbd_cdc_interface.c Source File

STSW-STLKT01

 
 /* Includes ------------------------------------------------------------------*/
 #include "usbd_cdc_interface.h"
 #include "main.h"
 
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 #define APP_RX_DATA_SIZE 2048
 #define APP_TX_DATA_SIZE 2048
 
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 USBD_CDC_LineCodingTypeDef LineCoding =
  {
  115200, /* baud rate*/
  0x00, /* stop bits-1*/
  0x00, /* parity - none*/
  0x08 /* nb. of bits 8*/
  };
 
 uint8_t UserRxBuffer[APP_RX_DATA_SIZE];/* Received Data over USB are stored in this buffer */
 uint8_t UserTxBuffer[APP_TX_DATA_SIZE];/* Received Data over UART (CDC interface) are stored in this buffer */
 uint32_t BuffLength;
 uint32_t UserTxBufPtrIn = 0;/* Increment this pointer or roll it back to
  start address when data are received over USART */
 uint32_t UserTxBufPtrOut = 0; /* Increment this pointer or roll it back to
  start address when data are sent over USB */
 
 volatile uint8_t USB_RxBuffer[USB_RxBufferDim];
 volatile uint16_t USB_RxBufferStart_idx = 0;
 
 /* TIM handler declaration */
 TIM_HandleTypeDef TimHandle;
 /* USB handler declaration */
 extern USBD_HandleTypeDef USBD_Device;
 
 /* Private function prototypes -----------------------------------------------*/
 static int8_t CDC_Itf_Init (void);
 static int8_t CDC_Itf_DeInit (void);
 static int8_t CDC_Itf_Control (uint8_t cmd, uint8_t* pbuf, uint16_t length);
 static int8_t CDC_Itf_Receive (uint8_t* pbuf, uint32_t *Len);
 
 static void Error_Handler(void);
 static void TIM_Config(void);
 
 USBD_CDC_ItfTypeDef USBD_CDC_fops = 
 {
  CDC_Itf_Init,
  CDC_Itf_DeInit,
  CDC_Itf_Control,
  CDC_Itf_Receive
 };
 
 /* Private functions ---------------------------------------------------------*/
 
 static int8_t CDC_Itf_Init(void)
 {
  /*##-2- Enable TIM peripherals Clock #######################################*/
  TIMx_CLK_ENABLE();
  
  /*##-3- Configure the NVIC for TIMx ########################################*/
  /* Set Interrupt Group Priority */
  HAL_NVIC_SetPriority(TIMx_IRQn, 0x6, 0);
  
  /* Enable the TIMx global Interrupt */
  HAL_NVIC_EnableIRQ(TIMx_IRQn);
  
  /*##-3- Configure the TIM Base generation #################################*/
  TIM_Config();
  
  /*##-4- Start the TIM Base generation in interrupt mode ####################*/
  /* Start Channel1 */
  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)
  {
  /* Starting Error */
  Error_Handler();
  }
  
  /*##-5- Set Application Buffers ############################################*/
  USBD_CDC_SetTxBuffer(&USBD_Device, UserTxBuffer, 0);
  USBD_CDC_SetRxBuffer(&USBD_Device, UserRxBuffer);
  
  return (USBD_OK);
 }
 
 static int8_t CDC_Itf_DeInit(void)
 {
  return (USBD_OK);
 }
 
 
 static int8_t CDC_Itf_Control (uint8_t cmd, uint8_t* pbuf, uint16_t length)
 { 
  switch (cmd)
  {
  case CDC_SEND_ENCAPSULATED_COMMAND:
  /* Add your code here */
  break;
 
  case CDC_GET_ENCAPSULATED_RESPONSE:
  /* Add your code here */
  break;
 
  case CDC_SET_COMM_FEATURE:
  /* Add your code here */
  break;
 
  case CDC_GET_COMM_FEATURE:
  /* Add your code here */
  break;
 
  case CDC_CLEAR_COMM_FEATURE:
  /* Add your code here */
  break;
 
  case CDC_SET_LINE_CODING:
  LineCoding.bitrate = (uint32_t)(pbuf[0] | (pbuf[1] << 8) |\
  (pbuf[2] << 16) | (pbuf[3] << 24));
  LineCoding.format = pbuf[4];
  LineCoding.paritytype = pbuf[5];
  LineCoding.datatype = pbuf[6];
  
  /* Set the new configuration */
 // ComPort_Config();
  break;
 
  case CDC_GET_LINE_CODING:
  pbuf[0] = (uint8_t)(LineCoding.bitrate);
  pbuf[1] = (uint8_t)(LineCoding.bitrate >> 8);
  pbuf[2] = (uint8_t)(LineCoding.bitrate >> 16);
  pbuf[3] = (uint8_t)(LineCoding.bitrate >> 24);
  pbuf[4] = LineCoding.format;
  pbuf[5] = LineCoding.paritytype;
  pbuf[6] = LineCoding.datatype; 
  break;
 
  case CDC_SET_CONTROL_LINE_STATE:
  /* Add your code here */
  break;
 
  case CDC_SEND_BREAK:
  /* Add your code here */
  break; 
  
  default:
  break;
  }
  
  return (USBD_OK);
 }
 
 uint8_t CDC_Fill_Buffer(uint8_t* Buf, uint32_t TotalLen)
 {
  uint16_t i;
  
  for (i = 0; i < TotalLen; i++)
  {
  UserTxBuffer[UserTxBufPtrIn] = Buf[i];
  UserTxBufPtrIn = (UserTxBufPtrIn + 1) % APP_RX_DATA_SIZE;
  }
  return (USBD_OK);
 }
 
 void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
 {
  uint32_t buffptr;
  uint32_t buffsize;
  
  if(UserTxBufPtrOut != UserTxBufPtrIn)
  {
  if(UserTxBufPtrOut > UserTxBufPtrIn) /* Rollback */
  {
  buffsize = APP_RX_DATA_SIZE - UserTxBufPtrOut;
  }
  else 
  {
  buffsize = UserTxBufPtrIn - UserTxBufPtrOut;
  }
  
  buffptr = UserTxBufPtrOut;
  
  USBD_CDC_SetTxBuffer(&USBD_Device, (uint8_t*)&UserTxBuffer[buffptr], buffsize);
  
  if(USBD_CDC_TransmitPacket(&USBD_Device) == USBD_OK)
  {
  UserTxBufPtrOut += buffsize;
  if (UserTxBufPtrOut == APP_RX_DATA_SIZE)
  {
  UserTxBufPtrOut = 0;
  }
  }
  }
 }
 
 
 static int8_t CDC_Itf_Receive(uint8_t* Buf, uint32_t *Len)
 {
 // uint16_t numByteToCopy;
 // if(((USB_RxBufferStart_idx) + (uint16_t)*Len) > USB_RxBufferDim)
 // {
 // numByteToCopy = USB_RxBufferDim - (USB_RxBufferStart_idx);
 // uint16_t Buf_idx = 0;
 // memcpy((uint8_t*)&USB_RxBuffer[USB_RxBufferStart_idx], (uint8_t*)&Buf[Buf_idx], numByteToCopy);
 // USB_RxBufferStart_idx = 0;
 // Buf_idx = numByteToCopy;
 // numByteToCopy = (uint16_t)(*Len - numByteToCopy);
 // memcpy((uint8_t*)&USB_RxBuffer[USB_RxBufferStart_idx], (uint8_t*)&Buf[Buf_idx], numByteToCopy);
 // USB_RxBufferStart_idx = numByteToCopy;
 // }
 // else
 // {
 // numByteToCopy = (uint16_t) * Len;
 // memcpy((uint8_t*)&USB_RxBuffer[USB_RxBufferStart_idx], (uint8_t*)&Buf[0], numByteToCopy);
 // USB_RxBufferStart_idx = USB_RxBufferStart_idx + numByteToCopy;
 // if(USB_RxBufferStart_idx == USB_RxBufferDim)
 // USB_RxBufferStart_idx = 0;
 // }
 // 
 // /* Initiate next USB packet transfer */
 // USBD_CDC_ReceivePacket(&USBD_Device);
  return (USBD_OK);
 }
 
 
 static void TIM_Config(void)
 { 
  /* Set TIMx instance */
  TimHandle.Instance = TIMx;
  
  /* Initialize TIM3 peripheral as follow:
  + Period = 10000 - 1
  + Prescaler = ((SystemCoreClock/2)/10000) - 1
  + ClockDivision = 0
  + Counter direction = Up
  */
  TimHandle.Init.Period = (CDC_POLLING_INTERVAL*1000) - 1;
  TimHandle.Init.Prescaler = 80-1;
  TimHandle.Init.ClockDivision = 0;
  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
  if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
  {
  /* Initialization Error */
  Error_Handler();
  }
 }
 
 
 static void Error_Handler(void)
 {
  /* Add your own code here */
 }
 
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Generated by
1.8.13
previous page start next page