static int8_t tunnelInit(void) { doubleBuffer_init(&usbReceiveBuffer, usbRecvData, sizeof(usbRecvData)); USBD_CDC_SetRxBuffer(&USBD_Device, usbRecvData); return USBD_OK; }
/** * @brief Initializes the CDC media low layer * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { /*##-6- Enable TIM peripherals Clock #######################################*/ USBCDCTIMx_CLK_ENABLE(); /*##-7- Configure the NVIC for TIMx ########################################*/ /* Set Interrupt Group Priority */ HAL_NVIC_SetPriority(USBCDCTIMx_IRQn, 6, 0); /* Enable the TIMx global Interrupt */ HAL_NVIC_EnableIRQ(USBCDCTIMx_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(&USBCDCTimHandle) != HAL_OK) { /* Starting Error */ Error_Handler(); } /*##-5- Set Application Buffers ############################################*/ USBD_CDC_SetTxBuffer(&usb_cdc_dev_param, UserTxBuffer, 0); USBD_CDC_SetRxBuffer(&usb_cdc_dev_param, UserRxBuffer); return (USBD_OK); }
/** * @brief CDC_Itf_Init * Initializes the CDC media low layer * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { #if 0 /*##-1- Configure the UART peripheral ######################################*/ /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* USART configured as follow: - Word Length = 8 Bits - Stop Bit = One Stop bit - Parity = No parity - BaudRate = 115200 baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 115200; UartHandle.Init.WordLength = UART_WORDLENGTH_8B; UartHandle.Init.StopBits = UART_STOPBITS_1; UartHandle.Init.Parity = UART_PARITY_NONE; UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UartHandle.Init.Mode = UART_MODE_TX_RX; if(HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /*##-2- Put UART peripheral in IT reception process ########################*/ /* Any data received will be stored in "UserTxBuffer" buffer */ if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK) { /* Transfer error in reception process */ Error_Handler(); } /*##-3- Configure the TIM Base generation #################################*/ now done in HAL_MspInit TIM_Config(); #endif /*##-4- Start the TIM Base generation in interrupt mode ####################*/ /* Start Channel1 */ __HAL_TIM_ENABLE_IT(&TIM3_Handle, TIM_IT_UPDATE); /*##-5- Set Application Buffers ############################################*/ USBD_CDC_SetTxBuffer(&hUSBDDevice, UserTxBuffer, 0); USBD_CDC_SetRxBuffer(&hUSBDDevice, UserRxBuffer); UserRxBufCur = 0; UserRxBufLen = 0; /* NOTE: we cannot reset these here, because USBD_CDC_SetInterrupt * may be called before this init function to set these values. * This can happen if the USB enumeration occurs after the call to * USBD_CDC_SetInterrupt. user_interrupt_char = VCP_CHAR_NONE; user_interrupt_data = NULL; */ return (USBD_OK); }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { hUsbDevice_0 = &hUsbDeviceFS; USBD_CDC_SetRxBuffer(hUsbDevice_0, ReceiveBuffer); USBD_CDC_ReceivePacket(hUsbDevice_0); return (USBD_OK); }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ USBD_CDC_SetRxBuffer(hUsbDevice_0, &Buf[0]); USBD_CDC_ReceivePacket(hUsbDevice_0); return (USBD_OK); /* USER CODE END 6 */ }
/** * @brief CDC_Itf_Init * Initializes the CDC media low layer * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { // USBD_CDC_SetTxBuffer(&hUSBDDevice, NULL, 0); USBD_CDC_SetRxBuffer(&hUSBDDevice, UserRxBuffer); return (USBD_OK); }
/** * @brief CDC_Itf_DataRx * Data received over USB OUT endpoint is processed here. * @param Buf: Buffer of data received * @param Len: Number of data received (in bytes) * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL * @note The buffer we are passed here is just UserRxBuffer, so we are * free to modify it. */ static int8_t CDC_Itf_Receive(uint8_t* Buf, uint32_t *Len) { #if 0 // this sends the data over the UART using DMA HAL_UART_Transmit_DMA(&UartHandle, Buf, *Len); #endif // TODO improve this function to implement a circular buffer // if we have processed all the characters, reset the buffer counters if (UserRxBufCur > 0 && UserRxBufCur >= UserRxBufLen) { memmove(UserRxBuffer, UserRxBuffer + UserRxBufLen, *Len); UserRxBufCur = 0; UserRxBufLen = 0; } uint32_t delta_len; if (user_interrupt_char == -1) { // no special interrupt character delta_len = *Len; } else { // filter out special interrupt character from the buffer bool char_found = false; uint8_t *dest = Buf; uint8_t *src = Buf; uint8_t *buf_top = Buf + *Len; for (; src < buf_top; src++) { if (*src == user_interrupt_char) { char_found = true; // raise exception when interrupts are finished pendsv_nlr_jump(user_interrupt_data); } else { if (char_found) { *dest = *src; } dest++; } } // length of remaining characters delta_len = dest - Buf; } if (UserRxBufLen + delta_len + CDC_DATA_FS_MAX_PACKET_SIZE > APP_RX_DATA_SIZE) { // if we keep this data then the buffer can overflow on the next USB rx // so we don't increment the length, and throw this data away } else { // data fits, leaving room for another CDC_DATA_FS_OUT_PACKET_SIZE UserRxBufLen += delta_len; } // initiate next USB packet transfer, to append to existing data in buffer USBD_CDC_SetRxBuffer(&hUSBDDevice, UserRxBuffer + UserRxBufLen); USBD_CDC_ReceivePacket(&hUSBDDevice); return USBD_OK; }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ USBD_CDC_SetRxBuffer(hUsbDevice_0, &Buf[0]); USBD_CDC_ReceivePacket(hUsbDevice_0); HAL_UART_Transmit_IT(&huart2, Buf, *Len); return (USBD_OK); /* USER CODE END 6 */ }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { /* USER CODE BEGIN 3 */ /* Set Application Buffers */ USBD_CDC_SetTxBuffer(&hUsbDeviceFS, UserTxBufferFS, 0); USBD_CDC_SetRxBuffer(&hUsbDeviceFS, UserRxBufferFS); return (USBD_OK); /* USER CODE END 3 */ }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]); USBD_CDC_ReceivePacket(&hUsbDeviceFS); CDC_RX_Data = &Buf[0]; return (USBD_OK); /* USER CODE END 6 */ }
/** * @brief CDC_Itf_Init * Initializes the CDC media low layer * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { /*##-5- Set Application Buffers ############################################*/ USBD_CDC_SetTxBuffer(&USBD_Device, UserTxBuffer, 0); USBD_CDC_SetRxBuffer(&USBD_Device, UserRxBuffer); return (USBD_OK); }
/** * @brief CDC_Init_HS * Initializes the CDC media low layer over the USB HS IP * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_HS(void) { hUsbDevice_1 = &hUsbDeviceHS; /* USER CODE BEGIN 8 */ /* Set Application Buffers */ USBD_CDC_SetTxBuffer(hUsbDevice_1, UserTxBufferHS, 0); USBD_CDC_SetRxBuffer(hUsbDevice_1, UserRxBufferHS); return (USBD_OK); /* USER CODE END 8 */ }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { hUsbDevice_0 = &hUsbDeviceFS; /* USER CODE BEGIN 4 */ /* Set Application Buffers */ USBD_CDC_SetTxBuffer(hUsbDevice_0, UserTxBuffer, 0); USBD_CDC_SetRxBuffer(hUsbDevice_0, UserRxBuffer); return (USBD_OK); /* USER CODE END 4 */ }
/** * @brief CDC_Receive_FS * Callback. Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* buf, uint32_t *len) { if(len == 0) return USBD_OK; /* not sure if this ever happens but it might */ /* Push the buffer we just received into the HAL UART TX quee */ HAL_StatusTypeDef r; while((r = HAL_UART_Transmit_IT(&huart2, buf, *len)) == HAL_BUSY) { // We could go into STOP mode here, but USB is connected so who cares about power? // UART, transmit timer are both higher priority interrupts so will interrupt us here } /* Swap the buffer that we'll receive next CDC packet into */ if(buf == cdc2usart_buf_a) USBD_CDC_SetRxBuffer(husb, cdc2usart_buf_b); else USBD_CDC_SetRxBuffer(husb, cdc2usart_buf_a); USBD_CDC_ReceivePacket(husb); return r == HAL_OK ? USBD_OK : USBD_FAIL; }
/** * @brief CDC_Itf_Init * Initializes the CDC media low layer * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { #if 0 /*##-1- Configure the UART peripheral ######################################*/ /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* USART configured as follow: - Word Length = 8 Bits - Stop Bit = One Stop bit - Parity = No parity - BaudRate = 115200 baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 115200; UartHandle.Init.WordLength = UART_WORDLENGTH_8B; UartHandle.Init.StopBits = UART_STOPBITS_1; UartHandle.Init.Parity = UART_PARITY_NONE; UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UartHandle.Init.Mode = UART_MODE_TX_RX; UartHandle.Init.OverSampling = UART_OVERSAMPLING_16; if(HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /*##-2- Put UART peripheral in IT reception process ########################*/ /* Any data received will be stored in "UserTxBuffer" buffer */ if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK) { /* Transfer error in reception process */ Error_Handler(); } #endif /*##-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); }
/* initializes the CDC media low level layer */ static int8_t CDC_Itf_Init(void) { TIM_Config(); if (HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK) { Error_Handler(); } USBD_CDC_SetTxBuffer(&USBD_Device, UserTxBuffer, 0); USBD_CDC_SetRxBuffer(&USBD_Device, UserRxBuffer); return USBD_OK; }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { hUsbDevice_0 = &hUsbDeviceFS; /* USER CODE BEGIN 4 */ /* Set Application Buffers */ USBD_CDC_SetTxBuffer(hUsbDevice_0, UserLowLevelTxBufferFS, 0); USBD_CDC_SetRxBuffer(hUsbDevice_0, UserLowLevelRxBufferFS); AppRxBufferHeadIndex = 0; AppRxBufferTailIndex = 0; if ( hUsbDevice_0 == NULL ) return USBD_FAIL; usb_init_count++; return (USBD_OK); /* USER CODE END 4 */ }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { uint32_t i; /* USER CODE BEGIN 7 */ for (i = 0; i < *Len; i++) UserTxBufferFS[i] = UserRxBufferFS[i]; USBD_CDC_SetTxBuffer(&hUsbDeviceFS, &UserTxBufferFS[0], *Len); USBD_CDC_TransmitPacket(&hUsbDeviceFS); USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]); USBD_CDC_ReceivePacket(&hUsbDeviceFS); return (USBD_OK); /* USER CODE END 7 */ }
static int8_t CDC_Itf_Init(void) { tx_wr = 0; tx_rd = 0; tx_overflow = 0; rx_wr = 0; rx_rd = 0; rx_overflow = 0; USBD_CDC_SetTxBuffer(&hUSBDDevice, tx_fifo, 0); USBD_CDC_SetRxBuffer(&hUSBDDevice, rx_buffer); cdc_timer_start(); return USBD_OK; }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { husb = &hUsbDeviceFS; /* Configure the USART with some sensible defaults TODO: If possible, don't drive TX high while CDC is "closed"? */ huart2.Instance = USART2; huart2.Init.BaudRate = 115200; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; huart2.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED ; huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; HAL_UART_Init(&huart2); /* Enable USART2 in NVIC, set priority to high */ NVIC_SetPriority(USART2_IRQn, USART_IRQ_PRIORITY); NVIC_EnableIRQ(USART2_IRQn); /* UART2 receives data to the CDC transmit buffer, byte at a time :( */ if(HAL_UART_Receive_IT(&huart2, usart2cdc_rx, 1) != HAL_OK) return USBD_FAIL; /* Configure USB transmit timer */ husbtimer.Instance = TIM3; husbtimer.Init.Period = 10000 - 1; /* approx 10ms, I think... */ husbtimer.Init.Prescaler = 48-1; husbtimer.Init.ClockDivision = 0; husbtimer.Init.CounterMode = TIM_COUNTERMODE_UP; if(HAL_TIM_Base_Init(&husbtimer) != HAL_OK) return USBD_FAIL; __TIM3_CLK_ENABLE(); NVIC_SetPriority(TIM3_IRQn, USB_TIMER_IRQ_PRIORITY); NVIC_EnableIRQ(TIM3_IRQn); /* Set Application USB Buffers */ USBD_CDC_SetTxBuffer(husb, usart2cdc_tx, 0); /* don't send anything now */ USBD_CDC_SetRxBuffer(husb, cdc2usart_buf_a); /* read into here if CDC data comes */ return USBD_OK; }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 7 */ // uncomment this for you know what //#define CDCecho #ifdef CDCecho for (int i = 0; i < *Len; i++) UserTxBufferFS[i] = UserRxBufferFS[i]; USBD_CDC_SetTxBuffer(&hUsbDeviceFS, &UserTxBufferFS[0], *Len); USBD_CDC_TransmitPacket(&hUsbDeviceFS); USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]); USBD_CDC_ReceivePacket(&hUsbDeviceFS); #endif return (USBD_OK); /* USER CODE END 7 */ }
/** * @brief CDC_Itf_Init * Initializes the CDC media low layer * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { /*##-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); }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ uint8_t result = USBD_OK; static uint8_t buff_RX[512]; static uint8_t buff_TX[512]; int i = 0; for (i = 0; i < *Len; i++) buff_TX[i] = buff_RX[i]; USBD_CDC_SetTxBuffer(hUsbDevice_0, &buff_TX[0], *Len); USBD_CDC_TransmitPacket(hUsbDevice_0); USBD_CDC_SetRxBuffer(hUsbDevice_0, &buff_RX[0]); USBD_CDC_ReceivePacket(hUsbDevice_0); return (result); /* USER CODE END 6 */ }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { hUsbDevice_0 = &hUsbDeviceFS; /* USER CODE BEGIN 4 */ /* Set Application Buffers */ USBD_CDC_SetTxBuffer(hUsbDevice_0, UserLowLevelTxBufferFS, 0); USBD_CDC_SetRxBuffer(hUsbDevice_0, UserLowLevelRxBufferFS); AppRxBufferHeadIndex = 0; AppRxBufferTailIndex = 0; if ( hUsbDevice_0 == NULL ) return USBD_FAIL; USBD_CDC_HandleTypeDef *pCDC = (USBD_CDC_HandleTypeDef *)hUsbDevice_0->pClassData; if ( pCDC->TxState != 0 ) { pCDC->TxState = 0; //pCDC->RxState = 0; } return (USBD_OK); /* USER CODE END 4 */ }
static int8_t CDC_Itf_Receive(uint8_t* pbuf, uint32_t *Len) { uint32_t n = *Len; uint32_t i; // Write the received buffer to the Rx fifo. for (i = 0; i < n; i ++) { uint32_t rx_wr_inc = (rx_wr == (RX_FIFO_SIZE - 1)) ? 0 : rx_wr + 1; if (rx_wr_inc != rx_rd) { rx_fifo[rx_wr] = pbuf[i]; rx_wr = rx_wr_inc; } else { rx_overflow += 1; } } USBD_CDC_SetRxBuffer(&hUSBDDevice, rx_buffer); USBD_CDC_ReceivePacket(&hUSBDDevice); return USBD_OK; }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { uint8_t i; for( i = 0; i < *Len; i++ ) { if( IsFifoFull( &UartObj->FifoRx ) == false ) { // Read one byte from the receive data register FifoPush( &UartObj->FifoRx, Buf[i] ); } } if( UartObj->IrqNotify != NULL ) { UartObj->IrqNotify( UART_NOTIFY_RX ); } USBD_CDC_SetRxBuffer(hUsbDevice_0, Buf); USBD_CDC_ReceivePacket(hUsbDevice_0); return (USBD_OK); }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ memcpy(User_Data, Buf, *Len); // if(User_Data[1] == 0) { // temp = atoi(&User_Data[0]); // } // else { // UiData[temp - 1] = atoi(&User_Data[0]); // memset(User_Data, 0, sizeof(User_Data)); // } if(temp == 0) { temp = atoi(&User_Data[0]); } else { UiData[temp - 1] = atoi(&User_Data[0]); temp = 0; memset(User_Data, 0, sizeof(User_Data)); } //a = atoi((const char *) User_Data[0]); //UiData[a] = //UiData[atoi(User_Data[0])] = atoi(User_Data[1]); USBD_CDC_SetRxBuffer(hUsbDevice_0, &Buf[0]); USBD_CDC_ReceivePacket(hUsbDevice_0); return (USBD_OK); /* USER CODE END 6 */ }
void USB_Handler(uint8_t* Buf, uint32_t *Len) { int sz; RTC_DateTypeDef sDate; RTC_TimeTypeDef sTime; if (UserRxBufferFS[0] == 0xAB) { settingsPacket.startByte = UserRxBufferFS[0]; settingsPacket.command = UserRxBufferFS[1]; for (int i = 0; i < 16; i++) settingsPacket.data[i] = UserRxBufferFS[i + 2]; switch (settingsPacket.command) { case READ_ID: settingsPacket.data[0] = 1; strcpy((char *) &settingsPacket.data[1], (char *) &device.settings->firmware.VERSION); break; case SET_TIME: sDate.Year = settingsPacket.data[0]; sDate.Month = settingsPacket.data[1]; sDate.Date = settingsPacket.data[2]; sTime.Hours = settingsPacket.data[3]; sTime.Minutes = settingsPacket.data[4]; sTime.Seconds = settingsPacket.data[5]; settingsPacket.data[0] = 1; #ifdef __RTC__ HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN); HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN); #endif break; case GET_DOOR_EVENT: settingsPacket.data[0] = 1; HAL_I2C_Mem_Read(&hi2c1, EEPROM_CODE, INIT_EEPROM + 4, I2C_MEMADD_SIZE_8BIT, (uint8_t*) device.door, sizeof(DOOR_T), 1000); device.door->STATUS = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_3); settingsPacket.data[1] = device.door->STATUS; #ifdef __DEDUG__ printf("door->STATUS %u\n", device.door->STATUS); #endif settingsPacket.data[2] = device.door->COUNT; settingsPacket.data[3] = device.door->TIME.Hours; settingsPacket.data[4] = device.door->TIME.Minutes; settingsPacket.data[5] = device.door->TIME.Seconds; settingsPacket.data[6] = device.door->DATE.Date; settingsPacket.data[7] = device.door->DATE.Month; settingsPacket.data[8] = device.door->DATE.Year; break; case READ_VERSION: settingsPacket.data[0] = 1; strcpy(&settingsPacket.data[1], &device.settings->firmware.VERSION[0]); break; case RESET_DOOR_EVENT: memset(device.door, 0, sizeof(DOOR_T)); HAL_I2C_Mem_Write(&hi2c1, EEPROM_CODE, INIT_EEPROM + 4, I2C_MEMADD_SIZE_8BIT, (uint8_t*) device.door, sizeof(DOOR_T), 1000); // HAL_I2C_Mem_Read(&hi2c1, EEPROM_CODE, INIT_EEPROM + 4, I2C_MEMADD_SIZE_8BIT, // (uint8_t*) device.door, sizeof(DOOR_T), 1000); break; } // for (int i = 0; i < *Len; i++) // UserTxBufferFS[i] = UserRxBufferFS[i]; // // USBD_CDC_SetTxBuffer(&hUsbDeviceFS, &UserTxBufferFS[0], *Len); USBD_CDC_SetTxBuffer(&hUsbDeviceFS, (uint8_t*) &settingsPacket, sizeof(settingsPacket)); USBD_CDC_TransmitPacket(&hUsbDeviceFS); USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]); USBD_CDC_ReceivePacket(&hUsbDeviceFS); } else { settingsPacket.startByte = UserRxBufferFS[0]; USBD_CDC_SetTxBuffer(&hUsbDeviceFS, (uint8_t*) &settingsPacket, 1); USBD_CDC_TransmitPacket(&hUsbDeviceFS); USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]); USBD_CDC_ReceivePacket(&hUsbDeviceFS); } }
/** * @brief VCP_Init * Initializes the CDC media low layer * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t VCP_Init(void) { USBD_CDC_SetRxBuffer(&hUSBDDevice, s_RxBuffer.Buffer); g_VCPInitialized = 1; return (0); }
/** * @brief CDC_Itf_Init * Initializes the CDC media low layer * @param None * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { USBD_CDC_SetRxBuffer(&USBD_Device, USBRxBuffer); return (USBD_OK); }