Viele von uns haben zu Hause irgendein Spielzeug, das wir aufbewahrt haben, ohne zu wissen, was wir damit machen sollen. Vielleicht weil wir nicht wissen, wie man es benutzt, oder es hat sehr einfache Funktionen (wie in meinem Fall) und ist damit etwas zu langweilig geworden. Ich wollte die Funktionen erweitern. So können wir ein bisschen Einfallsreichtum, ein bisschen von unserem Lieblingshobby und das Spielzeug zusammentun und mit diesen Elementen Änderungen vornehmen. Damit haben wir eine gute Zeit und ein Spielzeug fast von uns gemacht. Da Sie wahrscheinlich nicht das gleiche Spielzeugauto besitzen, dient dieser Blogbeitrag als Inspiration. Außerdem wende ich die Steuerung auch auf das Smart Robot Car Kit an. Dazu weiter unten mehr.

In diesem Fall handelt es sich bei dem gewählten Spielzeug um ein Auto aus dem Spielzeughandel, das nur einen Gleichstrommotor an den Hinterrädern mit einem Schalter mit zwei Stellungen für die Vorwärts- oder Rückwärtsfahrt hat. Um lenken zu können, hat es ein Rad auf dem Dach, das manuell einen Getriebemechanismus antreibt.

Die Änderung, die wir vornehmen werden, wird darin bestehen, vier Gleichstrommotoren (einen pro Rad) zu installieren. Wir werden einen neuen Lenkmechanismus herstellen, der von einem Servomotor angetrieben wird. Für das autonome Fahren werden wir Ultraschallsensoren installieren. Sie werden die Entfernung zu Hindernissen ermittelt. Die Steuerung wird entsprechend darauf reagiert, indem das Auto vorwärts- oder zurückfährt, bzw. nach rechts oder links abbiegt.

Die gleichen Eigenschaften werden wir auch beim Smart Robot Car 2WD von AZ-Delivery verwenden. Da dieses Auto keinen Lenkmechanismus besitzt, ist der Umbau sehr einfach. Wir werden nur die seitlichen Ultraschallsensoren installieren müssen.

Wenn wir das Auto, das wir umbauen wollen, ausgewählt haben, bereiten wir eine Tasse Kaffee oder Tee vor und beginnen mit der Planung. Als erstes müssen wir wissen, welche Komponenten wir für den jeweiligen Fall benötigen.

Benötigte Hardware und Komponenten

1	Mikrocontroller Board ATmega328 mit USB-Kabel
1	Jumper Wire Kabel 3 x 40 STK. je 20 cm M2M/ F2M / F2F
2	SG90 Micro Servo Motor 9G (alternativ hier) oder MG90S Micro Servomotor
1	Mini Breadboard 400 Pin
3	HC-SR04 Ultraschall Modul Entfernungsmesser (alternativ hier)
1	4-Kanal L293D Motortreiber Shield
4	DC3V-12V pre-wired DC Getriebemotor
1	Batteriehalter für 4x AA
4	AA Batterien

 

Wenn Sie das Smart Robot Car Kit verwenden:

1	Smart Robot Car DIY
2	HC-SR04 Ultraschall Modul Entfernungsmesser (alternativ hier)

 

Verwendete Software

• Arduino IDE
• Ultraschallsensor Library (Elegoo, alternativ github danke an Peter)
• Adafruit Motorshield Library v1 (über Bibliotheksverwalter h)
• Servomotor library (integriert h)
• ino sketch

 

Wenn Sie das Smart Robot Car Kit verwenden:

• Arduino IDE
• Ultraschallsensor Library (über Bibliotheksverwalter h)
• Servomotor library (integriert h)
• ino sketch

Zuerst werden wir die Modifikation des Spielzeugautos entwickeln und erklären und dann werden wir dasselbe mit dem Smart Robot Car tun.

Schaltung und Beschreibung der verwendeten Komponenten

Download der Schaltung

Gemäß dem Komponentenplan werden wir zum Bewegen der vier DC-Motoren das Modul "4-Kanal L293D Motortreiber Shield" verwenden. Es vereinfacht die Programmierung der Motoren und eliminiert viele Kabel. Außerdem benötigen wir im Sketch nur ein Objekt für jeden Motor mit dem wir die Motordrehzahl auswählen und mit den Vorwärts-, Rückwärts- und Stopp-Befehlen arbeiten können. Da es sich um ein Shield-Modul handelt, müssen wir es nur mit dem ATmega328-Mikrocontroller koppeln, und schon bilden sie eine Einheit.

Wir werden zwei SG90-Mikroservomotoren verwenden, von denen einer die Lenkung des Fahrzeugs antreibt und der andere einen kleinen 40-Grad-Schwenk mit dem vorderen Ultraschallsensor ausführt. Die HC-SR04-Ultraschallsensoren informieren uns über die Entfernung zu Objekten oder Hindernissen. Die 4 Gleichstrommotoren, die ich verwendet habe, sind die üblichen Motoren für Robotcar-Bausätze. Für die Stromversorgung des gesamten Sets habe ich zwei externe 5V-Gleichstrom-Batterien mit 1A verwendet, aber Sie können jeden Batteriesatz verwenden, der eine Mindestspannung von 5V Gleichstrom liefert.

Achten Sie genau auf die maximale Leistungsaufnahme der verschiedenen Module.

Änderung der Lenkanlage des Fahrzeugs

Ich werde kurz erklären, wie ich das Lenksystem des Autos verändert habe.

Das manuelle System des Wagens hatte ein Rad auf dem Dach, das Zahnräder bewegte. Diese Zahnräder bewegten eine Welle, die zur Vorderseite des Wagens geführt wurde, um die Lenkung zu bewegen. Wie Sie auf dem Bild sehen können, ist das System sehr umständlich und wird zudem manuell bedient.

Das neue Lenksystem wird durch den jeweiligen Servomotor, der auf das dazugehörige Vorderrad wirkt und über die starre vordere Querstange, betätigt. Die gesamte Baugruppe ist mit zwei Achsen am Fahrgestell befestigt, die mit den grünen Punkten auf dem Bild übereinstimmen. Auf diese Weise bewegt sich bei Betätigung des Servomotors die gesamte Baugruppe und schwenkt an diesen beiden Punkten.   Auf dem Bild sehen Sie links auch den Servomotor, an dem wir den vorderen Ultraschallsensor befestigen werden.

 

Beschreibung der Bedienung des Fahrzeugs und des Sketches

Die drei Ultraschallsensoren sind die „Augen“ des Autos. Der Mikrocontroller sendet Signale an die Ultraschallsensoren, so dass sie kontinuierlich Impulse aussenden. Wenn sie von einem Objekt abprallen, empfängt der Sensor das Signal und überträgt es an den Mikrocontroller. Die verstrichene Zeit wird durch zwei geteilt, da das Signal hin- und zurückgehen muss. Mit der Information über die benötigte Zeit und den Daten über die Schallgeschwindigkeit, wird die Entfernung zum Objekt berechnet. Die Informationen jedes Sensors werden in Variablen gespeichert und mit den Entfernungsgrenzen dauerhaft in einer Mehrfachschleife mit if-else-Bedingungen verglichen. Es werden die Entfernungen zu Objekten gemessen, die sich rechts, links und vor dem Auto befinden können. Wenn die Entfernung größer ist, fährt das Auto weiter, wenn eine der Entfernungen kleiner ist, vergleicht es die Entfernung zwischen der rechten und der linken Seite. Wenn die rechte Seite größer und die Entfernung zu einem Objekt größer als der Grenzwert ist, biegt es nach rechts ab. Wenn die Entfernung zwischen der rechten Seite kleiner ist als die linke, prüft es, ob die linke Entfernung zu einem Objekt größer ist, als der Grenzwert. Wenn ja, würde es nach links abbiegen. Wenn die drei Entfernungen zufällig unter den von uns programmierten Grenzwerten liegen, hält das Auto an und fährt 2 Sekunden rückwärts, um dann erneut den Entfernungsprüfungsprozess zu starten. Der Mikrocontroller führt je nach Bedingung einige Aktionen aus, um die H-Brücken der L293D-Chips des Motorschildmoduls zu aktivieren, damit die Motoren in die eine oder andere Richtung gedreht werden.

Beginnen wir mit der Entwicklung unseres Sketches. Um die Servomotoren, die Ultraschallsensoren und die Motorsteuerungsplatine verwenden zu können, müssen wir ihre Bibliotheken am Anfang des Sketches einbinden. Ich habe mich für diese SR04-Bibliothek entschieden, da ich sie sehr lange benutze und nie Probleme damit hatte. Sie müssen Sie herunterladen und auspacken. Im Unterordner finden Sie die ZIP-Datei HC-SR04.zip, die Sie in der Arduino IDE über das Menü Sketch->Bibliothek einbinden->.ZIP-Bibliothek hinzufügen installieren können.

#include "SR04.h"
#include <AFMotor.h>
#include <Servo.h>

Nachdem wir die Bibliotheken hinzugefügt haben, müssen wir mit der Implementierung und Konfiguration aller installierten Komponenten fortfahren. Wir beginnen mit der Implementierung der Ultraschallsensoren. Wir müssen dem Mikrocontroller mitteilen, an welche Pins wir die Pins jedes Sensors angeschlossen haben. Einer, der das Signal sendet (ECHO) und einer, der das Signal empfängt (TRIG), nachdem er auf das Objekt geprallt ist. Als Nächstes müssen wir einen Namen für jeden Sensor mit einigen Parametern erstellen. Dies geschieht durch die Implementierung eines Objekts der SR04-Bibliothek, das den Namen des Sensors und als Parameter die Namen der Pins zum Senden und Empfangen des Signals enthält. Nun müssen wir die Entfernungsdaten speichern, wofür wir für jeden Sensor eine Variable definieren.

#define TRIG_PIN_RIGHT 15
#define ECHO_PIN_RIGHT 14  
SR04 ultrasonics_sensor_right = SR04(ECHO_PIN_RIGHT,TRIG_PIN_RIGHT);
long right_distance;

#define TRIG_PIN_LEFT 17
#define ECHO_PIN_LEFT 16
SR04 ultrasonics_sensor_left = SR04(ECHO_PIN_LEFT,TRIG_PIN_LEFT);
long left_distance;

#define TRIG_PIN_FRONT 19 
#define ECHO_PIN_FRONT 18 
SR04 ultrasonics_sensor_front = SR04(ECHO_PIN_FRONT,TRIG_PIN_FRONT);
long front_distance;

Nun folgt die Implementierung der beiden Servomotoren. Wir erstellen ein Objekt für jeden Servomotor. Die Pins, an die wir die Signale des Servomotors anschließen, werden später in der setup()-Methode des Sketches definiert.

Servo servo_steering;
Servo servo_ultrasonic_front;

Das „4-channel L293D Motor driver Shield“ ist die letzte Komponente, die wir konfigurieren und implementieren müssen, damit wir die Steuerung der Motoren verwalten können. Wir müssen ein Bibliotheksobjekt für jeden Ausgangskanal der Motorsteuerung erstellen. In unserem Fall werden es die 4 Kanäle sein. Als Parameter müssen wir die Portnummer und die Frequenz des Arbeitssignals angeben. Laut Datenblatt des Mikrocontrollers arbeiten die Ports 3 und 4 nur mit einer Frequenz von 1KHz, also konfigurieren wir alle Ports mit dieser Frequenz. Außerdem ist bei dieser Aktualisierungsrate der Stromverbrauch geringer, so können wir die Batterie schonen.

Es ist sehr wichtig, den entsprechenden Jumper auf dem Shield zu entfernen, da wir die Platine mit externer Spannung versorgen werden und nicht vom Mikrocontroller.

AF_DCMotor right_front_motor(1, MOTOR12_1KHZ);
AF_DCMotor left_front_motor(2, MOTOR12_1KHZ);
AF_DCMotor left_rear_motor(3, MOTOR12_1KHZ);
AF_DCMotor right_rear_motor(4, MOTOR12_1KHZ);

Jetzt müssen wir die setup()-Methode schreiben. Darin werden die Pins definiert, an die wir die Leitungen der Servomotoren anschließen. Hier wird der PWM-Ausgang der digitalen Pins verwendet. Da wir mit einem Shield-Modul und seiner Bibliothek arbeiten, müssen wir glücklicherweise nur eine Zahl zwischen 0 und 255 angeben, die den minimalen bzw. maximalen Wert darstellt.

Die ersten beiden Zeilen der setup()-Methode sind sehr einfach: Wir initialisieren den Serial Monitor und geben auf ihm eine Nachricht aus.

Serial.begin (9600);
Serial.println ("Motors test");

Nun definieren wir hier die Pins, an die wir die Signale für die beiden Servomotoren senden.

servo_steering.attach(9);
servo_ultrasonic_front.attach(10);

Jetzt konfigurieren wir die Drehgeschwindigkeit der Motoren und den Anfangszustand dieser, wenn der Mikrocontroller initialisiert oder zurückgesetzt wird. Die Drehgeschwindigkeit wird mit der Anweisung motor_name.setSpeed(120) auf die Hälfte der Höchstgeschwindigkeit konfiguriert und die Motoren müssen angehalten werden, letzteres wird mit der Anweisung motor_name.run(RELEASE) konfiguriert.

left_front_motor.setSpeed(120);
left_front_motor.run(RELEASE);
right_front_motor.setSpeed(120);
right_front_motor.run(RELEASE);
left_rear_motor.setSpeed(120);
left_rear_motor.run(RELEASE);
right_rear_motor.setSpeed(120);
right_rear_motor.run(RELEASE);

Zum Abschluss der setup()-Methode rufen wir zwei Methoden auf, um die Servomotoren zu überprüfen, bevor unser Auto losfährt. Wir werden diese Methoden später erklären.

servo_ultrasonic_front_check();
servo_steering_check();

Die loop()-Methode ist sehr kurz, weil die Aktionen in Methoden ausgelagert wurden. Dadurch wird der Code sauberer und übersichtlicher. Die einzige Zeile dieser loop()-Methode ist der Aufruf der Methode zum Ausführen der Schwenkbewegung des Servomotors des vorderen Ultraschallsensors.

servo_ultrasonic_scan();

Die Methode führt einen Schwenk durch, indem sie den Servomotor in drei Winkeln (70, 90 und 110 Grad) positioniert. Sobald er in jedem dieser Winkel positioniert wurde, werden die drei Methoden aufgerufen, um die Entfernung möglicher Objekte oder Hindernisse rechts, links und vorne zu messen. Nach der Messung des vorderen Abstands wird die Methode object_distance_compare() aufgerufen, um die drei Messungen zu vergleichen und eine bestimmte Aktion in Bezug auf die Richtung des Fahrzeugs durchzuführen.

void servo_ultrasonic_scan() 
  
      servo_ultrasonic_front.write(90);
      right_distance_object();
      left_distance_object();
      front_distance_object();
      object_distance_compare();

      servo_ultrasonic_front.write(70);
      right_distance_object();
      left_distance_object();
      front_distance_object();
      object_distance_compare();

      servo_ultrasonic_front.write(90);
      right_distance_object();
      left_distance_object();
      front_distance_object();
      object_distance_compare();

      servo_ultrasonic_front.write(110);
      right_distance_object();
      left_distance_object();
      front_distance_object();
      object_distance_compare();

      servo_ultrasonic_front.write(90);
}

Ich erläutere die genannten Methoden. Die ersten drei nach der Positionierung messen die Entfernungen zu Objekten oder Hindernissen, auf die das Auto auf seinem Weg trifft. Der Ultraschallsensor misst die Entfernung zum nächstgelegenen Objekt oder Hindernis und speichert diese Entfernung in der Variable, die wir am Anfang definiert haben. Wir zeigen die Entfernungsdaten über den seriellen Monitor an. Für jeden Sensor gibt es eine eigene Methode.

void right_distance_object() {
      right_distance = ultrasonics_sensor_right.Distance();
      Serial.print("Distance to obstacles on the right ");
      Serial.print(right_distance);
      Serial.println(" cm");
      delay(100);
}

void left_distance_object() {
      left_distance = ultrasonics_sensor_leftt.Distance();
      Serial.print("Distance to obstacles on the left ");
      Serial.print(left_distance);
      Serial.println(" cm");
      delay(100);
}

void front_distance_object() {
      front_distance = ultrasonics_sensor_front.Distance();
      Serial.print("Distance to front obstacles ");
      Serial.print(front_distance);
      Serial.println(" cm");
      delay(100);
}

Die folgende Methode vergleicht die von den vorhergehenden Sensoren vorgenommenen Messungen mit verschachtelten if-else-Bedingungen. Je nach Ergebnis wird eine bestimmte Methode aufgerufen, wenn die jeweilige Bedingung erfüllt ist. Die erste Zeile vergleicht die von den drei Ultraschallsensoren gemessenen Werte. Wenn alle drei Werte übereinstimmen, wird die Methode car_advances() aufgerufen. Ist dagegen einer der drei Messwerte geringer, wird die zweite Zeile ausgeführt, die prüft, ob die vorhandenen Objekte rechts weiter entfernt sind, als links und ob sie auch weiter als 30 cm entfernt sind. Wenn ja, wird die Methode turn_right() aufgerufen. Wenn der Abstand nach links größer ist als nach rechts und die Objekte außerdem mehr als 30 cm entfernt sind, wird die Methode turn_left() aufgerufen. Die letzte Zeile ruft die Methode go_back() auf, wenn die drei zu prüfenden Entfernungen kleiner sind, als die von uns konfigurierte.

void object_distance_compare () {
  if (front_distance >= 100 && right_distance >= 30 && left_distance >= 30) { car_advances(); }  
    else { if (right_distance > left_distance && right_distance >= 30) { turn_right(); } 
      else { if (left_distance > right_distance && left_distance >= 30) { turn_left(); }
        else { if (front_distance < 100 && right_distance < 30 && left_distance < 30) { go_back();}
      }
      }
          }
}

Die Methode, die unser Auto in einer geraden Linie vorwärtsfahren lässt, positioniert den Servomotor für die Lenkung in einem Winkel von 100 Grad und aktiviert mit der Anweisung motor_name.run(FORWARD) die Pins des Mikrocontrollers, die es dem Modul L293D Motor Shield ermöglichen, die korrekte Spannung an die richtigen Motoren zu liefern, damit sich die Räder vorwärts drehen. Zur Erinnerung: Diese Methode wird so lange ausgeführt, wie die Ultraschallsensoren Entfernungen zu Objekten messen, die größer oder gleich den von uns festgelegten Entfernungen sind.

void car_advances() {
      servo_steering.write(100);
      left_front_motor.run (FORWARD);
      right_front_motor.run (FORWARD);
      left_rear_motor.run (FORWARD);
      right_rear_motor.run (FORWARD);
}

Wenn ein Messergebnis der Ultraschallsensoren zu einem Objekt geringer ist als die festgelegte Messung, werden die Messungen der seitlichen Sensoren verglichen. wenn auf der rechten Seite ein größerer Abstand als auf der linken Seite besteht und dieser auch größer ist als der von uns festgelegte, ruft der Block der bedingten Befehle die Methode turn_right() auf, die den Servomotor veranlasst, die Richtung unseres Autos auf 184 Grad zu positionieren. Die Motoren führen Dann den Befehlssatz aus, um vorwärts zu fahren. Auf diese Weise wird unser Auto nach rechts abbiegen und dann vorwärtsfahren.

void turn_right() {
      servo_steering.write(184);
      left_front_motor.run (FORWARD);
      right_front_motor.run (FORWARD);
      left_rear_motor.run (FORWARD);
      right_rear_motor.run (FORWARD);
}

Umgekehrt wird die Methode turn_left() ausgeführt, wenn der von den Seitensensoren ermittelte Abstand nach links größer ist als nach rechts und auch größer als der von uns eingestellte Abstand. Das veranlasst den Servomotor, die Lenkung um 20 Grad zu verstellen, so dass das Fahrzeug ohne anzuhalten in diese Richtung abbiegt.

void turn_left() {
      servo_steering.write(20);
      left_front_motor.run (FORWARD);
      right_front_motor.run (FORWARD);
      left_rear_motor.run (FORWARD);
      right_rear_motor.run (FORWARD);
}

Die letzte aufzurufende Methode ist go_back(), die ausgeführt wird, wenn keine der drei vorherigen Bedingungen erfüllt ist. Wenn das Fahrzeug in einen Bereich einfährt, in dem die frontalen Hindernisse weniger als 1 Meter und die seitlichen Hindernisse weniger als 20 Zentimeter betragen, werden folgende Befehle ausgeführt: Positionierung des Fahrzeugs in einem Winkel von 100 Grad, Anhalten der Motoren mit dem Befehl motor_name.run(RELEASE), Pause für 500 Millisekunden und anschließend mit dem Befehl motor_name.run(BACKWARD) für 2 Sekunden rückwärts drehen, was der in der letzten Zeile der Methode delay(2000) festgelegten Zeit entspricht.

void go_back() {
      servo_steering.write(100);
      left_front_motor.run(RELEASE);
      right_front_motor.run (RELEASE);
      left_rear_motor.run (RELEASE);
      right_rear_motor.run (RELEASE);
      delay(500);
      left_front_motor.run(BACKWARD);
      right_front_motor.run (BACKWARD);
      left_rear_motor.run (BACKWARD);
      right_rear_motor.run (BACKWARD);
      delay(2000);
}

Die letzten beiden Methoden erhalten den Aufruf von der setup()-Methode, werden also nur einmal ausgeführt, um zu prüfen, ob die Servomotoren einwandfrei funktionieren. Der erste prüft den Servomotor des vorderen Ultraschallsensors. Die Positionierungsgrade sind dieselben wie bei der Methode servo_ultrasonic_scan(), aber wir programmieren eine Verzögerung von 500 Millisekunden zwischen den Positionen.

void servo_ultrasonic_front_check() {
      servo_ultrasonic_front.write(90);
      delay (500);
      servo_ultrasonic_front.write(70);
      delay (500);
      servo_ultrasonic_front.write(90);
      delay (500);
      servo_ultrasonic_front.write(110);
      delay (500);
      servo_ultrasonic_front.write(90);
}

Die nächste und letzte Methode des Sketches prüft die Bewegung des Servomotors, der das Lenksystem des Fahrzeugs antreibt. Der Servomotor wird in den Arbeitswinkeln der Lenkung positioniert, um zu prüfen, ob er richtig funktioniert. Die Mittelstellung dieses Servomotors beträgt in diesem Auto 100 Grad, die Stellung für die Rechtsdrehung des Autos muss 184 Grad betragen, für die Linksdrehung 20 Grad. Die Pause zwischen den Stellungen beträgt 1 Sekunde.

void servo_steering_check() {
      servo_steering.write(100);
      delay (1000); 
      servo_steering.write(20);
      servo_steering.write(100);
      delay (1000);
      servo_steering.write(184);
      delay (1000);
      servo_steering.write(100);
}

Download toy_car_modification.ino sketch

 

Wenn Sie an dieser Stelle kein Video sehen, löschen Sie die Cookies Ihres Browsers, aktualisieren die Seite und erlauben die Cookies.

AZ-Delivery Smart Robot Car Modifizierung

Die Modifizierung des Smart Robot Car ist etwas anders. Wir brauchen das "4-channel L293D Motor driver Shield"-Modul nicht, weil es nur zwei Motoren hat. In diesem Fall verwenden wir das "L298N Motor Driver Board"-Modul, das auch eine H-Brücke enthält, die die nötige Leistung zum Antrieb der beiden Gleichstrommotoren liefert. Da wir kein Lenksystem haben, erfolgt die Richtungsänderung durch Änderung der Drehrichtung der Motoren. Das Modul "V5 Expansion Board Shield" wird verwendet, um alle Komponenten zu verbinden.

Der Prozess der Hinderniserkennung und der zu ergreifenden Maßnahmen ähnelt denen, die vorher erläutert wurden. Die Ultraschallsensoren messen den Abstand auf ähnliche Weise, d. h. wenn die vorderen und seitlichen Hindernisse weiter entfernt sind als der eingestellte Abstand, fährt das Auto vorwärts. Wenn einer der Sensoren ein Hindernis in einem geringeren als dem eingestellten Abstand erkennt, wird der Abstand zu den seitlichen Objekten verglichen und es wird in die Richtung gedreht, die einen größeren Abstand zu einem Hindernis hat. Wenn die drei Sensoren erkennen, dass der Abstand zu den Hindernissen geringer ist, als der eingestellte Abstand, fährt das Auto rückwärts.

Der Unterschied zwischen den beiden Autos liegt in der Funktionsweise der Motoren und ihrer Programmierung. In diesem Fall, mit dem "L298N Motor Driver Board" Modul, haben wir keine VORWÄRTS-, RÜCKWÄRTS- und RELEASE-Befehle. Um einen Motor zum Drehen zu bringen, müssen wir ihn zuerst aktivieren und über einen der beiden Kontakte der Motoren mit Spannung versorgen. Je nachdem, über welchen Kontakt die Spannung zugeführt wird, wird er sich in die eine oder andere Richtung drehen. Im Modul "L298N Motor Driver Board" aktiviert der EN A-Pin die IN1- und IN2-Leitungen für einen Motor und der EN B-Pin die IN3- und IN4-Leitungen für den zweiten Motor, so dass die Programmierung der Motoren wie folgt abläuft: Ein Motor wird aktiviert, indem man den EN-Pin auf HIGH setzt und um den entsprechenden Motor zu drehen, muss man von den beiden IN-Anschlüssen des Motors einen auf HIGH und den anderen auf LOW setzen. Wenn man den Zustand der beiden Anschlüsse ändert, dreht sich der Motor in die entgegengesetzte Richtung. In diesem Sinne werden wir das AZ-Delivery Smart Robot Car modifizieren.

Um die Sensoren und Servos an den Seiten hinzuzufügen, ist etwas Bastelarbeit notwendig.

Download des Schaltplans

Beschreibung des Sketches

Als erstes müssen wie immer die notwendigen Bibliotheken hinzugefügt werden. In diesem Fall brauchen wir nur die für die Ultraschallsensoren und für den Servomotor.

#include "SR04.h"
#include <Servo.h>

In den folgenden Zeilen deklarieren wir 6 Konstanten, um die Pins des Mikrocontrollers zu benennen, mit denen die Motoren gesteuert werden.

#define enable_right_motor 3
#define connection_1_motor_right 2
#define connection_2_motor_right 4 

#define enable_left_motor 6
#define connection_1_motor_left 7
#define connection_2_motor_left 8

Als Nächstes müssen die Ultraschallsensoren und der Servomotor des vorderen Ultraschallmoduls implementiert werden. Sowohl die Anschlussstifte als auch die Bezeichnung der Sensoren sind die gleichen, wie bei der Modifikation des vorherigen Fahrzeugs. Auch die Bezeichnung des Stellmotors ist die gleiche.

#define TRIG_PIN_RIGHT 15    
#define ECHO_PIN_RIGHT 14
SR04 ultrasonics_sensor_right = SR04(ECHO_PIN_RIGHT,TRIG_PIN_RIGHT);
long right_distance;

#define TRIG_PIN_LEFT 17
SR04 ultrasonics_sensor_left = SR04(ECHO_PIN_LEFT,TRIG_PIN_LEFT);
long left_distance;

#define TRIG_PIN_FRONT 19
#define ECHO_PIN_FRONT 18
SR04 ultrasonics_sensor_front = SR04(ECHO_PIN_FRONT,TRIG_PIN_FRONT);
long front_distance;

Servo servo_ultrasonic_front;

In der setup()-Methode sind die einzigen Unterschiede der fehlende Lenk-Servomotor und die Art und Weise, wie wir die Motoren konfigurieren. Wir müssen die Pins des Mikrocontrollers, an die das "L298N Motor Driver Board"-Modul angeschlossen ist, als OUTPUT konfigurieren. Wir werden ihren Zustand zwischen HIGH und LOW ändern, um die Motoren zu aktivieren und ihre Kontakte je nach der gewünschten Drehrichtung mit Spannung zu versorgen. Der Anschluss des Servomotor-Signals und der Aufruf der Methode servo_ultrasonic_front_check() sind identisch.

pinMode(enable_right_motor,OUTPUT);
pinMode(connection_1_motor_right, OUTPUT); 
pinMode(connection_2_motor_right, OUTPUT);
pinMode(enable_left_motor,OUTPUT);
pinMode(connection_1_motor_left, OUTPUT); 
pinMode(connection_2_motor_left, OUTPUT);

Die Methoden loop(), servo_ultrasonic_scan(), right_distance_object(), left_distance_object(), front_distance_object(), object_distance_compare() und servo_ultrasonic_front_check() sind genau dieselben, wie im vorherigen Kapitel und führen dieselben Funktionen wie oben erklärt aus.

Die Methoden car_advances(), turn_right(), turn_left() und go_back() sind dafür zuständig, die beiden Motoranschlüsse mit Spannung zu versorgen, damit sich das Smart Robot Car vorwärts bewegt, nach rechts oder links abbiegt, oder zurückfährt. Die erste Methode, die ich erkläre, ist car_advances(). Die erste Zeile des Kommentars zeigt uns durch den Serial Monitor, dass sich unser Auto vorwärtsbewegt. In der nächsten Zeile setzen wir den rechten Motor-Enable-Pin auf HIGH. Die nächsten beiden Leitungen sind die beiden Motorkontakte. Wir setzen einen Pin auf HIGH-Pegel (liefert Spannung) und den anderen auf LOW-Pegel, so dreht sich der Motor in Vorwärtsrichtung (wenn der Motor in die entgegengesetzte Richtung dreht, müssen wir nur die Motoranschlüsse im "L298N Motor Driver Board" Modul austauschen). Die letzten 3 Zeilen der Methode sind genau dieselben, wie oben beschrieben und gelten auch für den anderen Motor.

void car_advances() {
  Serial.println("Car advance");
  digitalWrite(enable_right_motor,HIGH);
  digitalWrite(connection_1_motor_right,HIGH);
  digitalWrite(connection_2_motor_right,LOW);
  digitalWrite(enable_left_motor,HIGH);
  digitalWrite(connection_1_motor_left,HIGH);
  digitalWrite(connection_2_motor_left,LOW);
}

Die turn_right()-Methode bewirkt, dass sich das Auto nach rechts dreht. Wir können beobachten, dass der Zustand der Pins zum rechten Motor entgegengesetzt ist. Dadurch wird dieser Motor in die entgegengesetzte Richtung gedreht. Also wenn sich der linke Motor vorwärts und der rechte Motor rückwärts drehen, wird sich unser Smart Robot Car schnell nach rechts um seine imaginäre Mittelachse drehen.

void turn_right() {
        Serial.println("Car turn right");
        digitalWrite(enable_right_motor,HIGH);
        digitalWrite(connection_1_motor_right,LOW);
        digitalWrite(connection_2_motor_right,HIGH);
        digitalWrite(enable_left_motor,HIGH);
        digitalWrite(connection_1_motor_left,HIGH);
        digitalWrite(connection_2_motor_left,LOW);
}

Sketch Download

In den folgenden zwei Methoden werden nur die Zustände der Pins zu den Motoren vertauscht, damit sie sich in die eine oder andere Richtung drehen. Auf diese Weise kann das Smart Robot Car nach links oder rückwärts fahren.

Wenn wir nicht wollen, dass die Drehung so abrupt erfolgt, müssen wir beim Aufruf zum Aktivieren des Motors digitalWrite(enable_name_motor,state) den Parameter state auf LOW setzen. Damit können wir den Motor deaktivieren und unabhängig vom Zustand der Motorkontakte wird er sich in keine Richtung drehen und stehen bleiben, während der andere Motor sich weiterdreht, so dass die Drehung auf dem gestoppten Rad erfolgt.

Wie Sie sehen können, ist das Smart Robot Car sehr vielseitig. Wir konnten es so modifizieren, dass es zwei Ultraschallsensoren installieren kann, um es etwas autonom zu machen. Es könnte auch so modifiziert werden, dass es zum Beispiel zu einem Smart Robot Car Line Follower wird.

Wir wünschen Ihnen viel Spaß beim Umbau Ihres Fahrzeugs.