Lerne in diesem Tutorial, wie du einen Piezo mit deinem Arduino verbindest und Töne in verschiedenen Höhen ausgibst.

Aktiver vs. Passiver Piezo

Es gibt zwei Arten von Piezos: Aktive – hier wird einfach nur Strom angelegt, damit sie einen einzigen vordefinierten Ton abgeben. Passive: Diese Piezos eignen sich hingegen, verschiedene Töne, also auch Melodien zu erzeugen.

Wenn du also mehr als nur einen einzigen Ton erzeugen möchtest, achte darauf, dir einen passiven Piezo zuzulegen. Im Folgenden sprechen wir ausschließlich über passive Piezos.

Den Piezo am Arduino anschließen

Da dein Piezo nur über zwei Pins verfügt, benötigst du auch nur zwei Kabel, um ihn an deinem Arduino anzuschließen. Schließe zunächst einen der Pins – welcher ist egal – an GND an. Den anderen Pin verbindest du mit einem Digitalpin des Arduinos. Im folgenden Aufbau ist das Pin 9:

Und das war auch schon alles. Zeit für etwas Musik!

Mit der Funktion tone() Töne erzeugen

Um Töne und Melodien mit verschieden langen Noten zu spielen, benötigst du nur die Funktion tone(). Du kannst auf diese Funktion direkt in deiner Arduino IDE zugreifen und musst hierfür nichts installieren oder vorbereiten.

Die Funktion rufst du immer mit mindestens zwei Parametern auf: dem Pin, an dem der Piezo angeschlossen ist und die Tonhöhe in Hertz.

Wenn dein Piezo also wie oben zu sehen an Digitalpin 9 angeschlossen ist und du den Kammerton A mit seinen 440 Hertz spielen möchtest, wäre der Code hierfür

tone(9, 440);

Dein Piezo spielt diesen Ton dann so lange, bis er den Befehl erhält, etwas anderes zu tun – z.B. einen anderen Ton auszugeben.

Du hast allerdings die Möglichkeit, die Tonlänge direkt über einen dritten Parameter vorzugeben. Soll der Piezo den Ton A genau 1000 Millisekunden spielen, trägst du folgendes in deinen Sketch ein:

tone(9, 440, 1000);

Wenn du deinen Piezo ganz ausschalten möchtest, erreichst du das ganz einfach mit der Funktion noTone().

noTone(9);

Noten und Melodien spielen

Jeder Note entspricht eine bestimmte Frequenz. Wie du oben gesehen hast, ist die Frequenz des Kammertons A genau 440Hz. Das A in der nächsten Oktave hat die Frequenz 880Hz.

Eine sehr umfangreiche Sammlung von Tönen und ihren entsprechenden Frequenzen findest du hier auf Github.

Zu jeder guten Melodie gehören auch Pausen. Diese kannst du wie gewohnt mit der Funktion delay() zwischen die Töne setzen.

Instrumente bauen

Natürlich ist es eine Sache, alle Töne und ihre Abfolge im Sketch vorzugeben und dann abspielen zu lassen. Spannender wird es jedoch, wenn du sie selbst spontan nach deinen Wünschen spielen kannst – also ein richtiges Instrument baust.

Hier findest du zwei Arduino Projekte, mit denen du deinen Arduino als Instrument verwenden kannst:

Arduino Orgel aus Überraschungseiern

Arduino Theremin mit A-Moll Pentatonik

In diesem Projekt baust du dir eine Orgel, die du spielst, indem du Überraschungseier berührst. Du benötigst hierfür nur ein paar Widerstände, Kabel und ein ganz besonders wichtiges “Bauteil”: deinen eigenen Körper.

Mithilfe der Bibliothek CapacitiveSensor misst du die elektrische Kapazität deines Körpers. Wenn du eines der Überraschungseier (bzw. dessen Aluminiumfolie) berührst, steigt der gemessene Wert und du kannst darauf basierend einen Ton abspielen. Dieses Projekt lässt dir viel Spielraum für Experimente: Du kannst verschiedene Widerstände verwenden und mit dem Schwellenwert der gemessenen Daten herumspielen. Mit der richtigen Kombination musst du die Überraschungseier nicht mal mehr berühren – dann näherst du nur deine Hand und die Arduino Orgel fängt an zu spielen.

Für dieses Projekt benötigst du:

• 5 Überraschungseier
• 5 Widerstände 1MΩ oder 10MΩ
• Lautsprecher oder Piezo-Summer*
• Arduino, Breadboard & Kabel

*Amazon Affiliate Links: Wenn du dort bestellst, erhalten wir eine kleine Provision.

Der Aufbau der Arduino Orgel

Deine Orgel kannst du in wenigen Minuten aufbauen. In dem folgenden Schaubild sind die 5 violetten Kabel für die Überraschungseier vorgesehen. Stecke ihre Enden einfach durch die Folie ins Ei – bei Bedarf kannst du sie mit etwas Kleber an der Aluminiumfolie fixieren. Du kannst natürlich auch jede andere Folie oder fünf Metallkörper verwenden, wenn du keine Überraschungseier zur Hand hast, oder sie schon aufgegessen hast.

Noch ein Hinweis: Wenn du einen Lautsprecher statt eines Piezo-Summers verwendest, benötigst du noch einen Widerstand im Bereich von 100Ω. Diesen steckst du zwischen Pin 11 und dem Lautsprecher, um zu verhindern, dass dein Arduino Schaden nimmt.

Der passende Sketch

Bevor du loslegen kannst, benötigst du die Bibliothek CapacitiveSensor von Paul Badger. Falls diese noch nicht bei dir installiert ist, kannst du das über den Bibliotheksverwalter in deiner Arduino IDE nachholen. Weitere Informationen zu dieser Bibliothek und ihrer Funktionen findest du im Arduino Playground (Englisch).

Zunächst bindest du die Bibliothek in deinem Sketch ein und definierst den Pin für den Lautsprecher und ein paar Variablen:

#include <CapacitiveSensor.h>
#define speaker 11

int sensitivity = 3000;
int threshold = 5000;

Die Variable sensitivity legt fest, wie viele Samples für die Messung verwendet werden. Theoretisch je mehr, desto besser – aber du solltest mit dem Wert etwas herumspielen, damit du die für deine “Orgeltasten” passende Einstellung findest.

Das gilt auch für die Variable threshold. Hier legst du fest, welcher Messwert überschritten werden muss, damit ein Ton abgespielt wird. Die passende Einstellung findest du, indem du die Werte in deinem Seriellen Monitor beobachtest, während du die Arduino Orgel spielst.

Als nächstes definierst du die Pins, an denen deine Überraschungseier hängen:

CapacitiveSensor   cs_2_4 = CapacitiveSensor(2, 4);
CapacitiveSensor   cs_2_5 = CapacitiveSensor(2, 5);
CapacitiveSensor   cs_2_6 = CapacitiveSensor(2, 6);
CapacitiveSensor   cs_2_7 = CapacitiveSensor(2, 7);
CapacitiveSensor   cs_2_8 = CapacitiveSensor(2, 8);

Wie du im schematischen Aufbau oben siehst, hängt jeden Überraschungsei am Digitalpin 2. Über diesen Pin wird die Messung gestartet. Jedes Ei hat jedoch seinen eigenen Pin für den Eingang der Messwerte – die Digitalpins 4 bis 8.

In der Funktion void setup() startest du nur den Seriellen Monitor mit einer Baudrate deiner Wahl.

Im Loop spielt die Musik

In der Funktion void loop() führst du zunächst für jedes Überraschungsei eine Messung durch. Die Zahl der Samples steht in der Variable sensitivity. Die Ergebnisse speicherst du in den Variablen sensor4 bis sensor8.

___STEADY_PAYWALL___

  long sensor4 =  cs_2_4.capacitiveSensor(sensitivity);
  long sensor5 =  cs_2_5.capacitiveSensor(sensitivity);
  long sensor6 =  cs_2_6.capacitiveSensor(sensitivity);
  long sensor7 =  cs_2_7.capacitiveSensor(sensitivity);
  long sensor8 =  cs_2_8.capacitiveSensor(sensitivity);

Diese 5 Sensorwerte gibst du im Seriellen Monitor (Code im gesamten Sketch unten) aus, damit du dort einen passenden Wert für die Variable threshold findest. Wenn du ein Überraschungsei berührst, schnellt der Wert nach oben, aber wie weit nach oben hängt vom Material ab und muss deshalb individuell von dir geprüft werden.

Hast du einen Wert gefunden, kannst du mit der Musik loslegen:

  if (sensor4 > threshold) tone(speaker, 440); // A
  if (sensor5 > threshold) tone(speaker, 523); // C
  if (sensor6 > threshold) tone(speaker, 587); // D
  if (sensor7 > threshold) tone(speaker, 659); // E
  if (sensor8 > threshold) tone(speaker, 784); // G

Über die Funktion tone() spielst du eine bestimmte Frequenz über den Piezo-Summer ab. Im Prinzip stehen dir hier alle möglichen Töne zur Verfügung, in diesem Projekt verwenden wir jedoch die A-Moll Pentatonik – also die Töne A – C – D – E – G. Der Clou: Damit hört sich fast alles einigermaßen gut an, auch wenn du kein geübter Musiker bist.

Zuletzt brauchst du noch eine Abfrage, wann dein Piezo-Summer still sein soll – nämlich wenn du gerade kein Überraschungsei berührst. Auch hier kommt wieder die Variable threshold zum Einsatz.

if (sensor4 <= threshold  &  sensor5 <= threshold & sensor6 <= threshold  &  sensor7 <= threshold &  sensor8 <= threshold) {
    noTone(speaker);
}

Und das sollte es gewesen sein. Wie gesagt, das Finetuning deiner Arduino Orgel wird dich noch etwas Zeit kosten, aber dann kannst du loslegen!

Hier der gesamte Sketch:

/*
  Arduino Organ by pollux labs, 2020
  More procects and tutorials: https://polluxlabs.net
*/

// Import the CapacitiveSensor Library.
#include <CapacitiveSensor.h>

//Define speaker pin
#define speaker 11

//Set sensor sensitivity
int sensitivity = 3000;

//Set threshold for triggering a tone
int threshold = 5000;

// Set the Send Pin & Receive Pin.
CapacitiveSensor   cs_2_4 = CapacitiveSensor(2, 4);
CapacitiveSensor   cs_2_5 = CapacitiveSensor(2, 5);
CapacitiveSensor   cs_2_6 = CapacitiveSensor(2, 6);
CapacitiveSensor   cs_2_7 = CapacitiveSensor(2, 7);
CapacitiveSensor   cs_2_8 = CapacitiveSensor(2, 8);

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  // Set the sensitivity of the sensors
  long sensor4 =  cs_2_4.capacitiveSensor(sensitivity);
  long sensor5 =  cs_2_5.capacitiveSensor(sensitivity);
  long sensor6 =  cs_2_6.capacitiveSensor(sensitivity);
  long sensor7 =  cs_2_7.capacitiveSensor(sensitivity);
  long sensor8 =  cs_2_8.capacitiveSensor(sensitivity);

  Serial.print(sensor4);
  Serial.print("\t");
  Serial.print(sensor5);
  Serial.print("\t");
  Serial.print(sensor6);
  Serial.print("\t");
  Serial.print(sensor7);
  Serial.print("\t");
  Serial.println(sensor8);

  // When your hand touches the sensor, the speaker will produce a tone.
  // Probably you'll have to experiment with the threshold.
  if (sensor4 > threshold) tone(speaker, 440); // A
  if (sensor5 > threshold) tone(speaker, 523); // C
  if (sensor6 > threshold) tone(speaker, 587); // D
  if (sensor7 > threshold) tone(speaker, 659); // E
  if (sensor8 > threshold) tone(speaker, 784); // G

  // When nothing is touched the speaker is quiet
  if (sensor4 <= threshold  &  sensor5 <= threshold & sensor6 <= threshold  &  sensor7 <= threshold &  sensor8 <= threshold) {
    noTone(speaker);
  }

  delay(10);
}

Wie geht es weiter?

Wenn dich Musikmachen mit dem Arduino interessiert, probiere doch noch ein anderes Instrument aus: Ein Arduino Theremin, das ebenfalls die A-Moll Pentatonik verwendet.

Fehlen dir noch Bauteile? Dann wirf einen Blick in unsere Übersicht der besten Arduino Starter Kits.

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):

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

27,90 €

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

3,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.; ...

9,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;

//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);
}