In diesem Projekt lernst du, wie du ein einfaches Arduino Theremin mit einem Piezo-Summer und dem Ultraschall-Sensor HC-SR04 baust. Aber nicht nur das – damit auch ungeübte Musiker ihre Freunde begeistern können, spielt dieses Theremin nur Töne innerhalb einer von dir festgelegten Tonleiter.

Im Folgenden verwenden wir die beliebte A-Moll Pentatonik als Beispiel. Du kannst aber auch jede andere Tonleiter definieren und verwenden. Mehr dazu später.

Anfänger

1 – 2 Stunden

ca. 10 € plus ggfs. Kosten für den Arduino Uno

Für dieses Projekt benötigst du (Mengen s. Beschreibung):

Angebot

Arduino UNO Rev3 [A000066] - All-in-One Mikrocontroller-Board für Elektroniklernen und Prototyping

29,99 €

AZDelivery Ultraschall Modul Kompatibel mit HC-SR04 Entfernungsmesser Sensor kompatibel mit Arduino und Raspberry Pi inklusive E-Book!

Ultraschall Entfernungsmessung von 2 cm bis zu 3 m auf ca. 3 mm genau; Maße...

5,29 €

AZDelivery KY-006 Passives Piezo Buzzer Alarm Modul kompatibel mit Arduino und Raspberry Pi inklusive eBook!

Piezoelektrischer Buzzer (passiv); Betriebsspannung 5 V

4,49 €

AZDelivery Breadboard Kit - 3X Jumper Wire m2m/f2m/f2f + 3er Set MB102 Breadboard kompatibel mit Raspberry Pi inklusive E-Book!

Steckbrett für schnellen Aufbau elektronischer Schaltungen mit 830 Kontakten.; ...

10,99 €

Der Aufbau des Arduino Theremins

Du musst nur zwei Bauteile auf deinem Breadboard montieren und mit deinem Arduino verbinden: Den Piezo-Summer und den Ultraschall-Sensor. Ersteren verbindest du mit dem Digitalpin 3 und mit Erde. Beim Ultraschall-Sensor verbindest du zunächst VCC mit Plus und GND mit Minus. Anschließend verbindest du den Ausgang TRIG mit dem Digitalpin 5 und ECHO mit dem Digitalpin 4 an deinem Arduino.

So funktioniert dein Theremin

Dieses Projekt funktioniert eigentlich ganz simpel: Der Ultraschall-Sensor HC-SR04 misst die Entfernung zu einem Objekt, z.B. zu deiner Hand. Diese Entfernung rechnest du in Tonhöhen um, die du über den Piezo-Summer ausgibst.

Da hier natürlich alle möglichen Entfernungen in einem bestimmten Bereich möglich sind, gibt es auch alle möglichen Töne – auch welche, die in klassischen Tonleitern nicht vorkommen. Deshalb sucht sich der folgende Sketch immer den nächsttieferen Ton in der A-Moll Pentatonik heraus. So spielst du kinderleicht ansprechende Melodien!

Der passende Sketch für Musiker

Zunächst legst du ein paar Variablen fest, die du später mit Leben füllst:

//Arduino Pins für den Ultraschall-Sensor
int trigger = 5;
int echo = 4;
int distance = 0;

//Pin des Piezo-Summers
const int piezo = 3;

//Variablen für die Bestimmung der Reichweite
int distance = 0;
int distanceHigh = 0;

//Variable für die Anzahl der Töne in der Tonleiter
int lengthOfScale = 0;

//Variable für die zu spielende Note
int note = 0;

Danach folgt ein Array, in dem die Töne der A-Moll Pentatonik stecken – genauer gesagt, welche Frequenzen (in Hertz) du mit deinem Piezo-Summer ausgibst. Das sind immer wieder die Töne A – C – D – E – G in verschiedenen Oktaven.

int scale[] = {
  147, 165, 196, 220, 262, 294, 330, 392, 440,
  523, 587, 659, 784, 880, 1047, 1175, 1319, 1568,
  1760, 2093, 2349
};

Auf Github findest du eine mehr oder weniger vollständige Liste aller Töne und ihrer Frequenzen.

Die Setup-Funktion

Hier startest du zunächst den Seriellen Monitor und legst die PinModes für die Pins des Ultraschall-Sensors fest. Dann kommt der erste interessante Teil des Sketchs: Dein Sensor hat eine theoretische Reichweite von 2cm bis 4m – die Reichweite, in der du spielst, wird aber vermutlich geringer sein.

Deshalb kalibrierst du den Sensor in den ersten fünf Sekunden nach dem Start. Das heißt, du bestimmst, wie weit weg deine Hand vom Sensor sein wird. Hierfür bewegst du deine Hand vor dem Sensor langsam circa 40-50cm weg. Die größte Entfernung speicherst du dann in die Variablen distanceHigh. Diese benötigst du später wieder.

void setup() {
  Serial.begin (9600);
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);

  while (millis() < 5000) {

    //Der Sensor misst die Entfernung
    digitalWrite(trigger, HIGH);
    digitalWrite(trigger, LOW);
    distance = pulseIn(echo, HIGH);
    Serial.println(distance);

    //Größte Entfernung speichern
    if (distance > distanceHigh) {
      distanceHigh = distance;
    }
  }
}

Hinweis: Um genau zu sein, misst der HC-SR04 nicht direkt die Entfernung, sondern nur wie lange ein ausgesendetes Ultraschall-Signal benötigt, um von einem Hindernis (deine Hand) wieder im Sensor einzutreffen. In diesem Tutorial erfährst du, wie du die Entfernung in cm messen kannst.

Jetzt musst du noch ermitteln, wie viele Töne sich in der Tonleiter, also im Array scale[] befinden. Das machst du folgendermaßen:

for (byte i = 0; i < (sizeof(scale) / sizeof(scale[0])); i++) {
  lengthOfScale += 1;
}

Der Loop

Hier spielt die Musik. Im Loop lässt du deinen Ultraschall-Sensor immer wieder die Entfernung zu deiner Hand messen. Je nachdem wie weit sie von ihm entfernt ist, erklingt ein anderer Ton. Zentral ist hierbei folgende Funktion:

note = map(distance, 250, distanceHigh, scale[0], scale[lengthOfScale - 1]);

Mithilfe der Funktion map() kannst du eine Zahl aus einem Bereich einem anderen Bereich zuordnen. In diesem Projekt „mapst“ du die aktuelle Entfernung deiner Hand (distance) auf eine bestimmte Tonfrequenz.

Hierfür sind zwei Bereiche notwendig: Die aktuelle Entfernung deiner Hand liegt im Bereich der minimalen (legst du auf 250 fest) und maximalen (distanceHigh) Entfernung deiner Hand, die du in der Kalibrierung zu Beginn festgelegt hast. Der zweite Bereich wird vom tiefsten Ton (also die Position 0 im Array scale[]) und dem höchsten Ton (ermittelst du mit scale[lengthOfScale – 1]) deiner Pentatonik im Array scale[] begrenzt.

Die Entfernung deiner Hand wird also in unserem konkreten Fall einer Zahl zwischen 147 und 2349 zugeordnet und in der Variablen note gespeichert.

In der Arduino-Referenz erfährst du mehr über die Funktion map().

Den richtigen Ton treffen

Bis jetzt hast du nur einen Frequenzbereich, in der die Note liegt. Dein Arduino Theremin soll aber keine ungenauen Zwischentöne spielen, sondern nur Noten der A-Moll Pentatonik. Hierfür benötigst du einen Loop und ein paar Abfragen:

    for (byte j = 0; j < (lengthOfScale); j++) {

    if (note == scale[j]) {
      tone(piezo, note);
      break;
    }
    else if (note > scale[j] && note < scale[j + 1]) {
      note = scale[j];
      tone(piezo, note);
      break;
    }
  }

Im For-Loop fragst du für jede Note des Arrays scale[] ab, ob du deine Hand schon in der richtigen Entfernung und die Note somit genau getroffen hast. In diesem Fall spielst du sie über die Funktion tone() mit deinem Piezo-Summer ab.

Falls nicht, fragst du im ersten else if, ob dein gespielter Ton zwischen zwei Noten steckt. Wenn das so ist, spielst du einfach die niedrigere von beiden.

Zu kompliziert? Ein Beispiel: Deine Hand hat eine Entfernung zum Sensor, die du mithilfe der Funktion map() auf eine Frequenz von 200 Hertz umgerechnet hast. Das ist aber keine Note der A-Moll Pentatonik, sondern liegt irgendwo zwischen einem G und einem Gis. Der nächsttiefere, richtige Ton ist laut deinem Array ein G mit 196 Hertz. Und den spielt dein Theremin dann.

Und das war’s! Schalte dein Arduino Theremin ein, kalibriere es und lass die Fetzen fliegen.

Hier nun der gesamte Sketch:

/*
   Arduino Theremin with A minor pentatonic scale
   pollux labs, 2020
   All rights reserved.
*/

const int trigger = 5;
const int echo = 4;

const int piezo = 3;

int distance = 0;
int distanceHigh = 0;

int lengthOfScale = 0;

int note = 0;

//A Minor pentatonic scale
int scale[] = {
  147, 165, 196, 220, 262, 294, 330, 392, 440,
  523, 587, 659, 784, 880, 1047, 1175, 1319, 1568,
  1760, 2093, 2349
};

//C Major scale
//int scale[] = {
//  131, 147, 165, 175, 196, 220, 247, 262, 294,
//  330, 349, 392, 440, 494, 523, 587, 659, 698,
//  784, 880, 988, 1047
//};


void setup() {
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);

  while (millis() < 5000) {
    digitalWrite(trigger, HIGH);
    digitalWrite(trigger, LOW);
    distance = pulseIn(echo, HIGH);

    if (distance > distanceHigh) {
      distanceHigh = distance;
    }
  }

  for (byte i = 0; i < (sizeof(scale) / sizeof(scale[0])); i++) {
    lengthOfScale += 1;
  }
}

void loop() {
  digitalWrite(trigger, HIGH);
  digitalWrite(trigger, LOW);

  distance = pulseIn(echo, HIGH);

  note = map(distance, 250, distanceHigh, scale[0], scale[lengthOfScale - 1]);

  for (byte j = 0; j < (lengthOfScale); j++) {

    if (note == scale[j]) {
      tone(piezo, note);
      break;
    }
    else if (note > scale[j] && note < scale[j + 1]) {
      note = scale[j];
      tone(piezo, note);
      break;
    }
  }
  delay(30);
}

Aufbau & Funktion

Der Sensor HC-SR04 ist schnell aufgebaut und angeschlossen:

Versorge ihn am Pin VCC von deinem Arduino aus mit 5V und lege die Erde an Gnd.

Dann verbindest du einen Digitalausgang mit dem Trigger (Trig am Sensor) und einen weiteren mit dem Pin Echo.

Der Ultraschallsensor funktioniert ganz simpel: Er bekommt ein Signal (oder eben Trigger) und sendet eine Ultraschallwelle aus. Diese wird dann von dem Objekt oder Hindernis vor dem Sensor reflektiert und vom HC-SR04 wieder empfangen.

Dein Arduino misst nur die Zeit, die zwischen Senden und Empfangen vergangen ist. In deinem Code rechnest du diese Zeitspanne dann in die Entfernung um. Fertig!

Übrigens: Mit dem Sensor kannst du Entfernungen zwischen 2cm und circa 4 Metern messen – ein ganz schönes Stück also.

Hier findest du ein Datenblatt zum HC SR04.

Der Code für den HC-SR04

Du musst nicht viel programmieren, um den HC-SR04 in Gang zu setzen.

Definiere erst einmal ein paar Variablen:

int trigger=7; 
int echo=6; 
long zeit=0; 
long entfernung=0; 

Hier legst du zunächst fest, dass die Sensorpins Trig und Echo am Arduino mit den Digitalpins 6 und 7 verbunden sind.

Außerdem brauchst du eine Variable für die Zeit, die zwischen Senden und Empfangen verstrichen ist und eine weitere für die Entfernung, die du hieraus berechnest.

In der Setup-Funktion startest du den Seriellen Monitor und legst die pinModes fest: Der Trigger ist ein OUTPUT, das Echo ein INPUT:

void setup(){
Serial.begin (9600); 
pinMode(trigger, OUTPUT); 
pinMode(echo, INPUT);}

Die Entfernung messen

Jetzt geht es ans Eingemachte. Du startest die Messung mit einer Schallwelle, misst die Zeit bis zu ihrer Rückkehr zum Sensor und berechnest die Entfernung.

void loop(){

digitalWrite(trigger, HIGH); 
delay(10);
digitalWrite(trigger, LOW);

zeit = pulseIn(echo, HIGH); 

entfernung = (zeit/2) * 0.03432;

Serial.print(entfernung); 
Serial.println(" cm"); 

delay(1000);}

Zunächst setzt du den Trigger für 10 Millisekunden auf HIGH und anschließend wieder auf LOW. Damit sendest du die Schallwelle aus.

Mit der Funktion pulseIn() misst du die Zeit, bis die Schallwelle wieder im Sensor eintrifft und speicherst diese in der Variable zeit.

Mit der Variable entfernung machst du folgendes: Du teilst zunächst die vergangene Zeit durch 2 – denn du möchtest ja nur die Wegstrecke vom Sensor bis zum Hindernis messen. Anschließend multiplizierst du diese Zeit mit der Schallgeschwindigkeit in Zentimeter pro Mikrosekunde.

Nun gibst du nur noch die berechnete Entfernung in deinem Seriellen Monitor aus und limitierst die Messungen per delay() auf eine pro Sekunde.

Hier kommt der vollständige Code:

int trigger=7; 
int echo=6; 
long zeit=0; 
long entfernung=0; 

void setup(){
Serial.begin (9600); 
pinMode(trigger, OUTPUT); 
pinMode(echo, INPUT); 
}

void loop(){
digitalWrite(trigger, HIGH); 
delay(10);
digitalWrite(trigger, LOW);

zeit = pulseIn(echo, HIGH); 

entfernung = (zeit/2) * 0.03432; 

Serial.print(entfernung); 
Serial.println(" cm"); 

delay(1000);
}

In welchen Projekten kannst du den Ultraschallsensor HC SR04 verwenden? Zum Beispiel in einem Fahrzeug, das Hindernissen ausweichen kann. Oder doch nur ganz einfach, um den Abstand zu einem Objekt zu messen.

In diesem Projekt lernst du, wie du dein eigenes Arduino Theremin baust. Oder doch ein anderer Sensor? Hier lernst du auch, wie du mit dem VL52L0X am Arduino Entfernungen misst.