Geschwindigkeits-, Entfernungs- und Winkelmessung für mobile Roboter mit Arduino und lm393 Geschwindigkeitssensor (h206)

Roboter haben langsam begonnen, in unsere Gesellschaft zu kriechen, um unser Leben einfacher zu machen. Wir können bereits die sechsrädrigen Lebensmittellieferroboter von Starship auf den Straßen Großbritanniens finden, die intelligent zwischen den Zivilisten navigieren, um ihr Ziel zu erreichen. Jeder mobile Roboter, der in die Umgebung navigiert, sollte sich immer seiner Position und Ausrichtung in Bezug auf die reale Welt bewusst sein. Es gibt viele Möglichkeiten, dies durch die Verwendung verschiedener Technologien wie GPS, HF-Triangulation, Beschleunigungsmesser, Gyroskope usw. zu erreichen. Jede Technik hat ihren eigenen Vorteil und ist für sich einzigartig. In diesem Tutorial zum Geschwindigkeitssensor LM393 von Arduino verwenden wir das einfache und leicht verfügbare Geschwindigkeitssensormodul LM393um einige wichtige Parameter wie Geschwindigkeit, zurückgelegte Strecke und Winkel des Roboters mit Arduino zu messen. Mit diesen Parametern kann der Roboter seinen realen Status erkennen und sicher navigieren.

Arduino ist die beliebteste Wahl unter Hobbyisten für den Bau von Robotern, vom einfachen Linienfolger bis zum komplexeren selbstausgleichenden oder Bodenreinigungsroboter. Sie können alle Arten von Robotern im Abschnitt Robotik überprüfen.

Wir werden einen kleinen Roboter bauen, der von einer Lithiumbatterie angetrieben wird, und ihn mit einem Joystick antreiben. Während der Laufzeit können wir die Geschwindigkeit, Entfernung und den Winkel des Roboters messen und in Echtzeit auf dem mit Arduino verbundenen LCD- Display anzeigen. Dieses Projekt hilft Ihnen nur bei der Messung dieser Parameter. Sobald Sie damit fertig sind, können Sie diese Parameter verwenden, um Ihren Bot nach Bedarf autonom zu betreiben. Klingt interessant, oder? Also lasst uns anfangen.

LM393 Geschwindigkeitssensormodul (H206)

Bevor wir uns mit dem Schaltplan und dem Code für das Projekt befassen, sollten wir das Geschwindigkeitssensormodul LM393 verstehen, da es eine wichtige Rolle im Projekt spielt. Das Geschwindigkeitssensormodul H206 besteht aus einem Infrarotlichtsensor, der in einen Spannungskomparator-IC LM393 integriert ist, daher der Name Geschwindigkeitssensor LM393. Das Modul besteht auch aus einer Gitterplatte, die an der rotierenden Welle des Motors montiert werden muss. Alle Komponenten sind im folgenden Bild gekennzeichnet.

Der Infrarotlichtsensor besteht aus einer IR-LED und einem Fototransistor, die durch einen kleinen Gab getrennt sind. Die gesamte Sensoranordnung befindet sich wie oben gezeigt in einem schwarzen Gehäuse. Die Gitterplatte besteht aus Schlitzen, die Platte ist zwischen dem Spalt des Infrarotlichtsensors so angeordnet, dass der Sensor die Lücken in der Gitterplatte erfassen kann. Jede Lücke in der Gitterplatte löst den IR-Sensor aus, wenn sie durch die Lücke geht. Diese Trigger werden dann unter Verwendung des Komparators in Spannungssignale umgewandelt. Der Komparator ist nichts anderes als ein LM393-IC von ON-Halbleitern. Das Modul verfügt über drei Pins, von denen zwei zur Stromversorgung des Moduls und ein Ausgangspin zum Zählen der Anzahl der Trigger verwendet werden.

Montageanordnung für den H206-Sensor

Die Montage dieser Sensortypen ist etwas schwierig. Es kann nur an Motoren montiert werden, deren Welle auf beiden Seiten hervorsteht. Eine Seite der Welle ist mit dem Rad verbunden, während die andere Seite zur Montage der Gitterplatte wie oben gezeigt verwendet wird.

Da das Rad und die Platte mit derselben Welle verbunden sind, drehen sich beide mit derselben Geschwindigkeit. Durch Messen der Geschwindigkeit der Platte können wir die Geschwindigkeit des Rads messen. Stellen Sie sicher, dass die Lücken in der Gitterplatte durch den IR-Sensor verlaufen. Erst dann kann der Sensor die Anzahl der durchgelassenen Lücken zählen. Sie können auch eine eigene mechanische Anordnung entwickeln, um den Sensor zu montieren, solange er die angegebene Bedingung erfüllt. Der IR-Sensor wird im Allgemeinen in vielen Robotikprojekten verwendet, um den Roboter über die Hindernisse zu führen.

Die oben gezeigte Gitterplatte hat 20 Schlitze (Gitter). Dies bedeutet, dass der Sensor 20 Lücken für eine vollständige Umdrehung des Rads findet. Indem wir die Anzahl der vom Sensor erkannten Lücken zählen, können wir die vom Rad zurückgelegte Strecke berechnen, indem wir messen, wie schnell der Sensor die Lücken findet, mit denen wir die Geschwindigkeit des Rads erkennen können. In unserem Roboter wird dieser Sensor an beiden Rädern montiert und somit können wir auch den Winkel des Roboters ermitteln. Der Drehwinkel kann jedoch mit dem Beschleunigungsmesser oder Gyroskop sinnvoller berechnet werden. Lernen Sie hier, wie Sie den Beschleunigungsmesser und das Gyroskop mit Arduino verbinden und versuchen, den Drehwinkel mit ihnen zu messen.

DIY Arduino LM393 Geschwindigkeitssensor Roboter Schaltplan

Das vollständige Schaltbild dieses Geschwindigkeits- und Entfernungsmessroboters ist unten dargestellt. Der Bot besteht aus Arduino Nano als Gehirn, die beiden Gleichstrommotoren für die Räder werden vom L298N H-Bridge Motor Driver-Modul angetrieben. Der Joystick dient zur Steuerung der Geschwindigkeit und Richtung des Bots und die beiden Geschwindigkeitssensoren H206 zur Messung der Geschwindigkeit, Entfernung und des Engels des Bots. Die gemessenen Werte werden dann im 16x2 LCD-Modul angezeigt. Mit dem an das LCD angeschlossenen Potentiometer kann der Kontrast des LCD eingestellt werden, und mit dem Widerstand wird der Strom begrenzt, der zur Hintergrundbeleuchtung des LCD fließt.

Der gesamte Stromkreis wird von einer 7,4-V-Lithiumzelle gespeist. Diese 7,4 V werden an den 12 V-Pin des Motortreibermoduls geliefert. Der Spannungsregler am Motortreibermodul wandelt dann die 7,4 V in geregelte + 5 V um, die zur Stromversorgung von Arduino, LCD, Sensoren und Joystick verwendet werden.

Der Motor wird von den digitalen Pins 8, 9, 10 und 11 des Arduino gesteuert. Da auch die Drehzahl des Motors geregelt werden muss, sollten PWM-Signale an den Pluspol des Motors geliefert werden. Daher haben wir Pin 9 und 10, die beide PWM-fähige Pins sind. Die X- und Y-Werte des Joysticks werden mit den Analogstiften A2 bzw. A3 gelesen.

Wie wir wissen, erzeugt der H206-Sensor einen Trigger, wenn der Spalt in der Gitterplatte erkannt wird. Da diese Trigger nicht immer genau gelesen werden sollten, um die richtige Geschwindigkeit und Entfernung zu berechnen, sind beide Trigger- (Ausgangs-) Pins mit den externen Interrupt-Pins 2 und 3 der Arduino-Platine verbunden. Bauen Sie die gesamte Schaltung auf einem Chassis zusammen und montieren Sie den Geschwindigkeitssensor wie beschrieben. Mein Bot sah nach Abschluss der Verbindungen wie folgt aus. Sie können sich auch das Video am Ende dieser Seite ansehen, um zu erfahren, wie der Sensor montiert wurde.

Nachdem der Hardware-Teil abgeschlossen ist, wollen wir uns mit der Logik befassen, wie wir die Geschwindigkeit, Entfernung und den einzelnen Bot messen, und dann mit dem Programmierabschnitt fortfahren.

Logik hinter der Geschwindigkeitsmessung mit dem Geschwindigkeitssensormodul LM393

Bei der Einrichtung der Sensormontage sollten Sie beachten, dass das Geschwindigkeitssensormodul LM393 (H206) nur die in der Gitterplatte vorhandenen Lücken misst. Bei der Montage sollte darauf geachtet werden, dass sich das Rad (dessen Geschwindigkeit gemessen werden soll) und die Gitterplatte mit der gleichen Geschwindigkeit drehen. Wie hier, da wir sowohl das Rad als auch die Platte auf derselben Welle montiert haben, drehen sich beide offensichtlich mit derselben Geschwindigkeit.

In unserem Setup haben wir zwei Sensoren für jedes Rad montiert, um den Winkel des Bots zu messen. Wenn Sie jedoch nur die Geschwindigkeit und die Entfernung messen möchten, können wir den Sensor an jedem Rad montieren. Der Ausgang des Sensors (Triggersignale) wird am häufigsten mit einem externen Interrupt-Pin eines Mikrocontrollers verbunden. Jedes Mal, wenn die Lücke in der Gitterplatte erkannt wird, wird ein Interrupt ausgelöst und der Code in der ISR (Interrupt Service Routine) ausgeführt. Wenn wir das Zeitintervall zwischen zwei solchen Auslösern berechnen können, können wir die Geschwindigkeit des Rades berechnen.

In Arduino können wir dieses Zeitintervall einfach mit der Funktion millis () berechnen. Diese Millis-Funktion wird ab dem Zeitpunkt des Einschaltens des Geräts jede Millisekunde um 1 Millisekunde erhöht. Wenn also der erste Interrupt auftritt, können wir den Wert von millis () in einer Dummy-Variablen speichern (wie in diesem Code pevtime ), und wenn der zweite Interrupt auftritt, können wir die Zeit berechnen, die durch Subtrahieren des pevtime- Werts von millis () benötigt wird..

Zeitaufwand = aktuelle Zeit - vorheriger Zeitaufwand = millis () - pevtime ; // Zeitplan in Millisekunden

Sobald wir die benötigte Zeit berechnet haben, können wir einfach den Wert der Drehzahl unter Verwendung der folgenden Formeln berechnen, wobei (1000 / Zeitplan) den RPS (Umdrehungen pro Sekunde) angibt und mit 60 multipliziert wird, um RPS in RPM (Umdrehungen pro Minute) umzuwandeln..

U / min = (1000 / Zeitplan) * 60;

Nach der Berechnung der Drehzahl können wir die Geschwindigkeit des Fahrzeugs anhand der folgenden Formeln berechnen, sofern wir den Radius des Rades kennen.

Geschwindigkeit = 2π × RPS × Radius. v = Radius des Rades * U / min * 0,104

Beachten Sie, dass die obige Formel zur Berechnung der Geschwindigkeit in m / s dient. Wenn Sie in km / h berechnen möchten, ersetzen Sie 0,0104 durch 0,376. Wenn Sie neugierig sind, wie der Wert 0,104 erhalten wurde, versuchen Sie, die Formel V = 2π × RPS × Radius des Rads zu vereinfachen.

Die gleiche Technik wird auch dann angewendet, wenn ein Hallsensor zum Messen der Geschwindigkeit eines rotierenden Objekts verwendet wird. Für den H206-Sensor gibt es jedoch einen Haken, die Gitterplatte hat 20 Steckplätze und daher wird der Mikrocontroller überlastet, um die Zeit zwischen zwei Steckplatzlücken zu messen. Daher messen wir die Geschwindigkeit nur bei voller Drehung eines Rades. Da für jede Lücke zwei Interrupts generiert werden (einer am Anfang und einer am Ende der Lücke), erhalten wir insgesamt 40 Interrupts für das Rad, um eine vollständige Umdrehung durchzuführen. Wir warten also auf 40 Interrupts, bevor wir die Geschwindigkeit des Rades berechnen. Der Code dafür ist unten gezeigt

if (Rotation> = 40) { timetaken = millis () - pevtime; // Zeitplan in Millisekunden U / min = (1000 / Zeitplan) * 60; // Formeln zur Berechnung der Drehzahl pevtime = millis (); Drehung = 0; }}

Ein weiterer Nachteil dieser Methode besteht darin, dass der Wert der Geschwindigkeit nicht auf Null abfällt, da der Interrupt immer darauf wartet, dass das Rad eine Umdrehung zur Berechnung des Drehzahlwerts ausführt. Dieser Nachteil kann leicht überwunden werden, indem ein einfacher Code hinzugefügt wird, der das Zeitintervall zwischen zwei Interrupts überwacht. Wenn es den Normalwert überschreitet, können wir den Wert von U / min und Geschwindigkeit auf Null setzen. Link im folgenden Code Wir haben die Variable dtime verwendet , um die Zeitdifferenz zu überprüfen. Wenn sie 500 Millisekunden überschreitet, wird der Wert von Geschwindigkeit und Drehzahl auf Null gesetzt.

/ * Bei stehendem Fahrzeug auf Null fallen * / if (millis () - dtime> 500) // 500 ms lang kein Inrupt gefunden { rpm = v = 0; // Drehzahl und Geschwindigkeit auf Null setzen dtime = millis (); }}

Logik hinter der Messung der vom Rad zurückgelegten Strecke

Wir wissen bereits, dass der Arduino 40 Interrupts erkennt, wenn das Rad eine vollständige Umdrehung ausführt. Für jede Umdrehung des Rades ist also ersichtlich, dass die vom Rad zurückgelegte Strecke gleich dem Umfang des Rades ist. Da wir den Radius des Rades bereits kennen, können wir die zurückgelegte Strecke mit der folgenden Formel leicht berechnen

Abstand = 2πr * Anzahl der Umdrehungen Abstand = (2 * 3,141 * Radius des Rades) * (left_intr / 40)

Wenn der Umfang des Rades unter Verwendung der Formel 2πr berechnet und dann mit der Anzahl der vom Rad ausgeführten Umdrehungen multipliziert wird.

Logik hinter dem Messen des Winkels des Bots

Es gibt viele Möglichkeiten, den Engel des Roboters zu bestimmen. Beschleunigungsmesser und Gyroskope werden normalerweise verwendet, um diese Werte zu bestimmen. Ein weiterer billiger Ansatz ist die Verwendung des H206-Sensors an beiden Rädern. Auf diese Weise würden wir wissen, wie viele Umdrehungen jedes Rad gemacht hat. Die folgende Abbildung zeigt, wie der Winkel berechnet wird.

Wenn der Roboter initialisiert wird, wird der Blickwinkel als 0 ° betrachtet. Von dort dreht es sich nach links, der Winkel wird negativ erhöht, und wenn es sich nach rechts dreht, wird der Engel positiv erhöht. Betrachten wir zum Verständnis den Bereich von -90 bis +90, wie in der Abbildung gezeigt. Da bei einer solchen Anordnung beide Räder den gleichen Durchmesser haben, drehen wir den Bot in einem Winkel von 90 °, wenn eines der Räder den Bot vollständig dreht.

Wenn das linke Rad beispielsweise eine vollständige Umdrehung ausführt (80 Interrupts), dreht sich der Bot um 90 ° nach links. Wenn das rechte Rad eine vollständige Umdrehung ausführt (80 Interrupts), dreht sich der Bot um -90 ° nach rechts. Jetzt wissen wir, dass sich der Bot um 90 ° gedreht hat, wenn der Arduino 80 Interrupts auf einem Rad erkennt, und anhand des Rads können wir feststellen, ob sich der Bot positiv (rechts) oder negativ (links) gedreht hat. So kann der linke und rechte Winkel mit den folgenden Formeln berechnet werden

int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);

Wobei 90 der Winkel ist, der bei einem Interrupt von 80 abgedeckt wird. Der resultierende Wert ist multiplizierte Anzahl Interrupts. Wir haben auch einen Modul von 360 verwendet, damit der resultierende Wert niemals 36 überschreitet. Sobald wir sowohl den linken als auch den rechten Winkel berechnet haben, kann der effektive Winkel, unter dem der Bot steht, einfach durch Subtrahieren des linken Winkels vom rechten Winkel erhalten werden.

angle = angle_right - angle_left;

Arduino Robot Code

Den vollständigen Arduino-Code für diesen Geschwindigkeits- und Winkelmessroboter finden Sie am Ende dieser Seite. Ziel des Programms ist es, die Geschwindigkeit, Entfernung und den Winkel des Bots anhand der obigen Logik zu berechnen und auf dem LCD-Bildschirm anzuzeigen. Abgesehen davon sollte es eine Option bieten , den Bot mit dem Joystick zu steuern.

Wir starten das Programm, indem wir die digitalen E / A-Pins für die beiden Motoren definieren. Beachten Sie, dass wir auch die Geschwindigkeit des Motors steuern müssen und daher die PWM-Pins von Arduino verwenden müssen, um die Motoren zu steuern. Hier haben wir den Pin 8,9,10 und 11 verwendet.

#define LM_pos 9 // linker Motor #define LM_neg 8 // linker Motor #define RM_pos 10 // rechter Motor #define RM_neg 11 // rechter Motor #define joyX A2 #define joyY A3

Um die Geschwindigkeit und die zurückgelegte Strecke zu messen, müssen wir den Radius des Rades kennen, den Wert messen und wie unten gezeigt in Metern eingeben. Für meinen Bot betrug der Radius 0,033 Meter, aber er kann für Sie je nach Bot unterschiedlich sein.

float radius_of_wheel = 0.033; // Messen Sie den Radius Ihres Rades und geben Sie ihn hier in cm ein

Innerhalb der Setup- Funktion initialisieren wir alle Werte auf Null und zeigen dann einen Einführungstext auf dem LCD an. Wir haben auch den seriellen Monitor für Debugging-Zwecke initialisiert. Dann haben wir erwähnt, dass die Geschwindigkeitssensoren H206 als externe Interrupts an Pin 2 und 3 angeschlossen sind. Dort, wo der Interrupt erkannt wird, werden die ISR-Funktionen Left_ISR und Right_ISR entsprechend ausgeführt.

void setup () { Rotation = U / min = Pevtime = 0; // Alle Variablen auf Null initialisieren Serial.begin (9600); lcd.begin (16, 2); // 16 * 2 LCD lcd.print ("Bot Monitor") initialisieren ; // Intro Message Zeile 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message Line 2 Delay (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, OUTPUT); pinMode (LM_neg, OUTPUT); pinMode (RM_pos, OUTPUT); pinMode (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR wird aufgerufen, wenn der linke Radsensor ausgelöst wird attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR wird aufgerufen, wenn der rechte Radsensor ausgelöst wird }

Innerhalb der Left_ISR-Routine erhöhen wir einfach eine Variable namens left_intr, die später zum Messen des Winkels des Bots verwendet wird. Innerhalb des Right_ISR machen wir dasselbe, aber zusätzlich berechnen wir hier auch die Geschwindigkeit. Die variable Drehung wird für jeden Interrupt erhöht und dann wird die obige Logik verwendet, um die Geschwindigkeit zu berechnen.

void Left_ISR () { left_intr ++; delay (10); } void Right_ISR () { right_intr ++; Verzögerung (10); Rotation ++; dtime = millis (); if (Rotation> = 40) { timetaken = millis () - pevtime; // Zeitplan in Millisekunden U / min = (1000 / Zeitplan) * 60; // Formeln zur Berechnung der Drehzahl pevtime = millis (); Drehung = 0; } }

Innerhalb der Haupt-Endlosschleifenfunktion überwachen wir die Werte von X und Y vom Joystick aus. Basierend auf dem Wert, wenn der Joystick bewegt wird, steuern wir den Bot entsprechend. Die Geschwindigkeit des Bots hängt davon ab, wie weit der Joystick gedrückt wird.

int xValue = analogRead (joyX); int yValue = analogRead (joyY); int Beschleunigung = Karte (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, Beschleunigung); analogWrite (RM_pos, Beschleunigung); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);

Dies hilft dem Benutzer, den Bot zu bewegen und zu überprüfen, ob die erhaltenen Werte den Erwartungen entsprechen. Schließlich können wir die Geschwindigkeit, Entfernung und den Winkel des Bots mithilfe der obigen Logik berechnen und mit dem folgenden Code auf dem LCD anzeigen.

v = Radius des Rades * U / min * 0,104; //0.033 ist der Radius des Rades in Meter Abstand = (2 * 3.141 * Radius des Rades) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); angle = angle_right - angle_left; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (Entfernung); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (Winkel);

Testen des Arduino-Roboters zur Messung von Entfernung, Geschwindigkeit und Winkel

Sobald Ihre Hardware fertig ist, laden Sie den Code in Ihr Arduino hoch und bewegen Sie Ihren Bot mit dem Joystick. Die Geschwindigkeit des Bots, die von ihm zurückgelegte Entfernung und der Winkel werden wie unten gezeigt auf dem LCD angezeigt.

Auf dem LCD stehen die Begriffe Lt und Rt für die Anzahl der linken Interrupts bzw. die Anzahl der rechten Interrupts. Sie können feststellen, dass diese Werte für jede vom Sensor erkannte Lücke erhöht werden. Das Tem S gibt die Geschwindigkeit des Bots in m / s an und der Term D gibt die zurückgelegte Entfernung in Metern an. Der Winkel des Bots wird am Ende angezeigt, wobei 0 ° für Gerade steht und bei Drehung gegen den Uhrzeigersinn negativ und bei Drehung im Uhrzeigersinn positiv ist.

Sie können sich auch das Video am Ende dieser Seite ansehen, um zu verstehen, wie der Bot funktioniert. Ich hoffe, Sie haben das Projekt verstanden und es genossen, es zu bauen. Wenn Sie irgendwelche Bedenken haben, lassen Sie sie im Kommentarbereich und ich werde versuchen, am besten zu antworten. Sie können auch Foren für schnelle technische Hilfe verwenden.