Projects/Incomplete/MIDIToneGenerator/MIDIToneGenerator.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 MIDI demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "MIDIToneGenerator.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_Device_t Keyboard_MIDI_Interface =
  44         {
  45                 .Config =
  46                         {
  47                                 .StreamingInterfaceNumber = 1,
  48
  49                                 .DataINEndpointNumber      = MIDI_STREAM_IN_EPNUM,
  50                                 .DataINEndpointSize        = MIDI_STREAM_EPSIZE,
  51                                 .DataINEndpointDoubleBank  = false,
  52
  53                                 .DataOUTEndpointNumber     = MIDI_STREAM_OUT_EPNUM,
  54                                 .DataOUTEndpointSize       = MIDI_STREAM_EPSIZE,
  55                                 .DataOUTEndpointDoubleBank = false,
  56                         },
  57         };
  58
  59 /** 8-bit 256 entry Sine Wave lookup table */
  60 const uint8_t SineTable[256] =
  61 {
  62         128, 131, 134, 137, 140, 143, 146, 149, 152, 156, 159, 162, 165, 168, 171, 174,
  63         176, 179, 182, 185, 188, 191, 193, 196, 199, 201, 204, 206, 209, 211, 213, 216,
  64         218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 237, 239, 240, 242, 243, 245,
  65         246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 254, 255, 255, 255, 255, 255,
  66         255, 255, 255, 255, 255, 255, 254, 254, 253, 252, 252, 251, 250, 249, 248, 247,
  67         246, 245, 243, 242, 240, 239, 237, 236, 234, 232, 230, 228, 226, 224, 222, 220,
  68         218, 216, 213, 211, 209, 206, 204, 201, 199, 196, 193, 191, 188, 185, 182, 179,
  69         176, 174, 171, 168, 165, 162, 159, 156, 152, 149, 146, 143, 140, 137, 134, 131,
  70         128, 124, 121, 118, 115, 112, 109, 106, 103,  99,  96,  93,  90,  87,  84,  81,
  71          79,  76,  73,  70,  67,  64,  62,  59,  56,  54,  51,  49,  46,  44,  42,  39,
  72          37,  35,  33,  31,  29,  27,  25,  23,  21,  19,  18,  16,  15,  13,  12,  10,
  73           9,   8,   7,   6,   5,   4,   3,   3,   2,   1,   1,   0,   0,   0,   0,   0,
  74           0,   0,   0,   0,   0,   0,   1,   1,   2,   3,   3,   4,   5,   6,   7,   8,
  75           9,  10,  12,  13,  15,  16,  18,  19,  21,  23,  25,  27,  29,  31,  33,  35,
  76          37,  39,  42,  44,  46,  49,  51,  54,  56,  59,  62,  64,  67,  70,  73,  76,
  77          79,  81,  84,  87,  90,  93,  96,  99, 103, 106, 109, 112, 115, 118, 121, 124,
  78 };
  79
  80 /** Array of structures describing each note being generated */
  81 struct
  82 {
  83         uint8_t  Pitch;
  84         uint32_t TableIncrement;
  85         uint32_t TablePosition;
  86 } NoteData[3];
  87
  88 uint8_t PhaseCounter;
  89
  90 /** Main program entry point. This routine contains the overall program flow, including initial
  91  *  setup of all components and the main program loop.
  92  */
  93 int main(void)
  94 {
  95         SetupHardware();
  96
  97         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  98         sei();
  99
 100         for (;;)
 101         {
 102                 MIDI_EventPacket_t ReceivedMIDIEvent;
 103                 if (MIDI_Device_ReceiveEventPacket(&Keyboard_MIDI_Interface, &ReceivedMIDIEvent))
 104                 {
 105                         if ((ReceivedMIDIEvent.Command == (MIDI_COMMAND_NOTE_ON >> 4)) && ((ReceivedMIDIEvent.Data1 & 0x0F) == 0))
 106                         {
 107                                 /* Find a free entry in the note table to use for the note being turned on */
 108                                 for (uint8_t i = 0; i < MAX_SIMULTANEOUS_NOTES; i++)
 109                                 {
 110                                         if (!(NoteData[i].Pitch))
 111                                         {
 112                                                 NoteData[i].Pitch          = ReceivedMIDIEvent.Data2;
 113                                                 NoteData[i].TableIncrement = (uint32_t)(BASE_INCREMENT * SCALE_FACTOR) +
 114                                                                              ((uint32_t)(BASE_INCREMENT * NOTE_OCTIVE_RATIO * SCALE_FACTOR) *
 115                                                                               (ReceivedMIDIEvent.Data2 - BASE_PITCH_INDEX));
 116                                                 NoteData[i].TablePosition  = 0;
 117                                                 break;
 118                                         }
 119                                 }
 120
 121                                 /* Turn on indicator LED to indicate note generation activity */
 122                                 LEDs_SetAllLEDs(LEDS_LED1);
 123                         }
 124                         else if ((ReceivedMIDIEvent.Command == (MIDI_COMMAND_NOTE_OFF >> 4)) && ((ReceivedMIDIEvent.Data1 & 0x0F) == 0))
 125                         {
 126                                 bool FoundActiveNote = false;
 127
 128                                 /* Find the note in the note table to turn off */
 129                                 for (uint8_t i = 0; i < MAX_SIMULTANEOUS_NOTES; i++)
 130                                 {
 131                                         if (NoteData[i].Pitch == ReceivedMIDIEvent.Data2)
 132                                         {
 133                                                 NoteData[i].Pitch = 0;
 134                                                 FoundActiveNote      = true;
 135                                                 break;
 136                                         }
 137                                 }
 138
 139                                 /* If all notes off, turn off the indicator LED */
 140                                 if (!(FoundActiveNote))
 141                                   LEDs_SetAllLEDs(LEDS_NO_LEDS);
 142                         }
 143                 }
 144
 145                 MIDI_Device_USBTask(&Keyboard_MIDI_Interface);
 146                 USB_USBTask();
 147         }
 148 }
 149
 150 /** ISR to handle the reloading of the PWM timer with the next sample. */
 151 ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 152 {
 153         uint16_t MixedSample = 0;
 154
 155         /* Sum together all the active notes to form a single sample */
 156         for (uint8_t i = 0; i < MAX_SIMULTANEOUS_NOTES; i++)
 157         {
 158                 if (NoteData[i].Pitch)
 159                 {
 160                         MixedSample += SineTable[NoteData[i].TablePosition >> 24];
 161                         NoteData[i].TablePosition += NoteData[i].TableIncrement;
 162                 }
 163         }
 164
 165         /* Output clamped mixed sample value to the PWM */
 166         OCR3A = (MixedSample <= 0xFF) ? MixedSample : 0xFF;
 167 }
 168
 169 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 170 void SetupHardware(void)
 171 {
 172         /* Disable watchdog if enabled by bootloader/fuses */
 173         MCUSR &= ~(1 << WDRF);
 174         wdt_disable();
 175
 176         /* Disable clock division */
 177         clock_prescale_set(clock_div_1);
 178
 179         /* Hardware Initialization */
 180         LEDs_Init();
 181         USB_Init();
 182
 183         /* Sample reload timer initialization */
 184         TIMSK0  = (1 << OCIE0A);
 185         OCR0A   = 255;
 186         TCCR0A  = (1 << WGM01);  // CTC mode
 187         TCCR0B  = (1 << CS00);   // Fcpu speed
 188
 189         /* Set speaker as output */
 190         DDRC |= (1 << 6);
 191
 192         /* PWM speaker timer initialization */
 193         TCCR3A  = ((1 << WGM30) | (1 << COM3A1) | (1 << COM3A0)); // Set on match, clear on TOP
 194         TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, Fcpu speed
 195 }
 196
 197 /** Event handler for the library USB Connection event. */
 198 void EVENT_USB_Device_Connect(void)
 199 {
 200         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 201
 202         /* Set speaker as output */
 203         DDRC |= (1 << 6);
 204 }
 205
 206 /** Event handler for the library USB Disconnection event. */
 207 void EVENT_USB_Device_Disconnect(void)
 208 {
 209         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 210
 211         /* Set speaker as input to reduce current draw */
 212         DDRC &= ~(1 << 6);
 213 }
 214
 215 /** Event handler for the library USB Configuration Changed event. */
 216 void EVENT_USB_Device_ConfigurationChanged(void)
 217 {
 218         bool ConfigSuccess = true;
 219
 220         ConfigSuccess &= MIDI_Device_ConfigureEndpoints(&Keyboard_MIDI_Interface);
 221
 222         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 223 }
 224
 225 /** Event handler for the library USB Control Request event. */
 226 void EVENT_USB_Device_ControlRequest(void)
 227 {
 228         MIDI_Device_ProcessControlRequest(&Keyboard_MIDI_Interface);
 229 }