Demos/Host/ClassDriver/MIDIHost/MIDIHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  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 MIDIHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "MIDIHost.h"
  38
  39 /** LUFA MIDI Class driver interface configuration and state information. This structure is
  40  *  passed to all MIDI Class driver functions, so that multiple instances of the same class
  41  *  within a device can be differentiated from one another.
  42  */
  43 USB_ClassInfo_MIDI_Host_t Keyboard_MIDI_Interface =
  44         {
  45                 .Config =
  46                         {
  47                                 .DataINPipeNumber       = 1,
  48                                 .DataINPipeDoubleBank   = false,
  49
  50                                 .DataOUTPipeNumber      = 2,
  51                                 .DataOUTPipeDoubleBank  = false,
  52                         },
  53         };
  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         puts_P(PSTR(ESC_FG_CYAN "MIDI Host Demo running.\r\n" ESC_FG_WHITE));
  64
  65         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  66         sei();
  67
  68         for (;;)
  69         {
  70                 switch (USB_HostState)
  71                 {
  72                         case HOST_STATE_Addressed:
  73                                 LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  74
  75                                 uint16_t ConfigDescriptorSize;
  76                                 uint8_t  ConfigDescriptorData[512];
  77
  78                                 if (USB_Host_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData,
  79                                                                        sizeof(ConfigDescriptorData)) != HOST_GETCONFIG_Successful)
  80                                 {
  81                                         puts_P(PSTR("Error Retrieving Configuration Descriptor.\r\n"));
  82                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  83                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  84                                         break;
  85                                 }
  86
  87                                 if (MIDI_Host_ConfigurePipes(&Keyboard_MIDI_Interface,
  88                                                              ConfigDescriptorSize, ConfigDescriptorData) != MIDI_ENUMERROR_NoError)
  89                                 {
  90                                         puts_P(PSTR("Attached Device Not a Valid MIDI Class Device.\r\n"));
  91                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  92                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  93                                         break;
  94                                 }
  95
  96                                 if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
  97                                 {
  98                                         puts_P(PSTR("Error Setting Device Configuration.\r\n"));
  99                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 100                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 101                                         break;
 102                                 }
 103
 104                                 puts_P(PSTR("MIDI Device Enumerated.\r\n"));
 105                                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 106                                 USB_HostState = HOST_STATE_Configured;
 107                                 break;
 108                         case HOST_STATE_Configured:
 109                                 CheckJoystickMovement();
 110
 111                                 MIDI_EventPacket_t MIDIEvent;
 112                                 while (MIDI_Host_ReceiveEventPacket(&Keyboard_MIDI_Interface, &MIDIEvent))
 113                                 {
 114                                         bool NoteOnEvent  = ((MIDIEvent.Command & 0x0F) == (MIDI_COMMAND_NOTE_ON  >> 4));
 115                                         bool NoteOffEvent = ((MIDIEvent.Command & 0x0F) == (MIDI_COMMAND_NOTE_OFF >> 4));
 116
 117                                         if (NoteOnEvent || NoteOffEvent)
 118                                         {
 119                                                 printf_P(PSTR("MIDI Note %s - Channel %d, Pitch %d, Velocity %d\r\n"), NoteOnEvent ? "On" : "Off",
 120                                                                                                                                                                                        ((MIDIEvent.Data1 & 0x0F) + 1),
 121                                                                                                                                                                                        MIDIEvent.Data2, MIDIEvent.Data3);
 122                                         }
 123                                 }
 124
 125                                 break;
 126                 }
 127
 128                 MIDI_Host_USBTask(&Keyboard_MIDI_Interface);
 129                 USB_USBTask();
 130         }
 131 }
 132
 133 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 134 void SetupHardware(void)
 135 {
 136         /* Disable watchdog if enabled by bootloader/fuses */
 137         MCUSR &= ~(1 << WDRF);
 138         wdt_disable();
 139
 140         /* Disable clock division */
 141         clock_prescale_set(clock_div_1);
 142
 143         /* Hardware Initialization */
 144         Serial_Init(9600, false);
 145         LEDs_Init();
 146         Buttons_Init();
 147         Joystick_Init();
 148         USB_Init();
 149
 150         /* Create a stdio stream for the serial port for stdin and stdout */
 151         Serial_CreateStream(NULL);
 152 }
 153
 154 void CheckJoystickMovement(void)
 155 {
 156         static uint8_t PrevJoystickStatus;
 157
 158         uint8_t MIDICommand = 0;
 159         uint8_t MIDIPitch;
 160
 161         /* Get current joystick mask, XOR with previous to detect joystick changes */
 162         uint8_t JoystickStatus  = Joystick_GetStatus();
 163         uint8_t JoystickChanges = (JoystickStatus ^ PrevJoystickStatus);
 164
 165         /* Get board button status - if pressed use channel 10 (percussion), otherwise use channel 1 */
 166         uint8_t Channel = ((Buttons_GetStatus() & BUTTONS_BUTTON1) ? MIDI_CHANNEL(10) : MIDI_CHANNEL(1));
 167
 168         if (JoystickChanges & JOY_LEFT)
 169         {
 170                 MIDICommand = ((JoystickStatus & JOY_LEFT)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 171                 MIDIPitch   = 0x3C;
 172         }
 173
 174         if (JoystickChanges & JOY_UP)
 175         {
 176                 MIDICommand = ((JoystickStatus & JOY_UP)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 177                 MIDIPitch   = 0x3D;
 178         }
 179
 180         if (JoystickChanges & JOY_RIGHT)
 181         {
 182                 MIDICommand = ((JoystickStatus & JOY_RIGHT)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 183                 MIDIPitch   = 0x3E;
 184         }
 185
 186         if (JoystickChanges & JOY_DOWN)
 187         {
 188                 MIDICommand = ((JoystickStatus & JOY_DOWN)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 189                 MIDIPitch   = 0x3F;
 190         }
 191
 192         if (JoystickChanges & JOY_PRESS)
 193         {
 194                 MIDICommand = ((JoystickStatus & JOY_PRESS)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 195                 MIDIPitch   = 0x3B;
 196         }
 197
 198         if (MIDICommand)
 199         {
 200                 MIDI_EventPacket_t MIDIEvent = (MIDI_EventPacket_t)
 201                         {
 202                                 .CableNumber = 0,
 203                                 .Command     = (MIDICommand >> 4),
 204
 205                                 .Data1       = MIDICommand | Channel,
 206                                 .Data2       = MIDIPitch,
 207                                 .Data3       = MIDI_STANDARD_VELOCITY,
 208                         };
 209
 210                 MIDI_Host_SendEventPacket(&Keyboard_MIDI_Interface, &MIDIEvent);
 211                 MIDI_Host_Flush(&Keyboard_MIDI_Interface);
 212         }
 213
 214         PrevJoystickStatus = JoystickStatus;
 215 }
 216
 217 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
 218  *  starts the library USB task to begin the enumeration and USB management process.
 219  */
 220 void EVENT_USB_Host_DeviceAttached(void)
 221 {
 222         puts_P(PSTR("Device Attached.\r\n"));
 223         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 224 }
 225
 226 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
 227  *  stops the library USB task management process.
 228  */
 229 void EVENT_USB_Host_DeviceUnattached(void)
 230 {
 231         puts_P(PSTR("\r\nDevice Unattached.\r\n"));
 232         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 233 }
 234
 235 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 236  *  enumerated by the host and is now ready to be used by the application.
 237  */
 238 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 239 {
 240         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 241 }
 242
 243 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 244 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 245 {
 246         USB_Disable();
 247
 248         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 249                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 250
 251         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 252         for(;;);
 253 }
 254
 255 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 256  *  enumerating an attached USB device.
 257  */
 258 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 259                                             const uint8_t SubErrorCode)
 260 {
 261         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 262                                  " -- Error Code %d\r\n"
 263                                  " -- Sub Error Code %d\r\n"
 264                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 265
 266         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 267 }
 268