Wir verbessern unsere Motorsteuerung mit Hilfe einer H-Brücke. Der Arduino kann jetzt den Motor in Richtung und Geschwindigkeit steuern.
Der analoge Ausgang eines Arduinos: PWM
Die Geschwindigkeit des Motors aus einem früheren Versuch soll gesteuert werden. Dort haben wir gesehen, dass durch anlegen einer Spannung an die Basis eines Transistors eine solche Steuerung möglich ist. Der Arduino soll diese Spannung erzeugen.
Da gibt es es doch so etwas wie analogWrite(). Also experimentieren wir einmal damit.
An Pin 9 wird eine LED mit Vorwiderstand angeschlossen. Pin 8 ist hier nicht brauchbar, da er keine analogen Werte ausgeben kann.
Auf der linken Seite wird ein analoger Wert an Pin A4 eingegeben. Er wird durch ein Potentiometer erzeugt. Ein Potentiometer ist ein Widerstand mit einem dritten Anschluss. Die beiden andern Anschlüsse sind mit +5V und Gnd verbunden. Der dritte Anschluss kann jetzt mit Hilfe eines Drehreglers von Gnd zu 5V verschoben werden. Daher können wählbare Spannungen zwischen 0 und 5V ausgegeben werden.
Dieser Wert wird vom Arduino an Pin A4 eingelesen und an Pin 9 wieder ausgegeben. Der Sketch ist sehr einfach und sollte mit Hilfe der Kommentare verständlich sein. Zusätzlich werden die eingelesenen und ausgegebenen Werte noch in der seriellen Konsole angezeigt.
Den Ausgang pin 9 schliessen wir an ein Oszilloskop an. Wie erwartet ergibt sich bei 0V am Eingang 0V am Ausgang und 5V am Eingang ergeben etwa 5V am Ausgang. Bei Zwischenwerten entsteht aber ein Rechtecksignal. Der Arduino gibt also kein analoges Signal aus, sondern nur ein digitales Rechtecksignal. Dabei steuert die Eingangspannung die Pulsweite. Das nennt man Pulsweitenmodulation, kurz PWM genannt.
Von PWM zu Gleichspannung
Eigentlich wollten wir ja eine Gleichspannung. Wie können wir das erreichen?
Aus den Versuchen mit dem Gleichrichter wissen wir, dass Kondensatoren helfen können. Der Kondensator C1 lädt und entlädt sich abhängig vom Spannungspegel an D9. Je nach Pulsverhältnis erhalten wir so einen mehr oder weniger stabilen Spannungspegel am Messpunkt.
Auch die Geschwindigkeitsregelung des Motors klappt bestens.
War dieser Aufwand überhaupt notwendig? Nein, eigentlich nicht. Aber ich konnte es nicht lassen, euch nochmals eine Verwendungsmöglichkeit für Kondensatoren zu zeigen. Der Motor lässt sich auch in der Geschwindigkeit steuern, wenn wir die PWM-Pulse direkt an den Motor geben. PWM arbeitet mit einer Frequenz von 490 Hz (auf gewissen Pins auch 980 Hz). Bei sehr leisen Motoren könnte das hörbar werden. Dann hätte unser Kondensator doch noch einen praktischen Sinn.
Doch eigentlich wollten wir auch die Laufrichtung des Motors bestimmen. Das tönt ganz einfach, ist aber trotzdem etwas komplizierter.
Wie wechselt man die Polarität an den Motoranschlüssen?
Der Motor wird in der Mitte eines grossen H's angeschlossen. Durch Betätigung der richtigen Schalter kann die Polarität der Anschlüsse am Motor gewählt werden. Das nennt man eine H-Brücke.
Jetzt wollen wir aber sicher nicht die Laufrichtung des Motors über 4 Schalter wählen. Ein kleiner Bedienungsfehler könnte zu einem Kurzschluss führen. Also müssen wir die Schalter durch Elektronik ersetzen und diese z. Bsp. von einem Arduino ansteuern. Mindestens 4 Transistoren müssten es dann schon sein.
Zum Glück kann uns die Elektronikindustrie da helfen. Sie baut mehrere Transistoren und das notwendige Beigemüse in einen Chip ein und verkauft das als Bauteil. Man nennt diese integrierte Schaltungen, abgekürzt IC (von integratet circuit).
Eine bekannte Variante ist der L293D. Er hat gleich zwei H-Brücken eingebaut und das D in der Bezeichnung bedeutet, dass die Schutzdioden für den Motor auch schon integriert sind.
Mit diesem Bauteil werden wir unsere Versuche durchführen.
Das Experiment
Links ist das Schema des Versuchsaufbaus zu sehen. Rechts ein Auszug aus dem Datenblatt des L293D.
Links am Arduino ist das Potentiometer wie in den früheren Versuchen an den analogen Pin A4 angeschlossen. An D9 wird ebenfalls unverändert das PWM-Signal zur Geschwindigkeitssteuerung ausgegeben. Interessant ist die Schaltung des L293D.
Was sofort auffällt, sind die 4 Masseanschlüsse des Chips. Laut Datenblatt sollten sie mit einer etwas grösseren Kupferfläche verlötet werden, da sie die Wärme aus dem Innern des Chips. Für unseren Versuch ist das aber nicht relevant, da wir keine grosse Leistung schalten und der Motor nur kurze Zeit in Betrieb ist.
Pin 16 ist die Versorgungsspannung des Chips. Er wird mit den 5V des Arduinos verbunden. Die Motorspannung (12V) aus der externen Stromversorgung wird an Pin 8 angeschlossen. Die Massen der beiden Stromversorgungen müssen miteinander verbunden sein.
Die rechte Hälfte des L293D brauchen wir nicht. Um diese abzuschalten genügt es, Pin 9 mit Masse zu verbinden.
Pin 3 und 6 speisen den Motor. Die Laufrichtung steuert der Arduino mit seinen Ausgängen D7 und D8. Diese führen zu Pin 2 und 7. Wenn Pin 2 HIGH ist, wird an Pin 3 die Motorspannung ausgegeben, andernfalls ist Pin 3 auf Masse. Dasselbe gilt für Pin 7 und Pin 6.
Alle Ausgänge auf der linken Seite funktionieren nur, wenn Pin 1 HIGH ist. Andernfalls sind sie alle auf Masse. Wir geben vom Arduino aus das PWM-Signal auf Pin 1 und können so die Geschwindigkeit steuern.
Der Sketch
Diesmal ist der Sketch etwas komplexer und muss etwas näher erklärt werden. Ihr müsst ihn nicht abtippen, er kann hier heruntergeladen werden.
Das Potentiometer steuert Richtung und Geschwindigkeit. In der Mittelstellung steht der Motor still. Dreht man das Poti nach links oder rechts, dreht sich der Motor mit zunehmender Geschwindigkeit in die entsprechende Richtung.
Die ersten Zeilen dienen der Definition von Konstanten. Ich habe hier die Deklaration mit const int gemacht, #define oder nur int wären ebenfalls möglich. Da das aber kein Programmierkurs ist, möchte ich nicht näher darauf eingehen.
In setup() wird der Motor zuerst angehalten und die Pins zur Richtungssteuerung auf OUTPUT gesetzt.
Die Funktion motorSteuerung() stellt die Richtung und die Geschwindigkeit fest und übergibt die notwendigen Werte an die H-Brücke.
Die Werte des Potentiometers liegen im Bereich von 0 bis 1023. Werte kleiner als 450 definiere ich als LINKS, zwischen 451 und 573 hält der Motor an (STOPP), darüber dreht er nach RECHTS. Da bei einer Richtungsänderung immer zuerst angehalten und danach weitergefahren wird, muss getestet werden, ob überhaupt eine Richtungsänderung notwendig ist. Dazu speichere ich in einer statischen Variablen die aktuelle Richtung (LINKS, STOPP oder RECHTS). Statische Variablen sind technisch gesehen globale Variablen, die aber nur im lokalen Scope sichtbar sind, hier also innerhalb der Funktion motorSteuerung(). Beim ersten Aufruf werden sie mit dem angegebenen Wert (hier STOPP) initialisiert und behalten später auch zwischen den Funktionsaufrufen den jeweils zugewiesenen Wert.
Die Geschwindigkeit wird ebenfalls aus dem potiVal berechnet. Beim Linkslauf steigen die Geschwindigkeiten von 511 bis 0 an, beim Rechtslauf von 512 bis 1023. Im Stoppbereich zwischen 451 und 573 wird die Geschwindigkeit einfach auf 0 gesetzt. Denn so erhaltenen Geschwindigkeitswert müssen wir nur noch durch 2 teilen, um in den zulässigen Bereich zu kommen.
Wenn die Richtung gewechselt werden muss, wird der Motor zuerst angehalten. Dazu wird die Geschwindigkeit auf 0 gesetzt. Danach bekommt er eine kurze Ruhepause. Ich habe hier 200 ms gewählt, das kann aber je nach Motor angepasst werden.
Wenn die neue Richtung RECHTS oder LINKS ist, werden die MotorPins entsprechend gesetzt. Andernfalls muss nichts gemacht werden, da der Motor ja schon steht. Die neue Richtung nur noch in der Variablen momentaneRichtung abgespeichert werden.
Jetzt muss dem Motor nur noch die vorher errechnete Geschwindigkeit mitgeteilt werden.
Download: Motor_digital3.ino
/*
Liest den Wert von einem Potentiometer
Steuert die Motorrichtung und Geschwindigkeit
*/
const int geschwindigkeitPin = 9;
const int motorPin1 = 8;
const int motorPin2 = 7;
const int potiPin = A4;
const int LINKS = -1;
const int STOPP = 0;
const int RECHTS = 1;
void setup() {
analogWrite(geschwindigkeitPin,0); // Motor anhalten
pinMode(motorPin1,OUTPUT);
pinMode(motorPin2,OUTPUT);
}
void motorSteuerung() {
static int momentaneRichtung = STOPP;
int neueRichtung;
int geschwindigkeit;
// Wert von Poti lesen
int potiVal = analogRead(potiPin);
// Richtung und Geschwindigkeit feststellen
if (potiVal < 450) {
neueRichtung = LINKS;
geschwindigkeit = 511 - potiVal; // links ist 0 die grösste Geschwindigkeit
} else if (potiVal > 574) {
neueRichtung = RECHTS;
geschwindigkeit = potiVal - 512; // rechts 512 = 0
} else {
neueRichtung = STOPP;
geschwindigkeit = 0;
}
geschwindigkeit = geschwindigkeit / 2; // Bereich ist 0 .. 255
if (neueRichtung != momentaneRichtung) {
// anhalten
analogWrite(geschwindigkeitPin,0);
delay(200); // etwas Pause
// neue Richtung
momentaneRichtung = neueRichtung;
switch (neueRichtung) {
case LINKS: digitalWrite(motorPin1,HIGH);
digitalWrite(motorPin2,LOW);
break;
case RECHTS: digitalWrite(motorPin1,LOW);
digitalWrite(motorPin2,HIGH);
}
}
// Geschwindigkeit
analogWrite(geschwindigkeitPin,geschwindigkeit);
}
void loop() {
motorSteuerung();
}
Willst du es genauer wissen ?
Wikipedia ist immer eine gute Informationsquelle:
Der Vierquadrantensteller
Eine Webseite:
dieelektronikerseite.de
Noch ein Video:
HomoFaciens