Demos/Device/LowLevel/Mouse/Mouse.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
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the Mouse demo. This file contains the main tasks of the demo and
  34  *  is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "Mouse.h"
  38
  39 /* Global Variables */
  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 moves the mouse).
  47  */
  48 uint16_t IdleCount = HID_IDLE_CHANGESONLY;
  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  *  starts the scheduler to run the application tasks.
  59  */
  60 int main(void)
  61 {
  62         SetupHardware();
  63
  64         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  65
  66         for (;;)
  67         {
  68                 Mouse_Task();
  69                 USB_USBTask();
  70         }
  71 }
  72
  73 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  74 void SetupHardware(void)
  75 {
  76         /* Disable watchdog if enabled by bootloader/fuses */
  77         MCUSR &= ~(1 << WDRF);
  78         wdt_disable();
  79
  80         /* Disable clock division */
  81         clock_prescale_set(clock_div_1);
  82
  83         /* Hardware Initialization */
  84         Joystick_Init();
  85         LEDs_Init();
  86         Buttons_Init();
  87         USB_Init();
  88
  89         /* Millisecond timer initialization, with output compare interrupt enabled for the idle timing */
  90         OCR0A  = 0x7D;
  91         TCCR0A = (1 << WGM01);
  92         TCCR0B = ((1 << CS01) | (1 << CS00));
  93         TIMSK0 = (1 << OCIE0A);
  94 }
  95
  96 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
  97  *  starts the library USB task to begin the enumeration and USB management process.
  98  */
  99 void EVENT_USB_Connect(void)
 100 {
 101         /* Indicate USB enumerating */
 102         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 103
 104         /* Default to report protocol on connect */
 105         UsingReportProtocol = true;
 106 }
 107
 108 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 109  *  the status LEDs and stops the USB management and Mouse reporting tasks.
 110  */
 111 void EVENT_USB_Disconnect(void)
 112 {
 113         /* Indicate USB not ready */
 114         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 115 }
 116
 117 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
 118  *  of the USB device after enumeration - the device endpoints are configured and the mouse reporting task started.
 119  */
 120 void EVENT_USB_ConfigurationChanged(void)
 121 {
 122         /* Indicate USB connected and ready */
 123         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 124
 125         /* Setup Mouse Report Endpoint */
 126         if (!(Endpoint_ConfigureEndpoint(MOUSE_EPNUM, EP_TYPE_INTERRUPT,
 127                                              ENDPOINT_DIR_IN, MOUSE_EPSIZE,
 128                                          ENDPOINT_BANK_SINGLE)))
 129         {
 130                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 131         }
 132 }
 133
 134 /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific
 135  *  control requests that are not handled internally by the USB library (including the HID commands, which are
 136  *  all issued via the control endpoint), so that they can be handled appropriately for the application.
 137  */
 138 void EVENT_USB_UnhandledControlPacket(void)
 139 {
 140         /* Handle HID Class specific requests */
 141         switch (USB_ControlRequest.bRequest)
 142         {
 143                 case REQ_GetReport:
 144                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 145                         {
 146                                 USB_MouseReport_Data_t MouseReportData;
 147
 148                                 Endpoint_ClearSETUP();
 149
 150                                 /* Create the next mouse report for transmission to the host */
 151                                 CreateMouseReport(&MouseReportData);
 152
 153                                 /* Write the report data to the control endpoint */
 154                                 Endpoint_Write_Control_Stream_LE(&MouseReportData, sizeof(MouseReportData));
 155
 156                                 /* Clear the report data afterwards */
 157                                 memset(&MouseReportData, 0, sizeof(MouseReportData));
 158
 159                                 /* Finalize the stream transfer to send the last packet or clear the host abort */
 160                                 Endpoint_ClearOUT();
 161                         }
 162
 163                         break;
 164                 case REQ_GetProtocol:
 165                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 166                         {
 167                                 Endpoint_ClearSETUP();
 168
 169                                 /* Write the current protocol flag to the host */
 170                                 Endpoint_Write_Byte(UsingReportProtocol);
 171
 172                                 /* Send the flag to the host */
 173                                 Endpoint_ClearIN();
 174
 175                                 Endpoint_ClearStatusStage();
 176                         }
 177
 178                         break;
 179                 case REQ_SetProtocol:
 180                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 181                         {
 182                                 Endpoint_ClearSETUP();
 183
 184                                 /* Set or clear the flag depending on what the host indicates that the current Protocol should be */
 185                                 UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 186
 187                                 Endpoint_ClearStatusStage();
 188                         }
 189
 190                         break;
 191                 case REQ_SetIdle:
 192                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 193                         {
 194                                 Endpoint_ClearSETUP();
 195
 196                                 /* Get idle period in MSB, must multiply by 4 to get the duration in milliseconds */
 197                                 IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
 198
 199                                 Endpoint_ClearStatusStage();
 200                         }
 201
 202                         break;
 203                 case REQ_GetIdle:
 204                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 205                         {
 206                                 Endpoint_ClearSETUP();
 207
 208                                 /* Write the current idle duration to the host, must be divided by 4 before sent to host */
 209                                 Endpoint_Write_Byte(IdleCount >> 2);
 210
 211                                 /* Send the flag to the host */
 212                                 Endpoint_ClearIN();
 213
 214                                 Endpoint_ClearStatusStage();
 215                         }
 216
 217                         break;
 218         }
 219 }
 220
 221 /** ISR for the timer 0 compare vector. This ISR fires once each millisecond, and increments the
 222  *  scheduler elapsed idle period counter when the host has set an idle period.
 223  */
 224 ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 225 {
 226         /* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
 227         if (IdleMSRemaining)
 228           IdleMSRemaining--;
 229 }
 230
 231 /** Fills the given HID report data structure with the next HID report to send to the host.
 232  *
 233  *  \param[out] ReportData  Pointer to a HID report data structure to be filled
 234  */
 235 void CreateMouseReport(USB_MouseReport_Data_t* ReportData)
 236 {
 237         uint8_t JoyStatus_LCL    = Joystick_GetStatus();
 238         uint8_t ButtonStatus_LCL = Buttons_GetStatus();
 239
 240         /* Clear the report contents */
 241         memset(ReportData, 0, sizeof(USB_MouseReport_Data_t));
 242
 243         if (JoyStatus_LCL & JOY_UP)
 244           ReportData->Y = -1;
 245         else if (JoyStatus_LCL & JOY_DOWN)
 246           ReportData->Y =  1;
 247
 248         if (JoyStatus_LCL & JOY_RIGHT)
 249           ReportData->X =  1;
 250         else if (JoyStatus_LCL & JOY_LEFT)
 251           ReportData->X = -1;
 252
 253         if (JoyStatus_LCL & JOY_PRESS)
 254           ReportData->Button  = (1 << 0);
 255
 256         if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 257           ReportData->Button |= (1 << 1);
 258 }
 259
 260 /** Sends the next HID report to the host, via the keyboard data endpoint. */
 261 void SendNextReport(void)
 262 {
 263         static USB_MouseReport_Data_t PrevMouseReportData;
 264         USB_MouseReport_Data_t        MouseReportData;
 265         bool                          SendReport;
 266
 267         /* Create the next mouse report for transmission to the host */
 268         CreateMouseReport(&MouseReportData);
 269
 270         /* Check to see if the report data has changed - if so a report MUST be sent */
 271         SendReport = (memcmp(&PrevMouseReportData, &MouseReportData, sizeof(USB_MouseReport_Data_t)) != 0);
 272
 273         /* Override the check if the Y or X values are non-zero - we want continuous movement while the joystick
 274          * is being held down (via continuous reports), otherwise the cursor will only move once per joystick toggle */
 275         if ((MouseReportData.Y != 0) || (MouseReportData.X != 0))
 276           SendReport = true;
 277
 278         /* Save the current report data for later comparison to check for changes */
 279         PrevMouseReportData = MouseReportData;
 280
 281         /* Check if the idle period is set and has elapsed */
 282         if ((IdleCount != HID_IDLE_CHANGESONLY) && (!(IdleMSRemaining)))
 283         {
 284                 /* Reset the idle time remaining counter */
 285                 IdleMSRemaining = IdleCount;
 286
 287                 /* Idle period is set and has elapsed, must send a report to the host */
 288                 SendReport = true;
 289         }
 290
 291         /* Select the Mouse Report Endpoint */
 292         Endpoint_SelectEndpoint(MOUSE_EPNUM);
 293
 294         /* Check if Mouse Endpoint Ready for Read/Write and if we should send a new report */
 295         if (Endpoint_IsReadWriteAllowed() && SendReport)
 296         {
 297                 /* Write Mouse Report Data */
 298                 Endpoint_Write_Stream_LE(&MouseReportData, sizeof(MouseReportData));
 299
 300                 /* Finalize the stream transfer to send the last packet */
 301                 Endpoint_ClearIN();
 302         }
 303 }
 304
 305 /** Task to manage HID report generation and transmission to the host, when in report mode. */
 306 void Mouse_Task(void)
 307 {
 308         /* Device must be connected and configured for the task to run */
 309         if (USB_DeviceState != DEVICE_STATE_Configured)
 310           return;
 311
 312         /* Send the next mouse report to the host */
 313         SendNextReport();
 314 }