Demos/Host/LowLevel/JoystickHostWithParser/JoystickHostWithParser.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2013.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2013  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 disclaims 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 JoystickHostWithParser demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "JoystickHostWithParser.h"
  38
  39 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  enters a loop to run the application tasks in sequence.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         puts_P(PSTR(ESC_FG_CYAN "Joystick HID Parser Host Demo running.\r\n" ESC_FG_WHITE));
  47
  48         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  49         GlobalInterruptEnable();
  50
  51         for (;;)
  52         {
  53                 JoystickHost_Task();
  54
  55                 USB_USBTask();
  56         }
  57 }
  58
  59 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  60 void SetupHardware(void)
  61 {
  62         /* Disable watchdog if enabled by bootloader/fuses */
  63         MCUSR &= ~(1 << WDRF);
  64         wdt_disable();
  65
  66         /* Disable clock division */
  67         clock_prescale_set(clock_div_1);
  68
  69         /* Hardware Initialization */
  70         Serial_Init(9600, false);
  71         LEDs_Init();
  72         USB_Init();
  73
  74         /* Create a stdio stream for the serial port for stdin and stdout */
  75         Serial_CreateStream(NULL);
  76 }
  77
  78 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  79  *  starts the library USB task to begin the enumeration and USB management process.
  80  */
  81 void EVENT_USB_Host_DeviceAttached(void)
  82 {
  83         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  84         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  85 }
  86
  87 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  88  *  stops the library USB task management process.
  89  */
  90 void EVENT_USB_Host_DeviceUnattached(void)
  91 {
  92         puts_P(PSTR(ESC_FG_GREEN "Device Unattached.\r\n" ESC_FG_WHITE));
  93         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  94 }
  95
  96 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  97  *  enumerated by the host and is now ready to be used by the application.
  98  */
  99 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 100 {
 101         puts_P(PSTR("Getting Config Data.\r\n"));
 102
 103         uint8_t ErrorCode;
 104
 105         /* Get and process the configuration descriptor data */
 106         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 107         {
 108                 if (ErrorCode == ControlError)
 109                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 110                 else
 111                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 112
 113                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 114
 115                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 116                 return;
 117         }
 118
 119         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 120         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 121         {
 122                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 123                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 124
 125                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 126                 return;
 127         }
 128
 129         printf_P(PSTR("Processing HID Report (Size %d Bytes).\r\n"), HIDReportSize);
 130
 131         /* Get and process the device's first HID report descriptor */
 132         if ((ErrorCode = GetHIDReportData()) != ParseSuccessful)
 133         {
 134                 puts_P(PSTR(ESC_FG_RED "Report Parse Error.\r\n"));
 135
 136                 if (!(HIDReportInfo.TotalReportItems))
 137                         puts_P(PSTR("Not a valid Joystick." ESC_FG_WHITE));
 138                 else
 139                         printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 140
 141                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 142                 USB_Host_SetDeviceConfiguration(0);
 143                 return;
 144         }
 145
 146         puts_P(PSTR("Joystick Enumerated.\r\n"));
 147         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 148 }
 149
 150 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 151 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 152 {
 153         USB_Disable();
 154
 155         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 156                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 157
 158         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 159         for(;;);
 160 }
 161
 162 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 163  *  enumerating an attached USB device.
 164  */
 165 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
 166 {
 167         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 168                                  " -- Error Code %d\r\n"
 169                                  " -- Sub Error Code %d\r\n"
 170                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 171
 172         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 173 }
 174
 175 /** Task to read and process the HID report descriptor and HID reports from the device
 176  *  and display the results onto the board LEDs.
 177  */
 178 void JoystickHost_Task(void)
 179 {
 180         if (USB_HostState != HOST_STATE_Configured)
 181           return;
 182
 183         /* Select and unfreeze joystick data pipe */
 184         Pipe_SelectPipe(JOYSTICK_DATA_IN_PIPE);
 185         Pipe_Unfreeze();
 186
 187         /* Check to see if a packet has been received */
 188         if (Pipe_IsINReceived())
 189         {
 190                 /* Check if data has been received from the attached joystick */
 191                 if (Pipe_IsReadWriteAllowed())
 192                 {
 193                         /* Create buffer big enough for the report */
 194                         uint8_t JoystickReport[Pipe_BytesInPipe()];
 195
 196                         /* Load in the joystick report */
 197                         Pipe_Read_Stream_LE(JoystickReport, Pipe_BytesInPipe(), NULL);
 198
 199                         /* Process the read in joystick report from the device */
 200                         ProcessJoystickReport(JoystickReport);
 201                 }
 202
 203                 /* Clear the IN endpoint, ready for next data packet */
 204                 Pipe_ClearIN();
 205         }
 206
 207         /* Freeze joystick data pipe */
 208         Pipe_Freeze();
 209 }
 210
 211 /** Processes a read HID report from an attached joystick, extracting out elements via the HID parser results
 212  *  as required and displays movement and button presses on the board LEDs.
 213  *
 214  *  \param[in] JoystickReport  Pointer to a HID report from an attached joystick device
 215  */
 216 void ProcessJoystickReport(uint8_t* JoystickReport)
 217 {
 218         uint8_t LEDMask = LEDS_NO_LEDS;
 219
 220         /* Check each HID report item in turn, looking for joystick X/Y/button reports */
 221         for (uint8_t ReportNumber = 0; ReportNumber < HIDReportInfo.TotalReportItems; ReportNumber++)
 222         {
 223                 /* Create a temporary item pointer to the next report item */
 224                 HID_ReportItem_t* ReportItem = &HIDReportInfo.ReportItems[ReportNumber];
 225
 226                 bool FoundData;
 227
 228                 if ((ReportItem->Attributes.Usage.Page        == USAGE_PAGE_BUTTON) &&
 229                         (ReportItem->ItemType                     == HID_REPORT_ITEM_In))
 230                 {
 231                         /* Get the joystick button value */
 232                         FoundData = USB_GetHIDReportItemInfo(JoystickReport, ReportItem);
 233
 234                         /* For multi-report devices - if the requested data was not in the issued report, continue */
 235                         if (!(FoundData))
 236                           continue;
 237
 238                         /* If button is pressed, all LEDs are turned on */
 239                         if (ReportItem->Value)
 240                           LEDMask = LEDS_ALL_LEDS;
 241                 }
 242                 else if ((ReportItem->Attributes.Usage.Page   == USAGE_PAGE_GENERIC_DCTRL) &&
 243                                  ((ReportItem->Attributes.Usage.Usage == USAGE_X)                  ||
 244                                   (ReportItem->Attributes.Usage.Usage == USAGE_Y))                 &&
 245                                  (ReportItem->ItemType                == HID_REPORT_ITEM_In))
 246                 {
 247                         /* Get the joystick relative position value */
 248                         FoundData = USB_GetHIDReportItemInfo(JoystickReport, ReportItem);
 249
 250                         /* For multi-report devices - if the requested data was not in the issued report, continue */
 251                         if (!(FoundData))
 252                           continue;
 253
 254                         int16_t DeltaMovement = HID_ALIGN_DATA(ReportItem, int16_t);
 255
 256                         /* Check to see if a (non-zero) delta movement has been indicated */
 257                         if (DeltaMovement)
 258                         {
 259                                 /* Determine if the report is for the X or Y delta movement, light LEDs as appropriate */
 260                                 if (ReportItem->Attributes.Usage.Usage == USAGE_X)
 261                                   LEDMask |= ((DeltaMovement > 0) ? LEDS_LED1 : LEDS_LED2);
 262                                 else
 263                                   LEDMask |= ((DeltaMovement > 0) ? LEDS_LED3 : LEDS_LED4);
 264                         }
 265                 }
 266         }
 267
 268         /* Display the button information on the board LEDs */
 269         LEDs_SetAllLEDs(LEDMask);
 270 }
 271