MIDI Based Theremin using a Raspberry Pi

This is a simple guide to build an electronic musical instrument. The MIDI notes are generated using a Raspberry Pi and a sonar sensor. Although the original Theremin is played using antennas, this one will use sonar technology as pitch control. The idea is to vary the distance between the user hand and the distance sensor, causing the pitch to change accordingly.

How will the measured distance (dist) translate to pitch?

This is done in the get_note() method.

def get_note(dist=0):
    """ Compute the note based on the distance measurements, get percentages of each scale and compare """
    # Config
    # you can play with these settings
    minDist = 3    # Distance Scale
    maxDist = 21
    octaves = 1
    minNote = 48   # c4 middle c
    maxNote = minNote + 12*octaves
    # Percentage formula
    fup = (dist - minDist)*(maxNote-minNote)
    fdown = (maxDist - minDist)
    note = minNote + fup/fdown
    """ To-do: calculate trends form historical data to get a smoother transitions """
    return int(note)

Like any other musical instrument, this one will translate a user action to sound. In this case the user changes the distance between the HC-SR04 sensor and an object (hand) producing a sound. The idea is to equally distribute the amount of notes through the distance scale, resulting in a playable area.

This is done using proportions. When dist = minDist the resulting note will be minNote. The same way is done on the other end of the scale. This enables the software to define the relation between the distance and the steps for each note in a function form. This function is evaluated every time a distance (dist) is measured.

It is assumed that the proportion of the measured distance (dist) should be equal to the proportion of the generated note (note).

$noteProportion  = distProportion$

Each proportion can be calculated using simple fractions.

$distProportion = \frac{dist - minDist}{maxDist - minDist}$

$noteProportion = \frac{note - minNote}{maxNote - minNote}$

The resulting formula to calculate the note.

$note\left ( dist \right ) = minNote + \frac{\left (dist - minDist\right )\times \left (maxNote - minNote\right )}{maxDist - minDist}$

NOTE: This is just one approach to define the interface of this instrument. Add-ons and changes can be made in order to get many different effects in the way this is played.

Just run or download the following code.

# Derick DeLeon
# 2014-02
# theremin.py
"""MIDI based theremin using a Raspberry Pi and a sonar HC-SR04 as pitch control"""
"""derickdeleon.com"""

import RPi.GPIO as GPIO
import pygame.midi
import time

# Distance Related Methods

def prepare(GPIO_ECHO, GPIO_TRIGGER):
    """ Initialize the Raspberry Pi GPIO  """
    # Set pins as output and input
    GPIO.setup(GPIO_TRIGGER,GPIO.OUT)    # Trigger
    GPIO.setup(GPIO_ECHO,GPIO.IN)        # Echo
    # Set trigger to False (Low)
    GPIO.output(GPIO_TRIGGER, False)
    # Allow module to settle
    time.sleep(0.5)

def get_distance(GPIO_ECHO, GPIO_TRIGGER):
    """ get the distance from the sensor, echo - the input from sensor """
    # Send 10us pulse to trigger
    GPIO.output(GPIO_TRIGGER, True)
    time.sleep(0.00001)
    GPIO.output(GPIO_TRIGGER, False)
    start = time.time()
    # Taking time
    while GPIO.input(GPIO_ECHO)==0:
        start = time.time()
    while GPIO.input(GPIO_ECHO)==1:
        stop = time.time()
    # Calculate pulse length
    elapsed = stop-start
    # Distance pulse travelled in that time is time
    # multiplied by the speed of sound (cm/s)
    distance = elapsed * 34300
    # That was the distance there and back so halve the value
    distance = distance / 2
    return distance

# Audio and MIDI Related Methods

def conf_midi():
    """ Initialize MIDI component """
    instrument = 79 # Whistle
    pygame.init()
    pygame.midi.init()
    port = 2
    global midiOutput   # It is used in other methods
    midiOutput = pygame.midi.Output(port, 1)
    midiOutput.set_instrument(instrument)

def play_midi(note, b4note, volume):
    """ Play a new MIDI note and turn off the last one """
    # use the last note to compare
    if (note != b4note):
        """ To-Do: smoother transitions between notes, use pitch bend. """
        midiOutput.note_off(b4note,volume)
        midiOutput.note_on(note,volume)
    # help to not consume all resources
    time.sleep(.15)

def get_note(dist=0):
    """ Compute the note based on the distance measurements, get percentages of each scale and compare """
    # Config
    # you can play with these settings
    minDist = 3    # Distance Scale
    maxDist = 21
    octaves = 1
    minNote = 48   # c4 middle c
    maxNote = minNote + 12*octaves
    # Percentage formula
    fup = (dist - minDist)*(maxNote-minNote)
    fdown = (maxDist - minDist)
    note = minNote + fup/fdown
    """ To-do: calculate trends form historical data to get a smoother transitions """
    return int(note)

# MAIN
GPIO.setwarnings(False)
# The pin number is the actual pin number
GPIO.setmode(GPIO.BCM)
# Set up the GPIO channels
trigger = 17
echo = 27
prepare(echo, trigger)
note = 0
conf_midi()
volume = 127
try:
    while True:
        b4note = note
        # get distance
        d = get_distance(echo, trigger)
        # calculate note
        note = get_note(d)
        # to-do, take a number of sample notes and average them, or any other statistical function. eg. Play just minor notes, ponderate average, etc. 
        # play the note
        play_midi(note, b4note, volume)
except KeyboardInterrupt:
    GPIO.cleanup()
    del midiOutput
    pygame.midi.quit()
GPIO.cleanup()
pygame.midi.quit()

Here's a sound sample of the MIDI Theremin in action or download from here:

Please see my previous posts for detailed information on wiring and operation.

MIDI and the Raspberry Pi
Distance sensor working on a Raspberry Pi

---

Please visit and thanks to:

Thanks to Matt Hawkins for his help.
http://www.raspberrypi-spy.co.uk/2012/12/ultrasonic-distance-measurement-using-python-part-1/
http://macduino.blogspot.mx/2013/11/HC-SR04-part1.html

Theremin Wiki

General MIDI Instrument Chart

A nice story about theremins in pop culture: The Real Instrument Behind The Sound In 'Good Vibrations'