Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.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   Copyright 2009  Denver Gingerich (denver [at] ossguy [dot] com)
  12
  13   Permission to use, copy, modify, and distribute this software
  14   and its documentation for any purpose and without fee is hereby
  15   granted, provided that the above copyright notice appear in all
  16   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 KeyboardMouse demo. This file contains the main tasks of
  35  *  the demo and is responsible for the initial application hardware configuration.
  36  */
  37
  38 #include "KeyboardMouse.h"
  39
  40 /** LUFA HID Class driver interface configuration and state information. This structure is
  41  *  passed to all HID Class driver functions, so that multiple instances of the same class
  42  *  within a device can be differentiated from one another. This is for the keyboard HID
  43  *  interface within the device.
  44  */
  45 USB_ClassInfo_HID_Device_t Keyboard_HID_Interface =
  46         {
  47                 .Config =
  48                         {
  49                                 .InterfaceNumber         = 0,
  50
  51                                 .ReportINEndpointNumber  = KEYBOARD_IN_EPNUM,
  52                                 .ReportINEndpointSize    = HID_EPSIZE,
  53
  54                                 .ReportINBufferSize      = sizeof(USB_KeyboardReport_Data_t),
  55                         },
  56
  57                 .State =
  58                         {
  59                                 .IdleCount               = 500,
  60                         }
  61         };
  62
  63 /** LUFA HID Class driver interface configuration and state information. This structure is
  64  *  passed to all HID Class driver functions, so that multiple instances of the same class
  65  *  within a device can be differentiated from one another. This is for the mouse HID
  66  *  interface within the device.
  67  */
  68 USB_ClassInfo_HID_Device_t Mouse_HID_Interface =
  69         {
  70                 .Config =
  71                         {
  72                                 .InterfaceNumber         = 0,
  73
  74                                 .ReportINEndpointNumber  = MOUSE_IN_EPNUM,
  75                                 .ReportINEndpointSize    = HID_EPSIZE,
  76
  77                                 .ReportINBufferSize      = sizeof(USB_MouseReport_Data_t),
  78                         },
  79
  80                 .State =
  81                         {
  82                                 // Leave all state values to their defaults
  83                         }
  84         };
  85
  86 /** Main program entry point. This routine contains the overall program flow, including initial
  87  *  setup of all components and the main program loop.
  88  */
  89 int main(void)
  90 {
  91         SetupHardware();
  92
  93         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  94
  95         for (;;)
  96         {
  97                 HID_Device_USBTask(&Keyboard_HID_Interface);
  98                 HID_Device_USBTask(&Mouse_HID_Interface);
  99                 USB_USBTask();
 100         }
 101 }
 102
 103 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 104 void SetupHardware()
 105 {
 106         /* Disable watchdog if enabled by bootloader/fuses */
 107         MCUSR &= ~(1 << WDRF);
 108         wdt_disable();
 109
 110         /* Disable clock division */
 111         clock_prescale_set(clock_div_1);
 112
 113         /* Hardware Initialization */
 114         Joystick_Init();
 115         LEDs_Init();
 116         USB_Init();
 117
 118         /* Millisecond timer initialization, with output compare interrupt enabled for the idle timing */
 119         OCR0A  = ((F_CPU / 64) / 1000);
 120         TCCR0A = (1 << WGM01);
 121         TCCR0B = ((1 << CS01) | (1 << CS00));
 122         TIMSK0 = (1 << OCIE0A);
 123 }
 124
 125 /** Event handler for the library USB Connection event. */
 126 void EVENT_USB_Connect(void)
 127 {
 128     LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 129 }
 130
 131 /** Event handler for the library USB Disconnection event. */
 132 void EVENT_USB_Disconnect(void)
 133 {
 134     LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 135 }
 136
 137 /** Event handler for the library USB Configuration Changed event. */
 138 void EVENT_USB_ConfigurationChanged(void)
 139 {
 140         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 141
 142         if (!(HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface)))
 143           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 144
 145         if (!(HID_Device_ConfigureEndpoints(&Mouse_HID_Interface)))
 146           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 147 }
 148
 149 /** Event handler for the library USB Unhandled Control Packet event. */
 150 void EVENT_USB_UnhandledControlPacket(void)
 151 {
 152         HID_Device_ProcessControlPacket(&Keyboard_HID_Interface);
 153         HID_Device_ProcessControlPacket(&Mouse_HID_Interface);
 154 }
 155
 156 /** ISR to keep track of each millisecond interrupt, for determining the HID class idle period remaining when set. */
 157 ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 158 {
 159         if (Keyboard_HID_Interface.State.IdleMSRemaining)
 160           Keyboard_HID_Interface.State.IdleMSRemaining--;
 161
 162         if (Mouse_HID_Interface.State.IdleMSRemaining)
 163           Mouse_HID_Interface.State.IdleMSRemaining--;
 164 }
 165
 166 /** HID class driver callback function for the creation of HID reports to the host.
 167  *
 168  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 169  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
 170  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
 171  *
 172  *  \return Number of bytes written in the report (or zero if no report is to be sent
 173  */
 174 uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
 175 {
 176         uint8_t JoyStatus_LCL    = Joystick_GetStatus();
 177         uint8_t ButtonStatus_LCL = Buttons_GetStatus();
 178
 179         if (HIDInterfaceInfo == &Keyboard_HID_Interface)
 180         {
 181                 USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;
 182
 183                 /* If first board button not being held down, no keyboard report */
 184                 if (!(ButtonStatus_LCL & BUTTONS_BUTTON1))
 185                   return 0;
 186
 187                 if (JoyStatus_LCL & JOY_UP)
 188                   KeyboardReport->KeyCode[0] = 0x04; // A
 189                 else if (JoyStatus_LCL & JOY_DOWN)
 190                   KeyboardReport->KeyCode[0] = 0x05; // B
 191
 192                 if (JoyStatus_LCL & JOY_LEFT)
 193                   KeyboardReport->KeyCode[0] = 0x06; // C
 194                 else if (JoyStatus_LCL & JOY_RIGHT)
 195                   KeyboardReport->KeyCode[0] = 0x07; // D
 196
 197                 if (JoyStatus_LCL & JOY_PRESS)
 198                   KeyboardReport->KeyCode[0] = 0x08; // E
 199
 200                 return sizeof(USB_KeyboardReport_Data_t);
 201         }
 202         else
 203         {
 204                 USB_MouseReport_Data_t* MouseReport = (USB_MouseReport_Data_t*)ReportData;
 205
 206                 /* If first board button being held down, no mouse report */
 207                 if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 208                   return 0;
 209
 210                 if (JoyStatus_LCL & JOY_UP)
 211                   MouseReport->Y = -1;
 212                 else if (JoyStatus_LCL & JOY_DOWN)
 213                   MouseReport->Y =  1;
 214
 215                 if (JoyStatus_LCL & JOY_RIGHT)
 216                   MouseReport->X =  1;
 217                 else if (JoyStatus_LCL & JOY_LEFT)
 218                   MouseReport->X = -1;
 219
 220                 if (JoyStatus_LCL & JOY_PRESS)
 221                   MouseReport->Button  = (1 << 0);
 222
 223                 return sizeof(USB_MouseReport_Data_t);
 224         }
 225 }
 226
 227 /** HID class driver callback function for the processing of HID reports from the host.
 228  *
 229  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 230  *  \param[in] ReportID  Report ID of the received report from the host
 231  *  \param[in] ReportData  Pointer to a buffer where the created report has been stored
 232  *  \param[in] ReportSize  Size in bytes of the received HID report
 233  */
 234 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
 235                                           const void* ReportData, const uint16_t ReportSize)
 236 {
 237         if (HIDInterfaceInfo == &Keyboard_HID_Interface)
 238         {
 239                 uint8_t  LEDMask   = LEDS_NO_LEDS;
 240                 uint8_t* LEDReport = (uint8_t*)ReportData;
 241
 242                 if (*LEDReport & 0x01) // NUM Lock
 243                   LEDMask |= LEDS_LED1;
 244
 245                 if (*LEDReport & 0x02) // CAPS Lock
 246                   LEDMask |= LEDS_LED3;
 247
 248                 if (*LEDReport & 0x04) // SCROLL Lock
 249                   LEDMask |= LEDS_LED4;
 250
 251                 LEDs_SetAllLEDs(LEDMask);
 252         }
 253 }