/*----------------------------------------------------------------------------
* Thread 1: Send thread
*---------------------------------------------------------------------------*/
void send_thread (void const *argument) {
T_MEAS *mptr;
mptr = osPoolAlloc(mpool); /* Allocate memory for the message */
mptr->voltage = 223.72; /* Set the message content */
mptr->current = 17.54;
mptr->counter = 120786;
osMessagePut(MsgBox, (uint32_t)mptr, osWaitForever); /* Send Message */
osDelay(100);
mptr = osPoolAlloc(mpool); /* Allocate memory for the message */
mptr->voltage = 227.23; /* Prepare a 2nd message */
mptr->current = 12.41;
mptr->counter = 170823;
osMessagePut(MsgBox, (uint32_t)mptr, osWaitForever); /* Send Message */
osThreadYield(); /* Cooperative multitasking */
osDelay(100);
mptr = osPoolAlloc(mpool); /* Allocate memory for the message */
mptr->voltage = 229.44; /* Prepare a 3rd message */
mptr->current = 11.89;
mptr->counter = 237178;
osMessagePut(MsgBox, (uint32_t)mptr, osWaitForever); /* Send Message */
osDelay(100);
/* We are done here, exit this thread */
}
/**
* @brief SD detect callback
* @param None
* @retval None
*/
void BSP_SD_DetectCallback(void)
{
if(BSP_SD_IsDetected())
{
osMessagePut ( StorageEvent, MSDDISK_CONNECTION_EVENT, 0);
}
else
{
osMessagePut ( StorageEvent, MSDDISK_DISCONNECTION_EVENT, 0);
}
}
/**
* @brief Main routine for Mass Storage Class
* @param None
* @retval None
*/
static void MSC_Application(void)
{
FRESULT res; /* FatFs function common result code */
uint32_t byteswritten; /* File write count */
uint8_t wtext[] = "This is STM32 working with FatFs"; /* File write buffer */
/* Register the file system object to the FatFs module */
if(f_mount(&USBDISKFatFs, (TCHAR const*)USBDISKPath, 0) != FR_OK)
{
/* FatFs Initialization Error */
Error_Handler();
}
else
{
/* Create and Open a new text file object with write access */
if(f_open(&MyFile1, "STM32_1.TXT", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
{
/* 'STM32_1.TXT' file Open for write Error */
Error_Handler();
}
else
{
/* Allow Second task to have access to FatFs */
osMessagePut(DiskEvent, DISK_READY_EVENT, 0);
/* Write data to the text file */
res = f_write(&MyFile1, wtext, sizeof(wtext), (void *)&byteswritten);
if((byteswritten == 0) || (res != FR_OK))
{
/* 'STM32_1.TXT' file Write or EOF Error */
Error_Handler();
}
else
{
/* Close the open text file */
f_close(&MyFile1);
/* If last access to Disk, unlink drive */
if(disk_op == 2)
{
osMessagePut(DiskEvent, DISK_REMOVE_EVENT, 0);
}
disk_op = 1;
/* Success of the demo: no error occurrence */
BSP_LED_On(LED1);
}
}
}
}
/**
* @brief SD detect callback
* @param None
* @retval None
*/
void BSP_SD_DetectCallback(void)
{
if((BSP_SD_IsDetected()))
{
/* After sd disconnection, a SD Init is required */
BSP_SD_Init();
osMessagePut ( StorageEvent, MSDDISK_CONNECTION_EVENT, 0);
}
else
{
osMessagePut ( StorageEvent, MSDDISK_DISCONNECTION_EVENT, 0);
}
}
/**
* @brief 接收完成回调函数
* @param huart: 指向串口实例.
* @retval None
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if( USART1 == huart->Instance )
{
osMessagePut( ReceiveDataQueueHandle, gUSART1_RX_TMP , 0); // 发送数据到缓冲区
}
}
/**************************************************************************//**
* @brief
* Main function is a CMSIS RTOS thread in itself
*
* @note
* This example uses threads, memory pool and message queue to demonstrate the
* usage of these CMSIS RTOS features. In this simple example, the same
* functionality could more easily be achieved by doing everything in the main
* loop.
*****************************************************************************/
int main(void)
{
int count = 0;
/* Chip errata */
CHIP_Init();
/* Initialize CMSIS RTOS structures */
/* create memory pool */
mpool = osPoolCreate(osPool(mpool));
/* create msg queue */
msgBox = osMessageCreate(osMessageQ(msgBox), NULL);
/* create thread 1 */
osThreadCreate(osThread(PrintLcdThread), NULL);
/* Infinite loop */
while (1)
{
count = (count + 1) & 0xF;
/* Send message to PrintLcdThread */
/* Allocate memory for the message */
lcdText_t *mptr = osPoolAlloc(mpool);
/* Set the message content */
(*mptr)[0] = count >= 10 ? '1' : '0';
(*mptr)[1] = count % 10 + '0';
(*mptr)[2] = '\0';
/* Send message */
osMessagePut(msgBox, (uint32_t) mptr, osWaitForever);
/* Wait now for half a second */
osDelay(500);
}
}
/**
* @brief User Process
* @param phost: Host handle
* @param id: Host Library user message ID
* @retval None
*/
static void USBH_UserProcess (USBH_HandleTypeDef *phost, uint8_t id)
{
switch (id)
{
case HOST_USER_SELECT_CONFIGURATION:
break;
case HOST_USER_DISCONNECTION:
osMessagePut ( StorageEvent, USBDISK_DISCONNECTION_EVENT, 0);
break;
case HOST_USER_CLASS_ACTIVE:
osMessagePut ( StorageEvent, USBDISK_CONNECTION_EVENT, 0);
break;
}
}
/**
* @brief USBH_LL_Disconnect
* Handle USB Host disconnection event
* @param phost: Host Handle
* @retval USBH_Status
*/
USBH_StatusTypeDef USBH_LL_Disconnect (USBH_HandleTypeDef *phost)
{
/*Stop Host */
USBH_LL_Stop(phost);
/* FRee Control Pipes */
USBH_FreePipe (phost, phost->Control.pipe_in);
USBH_FreePipe (phost, phost->Control.pipe_out);
phost->device.is_connected = 0;
if(phost->pUser != NULL)
{
phost->pUser(phost, HOST_USER_DISCONNECTION);
}
USBH_UsrLog("USB Device disconnected");
/* Start the low level driver */
USBH_LL_Start(phost);
phost->gState = HOST_DEV_DISCONNECTED;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_PORT_EVENT, 0);
#endif
return USBH_OK;
}
/**
* @brief USBH_MTP_ClassRequest
* The function is responsible for handling Standard requests
* for MTP class.
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_MTP_ClassRequest (USBH_HandleTypeDef *phost)
{
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_STATE_CHANGED_EVENT, 0);
#endif
return USBH_OK;;
}
/**
* @brief Storage drives initialization
* @param None
* @retval None
*/
void k_StorageInit(void)
{
/* Link the USB Host disk I/O driver */
FATFS_LinkDriver(&USBH_Driver, USBDISK_Drive);
/* Link the micro SD disk I/O driver */
FATFS_LinkDriver(&SD_Driver, mSDDISK_Drive);
/* Create USB background task */
osThreadDef(STORAGE_Thread, StorageThread, osPriorityBelowNormal, 0, 2 * configMINIMAL_STACK_SIZE);
osThreadCreate (osThread(STORAGE_Thread), NULL);
/* Create Storage Message Queue */
osMessageQDef(osqueue, 10, uint16_t);
StorageEvent = osMessageCreate (osMessageQ(osqueue), NULL);
/* Init Host Library */
USBH_Init(&hUSB_Host, USBH_UserProcess, 0);
/* Add Supported Class */
USBH_RegisterClass(&hUSB_Host, USBH_MSC_CLASS);
/* Start Host Process */
USBH_Start(&hUSB_Host);
/* Enable SD Interrupt mode */
BSP_SD_Init();
BSP_SD_ITConfig();
if(BSP_SD_IsDetected())
{
osMessagePut ( StorageEvent, MSDDISK_CONNECTION_EVENT, 0);
}
}
/**
* @brief Send a generic message which packages a command
* @param msgQ: Message Q to send the message to
* @param source: Where the message is being sent from
* @param command: The command to send
* @param timeout: How long the operating system must wait until the message is successfully placed in message Q msgQ
*/
void sendCommand(osMessageQId msgQ, msgSource_t source, msgCommand_t command, uint32_t timeout) {
uint8_t dataLength;
msg_genericMessage_t *messageTxPtr;
data_command_t *commandStructTxPtr;
// Allocate a block of memory in the global memory pool for the generic message
messageTxPtr = osPoolAlloc(genericMPool);
// Identify the size of the data that will be linked in based on the data struct used
dataLength = sizeof(data_command_t);
// Allocated memory for the data
commandStructTxPtr = pvPortMalloc(dataLength);
// Fill the data into the allocated memory block
commandStructTxPtr->messageType = MSG_TYPE_COMMAND;
commandStructTxPtr->command = command;
// Pass the pointer to the generic message
messageTxPtr->pData = commandStructTxPtr;
// Polpulate the generic message
messageTxPtr->mRsp = MRSP_HANDLE;
messageTxPtr->messageType = MSG_TYPE_COMMAND;
messageTxPtr->messageSource = source;
messageTxPtr->dataLength = dataLength;
// Send the message!
osMessagePut(msgQ, (uint32_t) messageTxPtr, timeout);
}
/**
* @brief Manages the DMA Half Transfer complete interrupt.
* @param None
* @retval None
*/
void BSP_AUDIO_OUT_HalfTransfer_CallBack(void)
{
if(haudio.state == AUDIOPLAYER_PLAY)
{
BSP_AUDIO_OUT_ChangeBuffer((uint16_t*)&haudio.buffer[AUDIO_BUFFER_SIZE /2], AUDIO_BUFFER_SIZE /2);
osMessagePut ( AudioEvent, BUFFER_OFFSET_HALF, 0);
}
}
/**
* @brief Manages the DMA Transfer complete interrupt.
* @param None
* @retval None
*/
void BSP_AUDIO_OUT_TransferComplete_CallBack(void)
{
if(haudio.state == AUDIOPLAYER_PLAY)
{
BSP_AUDIO_OUT_ChangeBuffer((uint16_t*)&haudio.buffer[0], AUDIO_BUFFER_SIZE /2);
osMessagePut ( AudioEvent, BUFFER_OFFSET_FULL, 0);
}
}
/**@brief Function for receiving the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
ble_evt_t * mptr;
mptr = osPoolAlloc(ble_evt_pool);
*mptr = *p_ble_evt;
(void)osMessagePut(ble_stack_msg_box, (uint32_t)mptr, 0);
}
/**
* @brief Manages the DMA Half Transfer complete interrupt.
* @param None
* @retval None
*/
static void AUDIO_HalfTransfer_CallBack(void)
{
if(haudio.in.state == AUDIO_RECORDER_PLAYING)
{
BSP_AUDIO_OUT_ChangeBuffer((uint16_t*)&haudio.buff[AUDIO_OUT_BUFFER_SIZE /2], AUDIO_OUT_BUFFER_SIZE /2);
osMessagePut ( AudioEvent, PLAY_BUFFER_OFFSET_HALF, 0);
}
}
/**
* @brief Manages the DMA Half Transfer complete interrupt.
* @param None
* @retval None
*/
void BSP_AUDIO_IN_HalfTransfer_CallBack(void)
{
/* PDM to PCM data convert */
BSP_AUDIO_IN_PDMToPCM((uint16_t*)&haudio.pdm[0],
(uint16_t*)&haudio.buff[haudio.ppcm]);
haudio.ppcm += AUDIO_IN_PDM_BUFFER_SIZE/4;
if (haudio.ppcm == AUDIO_IN_BUFFER_SIZE/2)
{
osMessagePut ( AudioEvent, REC_BUFFER_OFFSET_HALF, 0);
}
else if (haudio.ppcm >= AUDIO_IN_BUFFER_SIZE)
{
osMessagePut ( AudioEvent, REC_BUFFER_OFFSET_FULL, 0);
haudio.ppcm = 0;
}
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if(GPIO_Pin == MFX_IRQOUT_PIN)
{
if(BSP_SD_IsDetected())
{
if(CAMERA_Configured == 0)
{
BSP_SD_Init();
}
osMessagePut ( StorageEvent, MSDDISK_CONNECTION_EVENT, 0);
}
else
{
osMessagePut ( StorageEvent, MSDDISK_DISCONNECTION_EVENT, 0);
}
}
}
void StartTask_Uart1Reception (void const *argument)
{
extern osMessageQId Q_CmdReceptionHandle;
uint32_t reclen;
osStatus qretval; /*!< The return value which indicates the osMessagePut() implementation result */
uint8_t* ptrdata; /*!< Pointer to any byte in the uart buffer */
uint8_t (*ptr_bufhead)[1], /*!< Pointer to the head of the uart buffer */
(*ptr_buftail)[1]; /*!< Pointer to the tail of the uart buffer */
while (1)
{
osSignalWait (0x01, osWaitForever);
reclen = MAX_DEPTH_UART1_BUF - huart1.hdmarx->Instance->NDTR;
ptrdata = *uart_buf + reclen - 1; // point to the last char received
ptr_bufhead = (uint8_t(*)[1])uart1_buf[0];
ptr_buftail = (uint8_t(*)[1])uart1_buf[MAX_COUNT_UART1_BUF - 2];
if(*ptrdata == '\n')
{
/* Insert a terminal into the string */
*(ptrdata + 1) = 0x0;
if(*(--ptrdata) == '\r') // A command has been received
{
/*
* The current buffer has been used and post to the working thread
* switch to the next uart1 queue buffer to recevie the furture data
*/
qretval = osMessagePut(Q_CmdReceptionHandle, (uint32_t)(uart_buf), 0); // Put the pointer of the data container to the queue
if(qretval != osOK)
{
__breakpoint(0);
//printk(KERN_ERR "It's failed to put the command into the message queue!\r\n");
}
/* Move to the next row of the buffer */
uart_buf++;
if(uart_buf > (uint8_t(*)[50])ptr_buftail)
{
uart_buf = (uint8_t(*)[50])ptr_bufhead;
}
}
/* Reset DMA_EN bit can result in the TCIF interrupt.
The interrupt raises the HAL_UART_RxCpltCallback() event, the DMA_Rx will be restarted in it */
HAL_DMA_Abort(huart1.hdmarx);
USART_Start_Receive_DMA(&huart1);
}
else /* Continue recepition if the last char is not '\n' */
{
__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
}
}
}
/**
* @brief User Process
* @param phost: Host Handle
* @param id: Host Library user message ID
* @retval None
*/
static void USBH_UserProcess(USBH_HandleTypeDef *phost, uint8_t id)
{
switch(id)
{
case HOST_USER_SELECT_CONFIGURATION:
break;
case HOST_USER_DISCONNECTION:
osMessagePut(AppliEvent, APPLICATION_DISCONNECT, 0);
break;
case HOST_USER_CLASS_ACTIVE:
osMessagePut(AppliEvent, APPLICATION_READY, 0);
break;
default:
break;
}
}
void UARTThread(void const *argument) {
uint16_t delay = 0;
while(1) {
printf("Specify the LD2 LED blink period: ");
scanf("%hu", &delay);
printf("\r\nSpecified period: %hu\n\r", delay);
osMessagePut(MsgBox, delay, osWaitForever);
}
}
void Thread_ADC2 (void const *argument) {
while(1){
ADC0_SC1A=12; //channel 12
while ((ADC0_SC2 & 0x80)); //wait for conversion
while (!(ADC0_SC1A & 0x80));
osMessagePut(ADC2_queue,ADC0_RA,osWaitForever); // use message queue to send result
osDelay(10); //every 1 ms
}
}
static void demo_task2(void *arg)
{
uint32_t count = 0;
while (1) {
osMessagePut(p_msgqueue, count, 0xffffffff);
printf("demo_task2 put msg %d\n", count++);
osDelay(1000);
};
}
/**
* @brief User Process
* @param phost: Host handle
* @param id: Host Library user message ID
* @retval None
*/
static void USBH_UserProcess(USBH_HandleTypeDef *phost, uint8_t id)
{
switch(id)
{
case HOST_USER_SELECT_CONFIGURATION:
break;
case HOST_USER_DISCONNECTION:
BSP_LED_Off(LED1);
BSP_LED_Off(LED3);
osMessagePut(AppliEvent, DISCONNECTION_EVENT, 0);
break;
case HOST_USER_CLASS_ACTIVE:
osMessagePut(AppliEvent, CONNECTION_EVENT, 0);
break;
default:
break;
}
}
static void CDC_ProcessReception(USBH_HandleTypeDef *phost)
{
CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData;
USBH_URBStateTypeDef URB_Status = USBH_URB_IDLE;
uint16_t length;
switch(CDC_Handle->data_rx_state)
{
case CDC_RECEIVE_DATA:
USBH_BulkReceiveData (phost,
CDC_Handle->pRxData,
CDC_Handle->DataItf.InEpSize,
CDC_Handle->DataItf.InPipe);
CDC_Handle->data_rx_state = CDC_RECEIVE_DATA_WAIT;
break;
case CDC_RECEIVE_DATA_WAIT:
URB_Status = USBH_LL_GetURBState(phost, CDC_Handle->DataItf.InPipe);
/*Check the status done for reception*/
if(URB_Status == USBH_URB_DONE )
{
length = USBH_LL_GetLastXferSize(phost, CDC_Handle->DataItf.InPipe);
if(((CDC_Handle->RxDataLength - length) > 0) && (length > CDC_Handle->DataItf.InEpSize))
{
CDC_Handle->RxDataLength -= length ;
CDC_Handle->pRxData += length;
CDC_Handle->data_rx_state = CDC_RECEIVE_DATA;
}
else
{
CDC_Handle->data_rx_state = CDC_IDLE;
USBH_CDC_ReceiveCallback(phost);
}
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
}
break;
default:
break;
}
}
/**
* @brief This function prepares the state before issuing the class specific commands
* @param None
* @retval None
*/
USBH_StatusTypeDef USBH_CDC_SetLineCoding(USBH_HandleTypeDef *phost, CDC_LineCodingTypeDef *linecodin)
{
CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData;
if(phost->gState == HOST_CLASS)
{
CDC_Handle->state = CDC_SET_LINE_CODING_STATE;
CDC_Handle->pUserLineCoding = linecodin;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
}
return USBH_OK;
}
/**
* @brief Send a generic message which packages any data structure
* @param msgQ: Message Q to send the message to
* @param type: Type of data that is linked in
* @param source: Where the message is being sent from
* @param mRsp: Memory responsibility - whether or not the library should be responsible for allocating and deallocating the memory for the data
* @param *data: Pointer to the struct holding the message data
* @param timeout: How long the operating system must wait until the message is successfully placed in message Q msgQ
*/
void sendMessage(osMessageQId msgQ, msgType_t type, msgSource_t source, uint8_t mRsp, void *pData, uint32_t timeout) {
uint32_t dataLength; // Length of the data to be linked in
msg_genericMessage_t *messageTxPtr;
void *dataContentPtr;
// Allocate a block of memory in the global memory pool for the generic message
messageTxPtr = osPoolAlloc(genericMPool);
// Identify the size of the data that will be linked in based on the data struct used
switch (type) {
case MSG_TYPE_STRING:
dataLength = *((uint16_t *) pData) + sizeof(uint16_t);
break;
case MSG_TYPE_COMMAND:
dataLength = sizeof(data_command_t);
break;
case MSG_TYPE_COORDS:
dataLength = sizeof(data_coords_t);
break;
}
// If the library is held responsible for managing memory for data, do the thing!
if (mRsp) {
// Allocated memory for the data
dataContentPtr = pvPortMalloc(dataLength);
// Copy the data into the allocated memory block
memcpy(dataContentPtr, pData, dataLength);
// Pass the pointer to the generic message
messageTxPtr->pData = dataContentPtr;
messageTxPtr->mRsp = MRSP_HANDLE;
} else {
// Just pass the generic message the pointer, the library will not handle the memory
messageTxPtr->pData = pData;
messageTxPtr->mRsp = MRSP_NO_HANDLE;
}
// Polpulate the generic message
messageTxPtr->messageType = type;
messageTxPtr->messageSource = source;
messageTxPtr->dataLength = dataLength;
// Send the message!
osMessagePut(msgQ, (uint32_t) messageTxPtr, timeout);
}
/**
* @brief Message Queue Producer Thread.
* @param argument: Not used
* @retval None
*/
static void QueueSendThread (const void *argument)
{
for(;;)
{
/* Place this thread into the blocked state until it is time to run again.
The kernel will place the MCU into the Retention low power sleep state
when the idle thread next runs. */
osDelay(TX_DELAY);
/* Send to the queue - causing the queue receive thread to flash its LED.
It should not be necessary to block on the queue send because the Rx
thread will already have removed the last queued item. */
osMessagePut (osQueue, (uint32_t)QUEUED_VALUE, 0);
}
}
/**
* @brief USBH_HID_SOFProcess
* The function is for managing the SOF Process
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_HID_SOFProcess(USBH_HandleTypeDef *phost)
{
HID_HandleTypeDef *HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData;
if(HID_Handle->state == HID_POLL)
{
if(( phost->Timer - HID_Handle->timer) >= HID_Handle->poll)
{
HID_Handle->state = HID_GET_DATA;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_URB_EVENT, 0);
#endif
}
}
return USBH_OK;
}
/**************************************************************************//**
* @brief
* Main function is a CMSIS RTOS thread in itself
*
* @note
* This example uses threads, memory pool and message queue to demonstrate the
* usage of these CMSIS RTOS features. In this simple example, the same
* functionality could more easily be achieved by doing everything in the main
* loop.
*****************************************************************************/
int main(void)
{
int count = 0;
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
#if 0
/* Reduce power consumption by disabling part of RAM */
/* this requires changing linker script to avoid placing */
/* data in RAM above 32kB. Blocks 1,2,3 are turn off. */
EMU_MemPwrDown(_EMU_MEMCTRL_POWERDOWN_BLK123);
BURTC->POWERDOWN |= BURTC_POWERDOWN_RAM; /* turn BURTC RAM off */
LESENSE->POWERDOWN |= LESENSE_POWERDOWN_RAM; /* turn off LESENSE RAM */
#endif
/* Initialize CMSIS RTOS structures */
/* create memory pool */
mpool = osPoolCreate(osPool(mpool));
/* create msg queue */
msgBox = osMessageCreate(osMessageQ(msgBox), NULL);
/* create thread 1 */
osThreadCreate(osThread(PrintLcdThread), NULL);
/* Infinite loop */
while (1)
{
count = (count + 1) & 0xF;
/* Send message to PrintLcdThread */
/* Allocate memory for the message */
lcdText_t *mptr = osPoolAlloc(mpool);
/* Set the message content */
(*mptr)[0] = count >= 10 ? '1' : '0';
(*mptr)[1] = count % 10 + '0';
(*mptr)[2] = '\0';
/* Send message */
osMessagePut(msgBox, (uint32_t) mptr, osWaitForever);
/* Wait now for half a second */
osDelay(500);
}
}
/**
* @brief This function prepares the state before issuing the class specific commands
* @param None
* @retval None
*/
USBH_StatusTypeDef USBH_CDC_Receive(USBH_HandleTypeDef *phost, uint8_t *pbuff, uint32_t length)
{
USBH_StatusTypeDef Status = USBH_BUSY;
CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData;
if((CDC_Handle->state == CDC_IDLE_STATE) || (CDC_Handle->state == CDC_TRANSFER_DATA))
{
CDC_Handle->pRxData = pbuff;
CDC_Handle->RxDataLength = length;
CDC_Handle->state = CDC_TRANSFER_DATA;
CDC_Handle->data_rx_state = CDC_RECEIVE_DATA;
Status = USBH_OK;
#if (USBH_USE_OS == 1)
osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
}
return Status;
}