In diesem Teil unseres Arduino-Kurses befassen wir uns mit dem Betrieb von kleinen Motoren. Ich werde zeigen, wie man sie an den Mikrocontroller anschließt und ihre Drehrichtung und Geschwindigkeit steuert.
Diesem Thema habe ich einen eigenen Artikel gewidmet, weil der falsche Anschluss dieses scheinbar einfachen Elements oft den Arduino beschädigt.
Bevor wir uns mit den verschiedenen Aspekten der Arbeit mit kleinen Gleichstrommotoren beschäftigen, müsst ihr die beiden wichtigsten Regeln beherrschen: Erstens – schließt niemals einen Motor direkt an einen Arduino an. Zweitens – es ist am besten, nichts anzuschließen, bevor du die folgenden Informationen gelesen hast!
Andernfalls könntest du dich darauf vorbereiten, einen zweiten Arduino zu kaufen!
Warum sollen wir Motoren an den Arduino anschließen?
Durch die Steuerung der Drehrichtung und der Geschwindigkeit des Motors gibt es eine Menge Möglichkeiten. Mit diesen neuen Fähigkeiten können wir zum Beispiel einen einfachen mobilen Roboter bauen, der in der Wohnung herumfahren und Hindernissen ausweichen kann. Genauso gut können wir ein Fahrzeug bauen, das mit unserem Telefon ferngesteuert wird – die Möglichkeiten sind wirklich vielfältig.
Mit welchen Motoren werden wir uns speziell befassen?
In diesem Artikel werden wir das Steuerungsprinzip der beliebtesten DC-Bürstenmotoren besprechen. Sie werden am häufigsten von Heimwerkern verwendet, um ihre Konstruktionen anzutreiben. Es ist relativ einfach, solche Antriebe zu kaufen oder sie aus altem Spielzeug zu demontieren.
Es ist noch zu definieren, was kleine Gleichstrommotoren sind. Natürlich geht es nicht um ihre Größe, sondern um ihren Strombedarf. Für die Zwecke dieses Artikels bin ich davon ausgegangen, dass ich über Motoren sprechen werde, die im Durchschnitt weniger als 1 A ziehen, wenn sie von 5-9 V gespeist werden. Diese Grenzen werden in gewisser Weise durch den verwendeten Motorcontroller bestimmt, aber dazu später mehr.
Das Prinzip der Motorsteuerung ist universell. Das bedeutet, dass wir durch die Wahl eines entsprechend leistungsstärkeren Steuergeräts einen größeren Motor steuern können.
Warum können wir den Motor nicht an den Arduino anschließen?
Der Arduino, oder genauer gesagt der Mikrocontroller auf der Platine, ist von seiner Konstruktion her dazu gedacht, Signale zu steuern. Der Ausgang jeder Ausgangsleitung ist relativ klein, man kann von etwa 20 mA ausgehen. Man kann mit Sicherheit davon ausgehen, dass 99,999% der Motoren, denen man begegnet, wesentlich mehr Strom benötigen. Um genauer zu sein, können die Größenordnungen Hunderte oder Tausend Mal größer sein.
Der Fluss eines so großen Stroms durch ein nicht angepasstes System verursacht sofortige und irreversible Schäden!
Warum sind keine Motoren in unserem Set enthalten?
Ein Satz vernünftiger, universeller Motoren kostet mindestens 15 Euro!
Und warum? Nun, Motoren in das Set zu packen, wäre eine Verschwendung eures Geldes. Du lernst gerade erst, du weißt noch nicht, welche Projekte du später bauen wirst, und ohne das zu wissen, ist es unmöglich, die richtigen Motoren auszuwählen. Warum also in eine Ausrüstung investieren, die du nie benutzen wirst?
In dieser Folge werden wir den Motor durch Leuchtdioden ersetzen. Ihr werdet beobachten können, wie sich die Drehrichtung ändert (welche Diode leuchtet) und wie sich ihre Geschwindigkeit ändert (die Helligkeit der Dioden). Zur besseren Veranschaulichung habe ich in den Übungen auch Videos des angeschlossenen Motors eingefügt.
Fertige Sets für Forbot-Kurse
Sie können jetzt ein Set von mehr als 70 Elementen, die für die Kursübungen notwendig sind, bei unseren Händlern kaufen!
Beliebtes Paket: Arduino Meister – Robotik Meister
Kombinierte H-Brücken - kurz und bündig
Zwischen dem Arduino und den Motoren werden Zwischenkomponenten benötigt. Diese werden meist als H-Brücken oder, auf Englisch, h-bridge bezeichnet. Man kann solche Steuergeräte mit ein paar Transistoren selbst bauen oder eine kombinierte H-Brücke (d. h. eine Schaltung, die eine Brücke ist) verwenden. Als Einsteiger kann man mit fertigen Schaltungen beginnen.
Der Bau einer H-Brücke an sich ist für sehr hohe Ströme erforderlich. Dies ist jedoch eine schwierige Aufgabe. Am Anfang muss man sich damit nicht beschäftigen.
Die Hauptaufgabe der H-Brücken besteht sozusagen darin, die von den Mikrocontrollern gelieferten Signale zu lesen und in Größen umzuwandeln, die zur Steuerung von Motoren geeignet sind. Zum Beispiel kann ein Arduino, dessen Signalleitungen nach Verwendung einer H-Brücke mit maximal 5V und 20mA arbeiten können, problemlos einen Motor steuern, der 12V und 1A zum Betrieb benötigt.
Deine erste H-Brücke
In diesem Kurs werden wir uns mit dem recht alten, aber billigen und immer noch beliebten L293D-Chip beschäftigen. Sein Hauptvorteil in unserem Fall ist, dass diese Brücke in einem Through-Hole-Gehäuse (THT) geliefert wird und wir sie in eine Kontaktplatine einbauen können: Wichtig ist, dass wir zwei Brücken in einem Schaltkreis finden, so dass er sich ideal für die Steuerung von Roboterantrieben (linke/rechte Seite) usw. eignet.
Datenblatt (engl. datasheet) – ein vom Hersteller bereitgestelltes Dokument, in dem alle Informationen über einen bestimmten Schaltkreis zu finden sind.
Eine der wichtigsten Informationen, die bei jeder H-Brücke zu prüfen sind, ist die Leistungsfähigkeit. Konkret geht es darum, wie viel Strom der angeschlossene Motor aufnehmen kann. Wenn wir einen L293D verwenden, kann der durchschnittliche Strom pro Kanal 0,6 A und der maximale 1,2 A betragen. Was bedeutet das?
Im optimalen Fall sollten unsere Motoren während des Betriebs bis zu 0,6A ziehen, aber wenn der Strom für eine Weile auf 1,2A ansteigt, kann nichts Schlimmes passieren. Vorausgesetzt, es dauert nur eine kurze Zeit!
Denk daran, dass ein Motor, der unter Last läuft, einen viel höheren Strom aufnimmt, als wenn er frei läuft! Prüfe immer den maximalen Strom, den ein Motor aufnehmen kann!
Ich werde zunächst auf alle diese Punkte eingehen. Dann geht es weiter mit dem Anschluss des Schaltkreises auf der Kontaktplatine und der Programmierung. Zunächst einmal die Pins für die Spannungsversorgung:
- 4, 5, 12, 13 – sind mit der Masse (GND) verbunden
- 16 – Vcc Versorgung des Logikteils (5V)
- 8 – Vc Versorgung der Motoren (bis zu 36V)
Die Schaltung kann mit zwei separaten Stromquellen versorgt werden. Eine für den Logikteil und eine für die Motoren.
Es ist jedoch notwendig, die Erdungen beider Quellen (Batterien) zu verbinden!
Es ist zu bedenken, dass jede Brücke einen Spannungsabfall hat. Das bedeutet, dass z. B. beim Anschluss von 9 V an die Stromversorgung für die Motoren im L293D maximal 7 V fließen. Diese Schaltung ist recht alt und hat daher einen großen Spannungsabfall, neuere (z. B. TB6612) haben einen geringeren.
Pins für die Motorsteuerung:
- 2, 7 – Eingänge zur Bestimmung der Drehrichtung des ersten Motors
- 10, 15 – Eingänge zur Bestimmung der Drehrichtung des zweiten Motors
- 1 – ENABLE-Eingang zur Bestimmung der Drehzahl des ersten Motors
- 9 – ENABLE-Eingang zur Bestimmung der Drehzahl des zweiten Motors
Um den Motor anzuhalten oder die Drehrichtung zu ändern, müssen die Signale gemäß der folgenden Liste, der so genannten Wahrheitstabelle, gesetzt werden:
Wie man sieht, gibt es zwei Kombinationen, die den Motor zum Stillstand bringen. Einige Steuereinheiten führen, wenn zweimal die 1 eingetragen wird, eine Gegenstrombremsung durch. Dies kann sich manchmal nachteilig auf das gesamte System auswirken, führt aber zum sofortigen Anhalten des Motors.
Die Angabe von zwei niedrigen Zuständen führt normalerweise zu einem freien Stopp (bis der Motor an Schwung verliert). Informationen hierzu findet man in den technischen Daten der Brücke.
Pins für die Motoren:
- 3, 6 – Ausgänge zum ersten Motor
11, 14 – Ausgänge zum zweiten Motor
Einsatz der H-Brücke in der Praxis
Davon gibt es viel, aber es wird gleich alles klar werden! Zuerst die Stromversorgung, ich weiß nicht warum, aber sie bereitet Anfängern viele Probleme. Das Prinzip ist jedoch einfach – die Schaltung kann mit einer oder zwei Spannungen betrieben werden.
Wenn man die erste Option wählt, werden sowohl der Logikteil als auch die Motoren aus derselben Quelle gespeist – von dieser Konfiguration rate ich dringend ab. Vor allem, wenn du die Motoren mit den auf dem Arduino-Board verfügbaren 5V versorgen möchtest. Dies ist möglich, erfordert aber eine entsprechend effiziente Stromquelle und eine gute Filterung.
Die Stromversorgung der Motoren und des Arduinos über dieselbe Stromquelle kann zu Programmabbrüchen und häufigen Resets führen.
Am besten ist es jedoch, die beiden Versorgungen zu trennen, z. B.: die Motoren direkt von der Batterie und den Mikrocontroller über einen Stabilisator und geeignete Kondensatoren zu versorgen.
Daher ist es definitiv sicherer, die zweite Lösung zu wählen, bei der der Arduino aus einer separaten Quelle versorgt wird. In unserem Fall werden wir USB-Strom und eine 9-V-Batterie verwenden, um unsere Motoren direkt zu versorgen (der Arduino kann ebenfalls über diese Quelle versorgt werden, allerdings über einen eingebauten Stabilisator, so dass wir uns keine großen Sorgen über Interferenzen machen müssen).
Achtung!
In diesem Kurs geht es nur darum, bestimmte Mechanismen zu erlernen und zu demonstrieren. Die 9V-Batterie hat eine zu geringe Stromkapazität, um den Roboter zu betreiben. LiPo-Batterien sind hier definitiv besser geeignet.
Die Schaltung sollte wie die untenstehende aussehen. Beachte, dass wir 9V an die Platine angelegt haben, nicht 5V! Achte darauf, dass du nichts beschädigst!
Dort, wo die orangefarbenen Leitungen herauskommen, schließt du den „Motor“ an. Lies jedoch den Rest des Artikels, bevor du etwas anschließt!
Denk unbedingt an die Kondensatoren auf der Kontaktplatine. Sie filtern die direkt von der Batterie gelieferte Spannung. Sie reduzieren die Möglichkeit von Interferenzen beim Arduino!
Die Schaltung ist relativ komplex. Zunächst ist es sinnvoll, die Masse der L293D-Brücke zu verbinden. Dies kann mit den abgeschnittenen Beinen der Widerstände geschehen. Dadurch wird Platz gespart:
Und dann der Reihe nach:
Jetzt ist es an der Zeit, den Motor (zunächst einen) anzuschließen. Wie ich im Kurs erwähnt habe, werden wir die Motoren simulieren, damit wir sie nicht unnötig kaufen müssen. Wie werden wir das tun? Auf eine sehr einfache Weise.
Motor-Simulation
Wie ihr wisst, ist eine Leuchtdiode ein Halbleiterelement, das aufleuchtet, wenn der Strom in der richtigen Richtung durch es fließt. Wenn wir also zwei Dioden so parallel schalten, dass sie in entgegengesetzter Richtung angeschlossen sind, können wir prüfen, „in welche Richtung“ der Strom fließt – einmal leuchtet die eine Diode auf und einmal die andere. Anhand des Aufleuchtens der Diode können wir wiederum die Geschwindigkeit des Motors überprüfen.
Anstelle des Motors schließen wir also eine Schaltung wie die folgende an (1k-Widerstand):
Und das Ganze:
Arduino - einfache Motorsteuerung
Es ist Zeit für das erste Programm, in dem wir die obige, recht komplizierte Schaltung verwenden werden. Wir beginnen mit der Steuerung der Drehrichtung des Motors. Die Geschwindigkeitskontrolle heben wir uns für später auf. Wie bereits erwähnt, sind im Moment die folgenden Arduino-Pins für einen der Motoren zuständig:
- 6 (PWM) – Geschwindigkeitssteuerung
- 7, 8 – Steuerung der Drehrichtung
Beachte, dass hier auf die Arduino-Pin-Nummern Bezug genommen wird, und nicht auf die Anschlüsse der L293D-Brücke!
Wenn wir die Geschwindigkeit der Motoren nicht steuern wollen, müssen wir einen hohen Zustand an Pin 6 (PWM) einstellen. Wir könnten das Kabel auch direkt an 5V anschließen. Da der Anschluss jedoch bereits fertig ist, verwenden wir den des Arduino:
void setup() {
pinMode(6, OUTPUT); //PWM-Signal von Motor Nr. 1
digitalWrite(6, HIGH); //Wir setzen (dauerhaft) den Zustand High an Pin 6
pinMode(7, OUTPUT); //Signale zur Steuerung der Drehrichtung von Motor Nr. 1
pinMode(8, OUTPUT);
}
void loop() {
//Hier folgt der weitere Teil des Programms
}
Wenn die Schaltung richtig angeschlossen wurde, sollte nach dem Hochladen des folgenden Programms…. nichts passieren! Nun ist es an der Zeit, das fehlende Glied in die Schleife einzufügen. Nehmen wir an, wir wollen den Motor 3 Sekunden in die eine Richtung und 3 Sekunden in die andere Richtung drehen lassen (maximale Geschwindigkeit). Dazu müssen wir ein einfaches Programmierelement hinzufügen:
void setup() {
pinMode(6, OUTPUT); //PWM-Signal von Motor Nr. 1
digitalWrite(6, HIGH); //Wir setzen (dauerhaft) den Zustand High an Pin 6
pinMode(7, OUTPUT); //Signale zur Steuerung der Drehrichtung von Motor Nr. 1
pinMode(8, OUTPUT);
}
void loop() {
digitalWrite(7, LOW); //Motor Nr. 1 - Drehung nach links
digitalWrite(8, HIGH);
delay(3000);
digitalWrite(7, HIGH); //Motor Nr. 1 - Drehung nach rechts
digitalWrite(8, LOW);
delay(3000);
}
Gemäß der zuvor vorgestellten Wahrheitstabelle wissen wir, dass sich der Motor dreht, wenn einer der Eingänge einen niedrigen Zustand „0“ und der andere einen hohen Zustand „1“ annimmt. Die Drehrichtung hängt jedoch davon ab, welcher Eingang mit welchem Signal versorgt wird.
Sobald das Programm auf den Arduino hochgeladen wurde, sollten die beiden LEDs zu blinken beginnen. Schaut jedoch genau hin und versteht, warum dies geschieht. Es ist nicht das gleiche Diodenblinken wie in den ersten Teilen des Kurses. Die Dioden leuchten abwechselnd, weil der Strom einmal von Ausgang 1 zu Ausgang 2 fließt und einmal in die andere Richtung. Das Blinken ist möglich, weil die Dioden verkehrt herum eingesetzt sind. Zum besseren Verständnis sieh dir die Bilder unten an, wo ich anstelle der Dioden auch ein Voltmeter eingesetzt habe:
Einmal ist das Ergebnis positiv und einmal ist es negativ. In diesem Fall zeigt uns das Minus, dass der Strom in die entgegengesetzte Richtung fließt als am Anfang.
Jetzt ist es Zeit für ein Experiment, das nur ich durchführen werde, nämlich den Anschluss des Motors. Ich werde einen kleinen Motor verwenden, der mit einem Gleichstromgetriebe und einem roten Rad ausgestattet ist (um die Drehung besser sichtbar zu machen).
Wenn du einen kleinen Motor hast und ihn an die Schaltung anschließen willst, so wie ich es tue, dann stelle sicher, dass er eine ausreichend kleine Strommenge zieht (<1A) und mit etwa 6-9V betrieben werden kann.
Jetzt, da wir die Drehrichtung des Motors kontrollieren können, ist es Zeit für die Geschwindigkeit. Überprüfe vorher, was passiert, wenn du das Kabel an Pin 6 des Arduinos abziehst und an die Masse anschließt, während das obige Programm läuft.
Der Motor hat aufgehört, sich zu drehen (die LEDs haben aufgehört zu leuchten). Das heißt, wenn wir sehr schnell 0 oder 1 an diesen Eingang anlegen, können wir die Geschwindigkeit des Motors (die Helligkeit der LEDs) steuern. Erinnerst du dich, in welchem Teil des Kurses diese Analogie bereits aufgetaucht ist?
Hausaufgabe 8.1
Füge zwei weitere Dioden in die Schaltung ein und simuliere damit einen zweiten Motor. Schreibe ein Programm, das folgende Sequenzen ausführt: beide vorwärts, beide in entgegengesetzter Richtung, beide rückwärts und so weiter im Kreis. Halte dabei natürlich ein Intervall von z.B: 2 Sekunden.
PWM-Version - wir steuern die Geschwindigkeit
Für weitere Tests benötigst du das Wissen aus dem Artikel PWM und Arduino. Wie du vielleicht schon erraten hast, musst du nur ein PWM-Signal an den ENABLE1-Pin (des L293D-Chips) anlegen, um die Geschwindigkeit des Motors zu steuern!
Hier gibt es nichts weiter zu erklären. Es ist an der Zeit, ein einfaches Programm zu schreiben, das die Motoren abwechselnd langsamer oder schneller dreht. Erinnere dich daran, dass du die Diode nur oberhalb einer bestimmten PWM-Signalfüllschwelle aufleuchten siehst, und so wird es auch mit den Motoren sein. Jeder dreht sich ab einem etwas anderen Wert. Wir werden später darauf zurückkommen.
void setup() {
pinMode(6, OUTPUT); //PWM-Signal von Motor Nr. 1
pinMode(7, OUTPUT); //Signale zur Steuerung der Drehrichtung von Motor Nr. 1
pinMode(8, OUTPUT);
}
void loop() {
analogWrite(6, 100); //Niedrige Drehzahl
digitalWrite(7, LOW); //Motor Nr. 1 - Drehung nach links
digitalWrite(8, HIGH);
delay(3000); //3 Sekunden warten
analogWrite(6, 255); //Maximale Drehgeschwindigkeit
digitalWrite(7, LOW); //Motor Nr. 1 - Drehung nach links
digitalWrite(8, HIGH);
delay(3000); //3 Sekunden warten
}
Man sollte beobachten, dass eine Diode ihre Helligkeit merklich verändert! Jetzt ist es an der Zeit, die Geschwindigkeit des Motors flüssig zu verändern, aber bevor wir dazu kommen, ist es Zeit für eine kleine Zwischenbemerkung….
For-Schleife im Arduino
Es ist an der Zeit, eine äußerst nützliche Schleife zu besprechen, die in der Arduino-Sprache (und vielen anderen) verfügbar ist. Ich meine die FOR-Schleife, die es uns ermöglicht, bestimmte Anweisungen eine bestimmte Anzahl von Malen auszuführen.
Wir werden sie verwenden, wenn wir zum Beispiel 10 aufeinanderfolgende natürliche Zahlen schreiben, eine Diode 5 Mal blinken lassen wollen und so weiter. Bevor wir jedoch mit dem Beispiel fortfahren, ist es an der Zeit, den Aufbau der vorzustellen:
for (Zähler-Variable; Bedingung zum Beenden; Operation auf dem Zähler
) {
//Mehrfach auszuführendes Fragment
}
Es sieht verworren aus, ist aber zum Glück sehr einfach. Nach dem Schlüsselwort for öffnen wir eine Klammer und geben dort drei sehr wichtige Dinge an. Das erste davon ist die Zähler-Variable. Da der Inhalt der Schleife eine bestimmte Anzahl von Malen ausgeführt werden soll, muss das Programm irgendwoher wissen, wie viele Schleifendurchläufe bereits ausgeführt wurden.
Als nächstes geben wir nach dem Semikolon eine Bedingung an. Die Schleife wird so lange ausgeführt, wie die Bedingung erfüllt ist. Nach einem weiteren Semikolon müssen wir die Operation angeben, die bei jeder Schleife auf die Zählervariable angewendet werden soll. Schließlich schließen wir die runde Klammer.
Die for-Schleife in der Praxis
Verwenden wir eine for-Schleife, um z.B. eine Begrüßung über den UART zu schreiben: 25 Mal.
void setup() {
Serial.begin(9600); //Start der Kommunikation
for (int i = 0; i < 25; i++) { //25 Mal ausführen
Serial.println("Willkommen auf Forbot.com"); //Schreibe den Text in eine neue Zeile
delay(200); //Einen Moment warten
}
}
void loop() {
}
Der Effekt ist auf dem Terminal zu sehen:
Also genau so, wie wir es erwartet haben. Ich erkläre gleich, was der folgende Eintrag bedeutet:
for (int i = 0; i < 25; i++) { //25 Mal ausführen
Zähl-Variable, hier kam die einfache Notation int i = 0 , ich hoffe, Sie verstehen sie. Kurz gesagt, wir deklarieren eine neue lokale Variable i, die vom Typ int ist, und ihr Anfangswert ist 0. Wenn du Probleme hast, diesen Teil zu verstehen, gehe zurück zu dem Artikel über Variablen.
Die Schleifenbedingung besteht in diesem Fall darin, i < 25 zu schreiben, d. h. die Schleife wird so lange ausgeführt, wie der Wert der Variablen i kleiner als 25 ist.
Das letzte Element, i++, ist eine Inkrementierung der Zählvariablen (d. h. in jeder Schleife wird der Wert der Variablen um eins erhöht). Diese Schreibweise kannst du genauso gut durch i = i + 1 ersetzen, wenn du willst.
Zum besseren Verständnis der Bedingung kann man das Programm in einer modifizierten Version ausführen:
void setup() {
Serial.begin(9600); //Start der Kommunikation
for (int i = 0; i < 25; i++) { //25 Mal ausführen
Serial.print("Wert der Variablen i: ");
Serial.print(i); //Zählerwert anzeigen
Serial.print("\n"); //Gehe zu neuer Zeile
delay(200); //Einen Moment warten
}
}
void loop() {
}
Es ist nun leicht zu erkennen, welche Werte die Zählervariable (0-24) annimmt. Natürlich wird die Schleife auch 25 Mal ausgeführt, wenn statt:
for (int i = 0; i < 25; i++) { //25 Mal ausführen
geschrieben wird:
for (int i = 0; i <= 24; i++) { //25 Mal ausführen
oder:
for (int i = 1; i <= 25; i++) { //25 Mal ausführen
oder:
for (int i = 1; i < 26; i++) { //25 Mal ausführen
oder:
for (int i = 0; i < 50; i = i + 2) { //25 Mal ausführen
oder auch:
for (int i = 25; i > 0; i--) { //25 Mal ausführen
Wie man sieht, gibt es viele Möglichkeiten! Natürlich ist die erste die am häufigsten verwendete. Es lohnt sich jedoch, diese seltsamen Bedingungen zu üben, denn manchmal können sie die Dinge viel einfacher machen! Nun können wir uns wieder den Motoren zuwenden, insbesondere der sanften Drehzahlregelung.
Hausaufgabe 8.2
Schreibe ein Programm, das eine for-Schleife verwendet, um eine LED 5 Mal blinken zu lassen. Versuche auch, dasselbe mit einer while-Schleife zu schreiben.
Hausaufgabe 8.3
Schreibe ein Programm, das eine über den UART gesendete Zahl im Bereich 0-9 liest und dann die gleiche Anzahl von Sternchen * auf dem Bildschirm anzeigt.
Sanfte Beschleunigung des Motors
Jetzt, da wir die for-Schleife kennen, können wir sie verwenden, um den Motor sanft zu beschleunigen. Alles, was wir tun müssen, ist, den Füllstand des PWM-Signals gleichmäßig zu ändern, zum Beispiel alle 25 ms.
Der Code ist einfach und stellt sich wie folgt dar, da die Zählervariable i für den Füllstand des PWM-Signals verantwortlich ist:
void setup() {
pinMode(6, OUTPUT); //PWM-Signal von Motor Nr. 1
pinMode(7, OUTPUT); //Signale zur Steuerung der Drehrichtung von Motor Nr. 1
pinMode(8, OUTPUT);
digitalWrite(7, LOW); //Motor Nr. 1 - Drehung nach links
digitalWrite(8, HIGH);
}
void loop() {
for (int i = 0; i <= 255; i++) {
analogWrite(6, i); //Sanfte Motorbeschleunigung
delay(25);
}
}
Dabei ist zu bedenken, dass der Motor relativ schwer zu starten ist. Er muss sich erst hochdrehen und die Reibung in seinem Inneren überwinden. Außerdem gibt er ein quietschendes Geräusch von sich, bevor er sich zu drehen beginnt. Das kann man im folgenden Video hören:
Es lohnt sich, diese Tatsache zu bedenken. Oft haben Anfänger Probleme, weil ihr Roboter nicht fahren will. Meistens stellt sich heraus, dass entweder die verwendete Stromversorgung zu schwach ist oder das PWM-Signal noch zu wenig Füllung hat.
Hausaufgabe 8.4
Schreibe ein Programm, das mit Hilfe von 2 for-Schleifen den Motor gleichmäßig beschleunigt und abbremst.
Zusammenfassung
Damit ist der Teil über die Steuerung von Gleichstrommotoren abgeschlossen, der ursprünglich relativ kurz sein sollte. Es ist jedoch etwas mehr geworden, aber ich wollte euch mehr Informationen geben, damit ihr keine Probleme habt, die Motoren in euren eigenen Konstruktionen einzusetzen. Aufgrund des fehlenden Motors war dieser Teil für euch ein wenig theorielastig. Wir werden aber bei Bedarf in der Fortsetzung des Kurses mit den entsprechenden Antrieben auf diese Themen zurückkommen!
Im nächsten Teil des Kurses werden wir uns mit dem Umgang mit dem Ultraschall-Entfernungssensor und dem Schreiben eigener Funktionen (mit und ohne Argumente) beschäftigen. Das wird unsere Programme noch besser aussehen lassen!
