Demos/Device/LowLevel/MIDI/MIDI.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 MIDI input demo. This file contains the main tasks of the demo and
  34  *  is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "MIDI.h"
  38
  39 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  starts the scheduler to run the application tasks.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  47
  48         for (;;)
  49         {
  50                 MIDI_Task();
  51                 USB_USBTask();
  52         }
  53 }
  54
  55 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  56 void SetupHardware(void)
  57 {
  58         /* Disable watchdog if enabled by bootloader/fuses */
  59         MCUSR &= ~(1 << WDRF);
  60         wdt_disable();
  61
  62         /* Disable clock division */
  63         clock_prescale_set(clock_div_1);
  64
  65         /* Hardware Initialization */
  66         Joystick_Init();
  67         LEDs_Init();
  68         Buttons_Init();
  69         USB_Init();
  70 }
  71
  72 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs. */
  73 void EVENT_USB_Connect(void)
  74 {
  75         /* Indicate USB enumerating */
  76         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  77 }
  78
  79 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
  80  *  the status LEDs, disables the sample update and PWM output timers and stops the USB and MIDI management tasks.
  81  */
  82 void EVENT_USB_Disconnect(void)
  83 {
  84         /* Indicate USB not ready */
  85         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  86 }
  87
  88 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
  89  *  of the USB device after enumeration - the device endpoints are configured and the MIDI management task started.
  90  */
  91 void EVENT_USB_ConfigurationChanged(void)
  92 {
  93         /* Indicate USB connected and ready */
  94         LEDs_SetAllLEDs(LEDMASK_USB_READY);
  95
  96         /* Setup MIDI stream endpoints */
  97         if (!(Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPNUM, EP_TYPE_BULK,
  98                                              ENDPOINT_DIR_OUT, MIDI_STREAM_EPSIZE,
  99                                          ENDPOINT_BANK_SINGLE)))
 100         {
 101                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 102         }
 103
 104         if (!(Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPNUM, EP_TYPE_BULK,
 105                                              ENDPOINT_DIR_IN, MIDI_STREAM_EPSIZE,
 106                                          ENDPOINT_BANK_SINGLE)))
 107         {
 108                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 109         }
 110 }
 111
 112 /** Task to handle the generation of MIDI note change events in response to presses of the board joystick, and send them
 113  *  to the host.
 114  */
 115 void MIDI_Task(void)
 116 {
 117         static uint8_t PrevJoystickStatus;
 118
 119         /* Select the MIDI IN stream */
 120         Endpoint_SelectEndpoint(MIDI_STREAM_IN_EPNUM);
 121
 122         /* Check if endpoint is ready to be written to */
 123         if (Endpoint_IsINReady())
 124         {
 125                 uint8_t MIDICommand = 0;
 126                 uint8_t MIDIPitch;
 127
 128                 /* Get current joystick mask, XOR with previous to detect joystick changes */
 129                 uint8_t JoystickStatus  = Joystick_GetStatus();
 130                 uint8_t JoystickChanges = (JoystickStatus ^ PrevJoystickStatus);
 131
 132                 /* Get board button status - if pressed use channel 10 (percussion), otherwise use channel 1 */
 133                 uint8_t Channel = ((Buttons_GetStatus() & BUTTONS_BUTTON1) ? MIDI_CHANNEL(10) : MIDI_CHANNEL(1));
 134
 135                 if (JoystickChanges & JOY_LEFT)
 136                 {
 137                         MIDICommand = ((JoystickStatus & JOY_LEFT)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 138                         MIDIPitch   = 0x3C;
 139                 }
 140
 141                 if (JoystickChanges & JOY_UP)
 142                 {
 143                         MIDICommand = ((JoystickStatus & JOY_UP)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 144                         MIDIPitch   = 0x3D;
 145                 }
 146
 147                 if (JoystickChanges & JOY_RIGHT)
 148                 {
 149                         MIDICommand = ((JoystickStatus & JOY_RIGHT)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 150                         MIDIPitch   = 0x3E;
 151                 }
 152
 153                 if (JoystickChanges & JOY_DOWN)
 154                 {
 155                         MIDICommand = ((JoystickStatus & JOY_DOWN)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 156                         MIDIPitch   = 0x3F;
 157                 }
 158
 159                 if (JoystickChanges & JOY_PRESS)
 160                 {
 161                         MIDICommand = ((JoystickStatus & JOY_PRESS)? MIDI_COMMAND_NOTE_ON : MIDI_COMMAND_NOTE_OFF);
 162                         MIDIPitch   = 0x3B;
 163                 }
 164
 165                 /* Check if a MIDI command is to be sent */
 166                 if (MIDICommand)
 167                 {
 168                         USB_MIDI_EventPacket_t MIDIEvent = (USB_MIDI_EventPacket_t)
 169                                 {
 170                                         .CableNumber = 0,
 171                                         .Command     = MIDICommand,
 172
 173                                         .Data1       = (MIDICommand << 4) | Channel,
 174                                         .Data2       = MIDIPitch,
 175                                         .Data3       = MIDI_STANDARD_VELOCITY,
 176                                 };
 177
 178                         /* Write the MIDI event packet to the endpoint */
 179                         Endpoint_Write_Stream_LE(&MIDIEvent, sizeof(MIDIEvent));
 180
 181                         /* Send the data in the endpoint to the host */
 182                         Endpoint_ClearIN();
 183                 }
 184
 185                 /* Save previous joystick value for next joystick change detection */
 186                 PrevJoystickStatus = JoystickStatus;
 187         }
 188
 189         /* Select the MIDI OUT stream */
 190         Endpoint_SelectEndpoint(MIDI_STREAM_OUT_EPNUM);
 191
 192         /* Check if endpoint is ready to be read from, if so discard its (unused) data */
 193         if (Endpoint_IsOUTReceived())
 194           Endpoint_ClearOUT();
 195 }