Arduino MIDI Synth

Overview

This projects uses the MIDI protocol to send musical notes via USB-HID connection to a computer, where it can be used to play virtual instruments.

Ingredients

• Arduino Micro
• 74HC165N
• Push Buttons
• Resistors: 1 kΩ
• Breadboard
• Wires
• USB cable

Arduino Micro

The Micro is a microcontroller board based on the ATmega32U4, developed in conjunction with Adafruit. It has 20 digital input/output pins (of which 7 can be used as PWM outputs and 12 as analog inputs), a 16 MHz crystal oscillator, a micro USB connection, an ICSP header, and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a micro USB cable to get started. It has a form factor that enables it to be easily placed on a breadboard. The Micro board is similar to the Arduino Leonardo in that the ATmega32U4 has built-in USB communication, eliminating the need for a secondary processor. This allows the Micro to appear to a connected computer as a mouse and keyboard, in addition to a virtual (CDC) serial / COM port.

Source: https://store.arduino.cc/arduino-micro

Serial Connection

According to the documentation for the official Arduino Pro Micro:

Serial: 0 (RX) and 1 (TX). Used to receive (RX) and transmit (TX) TTL serial data using the ATmega32U4 hardware serial capability. Note that on the Micro, the Serial class refers to USB (CDC) communication; for TTL serial on pins 0 and 1, use the Serial1 class.

Therefore, to send the data over the TTL serial connection via digital pins 0 and 1, we should use the following commands:

void setup(){ 
    Serial1.begin(9600);
}

void loop(){ 
    Serial1.print("HelloWorld");
}

This will be relevant in the later section, when we will send native MIDI commands via serial connection directly to a hardware MIDI instrument.

74HC165N

The SN74HC165N is an 8-bit parallel-load or serial-in shift registers with complementary serial outputs available from the last stage. When the parallel load (PL) input is LOW, parallel data from the D0 to D7 inputs are loaded into the register asynchronously. When PL is HIGH, data enters the register serially at the Ds input and shifts one place to the right (Q0 → Q1 → Q2, etc.) with each positive-going clock transition. This feature allows parallel-to-serial converter expansion by tying the Q7 output to the DS input of the succeeding stage. Source: https://playground.arduino.cc/Code/ShiftRegSN74HC165N

To provide a maximum of 32 inputs (synth keys), 4 shift registers will be used, connected in a serial chain. The connections are the same as in the photo below except the number of shift registers. The output from the first stage is connected to the serial input of the next stage and the output of the last stage is connected to the Arduino. In this example, 13 push buttons will be used to represent all the notes with an addition of the octave (12 semitones + 1 octave).

Board Layout

The board was tested using the Arduino sketch found on the shift-register Arduino tutorial page (link above) and was confirmed working.

MIDI

MIDI Serial:

https://github.com/FortySevenEffects/arduino_midi_library/

MIDI USB:

https://www.arduino.cc/en/Tutorial/MidiDevice

MIDI note names -> note values

http://newt.phys.unsw.edu.au/jw/notes.html

MIDI serial output

https://www.youtube.com/watch?v=rmfAqg9O_os&t=0s&list=PL4_gPbvyebyH2xfPXePHtx8gK5zPBrVkg&index=6

MIDI Synth V1 Arduino sketch (MIDI USB only)

// include MIDI library
#include "MIDIUSB.h"
#include "PitchToNote.h"

// MIDI FUNCTIONS
void noteOn(byte channel, byte pitch, byte velocity) {
midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};
MidiUSB.sendMIDI(noteOn);
}

void noteOff(byte channel, byte pitch, byte velocity) {
midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};
MidiUSB.sendMIDI(noteOff);
}

// How many shift register chips are daisy-chained.
#define NUMBER_OF_SHIFT_CHIPS 4

// Width of data (how many ext lines).
#define DATA_WIDTH NUMBER_OF_SHIFT_CHIPS * 8

// Width of pulse to trigger the shift register to read and latch.
#define PULSE_WIDTH_USEC 5

// Optional delay between shift register reads.
#define POLL_DELAY_MSEC 1

#define BYTES_VAL_T unsigned long // was int before!!

long ploadPin = 8; // Connects to Parallel load pin the 165
long clockEnablePin = 9; // Connects to Clock Enable pin the 165
long dataPin = 11; // Connects to the Q7 pin the 165
long clockPin = 12; // Connects to the Clock pin the 165

BYTES_VAL_T pinValues;
BYTES_VAL_T oldPinValues;

/* This function is essentially a "shift-in" routine reading the
* serial Data from the shift register chips and representing
* the state of those pins in an unsigned integer (or long).
*/
BYTES_VAL_T read_shift_regs()
{
long bitVal;
BYTES_VAL_T bytesVal = 0;

// Trigger a parallel Load to latch the state of the data lines,
digitalWrite(clockEnablePin, HIGH);
digitalWrite(ploadPin, LOW);
delayMicroseconds(PULSE_WIDTH_USEC);
digitalWrite(ploadPin, HIGH);
digitalWrite(clockEnablePin, LOW);

// Loop to read each bit value from the serial out line
// of the SN74HC165N.
for(int i = 0; i < DATA_WIDTH; i++)
{
bitVal = digitalRead(dataPin);

// Set the corresponding bit in bytesVal.
bytesVal |= (bitVal << ((DATA_WIDTH-1) - i));

// Pulse the Clock (rising edge shifts the next bit).
digitalWrite(clockPin, HIGH);
delayMicroseconds(PULSE_WIDTH_USEC);
digitalWrite(clockPin, LOW);
}

return(bytesVal);
}

void setup()
{
//Serial.begin(9600);

// Initialize our digital pins...
pinMode(ploadPin, OUTPUT);
pinMode(clockEnablePin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, INPUT);

digitalWrite(clockPin, LOW);
digitalWrite(ploadPin, HIGH);

// Read in and display the pin states at startup.
pinValues = read_shift_regs();
oldPinValues = pinValues;
}

void loop()
{
// Read the state of all zones.
pinValues = read_shift_regs();

// If there was a chage in state, display which ones changed.
if(pinValues != oldPinValues)
{
for(int i = 0; i < DATA_WIDTH; i++){

int old = bitRead(oldPinValues, i);
int nou = bitRead(pinValues, i);

if(nou > old){
noteOn(0, 48+i+12, 64);
MidiUSB.flush();
continue;
}
else if(nou < old){
noteOff(0, 48+i+12, 64);
MidiUSB.flush();
continue;
}
}

oldPinValues = pinValues;
}
delay(POLL_DELAY_MSEC);
}