Demos/Device/LowLevel/Mouse/Mouse.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all 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 /** Indicates what report mode the host has requested, true for normal HID reporting mode, false for special boot
  40  *  protocol reporting mode.
  41  */
  42 bool UsingReportProtocol = true;
  43
  44 /** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
  45  *  for either the entire idle duration, or until the report status changes (e.g. the user moves the mouse).
  46  */
  47 uint16_t IdleCount = HID_IDLE_CHANGESONLY;
  48
  49 /** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
  50  *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
  51  *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
  52  */
  53 uint16_t IdleMSRemaining = 0;
  54
  55
  56 /** Main program entry point. This routine configures the hardware required by the application, then
  57  *  enters a loop to run the application tasks in sequence.
  58  */
  59 int main(void)
  60 {
  61         SetupHardware();
  62
  63         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  64         sei();
  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
  90 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
  91  *  starts the library USB task to begin the enumeration and USB management process.
  92  */
  93 void EVENT_USB_Device_Connect(void)
  94 {
  95         /* Indicate USB enumerating */
  96         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  97
  98         /* Default to report protocol on connect */
  99         UsingReportProtocol = true;
 100 }
 101
 102 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 103  *  the status LEDs and stops the USB management and Mouse reporting tasks.
 104  */
 105 void EVENT_USB_Device_Disconnect(void)
 106 {
 107         /* Indicate USB not ready */
 108         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 109 }
 110
 111 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
 112  *  of the USB device after enumeration - the device endpoints are configured and the mouse reporting task started.
 113  */
 114 void EVENT_USB_Device_ConfigurationChanged(void)
 115 {
 116         /* Indicate USB connected and ready */
 117         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 118
 119         /* Setup Mouse Report Endpoint */
 120         if (!(Endpoint_ConfigureEndpoint(MOUSE_EPNUM, EP_TYPE_INTERRUPT,
 121                                              ENDPOINT_DIR_IN, MOUSE_EPSIZE,
 122                                          ENDPOINT_BANK_SINGLE)))
 123         {
 124                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 125         }
 126
 127         USB_Device_EnableSOFEvents();
 128 }
 129
 130 /** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific
 131  *  control requests that are not handled internally by the USB library (including the HID commands, which are
 132  *  all issued via the control endpoint), so that they can be handled appropriately for the application.
 133  */
 134 void EVENT_USB_Device_UnhandledControlRequest(void)
 135 {
 136         /* Handle HID Class specific requests */
 137         switch (USB_ControlRequest.bRequest)
 138         {
 139                 case REQ_GetReport:
 140                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 141                         {
 142                                 USB_MouseReport_Data_t MouseReportData;
 143
 144                                 Endpoint_ClearSETUP();
 145
 146                                 /* Create the next mouse report for transmission to the host */
 147                                 CreateMouseReport(&MouseReportData);
 148
 149                                 /* Write the report data to the control endpoint */
 150                                 Endpoint_Write_Control_Stream_LE(&MouseReportData, sizeof(MouseReportData));
 151
 152                                 /* Clear the report data afterwards */
 153                                 memset(&MouseReportData, 0, sizeof(MouseReportData));
 154
 155                                 /* Finalize the stream transfer to send the last packet or clear the host abort */
 156                                 Endpoint_ClearOUT();
 157                         }
 158
 159                         break;
 160                 case REQ_GetProtocol:
 161                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 162                         {
 163                                 Endpoint_ClearSETUP();
 164
 165                                 /* Write the current protocol flag to the host */
 166                                 Endpoint_Write_Byte(UsingReportProtocol);
 167
 168                                 /* Send the flag to the host */
 169                                 Endpoint_ClearIN();
 170
 171                                 Endpoint_ClearStatusStage();
 172                         }
 173
 174                         break;
 175                 case REQ_SetProtocol:
 176                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 177                         {
 178                                 Endpoint_ClearSETUP();
 179
 180                                 /* Set or clear the flag depending on what the host indicates that the current Protocol should be */
 181                                 UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 182
 183                                 Endpoint_ClearStatusStage();
 184                         }
 185
 186                         break;
 187                 case REQ_SetIdle:
 188                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 189                         {
 190                                 Endpoint_ClearSETUP();
 191
 192                                 /* Get idle period in MSB, must multiply by 4 to get the duration in milliseconds */
 193                                 IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
 194
 195                                 Endpoint_ClearStatusStage();
 196                         }
 197
 198                         break;
 199                 case REQ_GetIdle:
 200                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 201                         {
 202                                 Endpoint_ClearSETUP();
 203
 204                                 /* Write the current idle duration to the host, must be divided by 4 before sent to host */
 205                                 Endpoint_Write_Byte(IdleCount >> 2);
 206
 207                                 /* Send the flag to the host */
 208                                 Endpoint_ClearIN();
 209
 210                                 Endpoint_ClearStatusStage();
 211                         }
 212
 213                         break;
 214         }
 215 }
 216
 217 /** Event handler for the USB device Start Of Frame event. */
 218 void EVENT_USB_Device_StartOfFrame(void)
 219 {
 220         /* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
 221         if (IdleMSRemaining)
 222           IdleMSRemaining--;
 223 }
 224
 225 /** Fills the given HID report data structure with the next HID report to send to the host.
 226  *
 227  *  \param[out] ReportData  Pointer to a HID report data structure to be filled
 228  */
 229 void CreateMouseReport(USB_MouseReport_Data_t* ReportData)
 230 {
 231         uint8_t JoyStatus_LCL    = Joystick_GetStatus();
 232         uint8_t ButtonStatus_LCL = Buttons_GetStatus();
 233
 234         /* Clear the report contents */
 235         memset(ReportData, 0, sizeof(USB_MouseReport_Data_t));
 236
 237         if (JoyStatus_LCL & JOY_UP)
 238           ReportData->Y = -1;
 239         else if (JoyStatus_LCL & JOY_DOWN)
 240           ReportData->Y =  1;
 241
 242         if (JoyStatus_LCL & JOY_LEFT)
 243           ReportData->X = -1;
 244         else if (JoyStatus_LCL & JOY_RIGHT)
 245           ReportData->X = 1;
 246
 247         if (JoyStatus_LCL & JOY_PRESS)
 248           ReportData->Button  = (1 << 0);
 249
 250         if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 251           ReportData->Button |= (1 << 1);
 252 }
 253
 254 /** Sends the next HID report to the host, via the keyboard data endpoint. */
 255 void SendNextReport(void)
 256 {
 257         static USB_MouseReport_Data_t PrevMouseReportData;
 258         USB_MouseReport_Data_t        MouseReportData;
 259         bool                          SendReport;
 260
 261         /* Create the next mouse report for transmission to the host */
 262         CreateMouseReport(&MouseReportData);
 263
 264         /* Check to see if the report data has changed - if so a report MUST be sent */
 265         SendReport = (memcmp(&PrevMouseReportData, &MouseReportData, sizeof(USB_MouseReport_Data_t)) != 0);
 266
 267         /* Override the check if the Y or X values are non-zero - we want continuous movement while the joystick
 268          * is being held down (via continuous reports), otherwise the cursor will only move once per joystick toggle */
 269         if ((MouseReportData.Y != 0) || (MouseReportData.X != 0))
 270           SendReport = true;
 271
 272         /* Check if the idle period is set and has elapsed */
 273         if ((IdleCount != HID_IDLE_CHANGESONLY) && (!(IdleMSRemaining)))
 274         {
 275                 /* Reset the idle time remaining counter */
 276                 IdleMSRemaining = IdleCount;
 277
 278                 /* Idle period is set and has elapsed, must send a report to the host */
 279                 SendReport = true;
 280         }
 281
 282         /* Select the Mouse Report Endpoint */
 283         Endpoint_SelectEndpoint(MOUSE_EPNUM);
 284
 285         /* Check if Mouse Endpoint Ready for Read/Write and if we should send a new report */
 286         if (Endpoint_IsReadWriteAllowed() && SendReport)
 287         {
 288                 /* Save the current report data for later comparison to check for changes */
 289                 PrevMouseReportData = MouseReportData;
 290
 291                 /* Write Mouse Report Data */
 292                 Endpoint_Write_Stream_LE(&MouseReportData, sizeof(MouseReportData));
 293
 294                 /* Finalize the stream transfer to send the last packet */
 295                 Endpoint_ClearIN();
 296         }
 297 }
 298
 299 /** Task to manage HID report generation and transmission to the host, when in report mode. */
 300 void Mouse_Task(void)
 301 {
 302         /* Device must be connected and configured for the task to run */
 303         if (USB_DeviceState != DEVICE_STATE_Configured)
 304           return;
 305
 306         /* Send the next mouse report to the host */
 307         SendNextReport();
 308 }