Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2019.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2019  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaims all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the KeyboardHostWithParser demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "KeyboardHostWithParser.h"
  38
  39 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  enters a loop to run the application tasks in sequence.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         puts_P(PSTR(ESC_FG_CYAN "Keyboard HID Parser Host Demo running.\r\n" ESC_FG_WHITE));
  47
  48         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  49         GlobalInterruptEnable();
  50
  51         for (;;)
  52         {
  53                 KeyboardHost_Task();
  54
  55                 USB_USBTask();
  56         }
  57 }
  58
  59 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  60 void SetupHardware(void)
  61 {
  62 #if (ARCH == ARCH_AVR8)
  63         /* Disable watchdog if enabled by bootloader/fuses */
  64         MCUSR &= ~(1 << WDRF);
  65         wdt_disable();
  66
  67         /* Disable clock division */
  68         clock_prescale_set(clock_div_1);
  69 #endif
  70
  71         /* Hardware Initialization */
  72         Serial_Init(9600, false);
  73         LEDs_Init();
  74         USB_Init();
  75
  76         /* Create a stdio stream for the serial port for stdin and stdout */
  77         Serial_CreateStream(NULL);
  78 }
  79
  80 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  81  *  starts the library USB task to begin the enumeration and USB management process.
  82  */
  83 void EVENT_USB_Host_DeviceAttached(void)
  84 {
  85         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  86         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  87 }
  88
  89 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  90  *  stops the library USB task management process.
  91  */
  92 void EVENT_USB_Host_DeviceUnattached(void)
  93 {
  94         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
  95         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  96 }
  97
  98 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  99  *  enumerated by the host and is now ready to be used by the application.
 100  */
 101 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 102 {
 103         puts_P(PSTR("Getting Config Data.\r\n"));
 104
 105         uint8_t ErrorCode;
 106
 107         /* Get and process the configuration descriptor data */
 108         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 109         {
 110                 if (ErrorCode == ControlError)
 111                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 112                 else
 113                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 114
 115                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 116
 117                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 118                 return;
 119         }
 120
 121         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 122         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 123
 124         {
 125                 puts_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"));
 126                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 127
 128                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 129                 return;
 130         }
 131
 132         printf_P(PSTR("Processing HID Report (Size %d Bytes).\r\n"), HIDReportSize);
 133
 134         /* Get and process the device's first HID report descriptor */
 135         if ((ErrorCode = GetHIDReportData()) != ParseSuccessful)
 136         {
 137                 puts_P(PSTR(ESC_FG_RED "Report Parse Error.\r\n"));
 138
 139                 if (!(HIDReportInfo.TotalReportItems))
 140                         puts_P(PSTR("Not a valid Keyboard." ESC_FG_WHITE));
 141                 else
 142                         printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 143
 144                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 145                 USB_Host_SetDeviceConfiguration(0);
 146                 return;
 147         }
 148
 149         puts_P(PSTR("Keyboard Enumerated.\r\n"));
 150         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 151 }
 152
 153 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 154 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 155 {
 156         USB_Disable();
 157
 158         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 159                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 160
 161         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 162         for(;;);
 163 }
 164
 165 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 166  *  enumerating an attached USB device.
 167  */
 168 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 169                                             const uint8_t SubErrorCode)
 170 {
 171         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 172                                  " -- Error Code %d\r\n"
 173                                  " -- Sub Error Code %d\r\n"
 174                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 175
 176         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 177 }
 178
 179 /** Task to read in and processes the next report from the attached device, displaying the report
 180  *  contents on the board LEDs and via the serial port.
 181  */
 182 void KeyboardHost_Task(void)
 183 {
 184         if (USB_HostState != HOST_STATE_Configured)
 185           return;
 186
 187         /* Select and unfreeze keyboard data pipe */
 188         Pipe_SelectPipe(KEYBOARD_DATA_IN_PIPE);
 189         Pipe_Unfreeze();
 190
 191         /* Check to see if a packet has been received */
 192         if (Pipe_IsINReceived())
 193         {
 194                 /* Check if data has been received from the attached keyboard */
 195                 if (Pipe_IsReadWriteAllowed())
 196                 {
 197                         /* Create buffer big enough for the report */
 198                         uint8_t KeyboardReport[Pipe_BytesInPipe()];
 199
 200                         /* Load in the keyboard report */
 201                         Pipe_Read_Stream_LE(KeyboardReport, Pipe_BytesInPipe(), NULL);
 202
 203                         /* Process the read in keyboard report from the device */
 204                         ProcessKeyboardReport(KeyboardReport);
 205                 }
 206
 207                 /* Clear the IN endpoint, ready for next data packet */
 208                 Pipe_ClearIN();
 209         }
 210
 211         /* Freeze keyboard data pipe */
 212         Pipe_Freeze();
 213 }
 214
 215 /** Processes a read HID report from an attached keyboard, extracting out elements via the HID parser results
 216  *  as required and prints pressed characters to the serial port. Each time a key is typed, a board LED is toggled.
 217  *
 218  *  \param[in] KeyboardReport  Pointer to a HID report from an attached keyboard device
 219  */
 220 void ProcessKeyboardReport(uint8_t* KeyboardReport)
 221 {
 222         /* Check each HID report item in turn, looking for keyboard scan code reports */
 223         for (uint8_t ReportNumber = 0; ReportNumber < HIDReportInfo.TotalReportItems; ReportNumber++)
 224         {
 225                 /* Create a temporary item pointer to the next report item */
 226                 HID_ReportItem_t* ReportItem = &HIDReportInfo.ReportItems[ReportNumber];
 227
 228                 /* Check if the current report item is a keyboard scan-code */
 229                 if ((ReportItem->Attributes.Usage.Page      == USAGE_PAGE_KEYBOARD) &&
 230                         (ReportItem->Attributes.BitSize         == 8)                   &&
 231                         (ReportItem->Attributes.Logical.Maximum > 1)                    &&
 232                         (ReportItem->ItemType                   == HID_REPORT_ITEM_In))
 233                 {
 234                         /* Retrieve the keyboard scan-code from the report data retrieved from the device */
 235                         bool FoundData = USB_GetHIDReportItemInfo(KeyboardReport, ReportItem);
 236
 237                         /* For multi-report devices - if the requested data was not in the issued report, continue */
 238                         if (!(FoundData))
 239                           continue;
 240
 241                         /* Key code is an unsigned char in length, cast to the appropriate type */
 242                         uint8_t KeyCode = (uint8_t)ReportItem->Value;
 243
 244                         /* If scan-code is non-zero, a key is being pressed */
 245                         if (KeyCode)
 246                         {
 247                                 /* Toggle status LED to indicate keypress */
 248                                 LEDs_ToggleLEDs(LEDS_LED2);
 249
 250                                 char PressedKey = 0;
 251
 252                                 /* Retrieve pressed key character if alphanumeric */
 253                                 if ((KeyCode >= HID_KEYBOARD_SC_A) && (KeyCode <= HID_KEYBOARD_SC_Z))
 254                                 {
 255                                         PressedKey = (KeyCode - HID_KEYBOARD_SC_A) + 'A';
 256                                 }
 257                                 else if ((KeyCode >= HID_KEYBOARD_SC_1_AND_EXCLAMATION) &
 258                                                  (KeyCode  < HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS))
 259                                 {
 260                                         PressedKey = (KeyCode - HID_KEYBOARD_SC_1_AND_EXCLAMATION) + '1';
 261                                 }
 262                                 else if (KeyCode == HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS)
 263                                 {
 264                                         PressedKey = '0';
 265                                 }
 266                                 else if (KeyCode == HID_KEYBOARD_SC_SPACE)
 267                                 {
 268                                         PressedKey = ' ';
 269                                 }
 270                                 else if (KeyCode == HID_KEYBOARD_SC_ENTER)
 271                                 {
 272                                         PressedKey = '\n';
 273                                 }
 274
 275                                 /* Print the pressed key character out through the serial port if valid */
 276                                 if (PressedKey)
 277                                   putchar(PressedKey);
 278                         }
 279
 280                         /* Once a scan-code is found, stop scanning through the report items */
 281                         break;
 282                 }
 283         }
 284 }
 285