Umdrehungs-Labor

Erst verstehen, dann ausprobieren

Ein Impuls ist ein Wechsel, kein Dauerzustand

HIGH und LOW sind zwei elektrische Signalzustände. Im Modell bedeutet HIGH: Licht kommt durch einen Schlitz. LOW bedeutet: Die Scheibe verdeckt das Licht. Die Kurve zeigt diese Zustände über die Zeit.

Gezählt wird der Wechsel von LOW zu HIGH. Das ist eine steigende Flanke. Bleibt ein Schlitz vor dem Sensor stehen, bleibt das Signal HIGH; es kommen dabei keine neuen Impulse hinzu. Jeder neue Schlitz erzeugt wieder einen Wechsel.

Eine Scheibe mit 10 Schlitzen liefert bei einer ganzen Umdrehung 10 Impulse. Die Anzahl der Impulse verrät die Strecke; die Impulse pro Sekunde verraten die Geschwindigkeit. Das sind zwei verschiedene Fragen.

Überleg kurz: Die Scheibe steht still und die Lampe leuchtet. Sollte der Zähler weiterlaufen?

Am echten Sensormodul können HIGH und LOW vertauscht sein. Beobachte zuerst deinen Sensor. Wichtig ist, pro Schlitz immer dieselbe Flanke zu zählen.

Bevor du die Vorlage ausfüllst

Der Sensor klingelt: Was macht ein Interrupt (Unterbrechung)?

Stell dir vor, du baust etwas und jemand klingelt. Du unterbrichst kurz deine Arbeit, machst einen Strich auf einer Liste und arbeitest dann an derselben Stelle weiter. So funktioniert hier das Zählen.

Der Signalwechsel am Sensor ist das Ereignis. Er löst einen Interrupt (Unterbrechung) aus. Der Arduino führt kurz onPulse() aus und setzt danach das Hauptprogramm fort. In onPulse() steht nur der Zählschritt. Längere Arbeiten erledigen wir in loop().

counter und counter++

Die Variable ist unsere Strichliste. ++ erhöht ihren Wert um genau eins.

long

Ein Datentyp für ganze Zahlen mit viel Platz. Auf dem Uno R3 reicht int nur bis 32767; long kann deutlich mehr Impulse speichern.

volatile

Ein Hinweis an den Compiler, der dein Programm übersetzt: „Diese Variable kann auch durch den Interrupt (Unterbrechung) geändert werden. Lies ihren aktuellen Wert aus dem Speicher.“ Wie wir die ganze Zahl sicher lesen, lernst du gleich nach der Vorlage.

attachInterrupt(..., onPulse, RISING)

Verbindet den Sensor mit unserer Funktion. digitalPinToInterrupt(SENSOR_PIN) sucht die passende Interruptnummer. onPulse ist der Funktionsname; RISING bedeutet: beim Wechsel von LOW zu HIGH reagieren.

setup() und loop()

setup() richtet beim Start einmal alles ein. loop() läuft danach immer wieder. pinMode(..., INPUT) stellt den Sensorpin als Eingang ein.

Überleg kurz: Warum reicht in onPulse() ein einziger Zählschritt?

Auf Deutsch nachlesen: Arduino: attachInterrupt() und RISING.

Vor deiner ersten Ausgabe im Serial Monitor

Warum wir den Zähler nur mit einer kurzen Lesepause kopieren

Der Zähler kann sich genau dann ändern, wenn dein Hauptprogramm ihn liest. Auf dem Uno R3 besteht eine long-Zahl aus vier Speicherteilen, den Bytes. Der Prozessor liest sie nacheinander. Kommt dazwischen ein Impuls, könnten Teile vom alten und vom neuen Wert zusammenkommen. Das Ergebnis wäre falsch.

Stell dir ein Zahlentableau vor, auf dem gerade die Ziffern wechseln. Für eine verlässliche Abschrift brauchen wir einen ganz kurzen, ungestörten Moment. volatile allein sorgt noch nicht für diesen Moment.

1. Kurz sperrennoInterrupts() verhindert vorübergehend, dass ein Interrupt (Unterbrechung) den Kopiervorgang unterbricht.
2. Zahl kopierenWir übernehmen counter vollständig in eine eigene Variable.
3. Sofort freigebeninterrupts() erlaubt die Bearbeitung der Interrupts (Unterbrechungen) wieder. Danach benutzen wir die Kopie.

Diese Hilfsfunktion kannst du unterhalb von onPulse(), außerhalb der anderen Funktionen, in dein Programm übernehmen:

readCounter() ist ein selbst gewählter Funktionsname. Bei jedem Aufruf erhältst du mit return eine sichere Momentaufnahme. Der Sensor und das Rad arbeiten währenddessen weiter.

Die Pause bleibt winzig: Zwischen noInterrupts() und interrupts() steht nur das Kopieren. Serial.println() und delay() gehören danach. Eine lange Sperre kann Impulse kosten.

Für die nächste Aufgabe: Hole dir mit long aktuell = readCounter(); die Zahl, gib aktuell mit Serial.println(aktuell); aus und warte anschließend 200 Millisekunden. 1000 Millisekunden sind eine Sekunde. Öffne in der Arduino-IDE den Serial Monitor und stelle passend zu Serial.begin(9600) die Geschwindigkeit 9600 Baud ein.

Auf Deutsch nachlesen: Arduino: volatile und mehrteilige Zähler · Arduino: noInterrupts().

So liest du den nächsten Versuch

Eine Abfrage sieht nur den Augenblick

Wenn du nur ab und zu durch ein Fenster schaust, kann jemand zwischen zwei Blicken vorbeilaufen. Genauso kann eine Abfrage einen vollständigen HIGH-Impuls übersehen. Je schneller das Rad dreht, desto kürzer wird jeder Impuls.

delay(25) hält das Hauptprogramm 25 Millisekunden an. Währenddessen fragt loop() den Pin nicht ab. Aktivierte Interrupts (Unterbrechungen) können aber weiterhin unsere kurze Zählfunktion aufrufen.

Die obere Kurve zeigt das Signal. Die Markierungen zeigen die Abfragezeitpunkte. „Verloren“ vergleicht die Anzahl der erkannten Impulse. Ändere zuerst nur die Pause, dann nur die Drehzahl: So erkennst du, welche Änderung welche Wirkung hat.

Überleg kurz: Reicht es, einmal nachzuschauen, wenn der gesamte Impuls zwischen zwei Blicken liegt?

Vor der ersten Messung

PWM ist ein Stellwert, keine gemessene Geschwindigkeit

PWM heißt Pulsweitenmodulation. Der Ausgang schaltet schnell zwischen an und aus. Bei 0 bleibt er aus, bei 255 bleibt er an. Bei ungefähr 128 ist er etwa die Hälfte der Zeit an. analogWrite() stellt dieses Verhältnis an einem passenden PWM-Pin ein.

Unser Motor bekommt seine Energie über einen Motortreiber; der Arduino gibt diesem die Steuersignale. Ein Motor wird nicht direkt aus einem Arduino-Pin versorgt. Nutze die bereits aufgebaute Motorschaltung aus deinem Kurs.

Eine PWM von 128 bedeutet deshalb nicht automatisch halbe Drehzahl. Reibung, Belastung und Batterie spielen mit. Unterhalb der Anlaufschwelle reicht die Wirkung noch nicht, um den stehenden Motor in Bewegung zu setzen. Diese Schwelle findest du durch Messungen.

So liest du das Diagramm: Waagerecht steht die PWM, senkrecht stehen die gemessenen Impulse pro Sekunde. Jeder Klick auf „1 Sekunde messen“ fügt einen Messpunkt und eine Tabellenzeile hinzu. Suche zuerst, ab wann überhaupt Impulse auftreten. Vergleiche danach mehrere höhere PWM-Werte.

Auf Deutsch nachlesen: Arduino: analogWrite() und PWM.

Bevor du am echten Motor misst

Eine Messung braucht einen Anfang und ein Ende

Der Zähler enthält auch die Impulse von vorher. Deshalb liest du mit readCounter() zuerst den Startwert, wartest eine Sekunde und liest den Endwert wieder sicher. Die Differenz Endwert − Startwert gehört zu dieser einen Sekunde.

Beispiel: Am Anfang steht 1200, am Ende 1230. Dazwischen kamen 30 Impulse an. Bei einer Scheibe mit 20 Schlitzen sind das 30 ÷ 20 = 1,5 Umdrehungen pro Sekunde. Für Umdrehungen pro Minute multiplizierst du mit 60.

Verwende die Funktion readCounter() aus Mission 1 weiter. Während der Sekunde bleiben die Interrupts (Unterbrechungen) aktiviert, damit der Sensor weiterzählen kann.

Vor der Zielfahrt

Früher ausschalten und trotzdem am Ziel ankommen

Ein rollendes Rad hat Schwung. Auch nach dem Ausschalten bewegt es sich weiter. Der Vorhalt ist die Anzahl der Impulse, um die du den Motor vor dem Ziel ausschaltest. Ein Beispiel: Das Ziel liegt bei 80 Impulsen, der gemessene Nachlauf beträgt 6. Dann probierst du das Ausschalten bei 74.

Dieser Wert passt nur zu ähnlichen Bedingungen. Bei höherer Geschwindigkeit ist der Nachlauf oft größer. Wenn du die letzten Impulse langsamer fährst, wird die Ankunft leichter vorhersehbar. Die schnelle Bremse ist eine weitere Möglichkeit des Motortreibers.

Die im Simulator gezeigte Bremsstellung mit beiden Eingängen auf HIGH gilt nicht für jeden Treiber. Für deinen echten Roboter verwendest du die Bremsfunktion und Anschlussbelegung aus dem Kurs beziehungsweise Datenblatt.

Was dein Fahrprogramm nacheinander tun muss

revs ist die gewünschte Anzahl der Umdrehungen. SLOTS ist die Anzahl der Schlitze pro Umdrehung. Aus beiden entsteht das Ziel target in Impulsen. Beispiel: 2,5 Umdrehungen mit 12 Schlitzen ergeben 30 Impulse.

Setze den Zähler bei stehendem Motor kurz geschützt auf null, schalte die Interrupts (Unterbrechungen) sofort wieder ein und starte dann den Motor. Auch beim Zurücksetzen darf kein Zählschritt dazwischenkommen:

while (readCounter() < target) bedeutet: „Wiederhole den Schleifenkörper, solange das Ziel noch nicht erreicht ist.“ Prüfe den Zähler bei jedem Durchlauf über die Lesefunktion. Die Interrupts (Unterbrechungen) bleiben zwischen den kurzen Lesezugriffen aktiv. Sobald die Bedingung falsch wird, geht es hinter der Schleife weiter; dort schaltest du den Motor aus.

Überleg kurz: Was würde passieren, wenn die Interrupts (Unterbrechungen) während der ganzen Warteschleife gesperrt blieben? Ohne neue Zählschritte würde das Ziel nie erreicht.

Auch ein nicht angeschlossener Sensor kann die Warteschleife endlos laufen lassen. Teste zuerst mit angehobenen Rädern und ergänze für eigene Projekte eine Zeitgrenze zum Abschalten.

Auf Deutsch nachlesen: Arduino: while-Schleifen.

Bevor du beide Motoren vergleichst

Warum gleiche Befehle noch keine Gerade ergeben

Bei gleicher Scheibe bedeuten mehr Impulse am linken Rad: Links wurde mehr Weg zurückgelegt. Das linke Rad läuft dann dem rechten voraus. Wie beim Lenken mit zwei Ruderblättern dreht der Roboter zur langsameren Seite, hier nach rechts.

Vergleiche die Zähler über denselben Zeitraum und mit demselben Startpunkt. Zählerdifferenz = linker Zähler − rechter Zähler. Ein positiver Wert bedeutet: Links liegt vorne. Ein negativer Wert bedeutet: Rechts liegt vorne.

Am echten Roboter erhält jedes Rad einen eigenen Sensor und einen eigenen volatile long-Zähler: countL für links und countR für rechts. Der linke Sensor an D2 erhöht nur countL, der rechte an D3 nur countR. Dazu richtest du zwei kurze Zählfunktionen und zwei Aufrufe von attachInterrupt() nach dem Muster aus Mission 1 ein.

Du kannst den schwächeren Motor von Hand mit etwas mehr PWM unterstützen. Ändern sich Batterie oder Boden, kann diese Einstellung wieder falsch sein. Deshalb soll der Roboter im nächsten Schritt laufend messen und selbst nachstellen.

Überleg kurz: Links stehen 70 Impulse, rechts 74. Welches Rad hat mehr Weg zurückgelegt, und zu welcher Seite wird der Roboter gelenkt?

Bevor du den Regelkreis zusammensetzt

Messen → vergleichen → nachstellen → wieder messen

Wir wollen, dass beide Räder gleich viele Impulse zählen. Dazu übernimmt das Programm die beiden Zähler gemeinsam während einer kurzen Lesepause in l und r. Anschließend berechnet es diff = l - r.

KP ist die Stärke der Korrektur. Je größer die Abweichung und je größer KP, desto stärker ändert der Regler die PWM. Läuft links voraus, wird links weniger und rechts mehr eingestellt. Bei einer negativen Differenz wirken die gleichen Rechenzeichen automatisch andersherum.

Rechenbeispiel: Start-PWM 170, diff = 3 und KP = 4. Die Korrektur ist 4 × 3 = 12. Links erhält 170 − 12 = 158, rechts 170 + 12 = 182.

BASE und MIN_PWM

Die Ausgangs-PWM und die untere Grenze, bei der der Motor noch zuverlässig läuft. Diese Werte legt dein Programm fest.

constrain(wert, MIN_PWM, 255)

Begrenzt das Ergebnis auf den nutzbaren Bereich: zu kleine Werte werden angehoben, zu große auf 255 begrenzt.

forward(speedL, speedR)

Steht hier für eine selbst geschriebene Funktion, die beide Motoren über deinen Treiber vorwärts ansteuert. Sie gehört nicht zu den eingebauten Arduino-Befehlen.

delay(20)

Bis zur nächsten Korrektur vergehen 20 Millisekunden. Die kurzen Zählfunktionen arbeiten weiter. Danach beginnt der Regelkreis erneut.

Zu große Korrekturen können den Roboter abwechselnd nach links und rechts lenken. Zu lange Pausen machen jede Korrektur spät. Ändere im Versuch immer erst einen Regler und beobachte die Wirkung.

Auf Deutsch nachlesen: Arduino: constrain(). Die sichere Lesepause erklärt Mission 1.

Vor den Rechenaufgaben

Von einer Radumdrehung zur Fahrstrecke

Bei einer ganzen Umdrehung rollt das Rad genau seinen Umfang ab, solange es nicht rutscht. Der Umfang ist π × Durchmesser. π sprichst du „Pi“; zum Rechnen kannst du ungefähr 3,14 nehmen.

Nennen wir den Raddurchmesser d, die Strecke s und die Schlitzzahl N. Teile zuerst die gewünschte Strecke durch den Radumfang. Das ergibt die nötigen Umdrehungen. Multipliziere anschließend mit N:

Impulse = s ÷ (π × d) × N

Beispiel: Ein Rad mit 8 cm Durchmesser und 16 Schlitzen soll 20 cm fahren. Eine Umdrehung schafft ungefähr 25,13 cm. Du brauchst 20 ÷ 25,13 ≈ 0,80 Umdrehungen und damit etwa 12,7 Impulse. Der Sensor zählt ganze Impulse: Du rundest hier auf 13.

Was ändert sich bei einer Drehung auf der Stelle?

Ein Rad fährt vorwärts, das andere rückwärts. Die Mitte zwischen den beiden Antriebsrädern bleibt ungefähr am selben Ort. Jedes Antriebsrad bewegt sich auf einem Kreis, dessen Durchmesser der Radabstand W ist. Eine volle 360°-Drehung bedeutet für jedes Rad einen Weg von π × W. Für 90° brauchst du nur ein Viertel davon.

Weg je Rad = π × W × Winkel ÷ 360
Impulse je Rad = N × W × Winkel ÷ (360 × d)

Beispiel: d = 8 cm, W = 16 cm, N = 20 und Winkel = 90°. Es ergeben sich 20 × 16 × 90 ÷ (360 × 8) = 10 Impulse je Rad. Die Fahrtrichtung legst du im Motorprogramm fest; ein einzelner Sensor erkennt sie nicht.

Vor dem Einsetzen prüfen: Raddurchmesser, Radabstand und Strecke müssen dieselbe Einheit haben, hier Zentimeter. Beim echten Roboter können Rutschen und Nachlauf das Ergebnis verändern. Miss nach und verbessere deine Werte.

Unser Roboter: zwei Motoren und ein passives Stützrad

So berechnest du die Drehung beim Zweiradroboter

Links und rechts sitzt je ein angetriebenes Rad. Das dritte Rad trägt einen Teil des Gewichts und rollt frei mit. Es braucht keinen Motor und keinen eigenen Impulszähler. Dieser Aufbau heißt Differentialantrieb. Die Formeln oben gelten auch für diesen Aufbau.

Raddurchmesser d

Der Durchmesser eines Antriebsrades einschließlich Reifen. Hier rechnen wir mit zwei gleich großen Antriebsrädern.

Radabstand W

Miss zwischen den Mitten der beiden Reifen auf der gemeinsamen Antriebsachse. Die Außenbreite des Gehäuses und der Abstand zum Stützrad gehören nicht in diese Formel.

Impulse pro Radumdrehung N

Zähle die Impulse für eine ganze Umdrehung des Antriebsrades. Sitzt die Scheibe direkt auf der Radachse, ist das ihre Schlitzzahl. Sitzt sie vor einem Getriebe, musst du dessen Übersetzung berücksichtigen oder N am Rad messen.

Fall A: Beide Räder bewegen sich — Drehung auf der Stelle

Für eine Linksdrehung fährt links rückwärts und rechts vorwärts, jeweils gleich weit. Für eine Rechtsdrehung vertauschst du die Richtungen. Das Drehzentrum liegt in der Mitte der Antriebsachse. Jedes Rad fährt auf einem Kreis mit dem Radius W ÷ 2.

Weg je Antriebsrad = π × W × Winkel ÷ 360
Impulse je Antriebsrad = N × W × Winkel ÷ (360 × d)

Fall B: Ein Antriebsrad bleibt stehen

Für eine Linksdrehung bleibt das linke Rad stehen, während das rechte vorwärtsfährt. Bei einer Rechtsdrehung bleibt das rechte stehen und das linke fährt vorwärts. Das Drehzentrum liegt jetzt am stehenden Rad. Der Radius für das fahrende Rad ist W — doppelt so groß wie in Fall A.

Weg des fahrenden Rades = 2 × π × W × Winkel ÷ 360
Impulse des fahrenden Rades = N × W × Winkel ÷ (180 × d)
Impulse des stehenden Rades = 0

Ein Beispiel für beide Fälle: d = 6 cm, W = 12 cm und N = 20. Bei 90° braucht Fall A je Rad 10 Impulse in entgegengesetzten Richtungen. In Fall B braucht das fahrende Rad 20 Impulse; das andere bleibt stehen. Bei 180° sind es entsprechend 20 je Rad beziehungsweise 40 am fahrenden Rad.

Was macht das Stützrad? Es folgt der Bewegung. Eine frei schwenkbare Rolle oder eine Kugelrolle kann sich dafür passend ausrichten. Seine Größe und sein Abstand zur Antriebsachse ändern diese idealen Formeln nicht. Reibung oder eine klemmende Rolle können die echte Drehung aber beeinflussen. Ein fest ausgerichtetes drittes Rad müsste bei einer solchen Drehung seitlich rutschen.

Für dein Programm: Zähle die Impulse jedes Antriebsrades getrennt und stoppe jedes Rad bei seinem eigenen Ziel. Beim Drehen auf der Stelle reicht es nicht, nur auf die Summe beider Zähler zu warten. In Fall B muss das stehende Rad tatsächlich stehen bleiben; eine passende Halte- oder Bremsfunktion hängt von deinem Motortreiber ab.

Auf Deutsch weiterlernen: TU Berlin: Radwege und Drehung beim Differentialantrieb.

Eine Funktion rechnet, zwei Funktionen bewegen den Roboter

cmToPulses(cm) berechnet mit deiner Formel die benötigten Impulse. float erlaubt Kommazahlen als Eingabe, etwa 12,5 cm; im C++-Code schreibst du dafür 12.5. long ist der ganzzahlige Rückgabewert. Runde dein Rechenergebnis passend und gib es mit return zurück.

driveCm(cm) benutzt diese Impulszahl als Fahrziel und die Stoppstrategie aus Mission 4. turnDeg(deg) berechnet das Ziel für jedes Rad bei einer Drehung auf der Stelle. void bedeutet: Die Funktion führt etwas aus, gibt aber keinen Zahlenwert zurück.

WHEEL_D, TRACK_W und SLOTS sind deine festen Robotermaße. const kennzeichnet Werte, die während des Programms unverändert bleiben. Lege für rückwärts und Drehungen ausdrücklich fest, welche Motoren in welche Richtung laufen.