/**
* @brief USB_SendBuffer
* User exposed function to send data over USB CDC interface
*
* @note
* this data falls through and returns 0 if a length less than 1 is provided
*
* @param Buf: Buffer of data to be send
* @param Len: Number of data to be send (in bytes)
* @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL or USBD_BUSY
*/
uint8_t USB_SendBuffer(uint8_t * buf, uint16_t len){
if(len > 0){
CDC_Transmit_FS(buf,len);
}
return USBD_OK;
}
/**
* @brief CDC_Transmit_FS
* Data send over USB IN endpoint are sent over CDC interface
* through this function.
* @note
*
*
* @param Buf: Buffer of data to be send
* @param Len: Number of data to be send (in bytes)
* @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL or USBD_BUSY
*/
uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len)
{
uint8_t result = USBD_OK;
if ( hUsbDevice_0 == NULL ) return USBD_FAIL;
if ( hUsbDevice_0->dev_state != USBD_STATE_CONFIGURED ) return USBD_FAIL;
USBD_CDC_HandleTypeDef *pCDC =
(USBD_CDC_HandleTypeDef *)hUsbDevice_0->pClassData;
/* Determine if transfer is already in progress. */
/* If transfer in progress is stuck in that state, */
/* then reset the interface and try again. */
if ( pCDC->TxState != 0 ) {
return USBD_BUSY;
}
usb_last_tx_not_busy_timestamp = HAL_GetTick();
/* USER CODE BEGIN 8 */
if (Len > APP_TX_DATA_SIZE)
{
int offset;
for (offset = 0; offset < Len; offset++)
{
int todo = MIN(APP_TX_DATA_SIZE,
Len - offset);
result = CDC_Transmit_FS(Buf + offset, todo);
if ( ( result != USBD_OK ) && ( result != USBD_BUSY ) ) {
/* Error: Break out now */
return result;
}
}
return USBD_OK;
}
pCDC = (USBD_CDC_HandleTypeDef *)hUsbDevice_0->pClassData;
uint32_t tx_completion_wait_timestamp = HAL_GetTick();
while(pCDC->TxState)
{
if ( HAL_GetTick() - tx_completion_wait_timestamp > (uint32_t)100 ) {
/* Timeout */
return USBD_BUSY;
}
} //Wait for previous transfer to complete
int i;
for ( i = 0; i < Len; i++ ) {
UserLowLevelTxBufferFS[i] = Buf[i];
}
USBD_CDC_SetTxBuffer(hUsbDevice_0, &UserLowLevelTxBufferFS[0], Len);
result = USBD_CDC_TransmitPacket(hUsbDevice_0);
/* USER CODE END 8 */
return result;
}
int main(void)
{
/* USER CODE BEGIN 1 */
USBD_StatusTypeDef result = USBD_OK;
uint32_t userSw_old = 0;
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USB_DEVICE_Init();
/* USER CODE BEGIN 2 */
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);
userSw_old = BSP_PB_GetState(BUTTON_USER);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
HAL_Delay(40);
BSP_LED_Toggle(LED4);
if ((BSP_PB_GetState(BUTTON_USER) == GPIO_PIN_SET) && (userSw_old == GPIO_PIN_RESET))
{
result = CDC_Transmit_FS(USB_TxBufferFS, sizeof(USB_TxBufferFS));
}
userSw_old = BSP_PB_GetState(BUTTON_USER);
/* USB Error */
if (result != USBD_OK)
{
while (1)
{
BSP_LED_On(LED3);
HAL_Delay(100);
}
}
}
/* USER CODE END 3 */
}
int main(void)
{
init();
HAL_Delay(500);
uint8_t message[]="started";
CDC_Transmit_FS(message,sizeof(message));
firstclock();
while (1)
{
// if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_3)==1){
getsensordata();
}
// }
}
size_t USBSerial::write(const uint8_t *buffer, size_t size)
{
unsigned long timeout=millis()+5;
if(hUsbDeviceFS.dev_state == USBD_STATE_CONFIGURED)
{
while(millis()<timeout)
{
if(CDC_Transmit_FS((uint8_t*)buffer, size) == USBD_OK)
{
return size;
}
}
}
return 0;
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
usart2cdc_rx++;
if(usart2cdc_rx == usart2cdc_buf + usart2cdc_SIZE) {
usart2cdc_rx = usart2cdc_buf;
}
if(RBUF_FREE(usart2cdc) < 8) {
/* usart2cdc buffer nearly full, try to TX CDC immediately
*/
if(CDC_Transmit_FS() != USBD_OK && RBUF_FREE(usart2cdc) <= 1) {
/* worst case: can't TX, and buffer already full. dropping a byte. */
usart2cdc_tx++;
if(usart2cdc_tx == usart2cdc_buf + usart2cdc_SIZE) {
usart2cdc_tx = usart2cdc_buf;
}
}
}
/* Queue next byte from USART */
HAL_UART_Receive_IT(&huart2, usart2cdc_rx, 1);
/* Ensure the USB TX timer is running (should be idempotent) */
HAL_TIM_Base_Start_IT(&husbtimer);
}
uint8_t UartUsbPutBuffer( Uart_t *obj, uint8_t *buffer, uint16_t size )
{
return CDC_Transmit_FS( buffer, size );
}
int __start(void) {
const volatile uint32_t *src;
volatile uint32_t *dest;
/* Set up BSS and copy data from flash */
for (src = &_eronly, dest = &_sdata; dest < &_edata;) {
*dest++ = *src++;
}
for (dest = &_sbss; dest < &_ebss;) {
*dest++ = 0;
}
SystemInit();
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/*
Make sure the flash option bytes are set such that we don't re-enter
bootloader mode
*/
set_dfu_option_bytes(0u);
MX_USB_DEVICE_Init();
/* Configure GPIO for the CAN_SILENT signal */
GPIO_InitTypeDef GPIO_InitStruct;
/* GPIO Ports Clock Enable */
__GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
__CRS_CLK_ENABLE();
/*Configure GPIO pin : PB7 */
GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/**CAN GPIO Configuration
PB8 ------> CAN_RX
PB9 ------> CAN_TX
*/
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_CAN;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* Configure the bxCAN transceiver */
CAN_HandleTypeDef hcan;
__CAN_CLK_ENABLE();
hcan.Instance = CAN;
hcan.Init.Mode = CAN_MODE_SILENT;
hcan.Init.TTCM = DISABLE;
hcan.Init.ABOM = ENABLE;
hcan.Init.AWUM = ENABLE;
hcan.Init.NART = DISABLE;
hcan.Init.RFLM = DISABLE;
hcan.Init.TXFP = DISABLE;
/* Set the bitrate and init */
set_can_bitrate(&hcan, 1000000u);
CanRxMsgTypeDef rx_msg;
hcan.pRxMsg = &rx_msg;
CanTxMsgTypeDef tx_msg;
hcan.pTxMsg = &tx_msg;
CAN_FilterConfTypeDef filter;
filter.FilterNumber = 0;
filter.FilterMode = CAN_FILTERMODE_IDMASK;
filter.FilterScale = CAN_FILTERSCALE_32BIT;
filter.FilterFIFOAssignment = CAN_FILTER_FIFO0;
filter.FilterActivation = ENABLE;
filter.BankNumber = 0;
filter.FilterMaskIdLow = filter.FilterIdLow = filter.FilterMaskIdHigh =
filter.FilterIdHigh = 0;
HAL_CAN_ConfigFilter(&hcan, &filter);
__HAL_UNLOCK(&hcan);
/*
Now that USB is active, we need to sync with the 1 kHz SOF packets to
tune the HSI48 so it's accurate enough not to disrupt the CAN bus.
*/
RCC_CRSInitTypeDef crs_config;
crs_config.Prescaler = RCC_CRS_SYNC_DIV1;
crs_config.Source = RCC_CRS_SYNC_SOURCE_USB;
crs_config.Polarity = RCC_CRS_SYNC_POLARITY_RISING;
crs_config.ReloadValue = RCC_CRS_RELOADVALUE_DEFAULT;
crs_config.ErrorLimitValue = RCC_CRS_ERRORLIMIT_DEFAULT;
crs_config.HSI48CalibrationValue = RCC_CRS_HSI48CALIBRATION_DEFAULT;
HAL_RCCEx_CRSConfig(&crs_config);
/* Don't continue unless we're synced */
while (!(HAL_RCCEx_CRSWaitSynchronization(1000000u) & RCC_CRS_SYNCOK));
while (1) {
/* Set up the command record */
size_t i;
uint8_t current_cmd;
uint8_t current_cmd_data[32];
uint8_t current_cmd_data_length;
uint8_t channel_open;
current_cmd = current_cmd_data_length = i = 0;
channel_open = 0;
rx_buffer_length = 0;
while (hUsbDevice_0 && hUsbDevice_0->pClassData) {
/*
If the RX buffer is non-empty, process any commands/messages in it
and then acknowledge the transfer to the USB stack
*/
if (rx_buffer_length) {
/*
Exit if we've read the entire buffer, or if transmit mailboxes
are full and the current command is a transmit.
*/
for (; i < rx_buffer_length &&
((current_cmd != 't' && current_cmd != 'T') ||
__HAL_CAN_GET_FLAG(&hcan, CAN_FLAG_TME0)); i++) {
if (rx_buffer[i] == '\r') {
uint8_t *buf = active_buffer ? tx_buffer_1 :
tx_buffer_0;
/* End of command -- process and reset state */
switch (current_cmd) {
case 'S':
/*
Setup bitrate -- data should be a number from
0 to 8.
*/
if (current_cmd_data[0] < '0' ||
current_cmd_data[0] > '8') {
buf[active_buffer_length++] = '\a';
} else if (set_can_bitrate(
&hcan,
bitrate_lookup[current_cmd_data[0] - '0'])) {
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'O':
/*
Open channel -- take CAN out of silent mode
and start receiving.
*/
if (!channel_open) {
channel_open = 1;
set_can_silent(&hcan, 0);
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'L':
/*
Open in listen-only -- CAN should already be
in silent mode but just make sure.
*/
if (!channel_open) {
channel_open = 1;
set_can_silent(&hcan, 1);
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'C':
/*
Close channel -- put CAN back in silent mode.
*/
if (channel_open) {
channel_open = 0;
set_can_silent(&hcan, 1);
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'V':
/* Hardware version */
buf[active_buffer_length++] = 'V';
buf[active_buffer_length++] = '0';
buf[active_buffer_length++] = '0';
buf[active_buffer_length++] = '0';
buf[active_buffer_length++] = '1';
buf[active_buffer_length++] = '\r';
break;
case 'v':
/* Major/minor version */
buf[active_buffer_length++] = 'v';
buf[active_buffer_length++] = '0';
buf[active_buffer_length++] = '0';
buf[active_buffer_length++] = '0';
buf[active_buffer_length++] = '1';
buf[active_buffer_length++] = '\r';
break;
case 'N':
/* Serial number */
buf[active_buffer_length++] = 'N';
buf[active_buffer_length++] = 'F';
buf[active_buffer_length++] = 'F';
buf[active_buffer_length++] = 'F';
buf[active_buffer_length++] = 'F';
buf[active_buffer_length++] = '\r';
break;
case 'T':
/* Extended message */
if (read_ext_message(&tx_msg, current_cmd_data,
current_cmd_data_length) &&
HAL_CAN_Transmit(&hcan, 0) == HAL_OK) {
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 't':
/* Standard message */
if (read_std_message(&tx_msg, current_cmd_data,
current_cmd_data_length) &&
HAL_CAN_Transmit(&hcan, 0) == HAL_OK) {
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'R':
/* Extended RTR */
if (read_ext_rtr(&tx_msg, current_cmd_data,
current_cmd_data_length) &&
HAL_CAN_Transmit(&hcan, 0) == HAL_OK) {
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'r':
/* Standard RTR */
if (read_std_rtr(&tx_msg, current_cmd_data,
current_cmd_data_length) &&
HAL_CAN_Transmit(&hcan, 0) == HAL_OK) {
buf[active_buffer_length++] = '\r';
} else {
buf[active_buffer_length++] = '\a';
}
break;
case '_':
/* Bootloader request */
if (current_cmd_data[0] == '_' &&
current_cmd_data[1] == 'd' &&
current_cmd_data[2] == 'f' &&
current_cmd_data[3] == 'u') {
/*
Set option bytes to force bootloader entry
*/
set_dfu_option_bytes(1u);
NVIC_SystemReset();
} else {
buf[active_buffer_length++] = '\a';
}
break;
case 'F':
/* Read status flags -- return 4 hex digits */
case 'Z':
/* Timestamp on/off -- 0=off, 1=on */
case 'M':
/* Acceptance mask -- 8 hex digits */
case 'm':
/* Acceptance value -- 8 hex digits */
case 's':
/* Set bitrate register -- 6 hex digits */
default:
/* NACK */
buf[active_buffer_length++] = '\a';
break;
}
current_cmd = current_cmd_data_length = 0;
} else if (current_cmd) {
/* Command data -- save it */
current_cmd_data[current_cmd_data_length++] =
rx_buffer[i];
/* Reset command state if the data is too long */
if (current_cmd_data_length == 32u) {
current_cmd = current_cmd_data_length = 0;
}
} else {
/*
The first letter of a line is the command type --
don't bother validating as we can't NACK until the
data has been received.
*/
current_cmd = rx_buffer[i];
}
}
if (i == rx_buffer_length) {
/* Mark last packet as received */
rx_buffer_length = i = 0;
USBD_CDC_ReceivePacket(hUsbDevice_0);
}
}
/*
Check the CAN controller for messages and process them if the
channel is open
*/
if (HAL_CAN_Receive(&hcan, CAN_FIFO0, 0) == HAL_OK && hUsbDevice_0 &&
channel_open) {
/*
Format the message and send it to the host.
The data format for a standard ID message is:
tiiildddddddddddddddd\r
The data format for a standard ID RTR is:
riii\r
The data format for an extended ID message is:
Tiiiiiiiildddddddddddddddd\r
The data format for an extended ID RTR is:
Riiiiiiii\r
*/
uint8_t *write_location;
if (active_buffer_length + EXT_MESSAGE_LEN > TX_BUFFER_SIZE) {
/*
Reset buffer if we're too far behind -- use worst-case
message length for calculation
*/
active_buffer_length = 0;
}
write_location = &((active_buffer ? tx_buffer_1 : tx_buffer_0)[active_buffer_length]);
if (rx_msg.IDE == CAN_ID_EXT && rx_msg.RTR) {
active_buffer_length += write_ext_rtr(
write_location, &rx_msg);
} else if (rx_msg.IDE == CAN_ID_EXT && !rx_msg.RTR) {
active_buffer_length += write_ext_message(
write_location, &rx_msg);
} else if (rx_msg.IDE == CAN_ID_STD && rx_msg.RTR) {
active_buffer_length += write_std_rtr(
write_location, &rx_msg);
} else if (rx_msg.IDE == CAN_ID_STD && !rx_msg.RTR) {
active_buffer_length += write_std_message(
write_location, &rx_msg);
}
}
if (!hUsbDevice_0 || !hUsbDevice_0->pClassData) {
/* Reset TX buffer if USB is not connected */
active_buffer_length = 0;
} else if (active_buffer_length &&
((USBD_CDC_HandleTypeDef*)hUsbDevice_0->pClassData)->TxState == 0) {
/* Transmit the next buffer if one is available */
CDC_Transmit_FS(active_buffer ? tx_buffer_1 : tx_buffer_0,
active_buffer_length);
active_buffer_length = 0;
active_buffer = active_buffer ? 0 : 1;
}
}
}
}
void getsensordata(void){
// PB6 --> CLOCK
// PB7 --> SI
// uint8_t uyari[]=" ilkdata: ";uint8_t uyari2[]=" ikincidata: ";
cyclecounter=0;
while(cyclecounter<L_ARRAY){
GPIOB->BSRR=(1<<6);
nop();
nop();
GPIOB->BSRR=(1<<22);
nop();
nop();
cyclecounter++;
if(c==0){
value=getadc1();
data12[(cyclecounter)]=(value);
}
else if(c==1){
value=getadc2();
data21[(cyclecounter)]=value;
}
} // end of while loop
// one more clock is required
GPIOB->BSRR=(1<<6);
nop();
nop();
GPIOB->BSRR=(1<<22);
nop();
nop();
// new conversion
GPIOB->BSRR=(1<<7);
nop();
nop();
GPIOB->BSRR=(1<<6);
nop();
nop();
GPIOB->BSRR=(1<<23);
nop();
nop();
GPIOB->BSRR=(1<<22);
nop();
nop();
i=0;
if(c==1){
c=0;
while(i<128){
i++;
sprintf(buf2,"\n\r%d",data21[i]);
p=buf2;
CDC_Transmit_FS(p,sizeof(buf2));
} //end of while
} //end of if
else if(c==0){
c=1;
while(i<128){
i++;
sprintf(buf2,"\n\r%d",data12[i]);
p=buf2;
CDC_Transmit_FS(p,sizeof(buf2));
// HAL_Delay(1);
}//end of while
} // end of else-if
}
/**
* @brief CDC_Transmit_FS
* Data send over USB IN endpoint are sent over CDC interface
* through this function.
* @note
*
*
* @param Buf: Buffer of data to be send
* @param Len: Number of data to be send (in bytes)
* @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL or USBD_BUSY
*/
uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len)
{
uint8_t result = USBD_OK;
if ( hUsbDevice_0 == NULL ) return USBD_FAIL;
if ( hUsbDevice_0->dev_state != USBD_STATE_CONFIGURED ) return USBD_FAIL;
USBD_CDC_HandleTypeDef *pCDC =
(USBD_CDC_HandleTypeDef *)hUsbDevice_0->pClassData;
/* Determine if transfer is already in progress. */
/* If transfer in progress is stuck in that state, */
/* then reset the interface and try again. */
if ( pCDC->TxState != 0 ) {
if ( ( last_tx_not_busy_timestamp != 0 ) &&
( HAL_GetTick() - last_tx_not_busy_timestamp > (uint32_t)1000) ) {
last_tx_not_busy_timestamp = 0;
/* Empirical evidence shows that in this state, the transmit */
/* is stuck, and an endless "setup" interrupt is being received. */
/* As a result, we need to completely reinitialize the USB */
/* circuitry/driver to get this working again. */
//MX_USB_DEVICE_DeInit();
//MX_USB_DEVICE_Init();
//pCDC->TxState = 0;
return USBD_BUSY;
} else {
return USBD_BUSY;
}
}
last_tx_not_busy_timestamp = HAL_GetTick();
/* USER CODE BEGIN 8 */
if (Len > APP_TX_DATA_SIZE)
{
int offset;
for (offset = 0; offset < Len; offset++)
{
int todo = MIN(APP_TX_DATA_SIZE,
Len - offset);
result = CDC_Transmit_FS(Buf + offset, todo);
if ( ( result != USBD_OK ) && ( result != USBD_BUSY ) ) {
/* Error: Break out now */
return result;
}
}
return USBD_OK;
}
pCDC = (USBD_CDC_HandleTypeDef *)hUsbDevice_0->pClassData;
uint32_t tx_completion_wait_timestamp = HAL_GetTick();
while(pCDC->TxState)
{
if ( HAL_GetTick() - tx_completion_wait_timestamp > (uint32_t)100 ) {
/* Timeout */
return USBD_BUSY;
}
} //Wait for previous transfer to complete
int i;
for ( i = 0; i < Len; i++ ) {
UserLowLevelTxBufferFS[i] = Buf[i];
}
USBD_CDC_SetTxBuffer(hUsbDevice_0, &UserLowLevelTxBufferFS[0], Len);
result = USBD_CDC_TransmitPacket(hUsbDevice_0);
/* USER CODE END 8 */
return result;
}
/* USER CODE BEGIN PRIVATE_FUNCTIONS_IMPLEMENTATION */
uint8_t CDC_TransmitData(uint8_t* pbuf, uint16_t len)
{
return CDC_Transmit_FS(pbuf, len);
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* try to USB transmit, if we succeed & buffer empty then we can stop TX timer until next time */
if(CDC_Transmit_FS() == USBD_OK && usart2cdc_rx == usart2cdc_tx)
HAL_TIM_Base_Stop_IT(&husbtimer);
}
void processRequestFromHost(uint8_t* buf, uint32_t* size)
{
char response[64] = {0};
char* request = strstr((char*)buf, "REQ_");
if (request)
{
if (strstr(request, "REQ_INFO"))
{
sprintf(response, "CO2 SENSOR V.0.1\r\n");
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
else if (strstr(request, "REQ_GET"))
{
uint16_t co2level = co2sensor.GetCurrentCO2Level();
sprintf(response, "CO2: %d\r\n", co2level);
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
else if (strstr(request, "REQ_MODE"))
{
if (graphMode == SECONDS)
{
graphMode = MINUTES;
}
else if (graphMode == MINUTES)
{
graphMode = HOURS;
}
else if (graphMode == HOURS)
{
graphMode = STATISTICS;
}
else if (graphMode == STATISTICS)
{
graphMode = SECONDS;
}
sprintf(response, "MODE CHANGED\r\n");
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
else if (strstr(request, "REQ_SLP"))
{
switchSystemMode(SLEEP);
sprintf(response, "DISPLAY OFF\r\n");
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
else if (strstr(request, "REQ_WAKE"))
{
switchSystemMode(ACTIVE);
sprintf(response, "DISPLAY ON\r\n");
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
else if (strstr(request, "REQ_RST"))
{
co2sensor.resetSensor();
sprintf(response, "SENSOR RESETED\r\n");
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
else
{
sprintf(response, "NOT SUPPORTED\r\n");
CDC_Transmit_FS((uint8_t*)response, strlen(response));
}
}
}
