C02 Der passive Piezo-Lautsprecher
Passive Buzzer Module

Auditive Ausgabe

Wie der aktive Piezo erzeugt der passive Piezo einfache Töne. Sie werden beide in Druckern, Computern oder Spielzeugen verbaut.

Die Tonvielfalt ist beim aktiven Piezo auf nur einen Ton begrenzt, ist aber einfach anzusteuern. Im Gegensatz dazu haben wir mit dem passiven Piezo mehr Programmieraufwand, können aber eine große Bandbreite an Tönen erzeugen.

 

Spezifikationen
- Working voltage: 3.3-5v
- Signalart: Digital
- Pinabstand: 2.54mm

Eines sollte ich hier vorab erwähnen: akustische Meisterwerke können wir mit Piezos nicht erzeugen. Die Piep-Töne erinnern eher an antike Computerspiele der 80er Jahre. Trotzdem kann es Töne erzeugen, die hervorragend für akustische Signale geeignet sind. Es funktioniert nach dem gleichen Grundprinzip eines Lautsprechers, in dem es durch Elektroimpulse Schall erzeugen kann: Eine Membran (aus Keramik) wird durch Elektrosignale hin- und herbewegt, die wiederum Luftmoleküle zum Schwingen bringt und Schallwellen erzeugt.

 

Der Aufbau

Verbinde dein Arduino mithilfe der Jumper Wire mit dem Modul:

 
 

Der Sketch: Töne mit for-Schleifen erzeugen

Der Sketch simuliert das Auf und Ab einer Sirene. Kopiere den unteren Sketch, füge ihn in die Arduino IDE ein und lade ihn auf das Arduino-Board rauf.

/********************************************************
C02 Der passive Piezo-Lautsprecher
Der Minimal-Sketch
Mr Robot UXSD / www.mrrobotuxsd.com
*********************************************************/

int piezoPin = 7;  //Pin-Nummer des Piezo

int cycles = 1500; //Anzahl der Schleifen um den Ton zu erzeugen


void setup() 
{
  pinMode(piezoPin, OUTPUT);  //den Piezo als OUTPUT deklarieren
}

void loop() 
{
  //die erste for-schleife erzeugt einen Ton, der höher wird
  //Die Schleife fängt ab 500 an und zählt bis cycles=1500
  for(int i = 500; i < cycles; i++) 
  {
    digitalWrite(piezoPin, HIGH); //Piezo einschalten
    delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
    
    digitalWrite(piezoPin, LOW);//Piezo ausschalten
    delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
  }


  //die zweite for-schleife erzeugt einen Ton, der tiefer wird
  //Die Schleife fängt ab cycles=1500 an und zählt bis 500 runter
  for(int i = cycles; i > 500; i--)
  {
    digitalWrite(piezoPin, HIGH); //Piezo einschalten
    delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
    
    digitalWrite(piezoPin, LOW);//Piezo ausschalten
    delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
  }

}
 

Der Sketch im Detail

Der erste Schritt besteht darin dem Piezo einem Pin zuzuordnen. Ich habe in meinem Aufbau den Piezo in Pin 3 eingesteckt. Dem Pin 3 ordnen wir nun die Variable piezoPin zu. Ab da an können wir statt der Zahl 3 die Variable piezoPin benutzen. Das hat den Vorteil, dass wir zentral an einer Stelle die Zahl ändern können und es wird im ganzen Programm aktualisiert. Die Alternative wäre dazu, an jeder Stelle wo der Piezo auftaucht die Zahl 3 einzutragen. Bei einem langen Programm kann das zu viel Arbeit führen und bildet eine potenzielle Fehlerquelle.

Die zweite Variable cyles bezieht sich auf die Länge des Tones, die wir erzeugen. Insgesamt sind es zwar 1500 Schritte, aber wir starten erst ab dem Wert 500. In Wirklichkeit benutzen wir also 1000 Schritte. 

int piezoPin = 7;  //Pin-Nummer des Piezo
int cycles = 1500; //Anzahl der Schleifen um den Ton zu erzeugen
 

Im void setup() wird der Pin 3 (piezoPin) mithilfe der pinMode()-Funktion als OUTPUT deklariert.

void setup() 
{
  pinMode(piezoPin, OUTPUT);  //den Piezo als OUTPUT deklarieren
}
 

Innerhalb von void loop() benützen wir zwei for-Schleifen, um den Ton zu erzeugen. Der erste zählt den Wert für den Ton hoch. Die for-Schleife besteht aus 3 Teilen: im ersten teilen wir dem Arduino mit, dass wir mit i=500 ab dem Wert 500 beginnen möchten - das ist der Startpunkt. Mit i<cycles geben wir an, dass der Wert bis 1500 (cycles=1500) hochgezählt werden und dann stoppen soll. Der i++ Teil des Schleifenkopfes gibt an, dass wir in Einer-Schritten hochzählen wollen. 

void loop() 
{
  //die erste for-schleife erzeugt einen Ton, der höher wird
  //Die Schleife fängt ab 500 an und zählt bis cycles=1500
  for(int i = 500; i < cycles; i++) 
  {
    ...//Schleifen-Inhalt
  }
  ...
 

Im Schleifen-Körper wird der Piezo sehr schnell ein- und ausgeschaltet. Unterschiedliche Pausen zwischen den Ein- und Aus-Zuständen erzeugen verschiedene Töne. Mit digitalWrite(piezoPin, HIGH) und digitalWrite(piezoPin, LOW) schalten wir den Piezo ein/aus und pausieren diesen Zustand in delayMicroseconds(i) für die Dauer von i. Da die Variable i in jedem Schleifen-Durchgang sich verändert, wird hier jedes Mal ein unterschiedlicher Wert platziert.
Die delayMicroseconds()-Funktion ist dir vielleicht neu. Beachte, dass es sich NICHT um Millisekunden handelt, sondern um Mikrosenkunden. Wir erinnern uns: 1000 Millisekunden sind eine Sekunde. In diesem Fall sind 1000 Mikrosekunden eine Millisekunde. Eine Millisekunde wird also in tausend Teile zerteilt. Es handelt sich um eine viel höhere Auflösung.

void loop() 
{
  //die erste for-schleife erzeugt einen Ton, der höher wird
  //Die Schleife fängt ab 500 an und zählt bis cycles=1500
  for(int i = 500; i < cycles; i++) 
  {
    digitalWrite(piezoPin, HIGH); //Piezo einschalten
    delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
    
    digitalWrite(piezoPin, LOW);//Piezo ausschalten
    delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
  }
  ...
 

Die zweite Schleife zählt den Wert von 1500 wieder runter auf 500. Auch dieser Schleifenkörper besteht aus 3 Teilen: im ersten teilen wir dem Arduino mit, dass wir mit i=cycles ab dem Wert 1500 beginnen möchten. Mit i>cycles geben wir an, dass der Wert bis 500 runtergezählt werden soll. Der i-- Teil des Schleifenkopfes gibt an, dass wir in Einer-Schritten runterzählen wollen. 

//die zweite for-schleife erzeugt einen Ton, der tiefer wird
//Die Schleife fängt ab cycles=1500 an und zählt bis 500 runter
for(int i = cycles; i > 500; i--)
{
 ...//Schleifen-Inhalt
}

Im Schleifen-Körper wird der Piezo sehr schnell ein- und ausgeschaltet – mit dem Unterschied, dass wir nun in delayMicroseconds() mit einem hohen Wert (1500) beginnen. Mit digitalWrite(piezoPin, HIGH) und digitalWrite(piezoPin, LOW) schalten wir den Piezo ein/aus und pausieren diesen Zustand in delayMicroseconds(i) für die Dauer von i. 

//die zweite for-schleife erzeugt einen Ton, der tiefer wird
//Die Schleife fängt ab cycles=1500 an und zählt bis 500 runter
for(int i = cycles; i > 500; i--)
{
  digitalWrite(piezoPin, HIGH); //Piezo einschalten
  delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
    
  digitalWrite(piezoPin, LOW);//Piezo ausschalten
  delayMicroseconds(i);  //Pausen in Microsekunden gemäß cycles
}
 
 

Falls du die hier beschriebenen Elektronik-Module nicht hast kannst du sie in meiner Einkaufsliste finden. Warum ich selber hauptsächlich mit Modulen der Marke Keyestudio arbeite erläutere ich unter diesem Blog-Artikel.

In dieser Übersicht äußere ich Empfehlungen aller Art.

Hier kommst du wieder zur Übersicht aller Module.