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                                 /* Create the next keyboard report for transmission to the host */
 147                                 CreateKeyboardReport(&KeyboardReportData);
 148
 149                                 Endpoint_ClearSETUP();
 150
 151                                 /* Write the report data to the control endpoint */
 152                                 Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 153                                 Endpoint_ClearOUT();
 154                         }
 155
 156                         break;
 157                 case REQ_SetReport:
 158                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 159                         {
 160                                 Endpoint_ClearSETUP();
 161
 162                                 /* Wait until the LED report has been sent by the host */
 163                                 while (!(Endpoint_IsOUTReceived()))
 164                                 {
 165                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 166                                           return;
 167                                 }
 168
 169                                 /* Read in the LED report from the host */
 170                                 uint8_t LEDStatus = Endpoint_Read_Byte();
 171
 172                                 Endpoint_ClearOUT();
 173                                 Endpoint_ClearStatusStage();
 174
 175                                 /* Process the incoming LED report */
 176                                 ProcessLEDReport(LEDStatus);
 177                         }
 178
 179                         break;
 180                 case REQ_GetProtocol:
 181                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 182                         {
 183                                 Endpoint_ClearSETUP();
 184
 185                                 /* Write the current protocol flag to the host */
 186                                 Endpoint_Write_Byte(UsingReportProtocol);
 187
 188                                 Endpoint_ClearIN();
 189                                 Endpoint_ClearStatusStage();
 190                         }
 191
 192                         break;
 193                 case REQ_SetProtocol:
 194                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 195                         {
 196                                 Endpoint_ClearSETUP();
 197                                 Endpoint_ClearStatusStage();
 198
 199                                 /* Set or clear the flag depending on what the host indicates that the current Protocol should be */
 200                                 UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 201                         }
 202
 203                         break;
 204                 case REQ_SetIdle:
 205                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 206                         {
 207                                 Endpoint_ClearSETUP();
 208                                 Endpoint_ClearStatusStage();
 209
 210                                 /* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
 211                                 IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
 212                         }
 213
 214                         break;
 215                 case REQ_GetIdle:
 216                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 217                         {
 218                                 Endpoint_ClearSETUP();
 219
 220                                 /* Write the current idle duration to the host, must be divided by 4 before sent to host */
 221                                 Endpoint_Write_Byte(IdleCount >> 2);
 222
 223                                 Endpoint_ClearIN();
 224                                 Endpoint_ClearStatusStage();
 225                         }
 226
 227                         break;
 228         }
 229 }
 230
 231 /** Event handler for the USB device Start Of Frame event. */
 232 void EVENT_USB_Device_StartOfFrame(void)
 233 {
 234         /* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
 235         if (IdleMSRemaining)
 236           IdleMSRemaining--;
 237 }
 238
 239 /** Fills the given HID report data structure with the next HID report to send to the host.
 240  *
 241  *  \param[out] ReportData  Pointer to a HID report data structure to be filled
 242  */
 243 void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
 244 {
 245         uint8_t JoyStatus_LCL     = Joystick_GetStatus();
 246         uint8_t ButtonStatus_LCL  = Buttons_GetStatus();
 247
 248         uint8_t UsedKeyCodes      = 0;
 249
 250         /* Clear the report contents */
 251         memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
 252
 253         /* Make sent key uppercase by indicating that the left shift key is pressed */
 254         ReportData->Modifier = KEYBOARD_MODIFER_LEFTSHIFT;
 255
 256         if (JoyStatus_LCL & JOY_UP)
 257           ReportData->KeyCode[UsedKeyCodes++] = 0x04; // A
 258         else if (JoyStatus_LCL & JOY_DOWN)
 259           ReportData->KeyCode[UsedKeyCodes++] = 0x05; // B
 260
 261         if (JoyStatus_LCL & JOY_LEFT)
 262           ReportData->KeyCode[UsedKeyCodes++] = 0x06; // C
 263         else if (JoyStatus_LCL & JOY_RIGHT)
 264           ReportData->KeyCode[UsedKeyCodes++] = 0x07; // D
 265
 266         if (JoyStatus_LCL & JOY_PRESS)
 267           ReportData->KeyCode[UsedKeyCodes++] = 0x08; // E
 268
 269         if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 270           ReportData->KeyCode[UsedKeyCodes++] = 0x09; // F
 271 }
 272
 273 /** Processes a received LED report, and updates the board LEDs states to match.
 274  *
 275  *  \param[in] LEDReport  LED status report from the host
 276  */
 277 void ProcessLEDReport(const uint8_t LEDReport)
 278 {
 279         uint8_t LEDMask = LEDS_LED2;
 280
 281         if (LEDReport & KEYBOARD_LED_NUMLOCK)
 282           LEDMask |= LEDS_LED1;
 283
 284         if (LEDReport & KEYBOARD_LED_CAPSLOCK)
 285           LEDMask |= LEDS_LED3;
 286
 287         if (LEDReport & KEYBOARD_LED_SCROLLLOCK)
 288           LEDMask |= LEDS_LED4;
 289
 290         /* Set the status LEDs to the current Keyboard LED status */
 291         LEDs_SetAllLEDs(LEDMask);
 292 }
 293
 294 /** Sends the next HID report to the host, via the keyboard data endpoint. */
 295 void SendNextReport(void)
 296 {
 297         static USB_KeyboardReport_Data_t PrevKeyboardReportData;
 298         USB_KeyboardReport_Data_t        KeyboardReportData;
 299         bool                             SendReport = true;
 300
 301         /* Create the next keyboard report for transmission to the host */
 302         CreateKeyboardReport(&KeyboardReportData);
 303
 304         /* Check to see if the report data has changed - if so a report MUST be sent */
 305         SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
 306
 307         /* Check if the idle period is set and has elapsed */
 308         if ((IdleCount != HID_IDLE_CHANGESONLY) && (!(IdleMSRemaining)))
 309         {
 310                 /* Reset the idle time remaining counter */
 311                 IdleMSRemaining = IdleCount;
 312
 313                 /* Idle period is set and has elapsed, must send a report to the host */
 314                 SendReport = true;
 315         }
 316
 317         /* Select the Keyboard Report Endpoint */
 318         Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
 319
 320         /* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
 321         if (Endpoint_IsReadWriteAllowed() && SendReport)
 322         {
 323                 /* Save the current report data for later comparison to check for changes */
 324                 PrevKeyboardReportData = KeyboardReportData;
 325
 326                 /* Write Keyboard Report Data */
 327                 Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 328
 329                 /* Finalize the stream transfer to send the last packet */
 330                 Endpoint_ClearIN();
 331         }
 332 }
 333
 334 /** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
 335 void ReceiveNextReport(void)
 336 {
 337         /* Select the Keyboard LED Report Endpoint */
 338         Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
 339
 340         /* Check if Keyboard LED Endpoint contains a packet */
 341         if (Endpoint_IsOUTReceived())
 342         {
 343                 /* Check to see if the packet contains data */
 344                 if (Endpoint_IsReadWriteAllowed())
 345                 {
 346                         /* Read in the LED report from the host */
 347                         uint8_t LEDReport = Endpoint_Read_Byte();
 348
 349                         /* Process the read LED report from the host */
 350                         ProcessLEDReport(LEDReport);
 351                 }
 352
 353                 /* Handshake the OUT Endpoint - clear endpoint and ready for next report */
 354                 Endpoint_ClearOUT();
 355         }
 356 }
 357
 358 /** Function to manage HID report generation and transmission to the host, when in report mode. */
 359 void HID_Task(void)
 360 {
 361         /* Device must be connected and configured for the task to run */
 362         if (USB_DeviceState != DEVICE_STATE_Configured)
 363           return;
 364
 365         /* Send the next keypress report to the host */
 366         SendNextReport();
 367
 368         /* Process the LED report sent from the host */
 369         ReceiveNextReport();
 370 }