Arduino and MIDI

THE_RB said:

I've done MIDI in to polyphonic audio out (8 notes). It was a bit tight on a PIC16F. Should be easy enough on a 18F chip at 40MHz (or the right arduino).

To generate the polyphonic notes I used a timer interrupt faster than the highest note frequency, and bresenham type note generation (pin toggling square waves).

What is your output? Multiple pins, or mixed into one PWM?

Click to expand...

THE_RB said:

Ignoring the MIDI side for now, you need a way to generate multiple independent frequencies in a timer interrupt.

The method I used was a timer interrupt about 10 times faster than the highest note, then used a bresenham timing system which can generate any not freq from any interrupt frequency. The benefit of that versatility is that the same interrupt frequency (one freq) can generate all different note freqs.

Assuming a 10MHz 8bit timer, set to prescaler 2:1 will make a timer interrupt every 10mil/512 or 19531 Hz. That's about 10 times your highest note of 2000Hz, which is fine.

Then the code looks like this;

Rich (BB code):

unsigned int bres1, bres2;  // 16bit varsd for the bresenham accumulators

// (gets here in interrupt at 19531 Hz)

// this generates an A note at 440Hz
bres1 += 880;  // 440*2 needed to toggle pin at 440Hz
if(bres1 >= 19531)
{
  bres1 -= 19531;
  PORTB.F1 = ~PORTB.F1;  // toggle pin1 at 440Hz
}

// this simultaneously generates a C note at 523Hz
bres2 += 1046;  // 523*2 needed 
if(bres2 >= 19531)
{
  bres2 -= 19531;
  PORTB.F2 = ~PORTB.F2;  // toggle pin2 at 523Hz
}

That goes inside the interrupt, and makes two notes at the same time, each note is a squarewave on its own digital output pin.

That should give you the basic idea. You can improve the code a lot by doubling the 19531 constant to 39062, which lets you use twice the resolution in the note freq (so 440 becomes 440*4).

The bresenham math is very fast and simple and maintains the freq ratio between the two frequencies (int freq at 19531Hz and note freq at 440Hz).

Obviously you need some trimmings like a flag to turn each note on/off, and to use a variable for 440*2 not a constant, so the note can be set elsewhere;

Rich (BB code):

// this generates one note
if(note1on==1)  // now this flag turns sound on/off
{
  bres1 += note1freq;  // now uses a var for the note freq
  if(bres1 >= 19531)
  {
    bres1 -= 19531;
    PORTB.F1 = ~PORTB.F1;  
  }
}

Click to expand...

DerStrom8 said:

... I have a function that determines the frequency from the note, which means I can obtain the period, and thus the required duty cycle.
...

Click to expand...

THE_RB said:

That sounds like too much work! The MIDI serial data already gives you the note, so you don't need to do calcs. You just need 12 constants, to represent the 12 possible notes.

The MIDI data also gives you the octave, so you get the note from the lookup table of 12 constants, and divide it by 2 (or multiply by 2) for each octave.

So note A1 is 440Hz, note A2 is 880Hz etc.

I would also stay well away from periods, it's easier to work in freq (not period) and that avoids the nasty and slow 1/freq division math.

Re the note Hi duty cycle needing to be <=1mS, that should not be hard. The note generation normally toggles the pin Hi and LO at twice the freq. So you toggle to HI at the correct time, but for the toggle to LO you include a "timeout" of X interrupts. A simple counter.

So if the int freq is 19531 Hz, you always toggle HI->LO after 19 interrupts, IF the normal HI->LO note toggle has not already occurred. That gives you <1mS HI duty on low freq notes, and 50:50 duty on higher freq notes >500 Hz.

I think for the moment you should try a single note generation, using the timer interrupt and get an understanding for the process and how you can refine ti to be fast and efficient. If you need to generate multiple simultaneous notes your code will need to be clean and very fast to execute.

This is not an easy task!

Click to expand...

DerStrom8 said:

...
note = MIDI.getData1();
octave = (note / 12) - 1;
...

Click to expand...

DerStrom8 said:

...
uint16_t frequency[128] PROGMEM = {
8, 9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 15, 16,
17, 18, 19, 21, 22, 23, 24, 26, 28, 29, 31, 33,
35, 37, 39, 41, 44, 46, 49, 52, 55, 58, 62, 65,
69, 73, 78, 82, 87, 92, 98, 104, 110, 117, 123,
131, 139, 147, 156, 165, 175, 185, 196, 208, 220,
233, 247, 262, 277, 294, 311, 330, 349, 370, 392,
415, 440, 466, 494, 523, 554, 587, 622, 659, 698,
740, 784, 831, 880, 932, 988, 1047, 1109, 1175,
1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865,
1976, 2093, 2217, 2349, 2489, 2637, 2794, 2960,
3136, 3322, 3520, 3729, 3951, 4186, 4435, 4699,
4978, 5274, 5588, 5920, 5920, 6645, 7040, 7459,
7902, 8372, 8870, 9397, 9956, 10548, 11175,
11840, 12544};
...

Click to expand...

unsigned long bres;       // now using 32bit accumulators
unsigned long note1freq;  // and 32bit note frequencies

// this code is in main(), and sets the note to play
note1freq = 225280;       // assign note A7 to note1


// code below is in the interrupt
if(note1on==1)            // this flag turns sound on/off
{
  bres1 += note1freq;     
  if(bres1 >= 625000)     // using 19531.25Hz * 32
  {
    bres1 -= 625000;
    PORTB.F1 = ~PORTB.F1; 
  }
}

THE_RB said:

Just dividing the note number by 12 gives you the octave. The rest depends on what scale your base data (for your 12 notes) is in.



That's pretty horrible too.
There's approximately a 6% change in frequency from any note (semitone) to the next semitone. So a +/-1% deviation in freq is a sixth of a note, which will sound really out of tune.

With specifying integer note frequencies of <100 this will be really bad, and ideally for the notes to sound nicely in tune you need keep the note frequencies to +/-0.1% tolerance or better. So the constant that makes the note should be >1000.

So with the note accuracy and the octaves, a good approach is to keep the 12 note frequencies as large numbers (with a lot of resolution) for the top octave, then for each octave down, divide that note freq by two. At the bottom octave the note value should be at resolution >1000.

So given 8 octaves;
A0 = 1760
A1 = 3520
A2 = 7040
A3 = 14080
A4 = 28160
A5 = 56320
A6 = 112640
A7 = 225280 (this one is the constant in your 12 value array)

So all your 12 note constants are up around 6 digit resolution.

And assuming the interrupt is still at 19531.25 Hz, (10 mill / 512), then the code to generate an A7 note in the interrupt is this;

Rich (BB code):

unsigned long bres;       // now using 32bit accumulators
unsigned long note1freq;  // and 32bit note frequencies

// this code is in main(), and sets the note to play
note1freq = 225280;       // assign note A7 to note1


// code below is in the interrupt
if(note1on==1)            // this flag turns sound on/off
{
  bres1 += note1freq;     
  if(bres1 >= 625000)     // using 19531.25Hz * 32
  {
    bres1 -= 625000;
    PORTB.F1 = ~PORTB.F1; 
  }
}

So using the larger numbers means now the notes are accurate over lots of octaves, but the code is still very simple and fast to make a note. For each note there is a 32bit addition and a 32bit comparison, and on occasions a 32bit subtraction (when the note is toggled).

That is still fast enough to generate multiple simultaneous notes in a timer interrupt that occurs every 512 instructions.

Like I said, it would be good to strip your code down and just get it making one note, where you can set the note in code. Then you can make sure the note sounds good and is in tune (compare to a keyboard or PC piano freeware etc).

Click to expand...

DerStrom8 said:

...
This is what I was referring to when I said divide by 12 and subtract 1 to get the octave.
...

Click to expand...