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