Demos/Device/LowLevel/Keyboard/Keyboard.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11   Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
  12
  13   Permission to use, copy, modify, distribute, and sell this
  14   software and its documentation for any purpose is hereby granted
  15   without fee, provided that the above copyright notice appear in
  16   all copies and that both that the copyright notice and this
  17   permission notice and warranty disclaimer appear in supporting
  18   documentation, and that the name of the author not be used in
  19   advertising or publicity pertaining to distribution of the
  20   software without specific, written prior permission.
  21
  22   The author disclaim all warranties with regard to this
  23   software, including all implied warranties of merchantability
  24   and fitness.  In no event shall the author be liable for any
  25   special, indirect or consequential damages or any damages
  26   whatsoever resulting from loss of use, data or profits, whether
  27   in an action of contract, negligence or other tortious action,
  28   arising out of or in connection with the use or performance of
  29   this software.
  30 */
  31
  32 /** \file
  33  *
  34  *  Main source file for the Keyboard demo. This file contains the main tasks of the demo and
  35  *  is responsible for the initial application hardware configuration.
  36  */
  37
  38 #include "Keyboard.h"
  39
  40 /** Indicates what report mode the host has requested, true for normal HID reporting mode, false for special boot
  41  *  protocol reporting mode.
  42  */
  43 bool UsingReportProtocol = true;
  44
  45 /** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
  46  *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
  47  */
  48 uint16_t IdleCount = 500;
  49
  50 /** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
  51  *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
  52  *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
  53  */
  54 uint16_t IdleMSRemaining = 0;
  55
  56
  57 /** Main program entry point. This routine configures the hardware required by the application, then
  58  *  enters a loop to run the application tasks in sequence.
  59  */
  60 int main(void)
  61 {
  62         SetupHardware();
  63
  64         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  65         sei();
  66
  67         for (;;)
  68         {
  69                 HID_Task();
  70                 USB_USBTask();
  71         }
  72 }
  73
  74 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  75 void SetupHardware(void)
  76 {
  77         /* Disable watchdog if enabled by bootloader/fuses */
  78         MCUSR &= ~(1 << WDRF);
  79         wdt_disable();
  80
  81         /* Disable clock division */
  82         clock_prescale_set(clock_div_1);
  83
  84         /* Hardware Initialization */
  85         Joystick_Init();
  86         LEDs_Init();
  87         USB_Init();
  88         Buttons_Init();
  89 }
  90
  91 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
  92  *  starts the library USB task to begin the enumeration and USB management process.
  93  */
  94 void EVENT_USB_Device_Connect(void)
  95 {
  96         /* Indicate USB enumerating */
  97         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  98
  99         /* Default to report protocol on connect */
 100         UsingReportProtocol = true;
 101 }
 102
 103 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 104  *  the status LEDs.
 105  */
 106 void EVENT_USB_Device_Disconnect(void)
 107 {
 108         /* Indicate USB not ready */
 109         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 110 }
 111
 112 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
 113  *  of the USB device after enumeration, and configures the keyboard device endpoints.
 114  */
 115 void EVENT_USB_Device_ConfigurationChanged(void)
 116 {
 117         bool ConfigSuccess = true;
 118
 119         /* Setup HID Report Endpoints */
 120         ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 121                                                     KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
 122         ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 123                                                     KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
 124
 125         /* Turn on Start-of-Frame events for tracking HID report period exiry */
 126         USB_Device_EnableSOFEvents();
 127
 128         /* Indicate endpoint configuration success or failure */
 129         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 130 }
 131
 132 /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific
 133  *  control requests that are not handled internally by the USB library (including the HID commands, which are
 134  *  all issued via the control endpoint), so that they can be handled appropriately for the application.
 135  */
 136 void EVENT_USB_Device_UnhandledControlRequest(void)
 137 {
 138         /* Handle HID Class specific requests */
 139         switch (USB_ControlRequest.bRequest)
 140         {
 141                 case REQ_GetReport:
 142                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 143                         {
 144                                 USB_KeyboardReport_Data_t KeyboardReportData;
 145
 146                                 Endpoint_ClearSETUP();
 147
 148                                 /* Create the next keyboard report for transmission to the host */
 149                                 CreateKeyboardReport(&KeyboardReportData);
 150
 151                                 /* Write the report data to the control endpoint */
 152                                 Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 153
 154                                 /* Finalize the stream transfer to send the last packet or clear the host abort */
 155                                 Endpoint_ClearOUT();
 156                         }
 157
 158                         break;
 159                 case REQ_SetReport:
 160                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 161                         {
 162                                 Endpoint_ClearSETUP();
 163
 164                                 /* Wait until the LED report has been sent by the host */
 165                                 while (!(Endpoint_IsOUTReceived()))
 166                                 {
 167                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 168                                           return;
 169                                 }
 170
 171                                 /* Read in the LED report from the host */
 172                                 uint8_t LEDStatus = Endpoint_Read_Byte();
 173
 174                                 /* Process the incoming LED report */
 175                                 ProcessLEDReport(LEDStatus);
 176
 177                                 /* Clear the endpoint data */
 178                                 Endpoint_ClearOUT();
 179
 180                                 Endpoint_ClearStatusStage();
 181                         }
 182
 183                         break;
 184                 case REQ_GetProtocol:
 185                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 186                         {
 187                                 Endpoint_ClearSETUP();
 188
 189                                 /* Write the current protocol flag to the host */
 190                                 Endpoint_Write_Byte(UsingReportProtocol);
 191
 192                                 /* Send the flag to the host */
 193                                 Endpoint_ClearIN();
 194
 195                                 Endpoint_ClearStatusStage();
 196                         }
 197
 198                         break;
 199                 case REQ_SetProtocol:
 200                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 201                         {
 202                                 Endpoint_ClearSETUP();
 203
 204                                 /* Set or clear the flag depending on what the host indicates that the current Protocol should be */
 205                                 UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 206
 207                                 Endpoint_ClearStatusStage();
 208                         }
 209
 210                         break;
 211                 case REQ_SetIdle:
 212                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 213                         {
 214                                 Endpoint_ClearSETUP();
 215
 216                                 /* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
 217                                 IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
 218
 219                                 Endpoint_ClearStatusStage();
 220                         }
 221
 222                         break;
 223                 case REQ_GetIdle:
 224                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 225                         {
 226                                 Endpoint_ClearSETUP();
 227
 228                                 /* Write the current idle duration to the host, must be divided by 4 before sent to host */
 229                                 Endpoint_Write_Byte(IdleCount >> 2);
 230
 231                                 /* Send the flag to the host */
 232                                 Endpoint_ClearIN();
 233
 234                                 Endpoint_ClearStatusStage();
 235                         }
 236
 237                         break;
 238         }
 239 }
 240
 241 /** Event handler for the USB device Start Of Frame event. */
 242 void EVENT_USB_Device_StartOfFrame(void)
 243 {
 244         /* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
 245         if (IdleMSRemaining)
 246           IdleMSRemaining--;
 247 }
 248
 249 /** Fills the given HID report data structure with the next HID report to send to the host.
 250  *
 251  *  \param[out] ReportData  Pointer to a HID report data structure to be filled
 252  */
 253 void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
 254 {
 255         uint8_t JoyStatus_LCL     = Joystick_GetStatus();
 256         uint8_t ButtonStatus_LCL  = Buttons_GetStatus();
 257
 258         uint8_t UsedKeyCodes      = 0;
 259
 260         /* Clear the report contents */
 261         memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
 262
 263         /* Make sent key uppercase by indicating that the left shift key is pressed */
 264         ReportData->Modifier = KEYBOARD_MODIFER_LEFTSHIFT;
 265
 266         if (JoyStatus_LCL & JOY_UP)
 267           ReportData->KeyCode[UsedKeyCodes++] = 0x04; // A
 268         else if (JoyStatus_LCL & JOY_DOWN)
 269           ReportData->KeyCode[UsedKeyCodes++] = 0x05; // B
 270
 271         if (JoyStatus_LCL & JOY_LEFT)
 272           ReportData->KeyCode[UsedKeyCodes++] = 0x06; // C
 273         else if (JoyStatus_LCL & JOY_RIGHT)
 274           ReportData->KeyCode[UsedKeyCodes++] = 0x07; // D
 275
 276         if (JoyStatus_LCL & JOY_PRESS)
 277           ReportData->KeyCode[UsedKeyCodes++] = 0x08; // E
 278
 279         if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 280           ReportData->KeyCode[UsedKeyCodes++] = 0x09; // F
 281 }
 282
 283 /** Processes a received LED report, and updates the board LEDs states to match.
 284  *
 285  *  \param[in] LEDReport  LED status report from the host
 286  */
 287 void ProcessLEDReport(const uint8_t LEDReport)
 288 {
 289         uint8_t LEDMask = LEDS_LED2;
 290
 291         if (LEDReport & KEYBOARD_LED_NUMLOCK)
 292           LEDMask |= LEDS_LED1;
 293
 294         if (LEDReport & KEYBOARD_LED_CAPSLOCK)
 295           LEDMask |= LEDS_LED3;
 296
 297         if (LEDReport & KEYBOARD_LED_SCROLLLOCK)
 298           LEDMask |= LEDS_LED4;
 299
 300         /* Set the status LEDs to the current Keyboard LED status */
 301         LEDs_SetAllLEDs(LEDMask);
 302 }
 303
 304 /** Sends the next HID report to the host, via the keyboard data endpoint. */
 305 void SendNextReport(void)
 306 {
 307         static USB_KeyboardReport_Data_t PrevKeyboardReportData;
 308         USB_KeyboardReport_Data_t        KeyboardReportData;
 309         bool                             SendReport = true;
 310
 311         /* Create the next keyboard report for transmission to the host */
 312         CreateKeyboardReport(&KeyboardReportData);
 313
 314         /* Check to see if the report data has changed - if so a report MUST be sent */
 315         SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
 316
 317         /* Check if the idle period is set and has elapsed */
 318         if ((IdleCount != HID_IDLE_CHANGESONLY) && (!(IdleMSRemaining)))
 319         {
 320                 /* Reset the idle time remaining counter */
 321                 IdleMSRemaining = IdleCount;
 322
 323                 /* Idle period is set and has elapsed, must send a report to the host */
 324                 SendReport = true;
 325         }
 326
 327         /* Select the Keyboard Report Endpoint */
 328         Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
 329
 330         /* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
 331         if (Endpoint_IsReadWriteAllowed() && SendReport)
 332         {
 333                 /* Save the current report data for later comparison to check for changes */
 334                 PrevKeyboardReportData = KeyboardReportData;
 335
 336                 /* Write Keyboard Report Data */
 337                 Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 338
 339                 /* Finalize the stream transfer to send the last packet */
 340                 Endpoint_ClearIN();
 341         }
 342 }
 343
 344 /** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
 345 void ReceiveNextReport(void)
 346 {
 347         /* Select the Keyboard LED Report Endpoint */
 348         Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
 349
 350         /* Check if Keyboard LED Endpoint contains a packet */
 351         if (Endpoint_IsOUTReceived())
 352         {
 353                 /* Check to see if the packet contains data */
 354                 if (Endpoint_IsReadWriteAllowed())
 355                 {
 356                         /* Read in the LED report from the host */
 357                         uint8_t LEDReport = Endpoint_Read_Byte();
 358
 359                         /* Process the read LED report from the host */
 360                         ProcessLEDReport(LEDReport);
 361                 }
 362
 363                 /* Handshake the OUT Endpoint - clear endpoint and ready for next report */
 364                 Endpoint_ClearOUT();
 365         }
 366 }
 367
 368 /** Function to manage HID report generation and transmission to the host, when in report mode. */
 369 void HID_Task(void)
 370 {
 371         /* Device must be connected and configured for the task to run */
 372         if (USB_DeviceState != DEVICE_STATE_Configured)
 373           return;
 374
 375         /* Send the next keypress report to the host */
 376         SendNextReport();
 377
 378         /* Process the LED report sent from the host */
 379         ReceiveNextReport();
 380 }