void sd_mmc_mci_write_multiple_sector_callback(void *psector) { #ifdef USB_DEVICE_VENDOR_ID // USB Device Stack V2 udi_msc_trans_block( false, (uint8_t*)psector, SD_MMC_SECTOR_SIZE, NULL); #else // USB Device Stack V1 uint16_t data_to_transfer = SD_MMC_SECTOR_SIZE; // Transfer sector to write from the USB interface. while (data_to_transfer) { while (!Is_usb_out_received(g_scsi_ep_ms_out)) { if(!Is_usb_endpoint_enabled(g_scsi_ep_ms_out)) return; // USB Reset } Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_out); data_to_transfer = usb_read_ep_rxpacket(g_scsi_ep_ms_out, psector, data_to_transfer, &psector); Usb_ack_out_received_free(g_scsi_ep_ms_out); } #endif }
//! //! @brief USB Command Block Wrapper (CBW) management //! //! This function decodes the CBW command and stores the SCSI command. //! static void usb_mass_storage_cbw(void) { bool cbw_error; Usb_reset_endpoint_fifo_access(EP_MS_OUT); //! Check if dCBWSignature is correct cbw_error = (Usb_read_endpoint_data(EP_MS_OUT, 32) != *(U32 *)&"USBC"); //! Store CBW Tag to be repeated in CSW dCBWTag = Usb_read_endpoint_data(EP_MS_OUT, 32); g_scsi_data_remaining = Usb_read_endpoint_data(EP_MS_OUT, 32); g_scsi_data_remaining = usb_format_usb_to_mcu_data(32, g_scsi_data_remaining); //! if (bmCBWFlags.bit7 == 1) {direction = IN;} if (Usb_read_endpoint_data(EP_MS_OUT, 8)) { ms_endpoint = EP_MS_IN; if (cbw_error) { Usb_ack_out_received_free(EP_MS_OUT); Usb_enable_stall_handshake(EP_MS_IN); return; } } else { ms_endpoint = EP_MS_OUT; if (cbw_error) { Usb_enable_stall_handshake(EP_MS_OUT); Usb_ack_out_received_free(EP_MS_OUT); return; } } usb_LUN = Usb_read_endpoint_data(EP_MS_OUT, 8); if (!ms_multiple_drive) { usb_LUN = get_cur_lun(); } //! Dummy CBWCBLength read Usb_read_endpoint_data(EP_MS_OUT, 8); //! Store scsi_command usb_read_ep_rxpacket(EP_MS_OUT, g_scsi_command, sizeof(g_scsi_command), NULL); Usb_ack_out_received_free(EP_MS_OUT); // Take the USB Mutex(i.e. we're allowed to perform a ms cmd). /* if( ( pdFALSE == ( xGiveUsbMutex = x_supervisor_SemaphoreTake( xUSBMutex, 0 ) ) ) || ( !scsi_decode_command() && g_scsi_data_remaining ) ) */ if( ( pdFALSE == (xGiveUsbMutex = x_supervisor_SemaphoreTake( xUSBMutex, 0 ) ) ) || ( !scsi_decode_command() && g_scsi_data_remaining ) ) { Usb_enable_stall_handshake(ms_endpoint); } }
// ! // ! @brief USB Command Block Wrapper (CBW) management // ! // ! This function decodes the CBW command and stores the SCSI command. // ! static void usb_mass_storage_cbw (void) { Bool cbw_error; Usb_reset_endpoint_fifo_access (EP_MS_OUT); // ! Check if dCBWSignature is correct cbw_error = (Usb_read_endpoint_data (EP_MS_OUT, 32) != *(U32 *) & "USBC"); // ! Store CBW Tag to be repeated in CSW dCBWTag = Usb_read_endpoint_data (EP_MS_OUT, 32); g_scsi_data_remaining = Usb_read_endpoint_data (EP_MS_OUT, 32); g_scsi_data_remaining = usb_format_usb_to_mcu_data (32, g_scsi_data_remaining); /* Show the remaining bytes { U8 Text_u8[20]; CI_StringOut (" - "); itoa ((S32)g_scsi_data_remaining,Text_u8); CI_StringOut (Text_u8); CI_StringOut (" - "); } */ // ! if (bmCBWFlags.bit7 == 1) {direction = IN;} if (Usb_read_endpoint_data (EP_MS_OUT, 8)) { ms_endpoint = EP_MS_IN; if (cbw_error) { Usb_ack_out_received_free (EP_MS_OUT); Usb_enable_stall_handshake (EP_MS_IN); return; } } else { ms_endpoint = EP_MS_OUT; if (cbw_error) { Usb_enable_stall_handshake (EP_MS_OUT); Usb_ack_out_received_free (EP_MS_OUT); return; } } usb_LUN = Usb_read_endpoint_data (EP_MS_OUT, 8); if (!ms_multiple_drive) { usb_LUN = get_cur_lun (); } // ! Dummy CBWCBLength read Usb_read_endpoint_data (EP_MS_OUT, 8); // ! Store scsi_command usb_read_ep_rxpacket (EP_MS_OUT, g_scsi_command, sizeof (g_scsi_command), NULL); Usb_ack_out_received_free (EP_MS_OUT); if (!scsi_decode_command ()) { Usb_enable_stall_handshake (ms_endpoint); } }
//! @brief Get data report from Host //! void hid_report_out(void) { int led_number; int led_state; if(Is_usb_out_received(EP_HID_GENERIC_OUT)) { Usb_reset_endpoint_fifo_access(EP_HID_GENERIC_OUT); memset(rxbuf, 0, RXBUF_SIZE); usb_read_ep_rxpacket(EP_HID_GENERIC_OUT, &rxbuf, RXBUF_SIZE, NULL); Usb_ack_out_received_free(EP_HID_GENERIC_OUT); // The Data has been read and stored in rxbuf led_state = rxbuf[0]&0x0F; // RepportOUT[0] is LEDS value led_number = rxbuf[1]&0x0F; switch (led_number) { case 1: if(led_state) { gpio_clr_gpio_pin(LED0_GPIO); } else { gpio_set_gpio_pin(LED0_GPIO);} break; case 2: if(led_state) { gpio_clr_gpio_pin(LED1_GPIO); } else { gpio_set_gpio_pin(LED1_GPIO);} break; case 3: if(led_state) { gpio_clr_gpio_pin(LED2_GPIO); } else { gpio_set_gpio_pin(LED2_GPIO);} break; case 4: if(led_state) { gpio_clr_gpio_pin(LED3_GPIO); } else { gpio_set_gpio_pin(LED3_GPIO);} break; } } //** Check if we received DFU mode command from host if(jump_bootloader) { uint32_t volatile tempo; gpio_set_gpio_pin(LED0_GPIO); gpio_set_gpio_pin(LED1_GPIO); gpio_set_gpio_pin(LED2_GPIO); gpio_set_gpio_pin(LED3_GPIO); Usb_detach(); // Detach actual generic HID application for(tempo=0;tempo<70000;tempo++); // Wait some time before //start_boot(); // Jumping to bootloader while(1); } }
void sd_mmc_spi_write_multiple_sector_callback(void *psector) { U16 data_to_transfer = MMC_SECTOR_SIZE; while (data_to_transfer) { while (!Is_usb_out_received(g_scsi_ep_ms_out)); Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_out); data_to_transfer = usb_read_ep_rxpacket(g_scsi_ep_ms_out, psector, data_to_transfer, &psector); Usb_ack_out_received_free(g_scsi_ep_ms_out); } }
void cdc_receiving(void) { // return: Anzahl empfangener Bytes im Fifo int bytes_rx, bytes_left; #if USB_DEVICE_FEATURE == ENABLED && USB_HOST_FEATURE == ENABLED usb_task(); #elif USB_DEVICE_FEATURE == ENABLED usb_device_task(); #elif USB_HOST_FEATURE == ENABLED usb_host_task(); #endif if ( usb_connected && Is_usb_out_received(RX_EP) ) { bytes_rx = Usb_byte_count(RX_EP); if ((bytes_rx > 0)&&(bytes_rx < cdc_rxleft)) { bytes_left = CDC_RXBUFFERSIZE-cdc_wrpos; Usb_reset_endpoint_fifo_access(RX_EP); if (bytes_rx <= bytes_left) { // Normalfall: kein Wrap usb_read_ep_rxpacket(RX_EP, (void *)cdc_rxbuffer+cdc_wrpos, bytes_rx, NULL); } else { usb_read_ep_rxpacket(RX_EP, (void *)cdc_rxbuffer+cdc_wrpos, bytes_left, NULL); usb_read_ep_rxpacket(RX_EP, (void *)cdc_rxbuffer, bytes_rx-bytes_left, NULL); } cdc_wrpos = (cdc_wrpos+bytes_rx)%CDC_RXBUFFERSIZE; // End copy in own fifo cdc_rxidle_pos = cdc_sof_counter + cdc_timeoutval; cdc_timeout_enabled = (cdc_timeoutval>0)&&(cdc_timeout_fct!=NULL); } // fi copy received Usb_ack_out_received_free(RX_EP); // moved outside of if-con } else if (cdc_timeout_enabled) { if ((int)(cdc_sof_counter - cdc_rxidle_pos) >= 0) { cdc_timeout_fct(cdc_rxlen); cdc_timeout_enabled = FALSE; } } // esle fi to // chain-tx (>64 byte): if (cdc_txbuffer_len > 0) { cdc_transmit(cdc_txbuffer, cdc_txbuffer_len); } // fi }
void at45dbx_write_multiple_sector_callback(void *psector) { U16 data_to_transfer = AT45DBX_SECTOR_SIZE; // Transfer sector to write from the USB interface. while (data_to_transfer) { while (!Is_usb_out_received(g_scsi_ep_ms_out)) { if(!Is_usb_endpoint_enabled(g_scsi_ep_ms_out)) return; // USB Reset } Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_out); data_to_transfer = usb_read_ep_rxpacket(g_scsi_ep_ms_out, psector, data_to_transfer, &psector); Usb_ack_out_received_free(g_scsi_ep_ms_out); } }
void sd_mmc_spi_write_multiple_sector_callback(void *psector) { #ifdef USB_DEVICE_VENDOR_ID // USB Device Stack V2 udi_msc_trans_block( false, (uint8_t*)psector, MMC_SECTOR_SIZE, NULL); #else // USB Device Stack V1 uint16_t data_to_transfer = MMC_SECTOR_SIZE; while (data_to_transfer) { while (!Is_usb_out_received(g_scsi_ep_ms_out)); Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_out); data_to_transfer = usb_read_ep_rxpacket(g_scsi_ep_ms_out, psector, data_to_transfer, &psector); Usb_ack_out_received_free(g_scsi_ep_ms_out); } #endif }
//! //! @brief This function takes the stream coming from the selected USB pipe and sends //! it to the DAC driver. Moreover, it ensures that both input and output stream //! keep synchronized by adding or deleting samples. //! //! @param side USB_STREAM_HOST for USB host, USB_STREAM_DEVICE for device. //! @param pipe_in Number of the addressed pipe/endpoint //! @param pFifoCount (return parameter) NULL or pointer to the number of used buffers at this time //! //! @return status: (USB_STREAM_STATUS_OK, USB_STREAM_STATUS_NOT_SYNCHRONIZED, //! USB_STREAM_STATUS_SPEED_UP, USB_STREAM_STATUS_SLOW_DOWN, USB_STREAM_STATUS_BUFFER_OVERFLOW) //! int usb_stream_input(usb_stream_side_t side, uint8_t pipe_in, uint32_t* pFifoCount) { uint16_t fifo_used_cnt; uint16_t byte_count=0; uint32_t i; UnionPtr pswap; UnionPtr buffer; // We comes here since we have received something. Let's increase the internal // activity counter. usb_stream_cnt++; fifo_used_cnt=usb_stream_fifo_get_used_room(); if (pFifoCount) *pFifoCount = fifo_used_cnt; // usb_stream_fifo_get_free_room() if( USB_STREAM_BUFFER_NUMBER-fifo_used_cnt==0 ) { // Fatal error: even with the synchro mechanism acting, we are in a case in which the // buffers are full. usb_stream_context->synchronized = false; usb_stream_context->status = USB_STREAM_ERROR_NOT_SYNCHRONIZED; return usb_stream_context->status; } pswap.s8ptr = buffer.s8ptr = usb_stream_fifo_get_buffer(usb_stream_context->wr_id); #if USB_HOST_FEATURE == true if( side==USB_STREAM_HOST ) { byte_count=Host_byte_count(pipe_in); } #endif #if USB_DEVICE_FEATURE == true if( side==USB_STREAM_DEVICE ) { byte_count=Usb_byte_count(pipe_in); } #endif if( byte_count==0 ) { if( cpu_is_timeout(&broken_stream_timer) ) { usb_stream_context->status = USB_STREAM_ERROR_BROKEN_STREAM; } else { usb_stream_context->status = USB_STREAM_ERROR_NO_DATA; } return usb_stream_context->status; } else { // reset time out detection cpu_set_timeout(cpu_ms_2_cy(BROKEN_STREAM_TIMER, FCPU_HZ), &broken_stream_timer); } #if USB_HOST_FEATURE == true if( side==USB_STREAM_HOST ) { Host_reset_pipe_fifo_access(pipe_in); host_read_p_rxpacket(pipe_in, (void*)buffer.s8ptr, byte_count, NULL); } #endif #if USB_DEVICE_FEATURE == true if( side==USB_STREAM_DEVICE ) { Usb_reset_endpoint_fifo_access(pipe_in); usb_read_ep_rxpacket(pipe_in, (void*)buffer.s8ptr, byte_count, NULL); } #endif usb_stream_context->status = USB_STREAM_ERROR_NONE; if( byte_count > USB_STREAM_REAL_BUFFER_SIZE ) { byte_count = USB_STREAM_REAL_BUFFER_SIZE; usb_stream_context->status = USB_STREAM_ERROR_OVERFLOW; } // Swap samples since they are coming from the USB world. if( usb_stream_context->bits_per_sample==16 ) for( i=0 ; i<byte_count/(16/8) ; i++ ) pswap.s16ptr[i] = swap16(pswap.s16ptr[i]); else if( usb_stream_context->bits_per_sample==32 ) for( i=0 ; i<byte_count/(32/8) ; i++ ) pswap.s32ptr[i] = swap32(pswap.s32ptr[i]); //for( i=0 ; i<byte_count/2 ; i++ ) // printf("0x%04hx ", pswap[i]); //printf("\r\n"); usb_stream_fifo_push(byte_count); fifo_used_cnt++; if( !usb_stream_context->synchronized ) { usb_stream_context->status = USB_STREAM_ERROR_NOT_SYNCHRONIZED; if( fifo_used_cnt>=(USB_STREAM_BUFFER_NUMBER/2) ) { // We have enough buffers to start the playback. void* buffer; uint16_t size; // CS2200 cs2200_freq_clk_out(_32_BITS_RATIO(usb_stream_resync_frequency, CS2200_FREF)); usb_stream_resync_step = PPM(usb_stream_resync_frequency, USB_STREAM_RESYNC_PPM_STEPS); usb_stream_resync_freq_ofst = usb_stream_resync_frequency; usb_stream_resync_ppm_ofst = 0; usb_stream_resync_last_room = fifo_used_cnt; #define TIMER_USB_RESYNC_CORRECTION 320 cpu_set_timeout( cpu_ms_2_cy(TIMER_USB_RESYNC_CORRECTION, FCPU_HZ), &usb_resync_timer ); usb_stream_context->synchronized=true; usb_stream_fifo_get(&buffer, &size); audio_mixer_dacs_output_direct(buffer, size/(usb_stream_context->channel_count*usb_stream_context->bits_per_sample/8)); // Fill also the reload stage of the PDCA. usb_stream_fifo_pull(); usb_stream_fifo_get(&buffer, &size); audio_mixer_dacs_output_direct(buffer, size/(usb_stream_context->channel_count*usb_stream_context->bits_per_sample/8)); } } return usb_stream_context->status; }
void device_full_custom_task(void) #endif { U32 time=0; bool startup=true; #ifdef FREERTOS_USED portTickType xLastWakeTime; xLastWakeTime = xTaskGetTickCount(); while (true) { vTaskDelayUntil(&xLastWakeTime, configTSK_USB_DFC_PERIOD); if( startup ) { time+=configTSK_USB_DFC_PERIOD; #define STARTUP_LED_DELAY 100 if ( time== 1*STARTUP_LED_DELAY ) LED_On( LED_MONO0_GREEN ); else if( time== 2*STARTUP_LED_DELAY ) LED_On( LED_MONO1_GREEN ); else if( time== 3*STARTUP_LED_DELAY ) LED_On( LED_MONO2_GREEN ); else if( time== 4*STARTUP_LED_DELAY ) LED_On( LED_MONO3_GREEN ); else if( time== 5*STARTUP_LED_DELAY ) LED_Off( LED_MONO0_GREEN ); else if( time== 6*STARTUP_LED_DELAY ) LED_Off( LED_MONO1_GREEN ); else if( time== 7*STARTUP_LED_DELAY ) LED_Off( LED_MONO2_GREEN ); else if( time== 8*STARTUP_LED_DELAY ) LED_Off( LED_MONO3_GREEN ); else if( time== 9*STARTUP_LED_DELAY ) startup=false; } // First, check the device enumeration state if (!Is_device_enumerated()) continue; #else // First, check the device enumeration state if (!Is_device_enumerated()) return; #endif // FREERTOS_USED if(Is_usb_out_received(EP_FC_OUT)) { U32 nchar; Usb_reset_endpoint_fifo_access(EP_FC_OUT); memset(rxbuf, 0, RXBUF_SIZE); usb_read_ep_rxpacket(EP_FC_OUT, &rxbuf, RXBUF_SIZE, NULL); Usb_ack_out_received_free(EP_FC_OUT); //printf("Received %s\n\r", rxbuf); if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=temp") ) { // Temperature sensor nchar=build_answer(txbuf, "temp"); b_temperature_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=js") ) { // Joystick nchar=build_answer(txbuf, "js"); b_joystick_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=pb1") ) { // Push button 1 nchar=build_answer(txbuf, "pb1"); b_pushb1_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=pb2") ) { // Push button 2 nchar=build_answer(txbuf, "pb2"); b_pushb2_get_value( txbuf+nchar ); b_report_pending=true; } #if BOARD == EVK1100 else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=pb3") ) { // Push button 3 nchar=build_answer(txbuf, "pb3"); sprintf( txbuf+nchar, "RELEASE\r\n"); b_report_pending=true; } #endif else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=light") ) { // light U32 value; nchar=build_answer(txbuf, "light"); b_light_get_value( txbuf+nchar, &value ); e_ledm_refresh_intensity( value ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_actuator_value actuator=ledm1") ) { // led1 nchar=build_answer(txbuf, "ledm1"); b_ledm1_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_actuator_value actuator=ledm2") ) { // led2 nchar=build_answer(txbuf, "ledm2"); b_ledm2_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_actuator_value actuator=ledm3") ) { // led3 nchar=build_answer(txbuf, "ledm3"); b_ledm3_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_actuator_value actuator=ledm4") ) { // led4 nchar=build_answer(txbuf, "ledm4"); b_ledm4_get_value( txbuf+nchar ); b_report_pending=true; } else if( !strncmp((const char*)rxbuf, STR_SET_LEDM1, strlen(STR_SET_LEDM1)) ) { // led1 nchar=build_answer(txbuf, "ledm1"); e_ledm1_set_value(rxbuf+strlen(STR_SET_LEDM1), txbuf+nchar); b_report_pending=true; } else if( !strncmp((const char*)rxbuf, STR_SET_LEDM2, strlen(STR_SET_LEDM2)) ) { // led2 nchar=build_answer(txbuf, "ledm2"); e_ledm2_set_value(rxbuf+strlen(STR_SET_LEDM2), txbuf+nchar); b_report_pending=true; } else if( !strncmp((const char*)rxbuf, STR_SET_LEDM3, strlen(STR_SET_LEDM3)) ) { // led3 nchar=build_answer(txbuf, "ledm3"); e_ledm3_set_value(rxbuf+strlen(STR_SET_LEDM2), txbuf+nchar); b_report_pending=true; } else if( !strncmp((const char*)rxbuf, STR_SET_LEDM4, strlen(STR_SET_LEDM4)) ) { // led4 nchar=build_answer(txbuf, "ledm4"); e_ledm4_set_value(rxbuf+strlen(STR_SET_LEDM2), txbuf+nchar); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=accx") ) { // accelerometer nchar=build_answer(txbuf, "accx"); accelerometer_measure(0, txbuf+nchar); b_report_pending=true; } else if( !strcmp((const char*)rxbuf, "get_sensor_value sensor=accy") ) { // accelerometer nchar=build_answer(txbuf, "accy"); accelerometer_measure(1, txbuf+nchar); b_report_pending=true; } } if( b_report_pending && Is_usb_in_ready(EP_FC_IN) ) { U8 data_to_transfer; char* ptr_cram=txbuf; //printf( "Sending %s", txbuf); #if 0 Usb_reset_endpoint_fifo_access(EP_FC_IN); usb_write_ep_txpacket(EP_FC_IN, &txbuf, TXBUF_SIZE, NULL); Usb_ack_in_ready_send(EP_FC_IN); #endif data_to_transfer = strlen(txbuf); while (data_to_transfer) { while (!Is_usb_in_ready(EP_FC_IN)); Usb_reset_endpoint_fifo_access(EP_FC_IN); data_to_transfer = usb_write_ep_txpacket(EP_FC_IN, ptr_cram, data_to_transfer, (const void**)&ptr_cram); Usb_ack_in_ready_send(EP_FC_IN); } b_report_pending=false; } #ifdef FREERTOS_USED } #endif }
void device_template_task(void) #endif { static U8 buf[EP_SIZE_TEMP2]; #ifdef FREERTOS_USED portTickType xLastWakeTime; xLastWakeTime = xTaskGetTickCount(); while (true) { vTaskDelayUntil(&xLastWakeTime, configTSK_USB_DTP_PERIOD); // First, check the device enumeration state if (!Is_device_enumerated()) continue; #else // First, check the device enumeration state if (!Is_device_enumerated()) return; #endif // FREERTOS_USED // HERE STARTS THE USB DEVICE APPLICATIVE CODE // The example below just performs a loopback transmission/reception. // All data received with the OUT endpoint is stored in a RAM buffer and // sent back to the IN endpoint. #if BOARD == EVK1100 // For example, display Start-of-Frame counter on LEDs LED_Display_Field(LED_MONO0_GREEN | LED_MONO1_GREEN | LED_MONO2_GREEN | LED_MONO3_GREEN, sof_cnt >> 5); #elif BOARD == EVK1101 || BOARD == UC3C_EK || BOARD == EVK1104 || BOARD == EVK1105 // For example, display Start-of-Frame counter on LEDs LED_Display_Field(LED0 | LED1, sof_cnt >> 5); #else #error The display of the SOFs must be defined here. #endif // If we receive something in the OUT endpoint, just store it in the RAM buffer if (Is_usb_out_received(EP_TEMP_OUT)) { LED_On(LED_APPLI_1); Usb_reset_endpoint_fifo_access(EP_TEMP_OUT); data_length = Usb_byte_count(EP_TEMP_OUT); usb_read_ep_rxpacket(EP_TEMP_OUT, buf, data_length, NULL); Usb_ack_out_received_free(EP_TEMP_OUT); LED_Off(LED_APPLI_1); } // Load the IN endpoint with the contents of the RAM buffer if (data_length && Is_usb_in_ready(EP_TEMP_IN)) { LED_On(LED_APPLI_0); Usb_reset_endpoint_fifo_access(EP_TEMP_IN); usb_write_ep_txpacket(EP_TEMP_IN, buf, data_length, NULL); data_length = 0; Usb_ack_in_ready_send(EP_TEMP_IN); LED_Off(LED_APPLI_0); } #ifdef FREERTOS_USED } #endif }