Demos/Device/LowLevel/Keyboard/Keyboard.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  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 static 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 static 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 static 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_EPADDR, EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
 121         ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPADDR, EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
 122
 123         /* Turn on Start-of-Frame events for tracking HID report period expiry */
 124         USB_Device_EnableSOFEvents();
 125
 126         /* Indicate endpoint configuration success or failure */
 127         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 128 }
 129
 130 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 131  *  the device from the USB host before passing along unhandled control requests to the library for processing
 132  *  internally.
 133  */
 134 void EVENT_USB_Device_ControlRequest(void)
 135 {
 136         /* Handle HID Class specific requests */
 137         switch (USB_ControlRequest.bRequest)
 138         {
 139                 case HID_REQ_GetReport:
 140                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 141                         {
 142                                 USB_KeyboardReport_Data_t KeyboardReportData;
 143
 144                                 /* Create the next keyboard report for transmission to the host */
 145                                 CreateKeyboardReport(&KeyboardReportData);
 146
 147                                 Endpoint_ClearSETUP();
 148
 149                                 /* Write the report data to the control endpoint */
 150                                 Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 151                                 Endpoint_ClearOUT();
 152                         }
 153
 154                         break;
 155                 case HID_REQ_SetReport:
 156                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 157                         {
 158                                 Endpoint_ClearSETUP();
 159
 160                                 /* Wait until the LED report has been sent by the host */
 161                                 while (!(Endpoint_IsOUTReceived()))
 162                                 {
 163                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 164                                           return;
 165                                 }
 166
 167                                 /* Read in the LED report from the host */
 168                                 uint8_t LEDStatus = Endpoint_Read_8();
 169
 170                                 Endpoint_ClearOUT();
 171                                 Endpoint_ClearStatusStage();
 172
 173                                 /* Process the incoming LED report */
 174                                 ProcessLEDReport(LEDStatus);
 175                         }
 176
 177                         break;
 178                 case HID_REQ_GetProtocol:
 179                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 180                         {
 181                                 Endpoint_ClearSETUP();
 182
 183                                 /* Write the current protocol flag to the host */
 184                                 Endpoint_Write_8(UsingReportProtocol);
 185
 186                                 Endpoint_ClearIN();
 187                                 Endpoint_ClearStatusStage();
 188                         }
 189
 190                         break;
 191                 case HID_REQ_SetProtocol:
 192                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 193                         {
 194                                 Endpoint_ClearSETUP();
 195                                 Endpoint_ClearStatusStage();
 196
 197                                 /* Set or clear the flag depending on what the host indicates that the current Protocol should be */
 198                                 UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 199                         }
 200
 201                         break;
 202                 case HID_REQ_SetIdle:
 203                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 204                         {
 205                                 Endpoint_ClearSETUP();
 206                                 Endpoint_ClearStatusStage();
 207
 208                                 /* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
 209                                 IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
 210                         }
 211
 212                         break;
 213                 case HID_REQ_GetIdle:
 214                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 215                         {
 216                                 Endpoint_ClearSETUP();
 217
 218                                 /* Write the current idle duration to the host, must be divided by 4 before sent to host */
 219                                 Endpoint_Write_8(IdleCount >> 2);
 220
 221                                 Endpoint_ClearIN();
 222                                 Endpoint_ClearStatusStage();
 223                         }
 224
 225                         break;
 226         }
 227 }
 228
 229 /** Event handler for the USB device Start Of Frame event. */
 230 void EVENT_USB_Device_StartOfFrame(void)
 231 {
 232         /* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
 233         if (IdleMSRemaining)
 234           IdleMSRemaining--;
 235 }
 236
 237 /** Fills the given HID report data structure with the next HID report to send to the host.
 238  *
 239  *  \param[out] ReportData  Pointer to a HID report data structure to be filled
 240  */
 241 void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
 242 {
 243         uint8_t JoyStatus_LCL     = Joystick_GetStatus();
 244         uint8_t ButtonStatus_LCL  = Buttons_GetStatus();
 245
 246         uint8_t UsedKeyCodes      = 0;
 247
 248         /* Clear the report contents */
 249         memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
 250
 251         /* Make sent key uppercase by indicating that the left shift key is pressed */
 252         ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
 253
 254         if (JoyStatus_LCL & JOY_UP)
 255           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_A;
 256         else if (JoyStatus_LCL & JOY_DOWN)
 257           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_B;
 258
 259         if (JoyStatus_LCL & JOY_LEFT)
 260           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_C;
 261         else if (JoyStatus_LCL & JOY_RIGHT)
 262           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_D;
 263
 264         if (JoyStatus_LCL & JOY_PRESS)
 265           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_E;
 266
 267         if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 268           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_F;
 269 }
 270
 271 /** Processes a received LED report, and updates the board LEDs states to match.
 272  *
 273  *  \param[in] LEDReport  LED status report from the host
 274  */
 275 void ProcessLEDReport(const uint8_t LEDReport)
 276 {
 277         uint8_t LEDMask = LEDS_LED2;
 278
 279         if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
 280           LEDMask |= LEDS_LED1;
 281
 282         if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
 283           LEDMask |= LEDS_LED3;
 284
 285         if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
 286           LEDMask |= LEDS_LED4;
 287
 288         /* Set the status LEDs to the current Keyboard LED status */
 289         LEDs_SetAllLEDs(LEDMask);
 290 }
 291
 292 /** Sends the next HID report to the host, via the keyboard data endpoint. */
 293 void SendNextReport(void)
 294 {
 295         static USB_KeyboardReport_Data_t PrevKeyboardReportData;
 296         USB_KeyboardReport_Data_t        KeyboardReportData;
 297         bool                             SendReport = true;
 298
 299         /* Create the next keyboard report for transmission to the host */
 300         CreateKeyboardReport(&KeyboardReportData);
 301
 302         /* Check to see if the report data has changed - if so a report MUST be sent */
 303         SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
 304
 305         /* Check if the idle period is set and has elapsed */
 306         if (IdleCount && (!(IdleMSRemaining)))
 307         {
 308                 /* Reset the idle time remaining counter */
 309                 IdleMSRemaining = IdleCount;
 310
 311                 /* Idle period is set and has elapsed, must send a report to the host */
 312                 SendReport = true;
 313         }
 314
 315         /* Select the Keyboard Report Endpoint */
 316         Endpoint_SelectEndpoint(KEYBOARD_IN_EPADDR);
 317
 318         /* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
 319         if (Endpoint_IsReadWriteAllowed() && SendReport)
 320         {
 321                 /* Save the current report data for later comparison to check for changes */
 322                 PrevKeyboardReportData = KeyboardReportData;
 323
 324                 /* Write Keyboard Report Data */
 325                 Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
 326
 327                 /* Finalize the stream transfer to send the last packet */
 328                 Endpoint_ClearIN();
 329         }
 330 }
 331
 332 /** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
 333 void ReceiveNextReport(void)
 334 {
 335         /* Select the Keyboard LED Report Endpoint */
 336         Endpoint_SelectEndpoint(KEYBOARD_OUT_EPADDR);
 337
 338         /* Check if Keyboard LED Endpoint contains a packet */
 339         if (Endpoint_IsOUTReceived())
 340         {
 341                 /* Check to see if the packet contains data */
 342                 if (Endpoint_IsReadWriteAllowed())
 343                 {
 344                         /* Read in the LED report from the host */
 345                         uint8_t LEDReport = Endpoint_Read_8();
 346
 347                         /* Process the read LED report from the host */
 348                         ProcessLEDReport(LEDReport);
 349                 }
 350
 351                 /* Handshake the OUT Endpoint - clear endpoint and ready for next report */
 352                 Endpoint_ClearOUT();
 353         }
 354 }
 355
 356 /** Function to manage HID report generation and transmission to the host, when in report mode. */
 357 void HID_Task(void)
 358 {
 359         /* Device must be connected and configured for the task to run */
 360         if (USB_DeviceState != DEVICE_STATE_Configured)
 361           return;
 362
 363         /* Send the next keypress report to the host */
 364         SendNextReport();
 365
 366         /* Process the LED report sent from the host */
 367         ReceiveNextReport();
 368 }
 369