/********************************************************************* * Function: void APP_DeviceCustomHIDTasks(void); * * Overview: Keeps the Custom HID demo running. * * PreCondition: The demo should have been initialized and started via * the APP_DeviceCustomHIDInitialize() and APP_DeviceCustomHIDStart() demos * respectively. * * Input: None * * Output: None * ********************************************************************/ void APP_DeviceCustomHIDTasks() { //Check if we have received an OUT data packet from the host if(HIDRxHandleBusy(USBOutHandle) == false) { //We just received a packet of data from the USB host. //Check the first uint8_t of the packet to see what command the host //application software wants us to fulfill. switch(ReceivedDataBuffer[0]) //Look at the data the host sent, to see what kind of application specific command it sent. { case COMMAND_TOGGLE_LED: //Toggle LEDs command LED_Toggle(LED_USB_DEVICE_HID_CUSTOM); break; case COMMAND_GET_BUTTON_STATUS: //Get push button state //Check to make sure the endpoint/buffer is free before we modify the contents if(!HIDTxHandleBusy(USBInHandle)) { ToSendDataBuffer[0] = 0x81; //Echo back to the host PC the command we are fulfilling in the first uint8_t. In this case, the Get Pushbutton State command. if(BUTTON_IsPressed(BUTTON_USB_DEVICE_HID_CUSTOM) == false) //pushbutton not pressed, pull up resistor on circuit board is pulling the PORT pin high { ToSendDataBuffer[1] = 0x01; } else //sw3 must be == 0, pushbutton is pressed and overpowering the pull up resistor { ToSendDataBuffer[1] = 0x00; } //Prepare the USB module to send the data packet to the host USBInHandle = HIDTxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ToSendDataBuffer[0],64); } break; case COMMAND_READ_POTENTIOMETER: //Read POT command. Uses ADC to measure an analog voltage on one of the ANxx I/O pins, and returns the result to the host { uint16_t pot; //Check to make sure the endpoint/buffer is free before we modify the contents if(!HIDTxHandleBusy(USBInHandle)) { //Use ADC to read the I/O pin voltage. See the relevant HardwareProfile - xxxxx.h file for the I/O pin that it will measure. //Some demo boards, like the PIC18F87J50 FS USB Plug-In Module board, do not have a potentiometer (when used stand alone). //This function call will still measure the analog voltage on the I/O pin however. To make the demo more interesting, it //is suggested that an external adjustable analog voltage should be applied to this pin. pot = ADC_Read10bit(ADC_CHANNEL_POTENTIOMETER); ToSendDataBuffer[0] = 0x37; //Echo back to the host the command we are fulfilling in the first uint8_t. In this case, the Read POT (analog voltage) command. ToSendDataBuffer[1] = (uint8_t)pot; //LSB ToSendDataBuffer[2] = pot >> 8; //MSB //Prepare the USB module to send the data packet to the host USBInHandle = HIDTxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ToSendDataBuffer[0],64); } } break; } //Re-arm the OUT endpoint, so we can receive the next OUT data packet //that the host may try to send us. USBOutHandle = HIDRxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ReceivedDataBuffer, 64); }
/********************************************************************* * Function: void APP_DeviceCustomHIDTasks(void); * * Overview: Keeps the Custom HID demo running. * * PreCondition: The demo should have been initialized and started via * the APP_DeviceCustomHIDInitialize() and APP_DeviceCustomHIDStart() demos * respectively. * * Input: None * * Output: None * ********************************************************************/ void APP_DeviceCustomHIDTasks() { //Check if we have received an OUT data packet from the host if(HIDRxHandleBusy(USBOutHandle) == false) { //We just received a packet of data from the USB host. //Check the first uint8_t of the packet to see what command the host //application software wants us to fulfill. if (ReceivedDataBuffer[0] == COMMAND_TOGGLE_LED) //Look at the data the host sent, to see what kind of application specific command it sent. { //Toggle LEDs command LED_Toggle(LED_GREEN); } else { if (!check_command()) { // strcpypgm2ram((char *) ToSendDataBuffer, (farchar *) "null"); *ToSendDataBuffer = 0xFF; } if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*) & ToSendDataBuffer[0], 64); } } //Re-arm the OUT endpoint, so we can receive the next OUT data packet //that the host may try to send us. USBOutHandle = HIDRxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ReceivedDataBuffer, 64); } }
/* * This routine will poll for a received Input report, process it * and send an Output report to the host. * Both directions use interrupt transfers. * The ownership of the USB buffers will change according * to the required operation. */ void send_receive (void) { static int usb_state = 'r'; static USB_HANDLE last_transmit = 0; static USB_HANDLE last_receive = 0; switch (usb_state) { case 'r': if (! HIDRxHandleBusy (last_receive)) { // The CPU owns the endpoint. Start receiving data. last_receive = HIDRxPacket (HID_EP, (unsigned char*) &hid_report_out, HID_INT_OUT_EP_SIZE); usb_state = 'p'; } break; case 'p': if (! HIDRxHandleBusy (last_receive)) { // The CPU owns the endpoint. if (last_receive->CNT > 0) { // Data was received. Copy it to the output buffer for sending. process_data(); // Ready to transmit the received data back to the host. usb_state = 't'; } else { // No data was received. Return to checking for new received data. usb_state = 'r'; } } break; case 't': if (! HIDTxHandleBusy (last_transmit)) { // The CPU owns the endpoint. Start sending data. last_transmit = HIDTxPacket (HID_EP, (unsigned char*) &hid_report_in, HID_INPUT_REPORT_BYTES); // Return to checking for new received data. usb_state = 'r'; } break; default: // Cannot happen. break; } }
void Keyboard(void) { static char* c = g_tx_queue; if (SwitchIsPressed()) { g_tx_queue[0] = 0; if (g_config_mode) { ++g_lgtm_strings_idx; if (g_lgtm_strings_idx >= NUM_LGTM_STRINGS) g_lgtm_strings_idx = 0; EEADR = 0; EEDATA = g_lgtm_strings_idx; EECON1bits.EEPGD = 0; EECON1bits.CFGS = 0; EECON1bits.WREN = 1; EECON2 = 0x55; EECON2 = 0xAA; EECON1bits.WR = 1; strcatpgm2ram(g_tx_queue, CFG_MODE_STR); } strcatpgm2ram(g_tx_queue, LGTM_STRINGS[g_lgtm_strings_idx]); c = g_tx_queue; } // Check if the IN endpoint is not busy, and if it isn't check if we want to // send keystroke data to the host. if (!HIDTxHandleBusy(g_usb_handle_in)) { memset(hid_report_in, 0, sizeof(hid_report_in)); if (*c) { HIDKey key; key = AsciiToHid(*c); ++c; hid_report_in[0] = key.modifier; hid_report_in[2] = key.code; } // Send the 8 byte packet over USB to the host. g_usb_handle_in = HIDTxPacket(HID_EP, (BYTE*)hid_report_in, 0x08); } // Check if any data was sent from the PC to the keyboard device. Report // descriptor allows // host to send 1 byte of data. Bits 0-4 are LED states, bits 5-7 are unused // pad bits. // The host can potentially send this OUT report data through the HID OUT // endpoint (EP1 OUT), // or, alternatively, the host may try to send LED state information by // sending a // SET_REPORT control transfer on EP0. See the USBHIDCBSetReportHandler() // function. if (!HIDRxHandleBusy(g_usb_handle_out)) { // Do something useful with the data now. Data is in the OutBuffer[0]. // Num Lock LED state is in Bit0. // if (hid_report_out[0] & 0x01) // Make LED1 and LED2 match Num Lock // state. g_usb_handle_out = HIDRxPacket(HID_EP, (BYTE*)&hid_report_out, 1); } return; }
void usb_tasks() { // User Application USB tasks if (USBDeviceState < CONFIGURED_STATE || USBSuspendControl == 1) return; // Check if we have received an OUT data packet from the host, and nothing is left in buffer if (!HIDRxHandleBusy(USBOutHandleCfg) && !HIDTxHandleBusy(USBInHandleCfg)) { // We just received a packet of data from the USB host. // Check the first byte of the packet to see what command the host // application software wants us to fulfill. uint8_t cmd = usbOutBuffer[0]; if (cmd == CFG_CMD_READ) { // format response cfg_read_report_t* report = (cfg_read_report_t*)usbInBuffer; report->command_id = CFG_CMD_READ; report->fw_major = FW_MAJOR; report->fw_minor = FW_MINOR; report->hw_revision = HW_REVISION; report->device_type = MUNIA_DEVICETYPE; uint8_t* r = &report->devid1; TBLPTR = 0x3FFFFF; asm("tblrd*-"); *r++ = TABLAT; asm("tblrd*"); *r = TABLAT; TBLPTRU = 0; memcpy(&report->config, &config, sizeof(config_t)); memset(usbInBuffer + sizeof(cfg_read_report_t), 0, sizeof(usbInBuffer) - sizeof(cfg_read_report_t)); USBInHandleCfg = HIDTxPacket(HID_EP_CFG, usbInBuffer, CFG_CMD_REPORT_SIZE); } else if (cmd == CFG_CMD_WRITE) { // extract config cfg_write_report_t* report = (cfg_write_report_t*)usbOutBuffer; memcpy(&config, &report->config, sizeof(config_t)); save_config(); apply_config(); // response usbInBuffer[0] = CFG_CMD_WRITE; usbInBuffer[1] = 1; // signifies ok memset(usbInBuffer + 2, 0, sizeof(usbInBuffer) - 2); USBInHandleCfg = HIDTxPacket(HID_EP_CFG, usbInBuffer, CFG_CMD_REPORT_SIZE); } else if (cmd == CFG_CMD_ENTER_BL) { // dbgs("jumping to bootloader\n"); asm("goto 0x001C"); } // re-arm USBOutHandleCfg = HIDRxPacket(HID_EP_CFG, usbOutBuffer, sizeof (usbOutBuffer)); } }
void Keyboard(void) { unsigned char i = 0; if(!HIDTxHandleBusy(lastINTransmission)) { hid_report_in[0] = 0; hid_report_in[1] = 0; hid_report_in[2] = 0; hid_report_in[3] = 0; hid_report_in[4] = 0; hid_report_in[5] = 0; hid_report_in[6] = 0; hid_report_in[7] = 0; if(dynamicFlags > 0) { hid_report_in[0] = dynamicFlags; } else { hid_report_in[0] = 0; } for(i = 0; i < reportIndex; i++) { hid_report_in[i + 2] = report[i]; } /* if(!PORTAbits.RA0) hid_report_in[2] = 0x28; //[ENTER] else hid_report_in[2] = 0; */ //Send the 8 byte packet over USB to the host. lastINTransmission = HIDTxPacket(HID_EP, (BYTE*)hid_report_in, 0x08); } if(!HIDRxHandleBusy(lastOUTTransmission)) { /* if(hid_report_out[0] & 0x02) //[CAPS]lock時に点灯 LATBbits.LATB4 = 1; else LATBbits.LATB4 = 0; if(hid_report_out[0] & 0x01) //[NUM]lock時に点灯 LATBbits.LATB5 = 1; else LATBbits.LATB5 = 0; */ lastOUTTransmission = HIDRxPacket(HID_EP,(BYTE*)&hid_report_out,1); } return; }//end keyboard()
/******************************************************************** * Function: void ProcessIO(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This function is a place holder for other user * routines. It is a mixture of both USB and * non-USB tasks. * * Note: None *******************************************************************/ void ProcessIO(void) { // User Application USB tasks if((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl == 1)) { return; } // Indicate USB is connected. xSystemState.bUsbConnected = 1; // If data was received from the host... if(!HIDRxHandleBusy(USBOutHandle)) { // Make sure the transmitter is not busy. if (!HIDTxHandleBusy(USBInHandle)) { // Process the data. unsigned char ucTransmitDataLength = ucProcessCommandPacket(ReceivedDataBuffer, ToSendDataBuffer); // Send the data if there is any. if (ucTransmitDataLength > 0) { // Fill the remaining bytes with 0xff if it's not full. unsigned char i; for (i = ucTransmitDataLength; i < 64; i++) { ToSendDataBuffer[i] = 0xff; } // Transmit the data. USBInHandle = HIDTxPacket(HID_EP, ToSendDataBuffer, 64); } // Re-arm the OUT endpoint to receive next packet if there is no data to send. else { USBOutHandle = HIDRxPacket(HID_EP, ReceivedDataBuffer, 64); } } } MSDTasks(); }
// Process USB commands void processUsbCommands(void) { // Check if we are in the configured state; otherwise just return if((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl == 1)) { // We are not configured return; } // Check if data was received from the host. if (!HIDRxHandleBusy(USBOutHandle)) { // Command mode switch (ReceivedDataBuffer[0]) { case 0x01: // System Commands switch (ReceivedDataBuffer[1]) { case 0x01: // System Commands // Copy any waiting debug text to the send data buffer ToSendDataBuffer[0] = 0xFF; // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; default: // Unknown command received break; } break; case 0x02: // Feeder Commands switch (ReceivedDataBuffer[1]) { case 0x02: // Feeder Status if (atmegaFeederRunning){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x03: // Go to feeder StartI2C(); WriteI2C(0x28); // sends address to the device IdleI2C(); WriteI2C(ReceivedDataBuffer[2]); // sends a control byte to the device IdleI2C(); StopI2C(); break; case 0x04: // Reset Feeder Z StartI2C(); WriteI2C(0x28); // sends address to the device IdleI2C(); WriteI2C(80); // sends a control byte to the device IdleI2C(); StopI2C(); break; case 0x05: // Full feeder reset StartI2C(); WriteI2C(0x28); // sends address to the device IdleI2C(); WriteI2C(70); // sends a control byte to the device IdleI2C(); StopI2C(); break; case 0x06: // Reset ATMEGA IC atmegaResetPin = 0; Delay1KTCYx(10); atmegaResetPin = 1; break; default: // Unknown command received break; } break; case 0x03: // Vacuum and Vibration Commands switch (ReceivedDataBuffer[1]) { case 0x01: // Vacuum 1 set if (ReceivedDataBuffer[2] == 0x01){ setVac1on; } else{ setVac1off; } break; case 0x02: // Vacuum 2 set if (ReceivedDataBuffer[2] == 0x01){ setVac2on; } else{ setVac2off; } break; case 0x03: // Vibration Motor set if (ReceivedDataBuffer[2] == 0x01){ setVibrationon; StartI2C(); WriteI2C(0x16); // sends address to the device IdleI2C(); WriteI2C(0x01); // sends a control byte to the device IdleI2C(); StopI2C(); } else{ setVibrationoff; StartI2C(); WriteI2C(0x16); // sends address to the device IdleI2C(); WriteI2C(0x02); // sends a control byte to the device IdleI2C(); StopI2C(); } break; case 0x04: // Vacuum 1 status if (vac1running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x05: // Vacuum 2 status if (vac2running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x06: // Vibration Motor status if (vibrationrunning == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x07: // Vibration Motor status vibrationmotor_duty_cycle = ReceivedDataBuffer[2]; StartI2C(); WriteI2C(0x16); // sends address to the device IdleI2C(); WriteI2C(0x03); // sends a control byte to the device IdleI2C(); WriteI2C(vibrationmotor_duty_cycle); // sends a control byte to the device IdleI2C(); StopI2C(); break; default: // Unknown command received break; } break; case 0x04: // LED Commands switch (ReceivedDataBuffer[1]) { case 0x01: // LED Base Camera on/off if (ReceivedDataBuffer[2] == 0x01){ OpenPWM1(0xFF); led1_duty_cycle = led1_duty_cycle * 4; SetDCPWM1(led1_duty_cycle); // outBaseLED = 1; led1running = 1; }else{ ClosePWM1(); // outBaseLED = 0; led1running = 0; } break; case 0x02: // LED Base Camera PWM set led1_duty_cycle = ReceivedDataBuffer[2]; Write_b_eep(baseLED_EEPROM_address, led1_duty_cycle); led1_duty_cycle = led1_duty_cycle * 4; SetDCPWM1(led1_duty_cycle); break; case 0x03: // LED Head Camera on/off if (ReceivedDataBuffer[2] == 0x01){ OpenPWM2(0xFF); led2_duty_cycle = led2_duty_cycle * 4; SetDCPWM2(led2_duty_cycle); // outBaseLED = 1; led2running = 1; }else{ ClosePWM2(); // outBaseLED = 0; led2running = 0; } break; case 0x04: // LED Head Camera PWM set led2_duty_cycle = ReceivedDataBuffer[2]; Write_b_eep(headLED_EEPROM_address, led2_duty_cycle); led2_duty_cycle = led2_duty_cycle * 4; SetDCPWM2(led2_duty_cycle); break; case 0x05: // LED Base Status if (led1running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x06: // LED Head Status if (led2running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; default: // Unknown command received break; } break; default: // Unknown command received break; } // Re-arm the OUT endpoint for the next packet USBOutHandle = HIDRxPacket(HID_EP, (BYTE*) & ReceivedDataBuffer, 64); } }
/******************************************************************** * Function: void ProcessIO(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This function is a place holder for other user * routines. It is a mixture of both USB and * non-USB tasks. * * Note: None *******************************************************************/ void ProcessIO(void) { if(DemoIntroState == 0xFF) { BL_CheckLoaderEnabled(); } // User Application USB tasks if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return; // Soft Start the APP_VDD if(AppPowerReady() == FALSE) return; DemoIntroduction(); if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host. { switch(ReceivedDataBuffer[0]) //Look at the data the host sent, to see what kind of application specific command it sent. { case 0x80: //mTouch callibration command mTouchCalibrate(); break; case 0x20: { WORD potVoltage; if(!HIDTxHandleBusy(USBInHandle)) { /* Select ADC channel */ ADCON0bits.CHS = 4; /* Make sure A/D interrupt is not set */ PIR1bits.ADIF = 0; /* Begin A/D conversion */ ADCON0bits.GO=1; //Wait for A/D convert complete while(!PIR1bits.ADIF); /* Get the value from the A/D */ potVoltage = ADRES; ToSendDataBuffer[0] = 0x20; ToSendDataBuffer[1] = (BYTE)(potVoltage); ToSendDataBuffer[2] = (BYTE)(potVoltage>>8); USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64); } } break; case 0x30: { WORD w; if(!HIDTxHandleBusy(USBInHandle)) { w = mTouchReadButton(0); ToSendDataBuffer[0] = 0x30; ToSendDataBuffer[1] = (BYTE)w; ToSendDataBuffer[2] = (BYTE)(w>>8); USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64); } } break; case 0x31: { WORD w; if(!HIDTxHandleBusy(USBInHandle)) { w = mTouchReadButton(1); ToSendDataBuffer[0] = 0x31; ToSendDataBuffer[1] = (BYTE)w; ToSendDataBuffer[2] = (BYTE)(w>>8); USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64); } }
/********************************************************************* * Function: void APP_DeviceCustomHIDTasks(void); * * Overview: Keeps the Custom HID demo running. * * PreCondition: The demo should have been initialized and started via * the APP_DeviceCustomHIDInitialize() and APP_DeviceCustomHIDStart() demos * respectively. * * Input: None * * Output: None * ********************************************************************/ void APP_DeviceCustomHIDTasks() { //Check if we have received an OUT data packet from the host if(HIDRxHandleBusy(USBOutHandle) == false) { //We just received a packet of data from the USB host. //Check the first uint8_t of the packet to see what command the host //application software wants us to fulfill. switch(ReceivedDataBuffer[0]) //Look at the data the host sent, to see what kind of application specific command it sent. { case READ_SFR: ReadSfr(); break; case WRITE_SFR: WriteSfr(); break; case ADC_CFG: AdcCfg(); break; case ADC_VALUE: AdcValue(); break; case ANALOGCMP_CFG: AnalogCmpCfg(); break; case SPI_CFG: SpiCfg(); break; case SPI_TRANSFERENCE: SpiTransference(); break; case SFR_CHANGE_BIT_VALUE: SfrChangeBitValue(); break; case I2C_CFG: I2cCfg(); break; case I2C_TRANSFERENCE: I2cTransference(); break; case CCP_CFG: CcpCfg(); break; case PWM_FPWM: PwmFpwm(); break; case PWM_DC: PwmDc(); break; case SFR_READ_BIT_VALUE: SfrReadBitValue(); break; case EUSART_TX: EusartTx(); break; case EUSART_RX: EusartRx(); break; case TEST: Test(); break; case UDF_CALL: UDF(); break; case UDF_PROGRAM: UDF_Program(); break; } //Re-arm the OUT endpoint, so we can receive the next OUT data packet //that the host may try to send us. USBOutHandle = HIDRxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ReceivedDataBuffer, 64); } }
/** * ProcessIO: **/ static void ProcessIO(void) { uint16_t address; uint16_t erase_length; uint8_t length; uint8_t checksum; uint8_t cmd; uint8_t rc = CH_ERROR_NONE; /* reset the LED state */ led_counter--; if (led_counter == 0) { CHugSetLEDsInternal(led_color); led_color *= 2; if (led_color > CH_STATUS_LED_BLUE) led_color = CH_STATUS_LED_GREEN; led_counter = BOOTLOADER_FLASH_INTERVAL; } /* User Application USB tasks */ if ((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl == 1)) return; /* no data was received */ if(HIDRxHandleBusy(USBOutHandle)) { if (idle_counter++ == 0xff && idle_command != 0x00) CHugDeviceIdle(); return; } /* got data, reset idle counter */ idle_counter = 0; /* clear for debugging */ memset (TxBuffer, 0xff, sizeof (TxBuffer)); cmd = RxBuffer[CH_BUFFER_INPUT_CMD]; switch(cmd) { case CH_CMD_GET_HARDWARE_VERSION: TxBuffer[CH_BUFFER_OUTPUT_DATA] = PORTB & 0x0f; break; case CH_CMD_RESET: /* only reset when USB stack is not busy */ idle_command = CH_CMD_RESET; break; case CH_CMD_GET_FIRMWARE_VERSION: memcpy (&TxBuffer[CH_BUFFER_OUTPUT_DATA], &FirmwareVersion, 2 * 3); break; case CH_CMD_ERASE_FLASH: /* are we lost or stolen */ if (flash_success == 0xff) { rc = CH_ERROR_DEVICE_DEACTIVATED; break; } memcpy (&address, (const void *) &RxBuffer[CH_BUFFER_INPUT_DATA+0], 2); /* allow to erase any address but not the bootloader */ if (address < CH_EEPROM_ADDR_RUNCODE) { rc = CH_ERROR_INVALID_ADDRESS; break; } memcpy (&erase_length, (const void *) &RxBuffer[CH_BUFFER_INPUT_DATA+2], 2); EraseFlash(address, address + erase_length); break; case CH_CMD_READ_FLASH: /* are we lost or stolen */ if (flash_success == 0xff) { rc = CH_ERROR_DEVICE_DEACTIVATED; break; } /* allow to read any address */ memcpy (&address, (const void *) &RxBuffer[CH_BUFFER_INPUT_DATA+0], 2); length = RxBuffer[CH_BUFFER_INPUT_DATA+2]; if (length > 60) { rc = CH_ERROR_INVALID_LENGTH; break; } ReadFlash(address, length, (unsigned char *) &TxBuffer[CH_BUFFER_OUTPUT_DATA+1]); checksum = CHugCalculateChecksum (&TxBuffer[CH_BUFFER_OUTPUT_DATA+1], length); TxBuffer[CH_BUFFER_OUTPUT_DATA+0] = checksum; break; case CH_CMD_WRITE_FLASH: /* are we lost or stolen */ if (flash_success == 0xff) { rc = CH_ERROR_DEVICE_DEACTIVATED; break; } /* write to flash that's not the bootloader */ memcpy (&address, (const void *) &RxBuffer[CH_BUFFER_INPUT_DATA+0], 2); if (address < CH_EEPROM_ADDR_RUNCODE) { rc = CH_ERROR_INVALID_ADDRESS; break; } length = RxBuffer[CH_BUFFER_INPUT_DATA+2]; if (length > CH_FLASH_TRANSFER_BLOCK_SIZE) { rc = CH_ERROR_INVALID_LENGTH; break; } checksum = CHugCalculateChecksum(&RxBuffer[CH_BUFFER_INPUT_DATA+4], length); if (checksum != RxBuffer[CH_BUFFER_INPUT_DATA+3]) { rc = CH_ERROR_INVALID_CHECKSUM; break; } /* copy low 32 bytes into flash buffer, and only write * in 64 byte chunks as this is a limitation of the * hardware */ if ((address & CH_FLASH_TRANSFER_BLOCK_SIZE) == 0) { memset (FlashBuffer, 0xff, CH_FLASH_WRITE_BLOCK_SIZE); memcpy (FlashBuffer, (const void *) &RxBuffer[CH_BUFFER_INPUT_DATA+4], length); } else { memcpy (FlashBuffer + CH_FLASH_TRANSFER_BLOCK_SIZE, (const void *) &RxBuffer[CH_BUFFER_INPUT_DATA+4], length); WriteBytesFlash(address - CH_FLASH_TRANSFER_BLOCK_SIZE, CH_FLASH_WRITE_BLOCK_SIZE, (unsigned char *) FlashBuffer); } break; case CH_CMD_BOOT_FLASH: /* are we lost or stolen */ if (flash_success == 0xff) { rc = CH_ERROR_DEVICE_DEACTIVATED; break; } /* only boot when USB stack is not busy */ idle_command = CH_CMD_BOOT_FLASH; break; case CH_CMD_SET_FLASH_SUCCESS: if (RxBuffer[CH_BUFFER_INPUT_DATA] != 0x00) { rc = CH_ERROR_INVALID_VALUE; break; } flash_success = RxBuffer[CH_BUFFER_INPUT_DATA]; EraseFlash(CH_EEPROM_ADDR_FLASH_SUCCESS, CH_EEPROM_ADDR_FLASH_SUCCESS + 1); WriteBytesFlash(CH_EEPROM_ADDR_FLASH_SUCCESS, 1, (unsigned char *) &RxBuffer[CH_BUFFER_INPUT_DATA]); break; case CH_CMD_SELF_TEST: rc = CHugSelfTest(); break; default: rc = CH_ERROR_UNKNOWN_CMD_FOR_BOOTLOADER; break; } /* always send return code */ if(!HIDTxHandleBusy(USBInHandle)) { TxBuffer[CH_BUFFER_OUTPUT_RETVAL] = rc; TxBuffer[CH_BUFFER_OUTPUT_CMD] = cmd; USBInHandle = HIDTxPacket(HID_EP, (BYTE*)&TxBuffer[0], CH_USB_HID_EP_SIZE); } /* re-arm the OUT endpoint for the next packet */ USBOutHandle = HIDRxPacket(HID_EP, (BYTE*)&RxBuffer, CH_USB_HID_EP_SIZE); }
/******************************************************************** * Function: void ProcessIO(void) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: This function is a place holder for other user * routines. It is a mixture of both USB and * non-USB tasks. * * Note: None *******************************************************************/ void ProcessIO(void) { // User Application USB tasks if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return; //Check if we have received an OUT data packet from the host if(!HIDRxHandleBusy(USBOutHandle)) { //We just received a packet of data from the USB host. //Check the first byte of the packet to see what command the host //application software wants us to fulfill. switch (ReceivedDataBuffer[0]) { case 0x01: // System Commands switch (ReceivedDataBuffer[1]) { case 0x01: // System Commands // Copy any waiting debug text to the send data buffer ToSendDataBuffer[0] = 0xFF; // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; default: // Unknown command received break; } break; case 0x02: // Feeder Commands switch (ReceivedDataBuffer[1]) { case 0x02: // Feeder Status if (FeederStatus() == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x03: // Go to feeder if ((ReceivedDataBuffer[2] >= 0) && (ReceivedDataBuffer[2] <= 16)){ moveToPosition(ReceivedDataBuffer[2]); } break; case 0x04: // Picker Up PickerUp(); break; case 0x05: // Zero Feeder ZeroFeeder(); break; case 0x06: // Picker Down PickerDown(); break; case 0x07: // Set Picker Port Output pickerBusval = ((ReceivedDataBuffer[3] << 8) | ReceivedDataBuffer[2]); pickerBus = pickerBusval; break; case 0x08: // Go to feeder if ((ReceivedDataBuffer[2] > 0) && (ReceivedDataBuffer[2] <= 16)){ moveToPositionWithoutPick(ReceivedDataBuffer[2]); } break; default: // Unknown command received break; } break; case 0x03: // Vacuum and Vibration Commands switch (ReceivedDataBuffer[1]) { case 0x01: // Vacuum 1 set if (ReceivedDataBuffer[2] == 0x01){ setVac1on; } else{ setVac1off; } break; case 0x02: // Vacuum 2 set if (ReceivedDataBuffer[2] == 0x01){ setVac2on; } else{ setVac2off; } break; case 0x03: // Vibration Motor set if (ReceivedDataBuffer[2] == 0x01){ SetDCOC1PWM(vibrationmotor_duty_cycle); vibrationrunning = 1; } else{ SetDCOC1PWM(0); vibrationrunning = 0; } break; case 0x04: // Vacuum 1 status if (vac1running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x05: // Vacuum 2 status if (vac2running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x06: // Vibration Motor status if (vibrationrunning == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x07: // Vibration Motor status vibrationmotor_duty_cycle = ReceivedDataBuffer[2] * 4; if (vibrationrunning == 1){ SetDCOC1PWM(vibrationmotor_duty_cycle); } break; default: // Unknown command received break; } break; case 0x04: // LED Commands switch (ReceivedDataBuffer[1]) { case 0x01: // LED Base Camera on/off if (ReceivedDataBuffer[2] == 0x01){ SetDCOC2PWM(led1_duty_cycle); led1running = 1; }else{ SetDCOC2PWM(0); led1running = 0; } break; case 0x02: // LED Base Camera PWM set led1_duty_cycle = ReceivedDataBuffer[2] * 4; if (led1running == 1){ SetDCOC2PWM(led1_duty_cycle); } break; case 0x03: // LED Head Camera on/off if (ReceivedDataBuffer[2] == 0x01){ SetDCOC3PWM(led2_duty_cycle); led2running = 1; }else{ SetDCOC3PWM(0); led2running = 0; } break; case 0x04: // LED Head Camera PWM set led2_duty_cycle = ReceivedDataBuffer[2] * 4; if (led2running == 1){ SetDCOC3PWM(led2_duty_cycle); } break; case 0x05: // LED Base Status if (led1running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; case 0x06: // LED Head Status if (led2running == 1){ ToSendDataBuffer[0] = 0x01; } else{ ToSendDataBuffer[0] = 0x00; } // Transmit the response to the host if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*) & ToSendDataBuffer[0], 64); } break; default: // Unknown command received break; } break; default: // Unknown command received break; } //Re-arm the OUT endpoint, so we can receive the next OUT data packet //that the host may try to send us. USBOutHandle = HIDRxPacket(HID_EP, (BYTE*)&ReceivedDataBuffer, 64); } }//end ProcessIO
void USBUpdate() { int a,b; // User Application USB tasks if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return; if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host. { switch(ReceivedDataBuffer[0]) //Look at the data the host sent, to see what kind of application specific command it sent. { case 0x01: a=EPPoll(*(int16*)&ReceivedDataBuffer[1]); if(!USBBusy()) { ToSendDataBuffer[0]=0x03; if(a!=0) ToSendDataBuffer[1]=0; else ToSendDataBuffer[1]=255; USBWrite(); } break; case 0x02: EPBufferSize=ReceivedDataBuffer[3]; for(a=0;a<EPBufferSize;a++)Set8(a,ReceivedDataBuffer[a+4]); EPSend(*(int16*)&ReceivedDataBuffer[1]); if(!USBBusy()) { ToSendDataBuffer[0]=0x02; USBWrite(); } break; case 0x06: ToSendDataBuffer[1]=KismetExecuteEvent(((int16*)&ReceivedDataBuffer[1])[0],ReceivedDataBuffer[3]); if(!USBBusy()) { ToSendDataBuffer[0]=0x06; USBWrite(); } break; case 0x07: OperationEnabled=0; if(!USBBusy()) { ToSendDataBuffer[0]=0x07; USBWrite(); } break; case 0x08: OperationEnabled=0xff; if(!USBBusy()) { ToSendDataBuffer[0]=0x08; USBWrite(); } break; case 0x03://EEPROM Write MemoryBeginWrite(((int16*)&ReceivedDataBuffer[1])[0]); MemoryWrite(ReceivedDataBuffer[3]); MemoryEndWrite(); if(!USBBusy()) { ToSendDataBuffer[0]=0x03; USBWrite(); } break; case 0x04://EEPROM WRITE PAGE MemoryBeginWrite(((int16*)&ReceivedDataBuffer[1])[0]); for(a=0;a<32;a++) MemoryWrite(ReceivedDataBuffer[3+a]); MemoryEndWrite(); if(!USBBusy()) { ToSendDataBuffer[0]=0x04; USBWrite(); } break; case 0x05://EEPROM READ if(!USBBusy()) { MemoryBeginRead(((int16*)&ReceivedDataBuffer[1])[0]); ToSendDataBuffer[0]=0x05; ToSendDataBuffer[1]=MemoryReadInt8(); MemoryEndRead(); USBWrite(); } break; case 0x40://READ TIME if(!USBBusy()) { ToSendDataBuffer[0]=0x40; ToSendDataBuffer[1]=RTCSecond; ToSendDataBuffer[2]=RTCMinute; ToSendDataBuffer[3]=RTCHour; INT16(ToSendDataBuffer[4])=RTCDay; USBWrite(); } break; case 0x41://WRITE TIME RTCSecond =ReceivedDataBuffer[1]; RTCMinute =ReceivedDataBuffer[2]; RTCHour =ReceivedDataBuffer[3]; RTCDay =INT16(ReceivedDataBuffer[4]); if(!USBBusy()) { ToSendDataBuffer[0]=0x41; USBWrite(); } break; case 0x50://SET TIMER SetTimer(ReceivedDataBuffer[1],ReceivedDataBuffer[2],INT16(ReceivedDataBuffer[3])); if(!USBBusy()) { ToSendDataBuffer[0]=0x50; USBWrite(); } break; } if(!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64); } ReceivedDataBuffer[0]=0; //Re-arm the OUT endpoint for the next packet USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64); } }
// Process input and output void ProcessIO(void) { //LED0 = ON; // If we are not in the configured state just return if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) { // We are not configured, set LED1 to off to show status //LED1 = OFF; return; } // We are configured, show state in LED1 //LED1 = ON; // Check to see if the success indicator is on and update the delay counter if (successIndicatorFlag == TRUE) { //LED2 = ON; successIndicatorCounter++; if (successIndicatorCounter == 20000) { //LED2 = OFF; successIndicatorCounter = 0; successIndicatorFlag = FALSE; } } // Check to see if the failure indicator is on and update the delay counter if (failureIndicatorFlag == TRUE) { //LED3 = ON; failureIndicatorCounter++; if (failureIndicatorCounter == 80000) { //LED3 = OFF; failureIndicatorCounter = 0; failureIndicatorFlag = FALSE; } } // Note: For all tests we expect to receive a 64 byte packet containing // the command in byte[0] and then the numbers 0-62 in bytes 1-63. unsigned char bufferPointer; unsigned char expectedData; unsigned char dataReceivedOk; unsigned char dataSentOk; // Check if data was received from the host. if(!HIDRxHandleBusy(USBOutHandle)) { // Test to see if we are in bulk send/receieve mode, or if we are waiting for a command if (bulkSendFlag == TRUE || bulkReceiveFlag == TRUE) { // We are either bulk sending or receieving // If we are bulk sending, check that we are not busy and send the next packet if (bulkSendFlag == TRUE && !HIDTxHandleBusy(USBInHandle)) { // Send the next packet expectedData = bulkSendPacketCounter; for (bufferPointer = 0; bufferPointer < 64; bufferPointer++) { ToSendDataBuffer[bufferPointer] = expectedData; } // Transmit the response to the host USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64); // Add this following delay in if you want to simulate a slow transfer // from a busy PIC when testing bulk sends: // for (long int counter = 0; counter < 1000; counter++) __delay_us(100); bulkSendPacketCounter++; // Next packet // Are we done yet? if (bulkSendPacketCounter == bulkSendExpectedPackets) { // All done, indicate success and go back to command mode bulkSendFlag = FALSE; successIndicatorFlag = TRUE; } } // If we are bulk receiving get the next packet if (bulkReceiveFlag == TRUE) { // The received data buffer is already filled by the USB stack // we just have to confirm the data integrity expectedData = bulkReceivePacketCounter; for (bufferPointer = 0; bufferPointer < 64; bufferPointer++) { // If the data isn't what we expected, turn on the failure light if (ReceivedDataBuffer[bufferPointer] != expectedData) failureIndicatorFlag = TRUE; } bulkReceivePacketCounter++; // Are we done yet? if (bulkReceivePacketCounter == bulkReceiveExpectedPackets) { // All done, indicate success and go back to command mode bulkReceiveFlag = FALSE; successIndicatorFlag = TRUE; } } } else { // Command mode switch(ReceivedDataBuffer[0]) { case 'M': dataReceivedOk = TRUE; ToSendDataBuffer[0] = highByte(frequency); ToSendDataBuffer[1] = lowByte(frequency); if (!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP, (BYTE*)&ToSendDataBuffer[0], 64); } break; case 0x80: // Test 1 - Single packet write to device // Test the receieved data expectedData = 0; dataReceivedOk = TRUE; for (bufferPointer = 1; bufferPointer < 64; bufferPointer++) { if (ReceivedDataBuffer[bufferPointer] != expectedData) dataReceivedOk = FALSE; expectedData++; } // Display the test result if (dataReceivedOk == TRUE) successIndicatorFlag = TRUE; else failureIndicatorFlag = TRUE; break; case 0x81: // Test 2 - Single packet read/write // Test the receieved data expectedData = 0; dataReceivedOk = TRUE; for (bufferPointer = 1; bufferPointer < 64; bufferPointer++) { if (ReceivedDataBuffer[bufferPointer] != expectedData) dataReceivedOk = FALSE; expectedData++; } // If we got the data correctly, send the response packet if (dataReceivedOk == TRUE) { expectedData = 0; dataSentOk = TRUE; for (bufferPointer = 0; bufferPointer < 64; bufferPointer++) { ToSendDataBuffer[bufferPointer] = expectedData; expectedData++; } // Transmit the response to the host if(!HIDTxHandleBusy(USBInHandle)) { USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64); } // Show our success successIndicatorFlag = TRUE; } else failureIndicatorFlag = TRUE; break; case 0x82: // Test 3 - Single packet write, 128 packets read // Test the receieved data expectedData = 0; dataReceivedOk = TRUE; for (bufferPointer = 1; bufferPointer < 64; bufferPointer++) { if (ReceivedDataBuffer[bufferPointer] != expectedData) dataReceivedOk = FALSE; expectedData++; } // If the receive was ok, go into bulk sending mode if (dataReceivedOk == TRUE) { // Go into bulk sending mode... bulkSendExpectedPackets = 128; bulkSendFlag = TRUE; bulkSendPacketCounter = 0; } else failureIndicatorFlag = TRUE; break; case 0x83: // Test 4 - 128 packets write, single packet read // Test the receieved data expectedData = 0; dataReceivedOk = TRUE; for (bufferPointer = 1; bufferPointer < 64; bufferPointer++) { if (ReceivedDataBuffer[bufferPointer] != expectedData) dataReceivedOk = FALSE; expectedData++; } // If the receive was ok, go into bulk receiving mode if (dataReceivedOk == TRUE) { // Go into bulk sending mode... bulkReceiveExpectedPackets = 127; bulkReceiveFlag = TRUE; bulkReceivePacketCounter = 0; } else failureIndicatorFlag = TRUE; break; case 0x84: // Test 5 - Single Packet write, timeout on read // Here we receive a command which expects a reply, but we // deliberately don't send one to test the timeout mechanisms // in the communication class // Test the receieved data expectedData = 0; dataReceivedOk = TRUE; for (bufferPointer = 1; bufferPointer < 64; bufferPointer++) { if (ReceivedDataBuffer[bufferPointer] != expectedData) dataReceivedOk = FALSE; expectedData++; } // Display the test result if (dataReceivedOk == TRUE) successIndicatorFlag = TRUE; else failureIndicatorFlag = TRUE; // Now we quit without replying break; default: // Unknown command received break; } } // Only rearm the OUT endpoint if we are not bulk sending if (bulkSendFlag == FALSE) { // Re-arm the OUT endpoint for the next packet USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64); } } }
void APP_tick() { if(HIDRxHandleBusy(USBOutHandle) == false) { switch(ReceivedDataBuffer[0]) { /*case 0x80: //Toggle LEDs command //LED_Toggle(LED_USB_DEVICE_HID_CUSTOM); break;*/ case 0x54: PWM_R_setPWM1(ReceivedDataBuffer[1]); // front PWM_R_setPWM2(ReceivedDataBuffer[2]); // back // Send Left & right to slave 18F2550 by SPI Left = ReceivedDataBuffer[3]; Right = ReceivedDataBuffer[4]; LeftRight[0] = (Left >= 0 && Left <= 255) ? Left : 256; LeftRight[1] = (Right >= 0 && Right <= 255) ? Right : 256; SPI_R_putsSPI(LeftRight); break; /*case 0x81: //Get push button state //Check to make sure the endpoint/buffer is free before we modify the contents if(!HIDTxHandleBusy(USBInHandle)) { ToSendDataBuffer[0] = 0x81; //Echo back to the host PC the command we are fulfilling in the first uint8_t. In this case, the Get Pushbutton State command. if(BUTTON_IsPressed(BUTTON_USB_DEVICE_HID_CUSTOM) == false) { //pushbutton not pressed, pull up resistor on circuit board is pulling the PORT pin high ToSendDataBuffer[1] = 0x01; } else { //sw3 must be == 0, pushbutton is pressed and overpowering the pull up resistor ToSendDataBuffer[1] = 0x00; } //Prepare the USB module to send the data packet to the host USBInHandle = HIDTxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ToSendDataBuffer[0],64); } break; case 0x37: { uint16_t pot; //Check to make sure the endpoint/buffer is free before we modify the contents if(!HIDTxHandleBusy(USBInHandle)) { //Use ADC to read the I/O pin voltage. See the relevant HardwareProfile - xxxxx.h file for the I/O pin that it will measure. //Some demo boards, like the PIC18F87J50 FS USB Plug-In Module board, do not have a potentiometer (when used stand alone). //This function call will still measure the analog voltage on the I/O pin however. To make the demo more interesting, it //is suggested that an external adjustable analog voltage should be applied to this pin. pot = ADC_Read10bit(ADC_CHANNEL_POTENTIOMETER); ToSendDataBuffer[0] = 0x37; //Echo back to the host the command we are fulfilling in the first uint8_t. In this case, the Read POT (analog voltage) command. ToSendDataBuffer[1] = (uint8_t)pot; //LSB ToSendDataBuffer[2] = pot >> 8; //MSB //Prepare the USB module to send the data packet to the host USBInHandle = HIDTxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ToSendDataBuffer[0],64); } } break;*/ } //Re-arm the OUT endpoint, so we can receive the next OUT data packet //that the host may try to send us. USBOutHandle = HIDRxPacket(CUSTOM_DEVICE_HID_EP, (uint8_t*)&ReceivedDataBuffer, 64); } }