//! @brief Send data report to Host //! void hid_report_in(void) { int joy =0; char* ptr_cram=txbuf; int data_to_transfer=0; if(!Is_usb_write_enabled(EP_HID_GENERIC_IN)) return; // Not ready to send report // Build the Joystick report if(is_joystick_up()|| is_joystick_down() || is_joystick_right() || is_joystick_left() ) //! Check for UP event { joy=0x01; } if(joy==last_joy) { return; // Same report then no send report } last_joy=joy; memset(txbuf, 0, RXBUF_SIZE); txbuf[0] = joy; // Send report data_to_transfer = sizeof(txbuf); while (data_to_transfer) { while (!Is_usb_in_ready(EP_HID_GENERIC_IN)); Usb_reset_endpoint_fifo_access(EP_HID_GENERIC_IN); data_to_transfer = usb_write_ep_txpacket(EP_HID_GENERIC_IN, ptr_cram, data_to_transfer, (const void**)&ptr_cram); Usb_ack_in_ready_send(EP_HID_GENERIC_IN); } }
void sd_mmc_mci_read_multiple_sector_callback(const void *psector) { #ifdef USB_DEVICE_VENDOR_ID // USB Device Stack V2 udi_msc_trans_block( true, (uint8_t*)psector, SD_MMC_SECTOR_SIZE, NULL); #else // USB Device Stack V1 uint16_t data_to_transfer = SD_MMC_SECTOR_SIZE; // Transfer read sector to the USB interface. while (data_to_transfer) { while (!Is_usb_in_ready(g_scsi_ep_ms_in)) { if(!Is_usb_endpoint_enabled(g_scsi_ep_ms_in)) return; // USB Reset } Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_in); data_to_transfer = usb_write_ep_txpacket(g_scsi_ep_ms_in, psector, data_to_transfer, &psector); Usb_ack_in_ready_send(g_scsi_ep_ms_in); } #endif }
void sendKeys(u8* buffer) { u32 i; #ifdef NOT_USED if (bDeviceState == CONFIGURED) { while(!PrevXferComplete); PrevXferComplete = 0; /* Use the memory interface function to write to the selected endpoint */ UserToPMABufferCopy(buffer, ENDP4_TXADDR, 8); /* Update the data length in the control register */ SetEPTxCount(ENDP4, 8); SetEPTxStatus (ENDP4, EP_TX_VALID); } #endif while (Is_usb_endpoint_stall_requested(EP_KB_IN)) { if (Is_usb_setup_received()) { usb_process_request(); } } // MSC Compliance - Free BAD out receive during SCSI command while( Is_usb_out_received(EP_CCID_OUT) ) { Usb_ack_out_received_free(EP_CCID_OUT); } while (!Is_usb_in_ready(EP_KB_IN)) { if(!Is_usb_endpoint_enabled(EP_KB_IN)) { i = 0; // todo USB Reset } } Usb_reset_endpoint_fifo_access(EP_KB_IN); /* Usb_write_endpoint_data(EP_KB_IN, 8, 'D'); Usb_write_endpoint_data(EP_KB_IN, 8, 'D'); Usb_write_endpoint_data(EP_KB_IN, 8, 'D'); Usb_write_endpoint_data(EP_KB_IN, 8, 'D'); */ usb_write_ep_txpacket(EP_KB_IN, buffer, 8, NULL); // Usb_send_in(EP_CONTROL); Usb_ack_in_ready_send(EP_KB_IN); // MSC Compliance - Wait end of all transmitions on USB line while( 0 != Usb_nb_busy_bank(EP_KB_IN) ) { if (Is_usb_setup_received()) usb_process_request(); } }
void cdc_transmit(const char *data, int len) { if (usb_connected) { if (Is_usb_write_enabled(TX_EP)) { Usb_reset_endpoint_fifo_access(TX_EP); cdc_txbuffer_len = usb_write_ep_txpacket(TX_EP, data, len, (const void **)&cdc_txbuffer); Usb_ack_in_ready_send(TX_EP); } // fi TX_EP empty } }
//! This function manages the HID Get_Descriptor request. //! static void hid_get_descriptor(U8 size_of_report, const U8* p_usb_hid_report) { bool zlp; U16 wIndex; U16 wLength; zlp = false; /* no zero length packet */ data_to_transfer = size_of_report; pbuffer = p_usb_hid_report; wIndex = Usb_read_endpoint_data(EP_CONTROL, 16); wIndex = usb_format_usb_to_mcu_data(16, wIndex); wLength = Usb_read_endpoint_data(EP_CONTROL, 16); wLength = usb_format_usb_to_mcu_data(16, wLength); Usb_ack_setup_received_free(); //!< clear the setup received flag if (wLength > data_to_transfer) { zlp = !(data_to_transfer % EP_CONTROL_LENGTH); //!< zero length packet condition } else { data_to_transfer = wLength; //!< send only requested number of data bytes } Usb_ack_nak_out(EP_CONTROL); while (data_to_transfer && (!Is_usb_nak_out(EP_CONTROL))) { while( !Is_usb_control_in_ready() && !Is_usb_nak_out(EP_CONTROL) ); if( Is_usb_nak_out(EP_CONTROL) ) break; // don't clear the flag now, it will be cleared after Usb_reset_endpoint_fifo_access(EP_CONTROL); data_to_transfer = usb_write_ep_txpacket(EP_CONTROL, pbuffer, data_to_transfer, &pbuffer); if( Is_usb_nak_out(EP_CONTROL) ) break; else Usb_ack_control_in_ready_send(); //!< Send data until necessary } if ( zlp && (!Is_usb_nak_out(EP_CONTROL)) ) { while (!Is_usb_control_in_ready()); Usb_ack_control_in_ready_send(); } while (!(Is_usb_nak_out(EP_CONTROL))); Usb_ack_nak_out(EP_CONTROL); while (!Is_usb_control_out_received()); Usb_ack_control_out_received_free(); }
void sd_mmc_spi_read_multiple_sector_callback(const void *psector) { U16 data_to_transfer = MMC_SECTOR_SIZE; while (data_to_transfer) { while (!Is_usb_in_ready(g_scsi_ep_ms_in)); Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_in); data_to_transfer = usb_write_ep_txpacket(g_scsi_ep_ms_in, psector, data_to_transfer, &psector); Usb_ack_in_ready_send(g_scsi_ep_ms_in); } }
Bool sbc_request_sense (void) { // U32 i; U8 allocation_length; U8 request_sense_output[18]; // The maximal size of request is 17. allocation_length = min (g_scsi_command[4], sizeof (request_sense_output)); if ((allocation_length != 0) && (2 > usb_LUN)) { // Initialize the request sense data. request_sense_output[0] = SBC_RESPONSE_CODE_SENSE; // 0x70. request_sense_output[1] = 0x00; // Obsolete. request_sense_output[2] = g_scsi_sense[usb_LUN].key; request_sense_output[3] = 0x00; // For direct access media, Information field. request_sense_output[4] = 0x00; // Give the unsigned logical block. request_sense_output[5] = 0x00; // Address associated with the sense key. request_sense_output[6] = 0x00; request_sense_output[7] = SBC_ADDITIONAL_SENSE_LENGTH; // Device shall not adjust the additional sense length to reflect truncation. request_sense_output[8] = SBC_COMMAND_SPECIFIC_INFORMATION_3; request_sense_output[9] = SBC_COMMAND_SPECIFIC_INFORMATION_2; request_sense_output[10] = SBC_COMMAND_SPECIFIC_INFORMATION_1; request_sense_output[11] = SBC_COMMAND_SPECIFIC_INFORMATION_0; request_sense_output[12] = g_scsi_sense[usb_LUN].asc; request_sense_output[13] = g_scsi_sense[usb_LUN].ascq; request_sense_output[14] = SBC_FIELD_REPLACEABLE_UNIT_CODE; request_sense_output[15] = SBC_SENSE_KEY_SPECIFIC_2; request_sense_output[16] = SBC_SENSE_KEY_SPECIFIC_1; request_sense_output[17] = SBC_SENSE_KEY_SPECIFIC_0; // Send the request data. Usb_reset_endpoint_fifo_access (g_scsi_ep_ms_in); usb_write_ep_txpacket (g_scsi_ep_ms_in, request_sense_output, allocation_length, NULL); Sbc_valid_write_usb (allocation_length); // MSC Compliance - Wait end of all transmitions on USB line, because a stall may be send after data while (0 != Usb_nb_busy_bank (EP_MS_IN)); } sbc_lun_status_is_good (); return (allocation_length <= g_scsi_command[4]); }
void at45dbx_read_multiple_sector_callback(const void *psector) { U16 data_to_transfer = AT45DBX_SECTOR_SIZE; // Transfer read sector to the USB interface. while (data_to_transfer) { while (!Is_usb_in_ready(g_scsi_ep_ms_in)) { if(!Is_usb_endpoint_enabled(g_scsi_ep_ms_in)) return; // USB Reset } Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_in); data_to_transfer = usb_write_ep_txpacket(g_scsi_ep_ms_in, psector, data_to_transfer, &psector); Usb_ack_in_ready_send(g_scsi_ep_ms_in); } }
void sd_mmc_spi_read_multiple_sector_callback(const void *psector) { #ifdef USB_DEVICE_VENDOR_ID // USB Device Stack V2 udi_msc_trans_block( true, (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_in_ready(g_scsi_ep_ms_in)); Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_in); data_to_transfer = usb_write_ep_txpacket(g_scsi_ep_ms_in, psector, data_to_transfer, &psector); Usb_ack_in_ready_send(g_scsi_ep_ms_in); } #endif }
Bool sbc_inquiry (void) { U8 allocation_length; DelayMs (2); // CMDT or EPVD bit is not 0 or PAGE or OPERATION CODE fields != 0x00. if ((g_scsi_command[1] & 0x03) || g_scsi_command[2]) { sbc_lun_status_is_cdb_field (); return FALSE; } // Send standard INQUIRY data (bytes 0 to (allocation_length - 1)). allocation_length = min (g_scsi_command[4], sizeof (sbc_st_std_inquiry_data)); if (allocation_length != 0) { while (!Is_usb_in_ready (g_scsi_ep_ms_in)) { if (!Is_usb_endpoint_enabled (g_scsi_ep_ms_in)) return FALSE; // USB Reset } Usb_reset_endpoint_fifo_access (g_scsi_ep_ms_in); usb_write_ep_txpacket (g_scsi_ep_ms_in, &sbc_std_inquiry_data, allocation_length, NULL); Sbc_valid_write_usb (allocation_length); // MSC Compliance - Wait end of all transmitions on USB line, because a stall may be send after data while (0 != Usb_nb_busy_bank (EP_MS_IN)); } sbc_lun_status_is_good (); if (allocation_length > g_scsi_command[4]) // Not enough space { return (FALSE); } return (TRUE); }
//! This function manages the SET FEATURE request. The USB test modes are //! supported by this function. //! void usb_set_feature(void) { U16 wValue = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16)); U16 wIndex = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16)); U16 wLength = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16)); if (wLength) goto unsupported_request; if (bmRequestType==USB_SETUP_SET_STAND_DEVICE) { #if (USB_REMOTE_WAKEUP_FEATURE == true) if (FEATURE_DEVICE_REMOTE_WAKEUP == wValue) { device_status |= USB_DEV_STATUS_REMOTEWAKEUP; remote_wakeup_feature = true; Usb_ack_setup_received_free(); Usb_ack_control_in_ready_send(); return; } #endif goto unsupported_request; } switch (wValue) { case FEATURE_ENDPOINT_HALT: wIndex = Get_desc_ep_nbr(wIndex); // clear direction flag if (bmRequestType != ENDPOINT_TYPE || wIndex == EP_CONTROL || !Is_usb_endpoint_enabled(wIndex)) goto unsupported_request; Usb_enable_stall_handshake(wIndex); Usb_ack_setup_received_free(); Usb_ack_control_in_ready_send(); break; #if (USB_HIGH_SPEED_SUPPORT==true) case FEATURE_TEST_MODE: if (bmRequestType != DEVICE_TYPE || wIndex & 0x00FF) goto unsupported_request; switch (wIndex >> 8) { case TEST_J: Usb_ack_setup_received_free(); Usb_ack_control_in_ready_send(); while (!Is_usb_control_in_ready()); Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2); Set_bits(AVR32_USBB_udcon, AVR32_USBB_UDCON_TSTJ_MASK); break; case TEST_K: Usb_ack_setup_received_free(); Usb_ack_control_in_ready_send(); while (!Is_usb_control_in_ready()); Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2); Set_bits(AVR32_USBB_udcon, AVR32_USBB_UDCON_TSTK_MASK); break; case TEST_SE0_NAK: Usb_ack_setup_received_free(); Usb_ack_control_in_ready_send(); while (!Is_usb_control_in_ready()); Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2); break; case TEST_PACKET: { static const U8 test_packet[] = { // 00000000 * 9 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 01010101 * 8 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, // 01110111 * 8 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, // 0, {111111S * 15}, 111111 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // S, 111111S, {0111111S * 7} 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, // 00111111, {S0111111 * 9}, S0 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E }; Usb_ack_setup_received_free(); Usb_ack_control_in_ready_send(); while (!Is_usb_control_in_ready()); Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2); Usb_disable_endpoint(EP_CONTROL); Usb_unallocate_memory(EP_CONTROL); (void)Usb_configure_endpoint(EP_CONTROL, TYPE_BULK, DIRECTION_IN, 64, SINGLE_BANK); Usb_reset_endpoint(EP_CONTROL); Set_bits(AVR32_USBB_udcon, AVR32_USBB_UDCON_TSTPCKT_MASK); usb_write_ep_txpacket(EP_CONTROL, &test_packet, sizeof(test_packet), NULL); Usb_send_in(EP_CONTROL); } break; case TEST_FORCE_ENABLE: // Only for downstream facing hub ports default: goto unsupported_request; } break; #endif case FEATURE_DEVICE_REMOTE_WAKEUP: default: goto unsupported_request; } return; unsupported_request: Usb_enable_stall_handshake(EP_CONTROL); Usb_ack_setup_received_free(); }
//! This function manages the GET DESCRIPTOR request. The device descriptor, //! the configuration descriptor and the device qualifier are supported. All //! other descriptors must be supported by the usb_user_get_descriptor //! function. //! Only 1 configuration is supported. //! void usb_get_descriptor(void) { bool zlp; U16 wLength; U8 descriptor_type; U8 string_type; Union32 temp; #if (USB_HIGH_SPEED_SUPPORT==true) bool b_first_data = true; #endif zlp = false; /* no zero length packet */ string_type = Usb_read_endpoint_data(EP_CONTROL, 8); /* read LSB of wValue */ descriptor_type = Usb_read_endpoint_data(EP_CONTROL, 8); /* read MSB of wValue */ switch (descriptor_type) { case DEVICE_DESCRIPTOR: data_to_transfer = Usb_get_dev_desc_length(); //!< sizeof(usb_dev_desc); pbuffer = Usb_get_dev_desc_pointer(); break; #if (USB_HIGH_SPEED_SUPPORT==false) case CONFIGURATION_DESCRIPTOR: data_to_transfer = Usb_get_conf_desc_length(); //!< sizeof(usb_conf_desc); pbuffer = Usb_get_conf_desc_pointer(); break; #else case CONFIGURATION_DESCRIPTOR: if( Is_usb_full_speed_mode() ) { data_to_transfer = Usb_get_conf_desc_fs_length(); //!< sizeof(usb_conf_desc_fs); pbuffer = Usb_get_conf_desc_fs_pointer(); }else{ data_to_transfer = Usb_get_conf_desc_hs_length(); //!< sizeof(usb_conf_desc_hs); pbuffer = Usb_get_conf_desc_hs_pointer(); } break; case OTHER_SPEED_CONFIGURATION_DESCRIPTOR: if( !Is_usb_full_speed_mode() ) { data_to_transfer = Usb_get_conf_desc_fs_length(); //!< sizeof(usb_conf_desc_fs); pbuffer = Usb_get_conf_desc_fs_pointer(); }else{ data_to_transfer = Usb_get_conf_desc_hs_length(); //!< sizeof(usb_conf_desc_hs); pbuffer = Usb_get_conf_desc_hs_pointer(); } break; case DEVICE_QUALIFIER_DESCRIPTOR: data_to_transfer = Usb_get_qualifier_desc_length(); //!< sizeof(usb_qualifier_desc); pbuffer = Usb_get_qualifier_desc_pointer(); break; #endif default: if (!usb_user_get_descriptor(descriptor_type, string_type)) { Usb_enable_stall_handshake(EP_CONTROL); Usb_ack_setup_received_free(); return; } break; } temp.u32 = Usb_read_endpoint_data(EP_CONTROL, 32); //!< read wIndex and wLength with a 32-bit access //!< since this access is aligned with a 32-bit //!< boundary from the beginning of the endpoint wLength = usb_format_usb_to_mcu_data(16, temp.u16[1]); //!< ignore wIndex, keep and format wLength Usb_ack_setup_received_free(); //!< clear the setup received flag if (wLength > data_to_transfer) { zlp = !(data_to_transfer % EP_CONTROL_LENGTH); //!< zero length packet condition } else { // No need to test ZLP sending since we send the exact number of bytes as // expected by the host. data_to_transfer = wLength; //!< send only requested number of data bytes } Usb_ack_nak_out(EP_CONTROL); while (data_to_transfer && !Is_usb_nak_out(EP_CONTROL)) { while (!Is_usb_control_in_ready() && !Is_usb_nak_out(EP_CONTROL)); if (Is_usb_nak_out(EP_CONTROL)) break; // don't clear the flag now, it will be cleared after Usb_reset_endpoint_fifo_access(EP_CONTROL); #if (USB_HIGH_SPEED_SUPPORT==true) // To support other descriptors like OTHER_SPEED_CONFIGURATION_DESCRIPTOR if( b_first_data ) { b_first_data = false; if( 0!= data_to_transfer ) { usb_write_ep_txpacket(EP_CONTROL, pbuffer, 1, &pbuffer); data_to_transfer--; } if( 0!= data_to_transfer ) { usb_write_ep_txpacket(EP_CONTROL, &descriptor_type, 1, NULL); pbuffer = ((const U8*)pbuffer)+1; data_to_transfer--; } } #endif if( 0!= data_to_transfer ) { data_to_transfer = usb_write_ep_txpacket(EP_CONTROL, pbuffer, data_to_transfer, &pbuffer); } if (Is_usb_nak_out(EP_CONTROL)) break; Usb_ack_control_in_ready_send(); //!< Send data until necessary } if (zlp && !Is_usb_nak_out(EP_CONTROL)) { while (!Is_usb_control_in_ready()); Usb_ack_control_in_ready_send(); } while (!Is_usb_nak_out(EP_CONTROL)); Usb_ack_nak_out(EP_CONTROL); while (!Is_usb_control_out_received()); Usb_ack_control_out_received_free(); }
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 }
//! This function manages the GET DESCRIPTOR request. The device descriptor, //! the configuration descriptor and the device qualifier are supported. All //! other descriptors must be supported by the usb_user_get_descriptor //! function. //! Only 1 configuration is supported. //! void usb_get_descriptor(void) { Bool zlp; U16 wLength; U8 descriptor_type; U8 string_type; Union32 temp; zlp = FALSE; /* no zero length packet */ string_type = Usb_read_endpoint_data(EP_CONTROL, 8); /* read LSB of wValue */ descriptor_type = Usb_read_endpoint_data(EP_CONTROL, 8); /* read MSB of wValue */ switch (descriptor_type) { case DEVICE_DESCRIPTOR: data_to_transfer = Usb_get_dev_desc_length(); //!< sizeof(usb_dev_desc); pbuffer = Usb_get_dev_desc_pointer(); break; case CONFIGURATION_DESCRIPTOR: data_to_transfer = Usb_get_conf_desc_length(); //!< sizeof(usb_conf_desc); pbuffer = Usb_get_conf_desc_pointer(); break; default: if (!usb_user_get_descriptor(descriptor_type, string_type)) { Usb_enable_stall_handshake(EP_CONTROL); Usb_ack_setup_received_free(); return; } break; } temp.u32 = Usb_read_endpoint_data(EP_CONTROL, 32); //!< read wIndex and wLength with a 32-bit access //!< since this access is aligned with a 32-bit //!< boundary from the beginning of the endpoint wLength = usb_format_usb_to_mcu_data(16, temp.u16[1]); //!< ignore wIndex, keep and format wLength Usb_ack_setup_received_free(); //!< clear the setup received flag if (wLength > data_to_transfer) { zlp = !(data_to_transfer % EP_CONTROL_LENGTH); //!< zero length packet condition } else { // No need to test ZLP sending since we send the exact number of bytes as // expected by the host. data_to_transfer = (U8)wLength; //!< send only requested number of data bytes } Usb_ack_nak_out(EP_CONTROL); while (data_to_transfer && !Is_usb_nak_out(EP_CONTROL)) { while (!Is_usb_control_in_ready() && !Is_usb_nak_out(EP_CONTROL)); if (Is_usb_nak_out(EP_CONTROL)) break; // don't clear the flag now, it will be cleared after Usb_reset_endpoint_fifo_access(EP_CONTROL); data_to_transfer = usb_write_ep_txpacket(EP_CONTROL, pbuffer, data_to_transfer, &pbuffer); if (Is_usb_nak_out(EP_CONTROL)) break; else Usb_ack_control_in_ready_send(); //!< Send data until necessary } if (zlp && !Is_usb_nak_out(EP_CONTROL)) { while (!Is_usb_control_in_ready()); Usb_ack_control_in_ready_send(); } while (!Is_usb_nak_out(EP_CONTROL)); Usb_ack_nak_out(EP_CONTROL); while (!Is_usb_control_out_received()); Usb_ack_control_out_received_free(); }
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 }