Wenn wir den Arduino verwenden, wollen wir manchmal Komponenten einsetzen, die eine höhere Spannung als 5 V benötigen. Hier kommen MOSFETs ins Spiel.
Bevor wir jedoch zu diesem Thema übergehen, wollen wir uns mit der Erzeugung von Klängen beschäftigen. Wir haben bereits einfache akustische Signale erzeugt, jetzt ist es an der Zeit, etwas Abwechslung hineinzubringen. So wird es möglich sein, eine Alarmsirene zu bauen.
Bestellen Sie ein Set mit Elementen und beginnen Sie mit dem Lernen in der Praxis! Hier gehts zum Shop >>
In der ersten Stufe des Arduino-Kurses haben wir mit einem Summer, der einen eingebauten Generator hatte, Töne erzeugt. Dieses Bauteil funktionierte sehr einfach: Wenn es mit Strom versorgt wurde, erzeugte es einen Dauerton, oder besser gesagt ein lautes Piepen. Das lag daran, dass der Hersteller einen Generator eingebaut hat, der das Bauteil, das den Ton erzeugt, in schnelle Schwingungen versetzt.
Beispiel eines Summertons mit einem Generator – softwaregesteuerte Ein- und Ausschaltung.
Wir werden uns nun mit dem Summer ohne Generator beschäftigen. Der Name dieses Bauteils sagt schon viel aus. Diesmal müssen wir, um etwas zu hören, selbst das entsprechende Signal liefern. Wie du wahrscheinlich schon vermutet hast, wird die Änderung dieses Signals (vor allem die Frequenz) den Klang beeinflussen.
Der auf dem obigen Foto gezeigte Summer unterscheidet sich nicht von demjenigen mit dem Generator. Man kann leicht zwei identisch aussehende Summer finden, die sich in ihrem Innenleben unterscheiden.
In den meisten Fällen unterscheidet sich ein Summer mit Generator optisch nicht
von einem ohne Generator.
Ob ein Bauteil mit einem Generator ausgestattet ist, lässt sich am einfachsten anhand seiner Dokumentation überprüfen. Wenn wir diese nicht besitzen, können wir sie an eine niedrige Spannung (3-5 V) anschließen. Im Falle eines eingebauten Generators hören wir ein kontinuierliches Piepen, ansonsten passiert praktisch nichts.
Der große Vorteil von Summern ohne Generator ist, dass sie in einem großen Spannungsbereich betrieben werden können. Im Falle des vorliegenden Modells kann es in Schaltkreisen mit einer Spannung von 1 bis 40 V verwendet werden.
Es ist Zeit, zu den praktischen Übungen überzugehen!
Fertige Sets für Forbot-Kurse
Die Komponenten für die Übungen aus dem Arduino-Kurs (Stufe 2) sind als fertige Sets erhältlich! Darin enthalten sind programmierbare Dioden, analoge und digitale Thermometer, 7-Segment-Anzeigen und ein Bewegungssensor (PIR).
Anschließen des Summers ohne Generator an einen Arduino
Wir beginnen mit dem einfachsten Anschluss, nämlich direkt an die Pins unseres Controllers. Dies ist möglich, weil der Summer sehr wenig Strom zieht und den Ausgang des Mikrocontrollers nicht beschädigt.
Wie angekündigt, verbinden wir:
- die erste Leitung des Summers mit GND,
- die zweite mit dem Arduino-Ausgang, z.B. A5.
Ein Summer ohne Generator ist kein polares Bauteil (wir können ihn frei anschließen). Um des Prinzips willen und zu meiner eigenen Beruhigung empfehle ich jedoch, sich an die anerkannten Standards zu halten und das schwarze Kabel mit der Masse zu verbinden.
Anschluss der Schaltung für den Test:
Erster Test des Summers ohne Generator
Zunächst wollen wir prüfen, was passiert, wenn wir den Summer so verwenden, wie wir es aus den vorherigen Übungen kennen, d.h. so, als ob er einen Generator hätte. Dazu ändern wir einfach den Zustand des Ausgangs:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
digitalWrite(A5, LOW); //Zyklische Änderung des Ausgangszustands
delay(1000);
digitalWrite(A5, HIGH);
delay(1000);
}
Wenn wir einen Summer mit einem Generator verwenden, hören wir laute Pieptöne mit einer Dauer von einer Sekunde. Dieses Mal sind jedoch nur leise „Pieptöne“ zu hören. Außerdem dauern sie nicht eine Sekunde. Der Ton ist kurz und ertönt nur, wenn sich der Zustand des Anschlusses ändert.
Das liegt daran, dass sich bei einer Änderung der Versorgungsspannung die Platte im Inneren des Summers verformt. Durch die Vibration dieses Teils wird der Ton erzeugt.
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
digitalWrite(A5, LOW); //Zyklische Änderung des Ausgangszustands
delay(100);
digitalWrite(A5, HIGH);
delay(100);
}
Funktionsweise der Schaltung in der Praxis:
Wie erwartet, wird der Ton nun häufiger ausgegeben. Wir können also die Änderungsrate noch weiter erhöhen:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
digitalWrite(A5, LOW); //Zyklische Änderung des Ausgangszustands
delay(10);
digitalWrite(A5, HIGH);
delay(10);
}
Funktionsweise des Systems in der Praxis:
Diesmal geschieht etwas Seltsames – wir hören bereits deutlich einen anderen Klang. Wenn man einen Schritt weiter geht, kann man das Programm mit einer Verzögerung von z.B. 1 ms testen. Ich überlasse dies jedoch denjenigen, die dies tun möchten.
Natürlich ist die Tonerzeugung mit der Funktion delay nicht bequem. Man muss bedenken, dass Verzögerungen das gesamte Programm anhalten. Folglich könnte der Arduino praktisch nichts anderes tun.
Es ist weitaus besser, eine fertige Funktion zu verwenden, die spezielle, in den Mikrocontroller eingebaute Schaltungen (insbesondere Timer/Zähler) nutzt.
Tone Funktion
Als Hilfe dient die sehr einfache Funktion tone(), die 3 Argumente benötigt:
- den Pin, an dem das Signal erzeugt werden soll,
- die Frequenz dieses Signals,
- Dauer – dieser Parameter ist nicht obligatorisch.
In der Praxis sieht die Verwendung dieser Funktion wie folgt aus:
tone(A5, 1000, 2000); //Erzeuge ein Signal mit einer Frequenz von 1000 Hz an Pin A5, das 2000 ms lang anhält.
Oder in einer abgekürzten Version:
tone(A5, 1000); //Erzeuge ein 1000Hz Signal an Pin A5
Wir werden vorerst nur diese Form (d.h. zwei Parameter) verwenden.
Tone Funktion in der Praxis
Es ist an der Zeit zu sehen, ob wir mit der neuen Funktion tatsächlich einen Ton erzeugen:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
tone(A5, 1000); //Erzeuge ein 1000Hz-Signal an Pin A5
}
void loop() {
}
Funktionsweise der Schaltung in der Praxis:
Es sei daran erinnert, dass die Funktion tone() die Erzeugung eines Signals an einem bestimmten Pin auslöst und dass dieses Signal standardmäßig immer dort erzeugt wird! Daher ist der Ton im obigen Programm immer zu hören, obwohl der Aufruf der Funktion tone() im Abschnitt setup() erfolgt. Dies hat jedoch einen Nachteil:
Die Funktion tone() verwendet einen im Arduino eingebauten Zähler (Timer), um einen Ton zu erzeugen, der auch für die Erzeugung des PWM-Signals verantwortlich ist. Daher wirkt sich die Verwendung dieser Funktion auch auf die Fähigkeit aus, PWM an den Ausgängen 3 und 11 zu erzeugen.
Um die Signalerzeugung zu stoppen, wenn sie einmal begonnen hat, verwende die zweite Funktion:
noTone(A5); //Signalerzeugung an Pin A5 ausschalten
Ein einfaches Piepsen lässt sich also wie folgt realisieren:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
tone(A5, 1000); //Erzeuge ein 1000Hz-Signal an Pin A5
delay(1000);
noTone(A5); //Signalerzeugung ausschalten
delay(1000);
}
Funktion des Codes in der Praxis:
Es funktioniert! Allerdings nicht sehr laut, und alles in allem sind hier keine Vorteile gegenüber dem Summer mit Generator zu erkennen. Gleich wird alles deutlicher werden!
Suche nach der lautesten Frequenz
Jeder Summer beginnt bei einer bestimmten charakteristischen Frequenz ein lautes Geräusch zu machen. Konkret geht es um die Resonanzfrequenz. Du kannst sie in der Dokumentation nachschlagen, aber ich ermutige dich jetzt, einen experimentellen Ansatz zu wählen.
In den obigen Beispielen haben wir ein Signal mit einer Frequenz von 1000Hz, also 1kHz, erzeugt. Woher kommt dieser Wert? Gute Frage – ich habe ihn einfach aus dem Nichts eingegeben und einen Wert gefunden, der einen Ton erzeugt. Verwenden wir jedoch die for-Schleife, um einen größeren Bereich zu prüfen:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
int Frequenz = 0;
for (Frequenz = 31; Frequenz < 65535; Frequenz++) {
tone(A5, Frequenz); //Erzeuge ein 1000Hz-Signal an Pin A5
}
}
Warum wird die for-Schleife bei einer Frequenz von 31 Hz bis 65535 Hz ausgeführt? Dies ist eine Einschränkung der Funktion tone(), die auf dem Arduino UNO Signale mit Frequenzen erzeugen kann, die sich in diesem Bereich mischen (wir werden in diesem Stadium des Kurses nicht auf die Gründe eingehen).
Die Funktionsweise des obigen Programms in der Praxis:
Wenn das Programm beginnt, hören wir ein Quietschen und dann verschiedene seltsame Geräusche. Nach ein paar Sekunden beginnt die Schleife von vorne und es ertönt wieder ein kurzes Quietschen. Durch die Änderung des Bereichs, den die Schleife durchläuft, kannst du versuchen, die lauteste Frequenz zu finden.
Es ist eine gute Übung, um sich zu merken, wie so ein Summer funktioniert!
Wenn man die Möglichkeit hat, kann man sich gleich die Katalognotiz ansehen und die Resonanzfrequenz herausfinden. Im Falle unseres Summers ist es: 4000 Hz ± 500 Hz. Wir sollten also erwarten, dass er im Bereich von 3500-4500 Hz am lautesten arbeitet.
Wir überprüfen dies mit einem einfachen Programm:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
tone(A5, 4000); //Erzeuge ein 4000Hz-Signal an Pin A5
delay(100);
noTone(A5);
delay(100);
}
Wir bekommen jetzt einen deutlich lauteren Ton:
Laute Alarmsirene
Mit dem obigen Programm lässt sich ein unterbrochener, gleichmäßiger Ton erzeugen. Wie der Test mit der for-Schleife gezeigt hat, lassen sich mit einem solchen Summer auch andere Töne erzeugen – es kommt nur auf die gewählte Frequenz an. Wir können also eine einfache Alarmsirene erzeugen:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
tone(A5, 4300); //Erzeuge ein 4300Hz-Signal am Pin A5
delay(150);
tone(A5, 3500); //Erzeuge ein 3500Hz-Signal an Pin A5
delay(150);
}
Funktionsweise des Programms in der Praxis:
Ich habe die Zeiten und Frequenzen auf experimentelle Weise gewählt. Leider enden meine musikalischen Fähigkeiten bei solchen Blindversuchen. Ich glaube aber, dass einige von euch mehr Talent haben und viel interessantere Klänge hervorzaubern können.
Für fortgeschrittene - Melodien erzeugen
Wenn man sich in der Welt der Musik wiederfindet, kann man verschiedene Melodien erzeugen. Leider ist das völlig außerhalb meiner Welt. Zum Glück ist dies ein Programmierkurs (und kein Musikkurs). Wenn du wirklich mehr machen willst, empfehle ich dir, einen Blick darauf zu werfen:
Datei > Beispiele > Digital > toneMelody
Dort findet ihr ein Beispielprogramm, das eine einfache Melodie erzeugt.
Am interessantesten für diejenigen, die in diesem Bereich weiterarbeiten wollen, sind die Definitionen aus der Datei pitches.h, die sich automatisch zusammen mit dem obigen Beispiel öffnet:
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
Natürlich kann man sie auch in das eigene Programm einfügen und damit aufwendige Tonsignale erzeugen. Ich überlasse das Thema denjenigen, die es wollen, da ich mich nicht in der Lage fühle, jemanden in musikalischen Angelegenheiten zu beraten….
Im Internet gibt es viele interessante Beispiele für die Verwendung dieser Funktion. Hier ist eines von ihnen:
Aber konzentrieren wir uns weiterhin auf die Elektronik und die Programmierung!
MOSFET - Steuerung mit einer höheren Spannung
Zu Beginn möchte ich darauf hinweisen, dass es hier nicht um die Steuerung von hoher Netzspannung über 200V geht.
Ich denke an Fälle, in denen wir Geräte steuern müssen, die z.B. 9V oder 12V benötigen. Es gibt einige Komponenten, die nicht in der Lage sind, mit der vom Arduino bereitgestellten Spannung, d.h. 5V, zu arbeiten. Hier können MOSFET-Transistoren helfen.
Der andere Vorteil der Steuerung durch „so kleine Zwischenglieder“ ist natürlich, dass sie eine viel höhere Strombelastbarkeit haben. An einem einzigen Arduino-Pin kann man ohne Bedenken etwa 20 mA ziehen. Nach dem Einsatz von MOSFETs werden es ganze Ampere sein!
Ein praktisches Beispiel dafür, wo ein solcher Transistor nützlich sein könnte, ist die Beleuchtungssteuerung. LED-Leisten benötigen meist eine 12-V-Stromversorgung und ihr Strombedarf kann mehrere Ampere erreichen. Eine direkte Steuerung über einen Arduino ist also nicht möglich!
In unserem Experiment werden wir einen MOSFET zur Steuerung eines Summers mit 12 V verwenden.
MOSFET in der Praxis - Steuerung eines Summers
In den Sets ist der bei Heimwerkern beliebte Transistor IRL540N enthalten. Seine Parameter sind natürlich in der Katalognotiz zu finden. Die wichtigsten davon sind:
- maximaler Drain-Strom Id: 36 A,
- maximale VDSS-Spannung: 100 V,
- Widerstand des Kanals Rdson: 0,044 Ω.
Prüfen wir zunächst einmal, ob der Transistor tatsächlich eine höhere Spannung steuern kann. Dazu schließen wir die Schaltung wie folgt an:
- Steuersignal über einen 10k-Widerstand an das Gate (äußerste linke Leitung des MOSFET),
- Masse des Arduino an die Quelle (äußerste rechte Leitung),
- vom Drain (mittlere Leitung) führen wir eine Leitung, die wir in die Platine einstecken (so dass sie mit keinem anderen Signal verbunden ist),
- eine zusätzliche Leitung vom VIN des Arduino wird in die Platine gesteckt – vorerst auch, damit sie keine Verbindung mit einem anderen Signal hat,
Wir überprüfen nun sehr sorgfältig die Verbindungen.
Wenn man einen Fehler macht, kann man den gesamten Arduino beschädigen.
- Schließe die Spannungsversorgung und das USB-Kabel an. Von nun an haben wir ~12V auf dem VIN-Pin, die direkt von der Stromversorgung kommen.
Anschließend laden wir ein einfaches Programm hoch, das den Zustand des Ausgangs ändert:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
digitalWrite(A5, LOW); //Zyklische Änderung des Ausgangszustands
delay(1000);
digitalWrite(A5, HIGH);
delay(1000);
}
Wenn alles in Ordnung ist, erhalten wir zwischen den beiden lose geführten Leitungen (grün und gelb im obigen Schaltplan) eine Spannung von deutlich über 5 V, die dort regelmäßig (im Sekundentakt) auftritt:
Wenn alles in Ordnung ist, können wir den Summer anschließen. Verbinde ihn, wie in der Abbildung unten gezeigt:
Anschließend laden wir das Programm mit unserer Alarmsirene hoch:
void setup() {
pinMode(A5, OUTPUT); //Konfiguration von A5 als Ausgang
}
void loop() {
tone(A5, 4300); //Erzeuge ein 4300Hz-Signal am Pin A5
delay(150);
tone(A5, 3500); /Erzeuge ein 3500Hz-Signal an Pin A5
delay(150);
}
Das Ganze wird mit einer höheren Spannung betrieben und das Geräusch, das aus der Schaltung kommt, ist viel leiser. Warum? Das piezoelektrische Element im Inneren des Summers speichert bei schnellen Schaltvorgängen Energie (verhält sich wie ein Kondensator).
Bei solch schnellen Zustandsänderungen kann diese Energie nirgendwo „entweichen“. Infolgedessen wird der Ton, der aus dem Element kommt, gedämpft. Glücklicherweise ist es relativ einfach, dieses Problem zu beheben. Schließe einfach einen Widerstand, z. B. 10 k, parallel zum Summer an, damit er sich schnell entladen kann.
In der Praxis sieht die Schaltung letztlich wie folgt aus:
Jetzt sollte alles richtig funktionieren. Wir können den mit einer höheren Spannung betriebenen Summer genießen! Es lohnt sich, zu prüfen, wie sich die Schaltung bei anderen Frequenzen verhält. Hat die höhere Spannung die Reaktion bei anderen Frequenzen verändert? Dies soll eine Übung für alle Freiwilligen sein.
Gerade in diesem Fall ist die Verwendung dieses Transistors nicht unbedingt notwendig und man kann den Summer sicher auch ohne ihn verwenden. Betrachte dies also als Beispiel und nicht als „Orakel“, dass du es so machen musst. Mir ging es vor allem darum zu zeigen, dass auch Bauteile, die mit höheren Spannungen arbeiten, sehr einfach über den Arduino gesteuert werden können. Wir haben das Thema an dieser Stelle nur leicht gestreift!
Zusammenfassung
Das Ziel dieses Teils war es, die neuen Komponenten zu beherrschen – vor allem den Summer ohne den Generator. Zusammen mit dem LED-Streifen (der im vorherigen Teil besprochen wurde) wird es nun möglich sein, eine laute und gut sichtbare Warnmelder zu bauen. Wir werden uns im nächsten Teil damit befassen und dabei unter anderem auch den Bewegungsmelder kennenlernen.
Bestellen Sie ein Set mit Elementen und beginnen Sie mit dem Lernen in der Praxis! Hier gehts zum Shop >>
