//! @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
}
