Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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 disclaim 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  *  starts the scheduler to run the application tasks.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         puts_P(PSTR(ESC_RESET ESC_BG_WHITE ESC_INVERSE_ON ESC_ERASE_DISPLAY
  47                "Keyboard HID Parser Host Demo running.\r\n" ESC_INVERSE_OFF));
  48
  49         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  50
  51         for (;;)
  52         {
  53                 Keyboard_HID_Task();
  54                 USB_USBTask();
  55         }
  56 }
  57
  58 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  59 void SetupHardware(void)
  60 {
  61         /* Disable watchdog if enabled by bootloader/fuses */
  62         MCUSR &= ~(1 << WDRF);
  63         wdt_disable();
  64
  65         /* Disable clock division */
  66         clock_prescale_set(clock_div_1);
  67
  68         /* Hardware Initialization */
  69         SerialStream_Init(9600, false);
  70         LEDs_Init();
  71         USB_Init();
  72 }
  73
  74 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  75  *  starts the library USB task to begin the enumeration and USB management process.
  76  */
  77 void EVENT_USB_DeviceAttached(void)
  78 {
  79         puts_P(PSTR("Device Attached.\r\n"));
  80         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  81 }
  82
  83 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  84  *  stops the library USB task management process.
  85  */
  86 void EVENT_USB_DeviceUnattached(void)
  87 {
  88         puts_P(PSTR("\r\nDevice Unattached.\r\n"));
  89         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  90 }
  91
  92 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  93  *  enumerated by the host and is now ready to be used by the application.
  94  */
  95 void EVENT_USB_DeviceEnumerationComplete(void)
  96 {
  97         LEDs_SetAllLEDs(LEDMASK_USB_READY);
  98 }
  99
 100 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 101 void EVENT_USB_HostError(const uint8_t ErrorCode)
 102 {
 103         USB_ShutDown();
 104
 105         puts_P(PSTR(ESC_BG_RED "Host Mode Error\r\n"));
 106         printf_P(PSTR(" -- Error Code %d\r\n"), ErrorCode);
 107
 108         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 109         for(;;);
 110 }
 111
 112 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 113  *  enumerating an attached USB device.
 114  */
 115 void EVENT_USB_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 116 {
 117         puts_P(PSTR(ESC_BG_RED "Dev Enum Error\r\n"));
 118         printf_P(PSTR(" -- Error Code %d\r\n"), ErrorCode);
 119         printf_P(PSTR(" -- Sub Error Code %d\r\n"), SubErrorCode);
 120         printf_P(PSTR(" -- In State %d\r\n"), USB_HostState);
 121
 122         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 123 }
 124
 125 /** Task to set the configuration of the attached device after it has been enumerated, and to read and process
 126  *  the HID report descriptor and HID reports from the device and display the results onto the board LEDs.
 127  */
 128 void Keyboard_HID_Task(void)
 129 {
 130         uint8_t ErrorCode;
 131
 132         switch (USB_HostState)
 133         {
 134                 case HOST_STATE_Addressed:
 135                         /* Standard request to set the device configuration to configuration 1 */
 136                         USB_ControlRequest = (USB_Request_Header_t)
 137                                 {
 138                                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),
 139                                         .bRequest      = REQ_SetConfiguration,
 140                                         .wValue        = 1,
 141                                         .wIndex        = 0,
 142                                         .wLength       = 0,
 143                                 };
 144
 145                         /* Select the control pipe for the request transfer */
 146                         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 147
 148                         /* Send the request, display error and wait for device detach if request fails */
 149                         if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 150                         {
 151                                 puts_P(PSTR("Control Error (Set Configuration).\r\n"));
 152                                 printf_P(PSTR(" -- Error Code: %d\r\n"), ErrorCode);
 153
 154                                 /* Indicate error via status LEDs */
 155                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 156
 157                                 /* Wait until USB device disconnected */
 158                                 while (USB_IsConnected);
 159                                 break;
 160                         }
 161
 162                         USB_HostState = HOST_STATE_Configured;
 163                         break;
 164                 case HOST_STATE_Configured:
 165                         puts_P(PSTR("Getting Config Data.\r\n"));
 166
 167                         /* Get and process the configuration descriptor data */
 168                         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 169                         {
 170                                 if (ErrorCode == ControlError)
 171                                   puts_P(PSTR("Control Error (Get Configuration).\r\n"));
 172                                 else
 173                                   puts_P(PSTR("Invalid Device.\r\n"));
 174
 175                                 printf_P(PSTR(" -- Error Code: %d\r\n"), ErrorCode);
 176
 177                                 /* Indicate error via status LEDs */
 178                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 179
 180                                 /* Wait until USB device disconnected */
 181                                 while (USB_IsConnected);
 182                                 break;
 183                         }
 184
 185                         puts_P(PSTR("Processing HID Report.\r\n"));
 186
 187                         /* Get and process the device's first HID report descriptor */
 188                         if ((ErrorCode = GetHIDReportData()) != ParseSuccessful)
 189                         {
 190                                 puts_P(PSTR("Report Parse Error.\r\n"));
 191                                 printf_P(PSTR(" -- Error Code: %d\r\n"), ErrorCode);
 192
 193                                 /* Indicate error via status LEDs */
 194                                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 195
 196                                 /* Wait until USB device disconnected */
 197                                 while (USB_IsConnected);
 198                                 break;
 199                         }
 200
 201                         puts_P(PSTR("Keyboard Enumerated.\r\n"));
 202
 203                         USB_HostState = HOST_STATE_Ready;
 204                         break;
 205                 case HOST_STATE_Ready:
 206                         /* Select and unfreeze keyboard data pipe */
 207                         Pipe_SelectPipe(KEYBOARD_DATAPIPE);
 208                         Pipe_Unfreeze();
 209
 210                         /* Check to see if a packet has been received */
 211                         if (Pipe_IsINReceived())
 212                         {
 213                                 /* Check if data has been received from the attached keyboard */
 214                                 if (Pipe_IsReadWriteAllowed())
 215                                 {
 216                                         /* Create buffer big enough for the report */
 217                                         uint8_t KeyboardReport[Pipe_BytesInPipe()];
 218
 219                                         /* Load in the keyboard report */
 220                                         Pipe_Read_Stream_LE(KeyboardReport, Pipe_BytesInPipe());
 221
 222                                         /* Process the read in keyboard report from the device */
 223                                         ProcessKeyboardReport(KeyboardReport);
 224                                 }
 225
 226                                 /* Clear the IN endpoint, ready for next data packet */
 227                                 Pipe_ClearIN();
 228                         }
 229
 230                         /* Freeze keyboard data pipe */
 231                         Pipe_Freeze();
 232                         break;
 233         }
 234 }
 235
 236 /** Processes a read HID report from an attached keyboard, extracting out elements via the HID parser results
 237  *  as required and prints pressed characters to the serial port. Each time a key is typed, a board LED is toggled.
 238  *
 239  *  \param KeyboardReport  Pointer to a HID report from an attached keyboard device
 240  */
 241 void ProcessKeyboardReport(uint8_t* KeyboardReport)
 242 {
 243         /* Check each HID report item in turn, looking for keyboard scan code reports */
 244         for (uint8_t ReportNumber = 0; ReportNumber < HIDReportInfo.TotalReportItems; ReportNumber++)
 245         {
 246                 /* Create a temporary item pointer to the next report item */
 247                 HID_ReportItem_t* ReportItem = &HIDReportInfo.ReportItems[ReportNumber];
 248
 249                 /* Check if the current report item is a keyboard scancode */
 250                 if ((ReportItem->Attributes.Usage.Page      == USAGE_PAGE_KEYBOARD) &&
 251                         (ReportItem->Attributes.BitSize         == 8)                   &&
 252                         (ReportItem->Attributes.Logical.Maximum > 1)                    &&
 253                         (ReportItem->ItemType                   == REPORT_ITEM_TYPE_In))
 254                 {
 255                         /* Retrieve the keyboard scancode from the report data retrieved from the device */
 256                         bool FoundData = USB_GetHIDReportItemInfo(KeyboardReport, ReportItem);
 257
 258                         /* For multi-report devices - if the requested data was not in the issued report, continue */
 259                         if (!(FoundData))
 260                           continue;
 261
 262                         /* Key code is an unsigned char in length, cast to the appropriate type */
 263                         uint8_t KeyCode = (uint8_t)ReportItem->Value;
 264
 265                         /* If scancode is non-zero, a key is being pressed */
 266                         if (KeyCode)
 267                         {
 268                                 /* Toggle status LED to indicate keypress */
 269                                 if (LEDs_GetLEDs() & LEDS_LED2)
 270                                   LEDs_TurnOffLEDs(LEDS_LED2);
 271                                 else
 272                                   LEDs_TurnOnLEDs(LEDS_LED2);
 273
 274                                 char PressedKey = 0;
 275
 276                                 /* Convert scancode to printable character if alphanumeric */
 277                                 if ((KeyCode >= 0x04) && (KeyCode <= 0x1D))
 278                                   PressedKey = (KeyCode - 0x04) + 'A';
 279                                 else if ((KeyCode >= 0x1E) && (KeyCode <= 0x27))
 280                                   PressedKey = (KeyCode - 0x1E) + '0';
 281                                 else if (KeyCode == 0x2C)
 282                                   PressedKey = ' ';
 283                                 else if (KeyCode == 0x28)
 284                                   PressedKey = '\n';
 285
 286                                 /* Print the pressed key character out through the serial port if valid */
 287                                 if (PressedKey)
 288                                   putchar(PressedKey);
 289                         }
 290
 291                         /* Once a scancode is found, stop scanning through the report items */
 292                         break;
 293                 }
 294         }
 295 }