microtherion/MP3_Shield_RealtimeMIDI.ino

## MP3_Shield_RealtimeMIDI.ino
/*
 *
 * File:     MP3_Shield_RealtimeMIDI.ino
 * Author:   Matthias Neeracher
 *
 * This code is in the public domain, with the exception of the contents of sVS1053b_Realtime_MIDI_Plugin.
 *
 * The code is based on Nathan Seidle's Sparkfun Electronics example code for the Sparkfun
 * MP3 Player and Music Instrument shields and and VS1053 breakout board.
 *
 * http://www.sparkfun.com/Code/MIDI_Example.pde
 * http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Dev/Arduino/Shields/VS_Shield_Example.zip
 *
 *      Spark Fun Electronics 2011
 *      Nathan Seidle
 *
 *      This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).
 *
 * THEORY OF OPERATIONS
 *
 * The VS1053b has two ways of playing MIDI: One method is that you simply send a Standard MIDI level 0 file through
 * SPI, and the chip will play it. This works exactly the same way as MP3 mode and will not be discussed further here.
 * The other method is that the VS1053b has a "Real Time MIDI mode", in which it will instantly execute MIDI commands
 * sent to it through either the UART or SPI.
 *
 * Real Time MIDI mode can be enabled with two different methods, controlled by USE_GPIO_INIT
 *  (1) Setting GPIO1 to HIGH (which is hardwired in the Sparkfun Music Instrument shield, and can be done through
 *      pin 4 in the MP3 Player Shield)
 *  (0) Sending a small software patch through SPI.
 *
 * MIDI data can be sent with two different methods as well, controlled by USE_SPI_MIDI
 *  (0) Through a (software) serial connection on pin 3, at 31250 baud
 *  (1) Through SPI, at an arbitrary data rate. For SPI, each byte of MIDI data needs to be prefixed by a 0 byte
 *      (The V1053b data sheet erroneously states that the padding should be a 0xFF byte).
 *
 * Both initialization methods and both transmission methods can be selected through the #defines below. Out of the box,
 * it probably makes most sense to enable real time MIDI through pin 4, and send serial data through pin 3, but if you
 * want to cut the traces for pin 3 and 4 and use those pins for another purpose, the alternative methods may come in
 * handy.
 */

#define USE_GPIO_INIT  1
#define USE_SPI_MIDI   0

#define USE_PATCH_INIT  !USE_GPIO_INIT
#define USE_SERIAL_MIDI !USE_SPI_INIT
#define USE_SPI         (USE_SPI_MIDI||USE_PATCH_INIT)

#if USE_SPI
#include <SPI.h>
#endif
#if USE_SERIAL_MIDI
#include <SoftwareSerial.h>
SoftwareSerial midiSerial(2,3); // Soft TX on 3, RX not used (2 is an input anyway, for VS_DREQ)
#endif

#if USE_SPI
#define VS_XCS    6 // Control Chip Select Pin (for accessing SPI Control/Status registers)
#define VS_XDCS   7 // Data Chip Select / BSYNC Pin
#define VS_DREQ   2 // Data Request Pin: Player asks for more data
#endif
#if USE_GPIO_INIT
#define VS_GPIO1  4  // Mode selection (0 = file / 1 = real time MIDI)
#endif

#define VS_RESET  8 //Reset is active low

#if USE_PATCH_INIT
//Write to VS10xx register
//SCI: Data transfers are always 16bit. When a new SCI operation comes in
//DREQ goes low. We then have to wait for DREQ to go high again.
//XCS should be low for the full duration of operation.
void VSWriteRegister(unsigned char addressbyte, unsigned char highbyte, unsigned char lowbyte){
  while(!digitalRead(VS_DREQ)) ; //Wait for DREQ to go high indicating IC is available
  digitalWrite(VS_XCS, LOW); //Select control

  //SCI consists of instruction byte, address byte, and 16-bit data word.
  SPI.transfer(0x02); //Write instruction
  SPI.transfer(addressbyte);
  SPI.transfer(highbyte);
  SPI.transfer(lowbyte);
  while(!digitalRead(VS_DREQ)) ; //Wait for DREQ to go high indicating command is complete
  digitalWrite(VS_XCS, HIGH); //Deselect Control
}

//
// Plugin to put VS10XX into realtime MIDI mode
// Originally from http://www.vlsi.fi/fileadmin/software/VS10XX/vs1053b-rtmidistart.zip
// Permission to reproduce here granted by VLSI solution.
//
const unsigned short sVS1053b_Realtime_MIDI_Plugin[28] = { /* Compressed plugin */
  0x0007, 0x0001, 0x8050, 0x0006, 0x0014, 0x0030, 0x0715, 0xb080, /*    0 */
  0x3400, 0x0007, 0x9255, 0x3d00, 0x0024, 0x0030, 0x0295, 0x6890, /*    8 */
  0x3400, 0x0030, 0x0495, 0x3d00, 0x0024, 0x2908, 0x4d40, 0x0030, /*   10 */
  0x0200, 0x000a, 0x0001, 0x0050,
};

void VSLoadUserCode(void) {
  int i = 0;

  while (i<sizeof(sVS1053b_Realtime_MIDI_Plugin)/sizeof(sVS1053b_Realtime_MIDI_Plugin[0])) {
    unsigned short addr, n, val;
    addr = sVS1053b_Realtime_MIDI_Plugin[i++];
    n = sVS1053b_Realtime_MIDI_Plugin[i++];
    while (n--) {
      val = sVS1053b_Realtime_MIDI_Plugin[i++];
      VSWriteRegister(addr, val >> 8, val & 0xFF);
    }
  }
}

#endif

void setup() {
#if USE_SPI
  pinMode(VS_DREQ, INPUT);
  pinMode(VS_XCS, OUTPUT);
  pinMode(VS_XDCS, OUTPUT);
  digitalWrite(VS_XCS, HIGH); //Deselect Control
  digitalWrite(VS_XDCS, HIGH); //Deselect Data
#endif
#if USE_SERIAL_MIDI
  midiSerial.begin(31250);
#endif

  pinMode(VS_RESET, OUTPUT);

  Serial.begin(57600); //Use serial for debugging
  Serial.println("\n******\n");
  Serial.println("MP3 Shield Example");

  //Initialize VS1053 chip
  digitalWrite(VS_RESET, LOW); //Put VS1053 into hardware reset

#if USE_SPI
  //Setup SPI for VS1053
  pinMode(10, OUTPUT); //Pin 10 must be set as an output for the SPI communication to work
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);

  //From page 12 of datasheet, max SCI reads are CLKI/7. Input clock is 12.288MHz.
  //Internal clock multiplier is 1.0x after power up.
  //Therefore, max SPI speed is 1.75MHz. We will use 1MHz to be safe.
  SPI.setClockDivider(SPI_CLOCK_DIV16); //Set SPI bus speed to 1MHz (16MHz / 16 = 1MHz)
  SPI.transfer(0xFF); //Throw a dummy byte at the bus
#endif

  delayMicroseconds(1);
  digitalWrite(VS_RESET, HIGH); //Bring up VS1053

#if USE_PATCH_INIT
  VSLoadUserCode();
#else
  pinMode(VS_GPIO1, OUTPUT);
  digitalWrite(VS_GPIO1, HIGH);  // Enable real time MIDI mode
#endif
}

void sendMIDI(byte data)
{
#if USE_SPI_MIDI
  SPI.transfer(0);
  SPI.transfer(data);
#else
  midiSerial.write(data);
#endif
}

//Plays a MIDI note. Doesn't check to see that cmd is greater than 127, or that data values are less than 127
void talkMIDI(byte cmd, byte data1, byte data2) {
#if USE_SPI_MIDI
  //
  // Wait for chip to be ready (Unlikely to be an issue with real time MIDI)
  //
  while (!digitalRead(VS_DREQ))
    ;
  digitalWrite(VS_XDCS, LOW);
#endif
  sendMIDI(cmd);
  //Some commands only have one data byte. All cmds less than 0xBn have 2 data bytes
  //(sort of: http://253.ccarh.org/handout/midiprotocol/)
  if( (cmd & 0xF0) <= 0xB0 || (cmd & 0xF0) >= 0xE0) {
    sendMIDI(data1);
    sendMIDI(data2);
  } else {
    sendMIDI(data1);
  }

#if USE_SPI_MIDI
  digitalWrite(VS_XDCS, HIGH);
#endif
}

//Send a MIDI note-on message.  Like pressing a piano key
//channel ranges from 0-15
void noteOn(byte channel, byte note, byte attack_velocity) {
  talkMIDI( (0x90 | channel), note, attack_velocity);
}

//Send a MIDI note-off message.  Like releasing a piano key
void noteOff(byte channel, byte note, byte release_velocity) {
  talkMIDI( (0x80 | channel), note, release_velocity);
}

void loop() {
  delay(1000);

  talkMIDI(0xB0, 0x07, 120); //0xB0 is channel message, set channel volume to near max (127)

#if 1
  //Demo Basic MIDI instruments, GM1
  //=================================================================
  Serial.println("Basic Instruments");
  talkMIDI(0xB0, 0, 0x00); //Default bank GM1

  //Change to different instrument
  for(int instrument = 0 ; instrument < 127 ; instrument++) {

    Serial.print(" Instrument: ");
    Serial.println(instrument, DEC);

    talkMIDI(0xC0, instrument, 0); //Set instrument number. 0xC0 is a 1 data byte command

    //Play notes from F#-0 (30) to F#-5 (90):
    for (int note = 30 ; note < 40 ; note++) {
      Serial.print("N:");
      Serial.println(note, DEC);

      //Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
      noteOn(0, note, 127);
      delay(200);

      //Turn off the note with a given off/release velocity
      noteOff(0, note, 127);
      delay(50);
    }

    delay(100); //Delay between instruments
  }
  //=================================================================
#endif

#if 0
  for(int instrument = 0 ; instrument < 1 ; instrument++) {
    for (int bank=0; bank<2; ++bank) {
      talkMIDI(0xB0, 0, bank ? 0x79 : 0);
      Serial.print("Bank: ");
      Serial.print(bank ? 0x79 : 0, DEC);
      Serial.print(" Instrument: ");
      Serial.println(instrument+1, DEC);

      talkMIDI(0xC0, instrument, 0);
      noteOn(0, 60, 127);
      noteOn(0, 63, 127);
      noteOn(0, 67, 127);
      delay(2000);

      //Turn off the note with a given off/release velocity
      noteOff(0, 60, 127);
      noteOff(0, 63, 127);
      noteOff(0, 67, 127);
      delay(100);
  }
  delay(5000);
}
#endif

#if 0
  //Demo GM2 / Fancy sounds
  //=================================================================
  Serial.println("Demo Fancy Sounds");
  talkMIDI(0xB0, 0, 0x78); //Bank select drums

  //For this bank 0x78, the instrument does not matter, only the note
  for(int instrument = 30 ; instrument < 31 ; instrument++) {

    Serial.print(" Instrument: ");
    Serial.println(instrument, DEC);

    talkMIDI(0xC0, instrument, 0); //Set instrument number. 0xC0 is a 1 data byte command

    //Play fancy sounds from 'High Q' to 'Open Surdo [EXC 6]'
    for (int note = 27 ; note < 87 ; note++) {
      Serial.print("N:");
      Serial.println(note, DEC);

      //Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
      noteOn(0, note, 127);
      delay(50);

      //Turn off the note with a given off/release velocity
      noteOff(0, note, 127);
      delay(50);
    }

    delay(100); //Delay between instruments
  }
#endif

#if 0
  //Demo Melodic
  //=================================================================
  Serial.println("Demo Melodic? Sounds");
  talkMIDI(0xB0, 0, 0x79); //Bank select Melodic
  //These don't sound different from the main bank to me

  //Change to different instrument
  for(int instrument = 27 ; instrument < 87 ; instrument++) {

    Serial.print(" Instrument: ");
    Serial.println(instrument, DEC);

    talkMIDI(0xC0, instrument, 0); //Set instrument number. 0xC0 is a 1 data byte command

    //Play notes from F#-0 (30) to F#-5 (90):
    for (int note = 30 ; note < 40 ; note++) {
      Serial.print("N:");
      Serial.println(note, DEC);

      //Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
      noteOn(0, note, 127);
      delay(500);

      //Turn off the note with a given off/release velocity
      noteOff(0, note, 127);
      delay(50);
    }

    delay(100); //Delay between instruments
  }
#endif
}
	/*
	*
	* File: MP3_Shield_RealtimeMIDI.ino
	* Author: Matthias Neeracher
	*
	* This code is in the public domain, with the exception of the contents of sVS1053b_Realtime_MIDI_Plugin.
	*
	* The code is based on Nathan Seidle's Sparkfun Electronics example code for the Sparkfun
	* MP3 Player and Music Instrument shields and and VS1053 breakout board.
	*
	* http://www.sparkfun.com/Code/MIDI_Example.pde
	* http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Dev/Arduino/Shields/VS_Shield_Example.zip
	*
	* Spark Fun Electronics 2011
	* Nathan Seidle
	*
	* This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).
	*
	* THEORY OF OPERATIONS
	*
	* The VS1053b has two ways of playing MIDI: One method is that you simply send a Standard MIDI level 0 file through
	* SPI, and the chip will play it. This works exactly the same way as MP3 mode and will not be discussed further here.
	* The other method is that the VS1053b has a "Real Time MIDI mode", in which it will instantly execute MIDI commands
	* sent to it through either the UART or SPI.
	*
	* Real Time MIDI mode can be enabled with two different methods, controlled by USE_GPIO_INIT
	* (1) Setting GPIO1 to HIGH (which is hardwired in the Sparkfun Music Instrument shield, and can be done through
	* pin 4 in the MP3 Player Shield)
	* (0) Sending a small software patch through SPI.
	*
	* MIDI data can be sent with two different methods as well, controlled by USE_SPI_MIDI
	* (0) Through a (software) serial connection on pin 3, at 31250 baud
	* (1) Through SPI, at an arbitrary data rate. For SPI, each byte of MIDI data needs to be prefixed by a 0 byte
	* (The V1053b data sheet erroneously states that the padding should be a 0xFF byte).
	*
	* Both initialization methods and both transmission methods can be selected through the #defines below. Out of the box,
	* it probably makes most sense to enable real time MIDI through pin 4, and send serial data through pin 3, but if you
	* want to cut the traces for pin 3 and 4 and use those pins for another purpose, the alternative methods may come in
	* handy.
	*/

	#define USE_GPIO_INIT 1
	#define USE_SPI_MIDI 0

	#define USE_PATCH_INIT !USE_GPIO_INIT
	#define USE_SERIAL_MIDI !USE_SPI_INIT
	#define USE_SPI (USE_SPI_MIDI\|\|USE_PATCH_INIT)

	#if USE_SPI
	#include <SPI.h>
	#endif
	#if USE_SERIAL_MIDI
	#include <SoftwareSerial.h>
	SoftwareSerial midiSerial(2,3); // Soft TX on 3, RX not used (2 is an input anyway, for VS_DREQ)
	#endif

	#if USE_SPI
	#define VS_XCS 6 // Control Chip Select Pin (for accessing SPI Control/Status registers)
	#define VS_XDCS 7 // Data Chip Select / BSYNC Pin
	#define VS_DREQ 2 // Data Request Pin: Player asks for more data
	#endif
	#if USE_GPIO_INIT
	#define VS_GPIO1 4 // Mode selection (0 = file / 1 = real time MIDI)
	#endif

	#define VS_RESET 8 //Reset is active low

	#if USE_PATCH_INIT
	//Write to VS10xx register
	//SCI: Data transfers are always 16bit. When a new SCI operation comes in
	//DREQ goes low. We then have to wait for DREQ to go high again.
	//XCS should be low for the full duration of operation.
	void VSWriteRegister(unsigned char addressbyte, unsigned char highbyte, unsigned char lowbyte){
	while(!digitalRead(VS_DREQ)) ; //Wait for DREQ to go high indicating IC is available
	digitalWrite(VS_XCS, LOW); //Select control

	//SCI consists of instruction byte, address byte, and 16-bit data word.
	SPI.transfer(0x02); //Write instruction
	SPI.transfer(addressbyte);
	SPI.transfer(highbyte);
	SPI.transfer(lowbyte);
	while(!digitalRead(VS_DREQ)) ; //Wait for DREQ to go high indicating command is complete
	digitalWrite(VS_XCS, HIGH); //Deselect Control
	}

	//
	// Plugin to put VS10XX into realtime MIDI mode
	// Originally from http://www.vlsi.fi/fileadmin/software/VS10XX/vs1053b-rtmidistart.zip
	// Permission to reproduce here granted by VLSI solution.
	//
	const unsigned short sVS1053b_Realtime_MIDI_Plugin[28] = { /* Compressed plugin */
	0x0007, 0x0001, 0x8050, 0x0006, 0x0014, 0x0030, 0x0715, 0xb080, /* 0 */
	0x3400, 0x0007, 0x9255, 0x3d00, 0x0024, 0x0030, 0x0295, 0x6890, /* 8 */
	0x3400, 0x0030, 0x0495, 0x3d00, 0x0024, 0x2908, 0x4d40, 0x0030, /* 10 */
	0x0200, 0x000a, 0x0001, 0x0050,
	};

	void VSLoadUserCode(void) {
	int i = 0;

	while (i<sizeof(sVS1053b_Realtime_MIDI_Plugin)/sizeof(sVS1053b_Realtime_MIDI_Plugin[0])) {
	unsigned short addr, n, val;
	addr = sVS1053b_Realtime_MIDI_Plugin[i++];
	n = sVS1053b_Realtime_MIDI_Plugin[i++];
	while (n--) {
	val = sVS1053b_Realtime_MIDI_Plugin[i++];
	VSWriteRegister(addr, val >> 8, val & 0xFF);
	}
	}
	}

	#endif

	void setup() {
	#if USE_SPI
	pinMode(VS_DREQ, INPUT);
	pinMode(VS_XCS, OUTPUT);
	pinMode(VS_XDCS, OUTPUT);
	digitalWrite(VS_XCS, HIGH); //Deselect Control
	digitalWrite(VS_XDCS, HIGH); //Deselect Data
	#endif
	#if USE_SERIAL_MIDI
	midiSerial.begin(31250);
	#endif

	pinMode(VS_RESET, OUTPUT);

	Serial.begin(57600); //Use serial for debugging
	Serial.println("\n******\n");
	Serial.println("MP3 Shield Example");

	//Initialize VS1053 chip
	digitalWrite(VS_RESET, LOW); //Put VS1053 into hardware reset

	#if USE_SPI
	//Setup SPI for VS1053
	pinMode(10, OUTPUT); //Pin 10 must be set as an output for the SPI communication to work
	SPI.begin();
	SPI.setBitOrder(MSBFIRST);
	SPI.setDataMode(SPI_MODE0);

	//From page 12 of datasheet, max SCI reads are CLKI/7. Input clock is 12.288MHz.
	//Internal clock multiplier is 1.0x after power up.
	//Therefore, max SPI speed is 1.75MHz. We will use 1MHz to be safe.
	SPI.setClockDivider(SPI_CLOCK_DIV16); //Set SPI bus speed to 1MHz (16MHz / 16 = 1MHz)
	SPI.transfer(0xFF); //Throw a dummy byte at the bus
	#endif

	delayMicroseconds(1);
	digitalWrite(VS_RESET, HIGH); //Bring up VS1053

	#if USE_PATCH_INIT
	VSLoadUserCode();
	#else
	pinMode(VS_GPIO1, OUTPUT);
	digitalWrite(VS_GPIO1, HIGH); // Enable real time MIDI mode
	#endif
	}

	void sendMIDI(byte data)
	{
	#if USE_SPI_MIDI
	SPI.transfer(0);
	SPI.transfer(data);
	#else
	midiSerial.write(data);
	#endif
	}

	//Plays a MIDI note. Doesn't check to see that cmd is greater than 127, or that data values are less than 127
	void talkMIDI(byte cmd, byte data1, byte data2) {
	#if USE_SPI_MIDI
	//
	// Wait for chip to be ready (Unlikely to be an issue with real time MIDI)
	//
	while (!digitalRead(VS_DREQ))
	;
	digitalWrite(VS_XDCS, LOW);
	#endif
	sendMIDI(cmd);
	//Some commands only have one data byte. All cmds less than 0xBn have 2 data bytes
	//(sort of: http://253.ccarh.org/handout/midiprotocol/)
	if( (cmd & 0xF0) <= 0xB0 \|\| (cmd & 0xF0) >= 0xE0) {
	sendMIDI(data1);
	sendMIDI(data2);
	} else {
	sendMIDI(data1);
	}

	#if USE_SPI_MIDI
	digitalWrite(VS_XDCS, HIGH);
	#endif
	}

	//Send a MIDI note-on message. Like pressing a piano key
	//channel ranges from 0-15
	void noteOn(byte channel, byte note, byte attack_velocity) {
	talkMIDI( (0x90 \| channel), note, attack_velocity);
	}

	//Send a MIDI note-off message. Like releasing a piano key
	void noteOff(byte channel, byte note, byte release_velocity) {
	talkMIDI( (0x80 \| channel), note, release_velocity);
	}

	void loop() {
	delay(1000);

	talkMIDI(0xB0, 0x07, 120); //0xB0 is channel message, set channel volume to near max (127)

	#if 1
	//Demo Basic MIDI instruments, GM1
	//=================================================================
	Serial.println("Basic Instruments");
	talkMIDI(0xB0, 0, 0x00); //Default bank GM1

	//Change to different instrument
	for(int instrument = 0 ; instrument < 127 ; instrument++) {

	Serial.print(" Instrument: ");
	Serial.println(instrument, DEC);

	talkMIDI(0xC0, instrument, 0); //Set instrument number. 0xC0 is a 1 data byte command

	//Play notes from F#-0 (30) to F#-5 (90):
	for (int note = 30 ; note < 40 ; note++) {
	Serial.print("N:");
	Serial.println(note, DEC);

	//Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
	noteOn(0, note, 127);
	delay(200);

	//Turn off the note with a given off/release velocity
	noteOff(0, note, 127);
	delay(50);
	}

	delay(100); //Delay between instruments
	}
	//=================================================================
	#endif

	#if 0
	for(int instrument = 0 ; instrument < 1 ; instrument++) {
	for (int bank=0; bank<2; ++bank) {
	talkMIDI(0xB0, 0, bank ? 0x79 : 0);
	Serial.print("Bank: ");
	Serial.print(bank ? 0x79 : 0, DEC);
	Serial.print(" Instrument: ");
	Serial.println(instrument+1, DEC);

	talkMIDI(0xC0, instrument, 0);
	noteOn(0, 60, 127);
	noteOn(0, 63, 127);
	noteOn(0, 67, 127);
	delay(2000);

	//Turn off the note with a given off/release velocity
	noteOff(0, 60, 127);
	noteOff(0, 63, 127);
	noteOff(0, 67, 127);
	delay(100);
	}
	delay(5000);
	}
	#endif

	#if 0
	//Demo GM2 / Fancy sounds
	//=================================================================
	Serial.println("Demo Fancy Sounds");
	talkMIDI(0xB0, 0, 0x78); //Bank select drums

	//For this bank 0x78, the instrument does not matter, only the note
	for(int instrument = 30 ; instrument < 31 ; instrument++) {

	Serial.print(" Instrument: ");
	Serial.println(instrument, DEC);

	talkMIDI(0xC0, instrument, 0); //Set instrument number. 0xC0 is a 1 data byte command

	//Play fancy sounds from 'High Q' to 'Open Surdo [EXC 6]'
	for (int note = 27 ; note < 87 ; note++) {
	Serial.print("N:");
	Serial.println(note, DEC);

	//Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
	noteOn(0, note, 127);
	delay(50);

	//Turn off the note with a given off/release velocity
	noteOff(0, note, 127);
	delay(50);
	}

	delay(100); //Delay between instruments
	}
	#endif

	#if 0
	//Demo Melodic
	//=================================================================
	Serial.println("Demo Melodic? Sounds");
	talkMIDI(0xB0, 0, 0x79); //Bank select Melodic
	//These don't sound different from the main bank to me

	//Change to different instrument
	for(int instrument = 27 ; instrument < 87 ; instrument++) {

	Serial.print(" Instrument: ");
	Serial.println(instrument, DEC);

	talkMIDI(0xC0, instrument, 0); //Set instrument number. 0xC0 is a 1 data byte command

	//Play notes from F#-0 (30) to F#-5 (90):
	for (int note = 30 ; note < 40 ; note++) {
	Serial.print("N:");
	Serial.println(note, DEC);

	//Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
	noteOn(0, note, 127);
	delay(500);

	//Turn off the note with a given off/release velocity
	noteOff(0, note, 127);
	delay(50);
	}

	delay(100); //Delay between instruments
	}
	#endif
	}