loading

Made by Søren Østergaard Petersen, OEAAM16EDA

This instructable describes an arduino based MIDI controller. This is a school project. By using your hand you can play simple melodies via the MIDI connection and a connected MIDI instrument (or as in this case a notebook running a softsynth software). You can play notes from a C major scale, c-d-e-f-g-a-b-c. To be able to connect the MIDI controller to a notebook, you will need a MIDI to USB interface like m-audio Uno .

Step 1: Demonstration Video

Turn up the volume and enjoy !

How it works:

The MIDI controller uses an Arduino MEGA 2560 board. Two light (LDR) sensors built into 16mm electrical tube form a double sensor system and are used for creating a stable trigger without any false double triggering. A flashlight is creating a light beam, when the beam is interrupted by the hand playing the controller, the lower light sensor senses the missing beam, and a HC-SR04 ultrasonic sensor measures the distance from sensor to hand.

The distance measured is used in the Arduino program for calculating and setting up the appropriate note number value to be packed into a MIDI Note On message and transmittet on the MIDI interface. The MIDI output interface uses a 74HC14 hex inverter and is pretty much a standard circuit. MIDI communication uses serial1, the standard serial port is used for debugging.

When the hand is moved straight up and away from the light beam, the upper light sensor senses the light beam again and a MIDI Note Off message is packed and transmittet on the MIDI output.

The playing area between the sensors is around 63cm, and the total length of the MIDI controller is around 75cm.

Step 2: Details of the Light Sensors

The two light sensors are mounted on top of each other to form a double sensor system. It prevents false triggering when used correct in the software. Each light sensor consists of a photo resistor module built into a 16 mm standard electrical tube. A slot is made in each tube with a hacksaw and the photo resistor PCB can be pressed into the slot. The sensors are taped together with duct tape and also fixed to one end of a piece of wood. No light must be able to reach the sensors from behind.The light sensors has built in 10k pull-up resistors.

Step 3: Details of the HC-SR04 Ultrasonic Sensor

The HC-SR04 ultra sonic sensor is fixed in the other end of the MIDI controller. A bright flashlight is placed here too, it creates the necessary light beam.

Step 4: The Aduino Circuit

The MIDI output circuit is basically a standard 74HC14 hex inverter and a few resistors plus a 5 pin DIN female connector. The 74HC14 circuit drives the MIDI output and at the same time provide some means of protection for the Arduino board against the "real world" connected to MIDI out. An extra practical feature is the MIDI activity LED that signals when data is sent.

I have used a proper prototype PCB for my hardware because I had a lot of problems with bad connections on my breadboard. The schematic is made in Fritzing, a high resolution pdf copy can be downloaded by pressing the link below. I prefer using a proper schematics program like Kicad, I think Fritzing is to limited for anything but the simplest experiments.

Materials used:

1 pcs Arduino MEGA 2560

2 pcs Photo resistor (LDR) with built-in pull up resistor (from 37 sensor kit)

1 pcs HC-SR04 ultrasonic sensor

1 pcs 74HC14 hex inverting Schmitt trigger

2 pcs resistor 220 Ohm 0.25W

1 pcs resistor 1k Ohm 0.25W

1 pcs LED low current 2mA

1 pcs 100nF ceramic capacitor (for power supply decoupling, directly at the 74HC14's power pins)

Breadboard or prototype PCB

2 pcs 16mm electrical tube, length 65mm

1 pcs of wood, length 75cm

Duct tape

Wires

Step 5: I/O Listing

Step 6: The Aduino Code

The sketch test_Midi6 uses the NewPing library which you must include in your Arduino programming enviroment, to use the HC-SC04 ultrasonic sensor. The sketch is commented in danish, sorry.. To keep the sketch well-structured, seperate functions are made up for different logic parts of the sketch and global variables are mostly avoided. The programflow is visualized in the MIDI controller flowchart pdf.

//  15-05-2017 version : test_Midi6
//  Søren Østergaard Petesen
//  Arduino MEGA 2560
//  Dette program udgør en simpel MIDI controller som kan styre en ekstern MIDI enhed, f.eks en softsynt på en PC.
//  MIDI controlleren kan sende toneanslag (note on kommando) hhv. (note off kommando) for en oktav C-C, C dur skala.
//  Der spilles med en "karate hånd" på et brædt
//  hvor sensorerne er monteret. MIDI kommandoerne trigges af en dobbelt LDR sensor, da der skal laves en sikker
//  detektering af både når hånden lander på brættet (note on), samt når hånden fjernes igen (note off).
//  MIDI kommandoerne "note on" og "note off" består hver af 3 bytes som sendes på serial1 porten
//  vha det i hardware opbyggede MIDI interface.
//  Tonehøjden bestemmes vha ultralydssensor HC-SR04

#include <NewPing.h>    // bibliotek til den anvendte ultralydssensor HC-SR04
#define TRIGGER_PIN  3    // Arduino pin til trigger pin på ultrasonic sensor
#define ECHO_PIN     2    // Arduino pin til echo pin på ultrasonic sensor
#define MAX_DISTANCE  100 // Maximum afstand for Ping
#define Median 5          // Antal målinger der beregnes gennemsnit af for at få en sikker afstandsbestemmelse

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // Creating the NewPing Object.

int Senspin1 = 53;        //Underste LDR1 føler
int Senspin2 = 52;        //Øverste LDR2 føler

byte MIDIByte2;           //Variabel deklaration for MIDIByte2
bool klar_note_on = 1;    //Variabel deklaration for klar_note_on, styrer afsendelse af note on kommando.Første kommando er en note on kommando
bool klar_note_off = 0;   //Variabel deklaration for klar_note_off, styrer afsendelse af note off kommando


void setup() {
  pinMode(Senspin1, INPUT); // sæt sensor input
  pinMode(Senspin2, INPUT); // sæt sensor input
  Serial1.begin(31250);     // Serial1 bruges til MIDI kommunikation: 31250 bit/sekundt
  Serial.begin(9600);       //serial monitor, til test
}

void loop()
{
  bool Sensor1 = digitalRead(Senspin1); //Læs LDR1 - underte LDR
  bool Sensor2 = digitalRead(Senspin2); //læs LDR2 - øverste LDR
  if (Sensor1 && klar_note_on) //hvis LDR1 aktiveret og klar til note on
  {
    byte Note_Byte = Hent_tonehojde();      //Hent tone højde via ultralyds sensor
    MIDIByte2 = Hent_MidiByte2(Note_Byte); // Hent MidByte2, MIDI note number, værdien 0xFF er out of range
    Send_Note_On(MIDIByte2);      // kald Send_Note_On funktion
    klar_note_on = 0;             // der skal kun sendes en note on kommando
    klar_note_off = 1;            // næste kommando er note off
  }
  if (Sensor2 && !Sensor1 && klar_note_off) // Hvis der skal sendes note off kommando gøres det her..
  {
    Send_Note_Off(MIDIByte2);   // send note off kommando
    klar_note_off = 0;  // der skal kun sendes en note off kommando
  }
  if (!Sensor1  && !Sensor2 ) // her gøres klar til ny note on kommando, hånd er væk fra brædt
  {
    klar_note_on = 1;
  }
}


byte Hent_MidiByte2(byte NoteByte) { // Denne funktion returnerer MIDI note number, valgt ud fra NoteByte
  byte MIDIB2;
  switch (NoteByte)   // her defineres hvilken værdi MIDIByte2 skal have ud fra værdien af Note_Byte
  {
    case 0: {
        MIDIB2 = 0x3C;  // tonen 'C'
      }
      break;
    case 1: {
        MIDIB2 = 0x3E;  // tonen 'D'
      }
      break;
    case 2: {
        MIDIB2 = 0x40;  // tonen 'E'
      }
      break;
    case 3: {
        MIDIB2 = 0x41;  // tonen 'F'
      }
      break;
    case 4: {
        MIDIB2 = 0x43;  // tonen 'G'
      }
      break;
    case 5: {
        MIDIB2 = 0x45;  // tonen 'A'
      }
      break;
    case 6: {
        MIDIB2 = 0x47;  // tonen 'B'
      }
      break;
    case 7: {
        MIDIB2 = 0x48;  // tonen 'C'
      }
      break;
    default: {
        MIDIB2 = 0xFF; // out of range
      }
  }
  return MIDIB2;      //returner MIDI note number
}

byte Hent_tonehojde() {   //Denne funktion henter resultatet af ultralydsmålingen
  unsigned int Tid_uS;    // målt tid i uS
  byte Afstand;           // beregnet afstand i cm
  byte resultat;          // inddeling af spille område
  const float Omregningsfaktor = 58.3; // 2*(1/343 m/s)/100 = 58,3uS/cm, der ganges med 2 da tiden er summen af tiden frem og tilbage.
  Tid_uS = sonar.ping_median(Median); // Send ping, få tid retur i uS, gennemsint af Median målinger
  Afstand = Tid_uS / Omregningsfaktor;  // Omregn tid til afstand i cm (0 = outside distance range)
  resultat = Afstand / 8; //Beregn resultat
  return resultat;        //Returner resultat
}

void Send_Note_On(byte tonenr) { //Denne funktion sender en note on kommando på MIDI interfacet
  const byte kommando = 0x90;   //Note on kommando på MIDI kanal 1
  const byte volumen = 0xFF;    // volumen / Velocity = 127
  Serial1.write(kommando);      //send note on kommando
  Serial1.write(tonenr);        //send tone nummer
  Serial1.write(volumen);       //send volumen (velocity)
}

void Send_Note_Off(byte tonenr) {//Denne funktion sender note off kommando på MIDI interfacet
  const byte kommando = 0x80;    //Note off kommando på MIDI kanal 1
  const byte volumen = 0xFF;     // volumen / Velocity = 127
  Serial1.write(kommando);       //send note off kommando
  Serial1.write(tonenr);         //send tone nummer
  Serial1.write(volumen);        //send volumen (velocity)
}



Step 7: The Basics of MIDI Communication

MIDI (Musical Instrument Digital Interface) is a universal serial communication protocol for interfacing electronic musical instruments and other devices. Serial communication is used (31250 bit/s, transmission medium is a current loop, opto-isolated at the receiver end. 5pin DIN connectors are used. 16 logical communication channels are possible in one physical MIDI connection. Many commands are defined in the MIDI standard, I use two commands in this project, these commands consists of 3 bytes:

a) Note On command:

1. byte send = 0x90 meaning note on command on MIDI channel 1

2. byte send = 0xZZ ZZ is note number, I use the range 0x3C to 0x48

3. byte send =0xFF FF = 255 meaning max volume, range 0x00 to 0xFF

b) Note Off command:
1. byte send = 0x80 meaning note off command on MIDI channel 1

2. byte send = 0xZZ ZZ is note number, I use the range 0x3C to 0x48

3. byte send =0xFF FF = 255 meaning max volume, range 0x00 to 0xFF

<p>That's a fun instrument :) Do you have the code to upload to step 6?</p>
<p>Yes I have, I'm stil trying to find a way to post it so it will be readable..</p>

About This Instructable

205views

3favorites

License:

More by SorenPet:EAL - Arduino MIDI Controller 
Add instructable to: