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