#include #include #include "system.h" #include "usb.h" #include "usb_device_hid.h" #include "app_led_usb_status.h" #define PACKED int key_counter = 0; const struct{uint8_t report[HID_RPT01_SIZE];}hid_rpt01={ { 0x05, 0x01, // USAGE_PAGE (Generic Desktop) 0x09, 0x06, // USAGE (Keyboard) 0xa1, 0x01, // COLLECTION (Application) 0x05, 0x07, // USAGE_PAGE (Keyboard) 0x19, 0xe0, // USAGE_MINIMUM (Keyboard LeftControl) 0x29, 0xe7, // USAGE_MAXIMUM (Keyboard Right GUI) 0x15, 0x00, // LOGICAL_MINIMUM (0) 0x25, 0x01, // LOGICAL_MAXIMUM (1) 0x75, 0x01, // REPORT_SIZE (1) 0x95, 0x08, // REPORT_COUNT (8) 0x81, 0x02, // INPUT (Data,Var,Abs) 0x95, 0x01, // REPORT_COUNT (1) 0x75, 0x08, // REPORT_SIZE (8) 0x81, 0x03, // INPUT (Cnst,Var,Abs) 0x95, 0x05, // REPORT_COUNT (5) 0x75, 0x01, // REPORT_SIZE (1) 0x05, 0x08, // USAGE_PAGE (LEDs) 0x19, 0x01, // USAGE_MINIMUM (Num Lock) 0x29, 0x05, // USAGE_MAXIMUM (Kana) 0x91, 0x02, // OUTPUT (Data,Var,Abs) 0x95, 0x01, // REPORT_COUNT (1) 0x75, 0x03, // REPORT_SIZE (3) 0x91, 0x03, // OUTPUT (Cnst,Var,Abs) 0x95, 0x06, // REPORT_COUNT (6) 0x75, 0x08, // REPORT_SIZE (8) 0x15, 0x00, // LOGICAL_MINIMUM (0) 0x25, 0x65, // LOGICAL_MAXIMUM (101) 0x05, 0x07, // USAGE_PAGE (Keyboard) 0x19, 0x00, // USAGE_MINIMUM (Reserved (no event indicated)) 0x29, 0x65, // USAGE_MAXIMUM (Keyboard Application) 0x81, 0x00, // INPUT (Data,Ary,Abs) 0xc0} // End Collection }; typedef struct PACKED { /* The union below represents the first byte of the INPUT report. It is * formed by the following HID report items: * * 0x19, 0xe0, // USAGE_MINIMUM (Keyboard LeftControl) * 0x29, 0xe7, // USAGE_MAXIMUM (Keyboard Right GUI) * 0x15, 0x00, // LOGICAL_MINIMUM (0) * 0x25, 0x01, // LOGICAL_MAXIMUM (1) * 0x75, 0x01, // REPORT_SIZE (1) * 0x95, 0x08, // REPORT_COUNT (8) * 0x81, 0x02, // INPUT (Data,Var,Abs) * * The report size is 1 specifying 1 bit per entry. * The report count is 8 specifying there are 8 entries. * These entries represent the Usage items between Left Control (the usage * minimum) and Right GUI (the usage maximum). */ union PACKED { uint8_t value; struct PACKED { unsigned leftControl :1; unsigned leftShift :1; unsigned leftAlt :1; unsigned leftGUI :1; unsigned rightControl :1; unsigned rightShift :1; unsigned rightAlt :1; unsigned rightGUI :1; } bits; } modifiers; /* There is one byte of constant data/padding that is specified in the * input report: * * 0x95, 0x01, // REPORT_COUNT (1) * 0x75, 0x08, // REPORT_SIZE (8) * 0x81, 0x03, // INPUT (Cnst,Var,Abs) */ unsigned :8; /* The last INPUT item in the INPUT report is an array type. This array * contains an entry for each of the keys that are currently pressed until * the array limit, in this case 6 concurent key presses. * * 0x95, 0x06, // REPORT_COUNT (6) * 0x75, 0x08, // REPORT_SIZE (8) * 0x15, 0x00, // LOGICAL_MINIMUM (0) * 0x25, 0x65, // LOGICAL_MAXIMUM (101) * 0x05, 0x07, // USAGE_PAGE (Keyboard) * 0x19, 0x00, // USAGE_MINIMUM (Reserved (no event indicated)) * 0x29, 0x65, // USAGE_MAXIMUM (Keyboard Application) * * Report count is 6 indicating that the array has 6 total entries. * Report size is 8 indicating each entry in the array is one byte. * The usage minimum indicates the lowest key value (Reserved/no event) * The usage maximum indicates the highest key value (Application button) * The logical minimum indicates the remapped value for the usage minimum: * No Event has a logical value of 0. * The logical maximum indicates the remapped value for the usage maximum: * Application button has a logical value of 101. * * In this case the logical min/max match the usage min/max so the logical * remapping doesn't actually change the values. * * To send a report with the 'a' key pressed (usage value of 0x04, logical * value in this example of 0x04 as well), then the array input would be the * following: * * LSB [0x04][0x00][0x00][0x00][0x00][0x00] MSB * * If the 'b' button was then pressed with the 'a' button still held down, * the report would then look like this: * * LSB [0x04][0x05][0x00][0x00][0x00][0x00] MSB * * If the 'a' button was then released with the 'b' button still held down, * the resulting array would be the following: * * LSB [0x05][0x00][0x00][0x00][0x00][0x00] MSB * * The 'a' key was removed from the array and all other items in the array * were shifted down. */ uint8_t keys[6]; } KEYBOARD_INPUT_REPORT; /* This typedef defines the only OUTPUT report found in the HID report * descriptor and gives an easy way to parse the OUTPUT report. */ typedef union PACKED { /* The OUTPUT report is comprised of only one byte of data. */ uint8_t value; struct { /* There are two report items that form the one byte of OUTPUT report * data. The first report item defines 5 LED indicators: * * 0x95, 0x05, // REPORT_COUNT (5) * 0x75, 0x01, // REPORT_SIZE (1) * 0x05, 0x08, // USAGE_PAGE (LEDs) * 0x19, 0x01, // USAGE_MINIMUM (Num Lock) * 0x29, 0x05, // USAGE_MAXIMUM (Kana) * 0x91, 0x02, // OUTPUT (Data,Var,Abs) * * The report count indicates there are 5 entries. * The report size is 1 indicating each entry is just one bit. * These items are located on the LED usage page * These items are all of the usages between Num Lock (the usage * minimum) and Kana (the usage maximum). */ unsigned numLock :1; unsigned capsLock :1; unsigned scrollLock :1; unsigned compose :1; unsigned kana :1; /* The second OUTPUT report item defines 3 bits of constant data * (padding) used to make a complete byte: * * 0x95, 0x01, // REPORT_COUNT (1) * 0x75, 0x03, // REPORT_SIZE (3) * 0x91, 0x03, // OUTPUT (Cnst,Var,Abs) * * Report count of 1 indicates that there is one entry * Report size of 3 indicates the entry is 3 bits long. */ unsigned :3; } leds; } KEYBOARD_OUTPUT_REPORT; /* This creates a storage type for all of the information required to track the * current state of the keyboard. */ typedef struct { USB_HANDLE lastINTransmission; USB_HANDLE lastOUTTransmission; unsigned char key; bool waitingForRelease; } KEYBOARD; // ***************************************************************************** // ***************************************************************************** // Section: File Scope or Global Variables // ***************************************************************************** // ***************************************************************************** static KEYBOARD keyboard; #if !defined(KEYBOARD_INPUT_REPORT_DATA_BUFFER_ADDRESS_TAG) #define KEYBOARD_INPUT_REPORT_DATA_BUFFER_ADDRESS_TAG #endif static KEYBOARD_INPUT_REPORT inputReport KEYBOARD_INPUT_REPORT_DATA_BUFFER_ADDRESS_TAG; #if !defined(KEYBOARD_OUTPUT_REPORT_DATA_BUFFER_ADDRESS_TAG) #define KEYBOARD_OUTPUT_REPORT_DATA_BUFFER_ADDRESS_TAG #endif static volatile KEYBOARD_OUTPUT_REPORT outputReport KEYBOARD_OUTPUT_REPORT_DATA_BUFFER_ADDRESS_TAG; // ***************************************************************************** // ***************************************************************************** // Section: Private Prototypes // ***************************************************************************** // ***************************************************************************** static void APP_KeyboardProcessOutputReport(void); //Exteranl variables declared in other .c files extern volatile signed int SOFCounter; //Application variables that need wide scope KEYBOARD_INPUT_REPORT oldInputReport; signed int keyboardIdleRate; signed int LocalSOFCount; static signed int OldSOFCount; void APP_KeyboardInit(void) { //initialize the variable holding the handle for the last // transmission keyboard.lastINTransmission = 0; keyboard.key = 4; keyboard.waitingForRelease = false; //Set the default idle rate to 500ms keyboardIdleRate = 500; //Copy the (possibly) interrupt context SOFCounter value into a local variable. //Using a while() loop to do this since the SOFCounter isn't necessarily atomically //updated and therefore we need to read it a minimum of twice to ensure we captured the correct value. while(OldSOFCount != SOFCounter) { OldSOFCount = SOFCounter; } //enable the HID endpoint USBEnableEndpoint(HID_EP, USB_IN_ENABLED|USB_OUT_ENABLED|USB_HANDSHAKE_ENABLED|USB_DISALLOW_SETUP); //Arm OUT endpoint so we can receive caps lock, num lock, etc. info from host keyboard.lastOUTTransmission = HIDRxPacket(HID_EP,(uint8_t*)&outputReport, sizeof(outputReport) ); } void APP_KeyboardTasks(void) { signed int TimeDeltaMilliseconds; unsigned char i; bool needToSendNewReportPacket; if( USBGetDeviceState() < CONFIGURED_STATE ) { return; // NOT configured yet } if( USBIsDeviceSuspended()== true ) { return; // Device suspended } while(LocalSOFCount != SOFCounter) { LocalSOFCount = SOFCounter; // Get a new SOF value for shure. } //Compute time since last update TimeDeltaMilliseconds = LocalSOFCount - OldSOFCount; if(TimeDeltaMilliseconds < 0) { TimeDeltaMilliseconds = (32767 - OldSOFCount) + LocalSOFCount; } // if too large then Idle rate is == 0 - Update OldSOF (even no data sent) if(TimeDeltaMilliseconds > 5000) { OldSOFCount = LocalSOFCount - 5000; } // check if IN is busy, if not, send new data if(HIDTxHandleBusy(keyboard.lastINTransmission) == false) { memset(&inputReport, 0, sizeof(inputReport)); //clear IN report buffer if(keyboard.waitingForRelease == false) { keyboard.waitingForRelease = true; if(key_counter > 1000){ inputReport.keys[0] = keyboard.key++; if(keyboard.key == 40) { keyboard.key = 4; } key_counter = 0; } else{ key_counter++; } } else { keyboard.waitingForRelease = false; } needToSendNewReportPacket = false; for(i = 0; i < sizeof(inputReport); i++) { if(*((uint8_t*)&oldInputReport + i) != *((uint8_t*)&inputReport + i)) { needToSendNewReportPacket = true; // there was change in data break; } } // OR if(keyboardIdleRate != 0) { if(TimeDeltaMilliseconds >= keyboardIdleRate) { needToSendNewReportPacket = true; } } if(needToSendNewReportPacket == true) { oldInputReport = inputReport; keyboard.lastINTransmission = HIDTxPacket(HID_EP, (uint8_t*)&inputReport, sizeof(inputReport)); OldSOFCount = LocalSOFCount; //Save the current time } } // Receive data if(HIDRxHandleBusy(keyboard.lastOUTTransmission) == false) { APP_KeyboardProcessOutputReport(); keyboard.lastOUTTransmission = HIDRxPacket(HID_EP,(uint8_t*)&outputReport,sizeof(outputReport)); } return; } static void APP_KeyboardProcessOutputReport(void) { // no dedicated LED for this keyboard! } static void USBHIDCBSetReportComplete(void) { outputReport.value = CtrlTrfData[0]; APP_KeyboardProcessOutputReport(); } void USBHIDCBSetReportHandler(void) { // Prepare to receive keyboard LED status byte USBEP0Receive((uint8_t*)&CtrlTrfData, USB_EP0_BUFF_SIZE, USBHIDCBSetReportComplete); } void USBHIDCBSetIdleRateHandler(uint8_t reportID, uint8_t newIdleRate) { if(reportID == 0) //Firmware doesn't use report ID (always 0) { keyboardIdleRate = newIdleRate; } }