Programmier-Blog

In diesem Tutorial bauen wir zusammen einen einfachen Roboterbausatz und steigen langsam in die Programmierung des Arduino UNO ein. Dieses Tutorial ist für Anfänger gedacht, es wird also alles Schritt für Schrit genau erklärt.

Der Arduino UNO ist ein Mikrocontroller, der mit einer C ähnlichen Sprache programmiert wird. Dieser Controller steuert den Roboter. Die Programmierung ist leicht zu lernen.

Inhalt:

1. Teile des Bausatzes 2. Werkzeug und weiteres benötigtes Material 3. Der Aufbau Schritt für Schritt 4. Arduino IDE nutzen 5. Code entwickeln und verstehen

1. Teile des Bausatzes

Nachfolgend sind hier die Teile des Bausatzes aufgelistet, den ich verwendet habe. Es gibt auch weitere ähnliche Bausätze, der folgende Artikel könnte auch für diese Bausätze nützlich sein.

Bild des Bausatzes mit allen Teilen und Nummerierung

Diesen Bausatz findest Du hier*: 2WD Roboter Smart Car Arduino Kit

Nummer	Beschreibung	Anzahl
1	Grundplatte zum Anbau der einzelnen Teile	1
2	Getriebemotoren	2
3	Sensorshield v5.0 zum Verbinden der elektrischen Bauteile mit dem Arduino UNO R3	1
4	Motortreiber mit doppelter H-Brücke	1
5	UNO R3 ATMega328P CH340G	1
6	Batteriehalter für 4 Batterien AA	1
7	Rolle als Ersatz der Hinterräder	1
8	Räder mit Bereifung für die Motoren	1
9	Verbindungsdrähte rot und schwarz	4
10	SG90 Micor-Servo 9g	1
11	HC-SR04 Ultraschallsensor	1
12	Servohalter für Ultraschallsensor	1
13	Tüte mit Befestigungsschrauben	1
14	Befestigungssatz für die Getriebemotoren	1
15	USB Verbindungskabel zum Programmieren des UNO R3	1

2. Werkzeug und weiteres benötigtes Material

Die folgende Liste zeigt dir, welches Werkzeug Du unbedingt benötigst, um den Bausatz aufzubauen. Mit den Links* in der Liste kannst Du das Werkzeug auch gleichbestellen, falls es dir noch fehlt.

Verschiedene Schraubendreher*
Lötkolben oder besser Lötstation*
Seitenschneider*

Zusätzlich empfehle ich dir eine kleine Zange oder Gabelschlüssel M3 und M4. Zur besseren Befestigung nutze ich kleine Kabelbinder* und PVC-Schrauben, Gewindestücken und Muttern für Platinen. Alternativ kannst Du auch auf Heißkleber und Klebeband zurückgreifen, wenn dich das nicht stört. Ich selbst möchte in diesem Tutorial aber einigermaßen haltbare Befestigungen ausführen.

Für den mitgelieferten Ultraschallsensor benötigst Du zusätzlich eine 4 adrige Leitung*.

Werbung (Affiliate - ich bekomme eine kleine Provision, dein Preis ändert sich nicht)

3. Der Aufbau Schritt für Schritt

In diesem Kapitel gehen wir Schritt für Schritt den Aufbau durch. Du kannst diesen Bausatz auch anders aufbauen, auch mit zusätzlichen Teilen, dies hier ist also eine Art empfohlener Grundaufbau für Anfänger. Der Bausatz lässt sich danach noch prima erweitern.

3.1 Montage der Motore, der Rolle und des Schalters

Da an die Motoren noch Drähte angelötet werden müssen, empfehle ich dies zuerst zu tun, denn im eingebauten Zustand wird das Löten schwierig.

Gut ist auch, wenn Du die Drähte mit Kabelbindern gegen Zug entlastest, nebenbei fällt so auch das Löten leichter.

Anschließend können die Motoren, die hintere Rolle und der Schalter montiert werden. Befreie zuvor die Acrylteile von der Schultfolie.

Sicht von der Unterseite

Aufbau des Motors, der Rolle und des Schalters

Die vier Gewindestücken an der Unterseite mit je einer Schraube befestigen und anschließend die Rolle auf die Gewindestücke schrauben
Motoranschlußleitungen nach innen zeigen lassen
Schalter von Oberseite aus einklicken
Je Motor 2 Befestigungsteile mit 2 langen Schrauben und 2 Muttern dienen zur Motorbefestigung
Drehzahlmessung ist mit diesem Bausatz nicht möglich, dazu würde noch je eine Gabellichtschranke benötigt

3.2 Platinen und Batteriekasten befestigen

Als nächstes werden das Arduino UNO Board, der Motortreiber und der Batteriekasten montiert.

Sicht von der Oberseite

Aufbau der Platinen und des Batteriekastens

Die Platinen sind hier mit Gewindestücke, Schrauben und Muttern aus PVC montiert. Die entsprechenden Löcher müssen gebohrt werden oder Du stichst Sie mit einer alten Lötkolbenspitze durch und schneidest das überschüssige PVC weg. Alternativ tut es auch Heißkleber und ein Stück Holz oder ähnliches.
Der Batteriekasten wurde hier von unten mit Schrauben befestigt
Die Leitungen können durch die vorhandenen Bohrungen verlegt werden und mit Kabelbindern befestigt werden

Werbung (Affiliate - ich bekomme eine kleine Provision, dein Preis ändert sich nicht)

3.3 Servomotor montieren und Drähte anschließen

Sicht von der Oberseite

Montage des Servomotors und ausführen der Anschlüsse

Drähte der Motoren anschließen, welche Klemme rot bzw.schwarz ist, bestimmt die Drehrichtung des Motors. Das kann nachträglich geändert werden.
Halterung des Servomotors mit mitgelieferten Schrauben montieren. Aufnahme für die Motorwelle einkürzen und von unten mit Schrauben befestigen
Anschluss des Motortreibers (LN298N), schwarz (-) kommt direkt vom Batteriekasten, rot wird über den Schalter geführt und verlötet. Anschließend vom Schalter zum Motortreiber weitergeführt. Auch das Arduino-Board muss noch mit Spannung versorgt werden, z.b. mit einem 5,5mm Stecker zur externen Spannungsversorung. Die Spannung wird direkt von der Versorungsspannung des Motortreibers genommen.
Montage des Servohalters an der Grundplatte
Die beiden oberer Teile des Servohalters werden über den Motor gesteckt und von der Seite verschraubt
Anschlußstecker des Servomotors mit dem (auf dem UNO aufgesteckten) Sensor-Shield verbinden, Ausgang 7 (siehe Schaltplan unten)
Ultraschallsensor mit Kabelbindern am Halter besfestigen, die Anschlußdrähte des Sensors sind im Bausatz nicht enthalten und werden zusätzlich benötigt zur Verwendung des Sensors (Verbindungsleitung*)

Hier die Übersicht aller Anschlüsse für das folgende Programmbeispiel.

4. Arduino IDE verwenden

Um den Roboter jetzt programmieren zu können, benötigst Du die Arduino IDE. Diese kannst Du kostenlos runterladen: Arduino IDE.

Nach dem Download und der Installation kannst Du die Entwicklungsumgebung nutzen, allerdings bnötigst Du, für den hier verwendeten Chip CH340, noch einen Treiber. Diesen findest Du auf der Seite von roboterbausatz.de hier.

Der Treiber kommt als .zip und muss zunächst entpackt werden. Starte dann die Anwendung "Setup" im Ordner "CH341SER". Anchließend sollte der Treiber installiert werden.

Erfolgreiche Installation des Arduino-Treibers

Schliesse das Arduino UNO Board nun mit dem mitgelieferten Kabel an deinen PC an. Das Board sollte im Geräte-Manager erkannt werden. Das Arduino UNO sollte nun blinken, da standardmäßig ein Blink-Sketch geladen ist.

Starte die Arduino IDE und stelle das richtige Board und den richtigen seriellen Port ein. Den Port, den dein Arduino verwendet, kannst Du im Gerätemanager erkennen.

Einstellung des UNO Borads in der Arduino IDE

5. Code entwickeln und verstehen

In diesem Abschnitt wollen wir uns nach und nach an die Programmierung des Roboters ran machen. Am Ende soll er, mit Hilfe des Ultraschallsensors, autonom fahren können.

Lege zunächst einen neuen Sketch an und speichere diesen ab. Mein Sketch heisst "roboter1_autonom"

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

Übertrage nun den Sketch auf das Arduino UNO Board, nutze dazu den Button mit dem Pfeil nach rechts.

Nach dem Hochladen sollte die LED am Arduino aufhören zu blinken, denn das Programm tut nichts. Aber das wird sich gleich ändern.

Wir wollen den Roboter im ersten Schritt einfach nur vorwärts und rückwärts fährt, im Abstand von 1 Sekunde. Dazu schauen wir uns erstmal an, wie der Motortreiber angesteuert wird. Im Bild ist zu sein, welche Eingänge eingeschaltet werden müssen, damit der Treiber eine bestimmte Fahrbewegung ausführt.

Zunächst müssen wir die Eingänge festlegen, die wir für die Motoren verwenden. Dazu legen wir einige Konstanten fest, das sind Variablen, deren Wert wir später nicht mehr ändern können. Konstanten deshalb, weil der Wert für diese Variablen klar ist und kein Speicher für evtl. größere Werte reserviert werden muss.

Die Reihenfolge ist der Übersichtlichkeit halber genauso wie im oberen Bild.

In der "setup()"-Methode werden Operation ausgeführt, die beim Start bestimmte Festlegungen oder Einstellungen einmalig vornehmen sollen. In unserem Fall bestimmen wir die Verwendung von I1 bis I4 als Ausgänge.

#define I_4  4  //Motor rechts 
#define I_3  3  //Motor rechts
#define I_2  2  //Motor links
#define I_1  1  //Motor links

void setup() {

    //Ausgänge Motor
    pinMode(I_1, OUTPUT);
    pinMode(I_2, OUTPUT);
    pinMode(I_3, OUTPUT);
    pinMode(I_4, OUTPUT);
}

Die Funktionen "setup()" und "loop()" sind fertige Funktionen von Arduino. Wir können aber auch selbst Funktionen anlegen. Das machen wir jetzt zum vorwärts und rückwärts fahren.

void forward(){ 
     digitalWrite(I_1, HIGH); 
     digitalWrite(I_2, LOW);
     digitalWrite(I_3, HIGH);
     digitalWrite(I_4, LOW);
}
     
void backward(){ 
     digitalWrite(I_1, LOW);
     digitalWrite(I_2, HIGH);
     digitalWrite(I_3, LOW);
     digitalWrite(I_4, HIGH);
}

Die Funktion "setup()", das haben wir schon festgestellt, führt nur einmal etwas aus. Anders die Funktion "loop()", diese können wir für unseren Ablauf nutzen. Wir steuern den Roboter vor, warten eine halbe Sekunde, dann zurück und wieder eine halbe Sekunde warten. Da "loop()" in einer ständigen Schleife läuft, entsteht daraus schon unser Ablauf.

Sei vorsichtig beim Testen, nimm den Roboter zunächst in die Hand und prüfe, ob sich die Räder jeweils richtig herum drehen. Die Drehrichtung kannst Du durch vertauschen der Motordrähte am jeweiligen Ausgang des Motortreibers erreichen.

void loop(){
  forward();
  delay(500);
  backward();
  delay(500);
}

Die "loop()"-Funktion wird natürlich nicht so einfach bleiben, aber das Beispiel soll zeigen, dass von dort unser Programablauf gesteuert wird.

Wir brauchen im nächsten Schritt noch die Funktionen fürs Lenken und Anhalten. Die Ausgänge werden so geschalten, dass das innere Rad in Lenkrichtung rückwärts dreht und das äußere Rad vorwärts. Zum bremsen geht natürlich alles auf "LOW". Mit dem geänderten Code in "setup()" testest Du dann, ob alles richtig funktioniert.

void stearLeft(){ digitalWrite(I_1, LOW); digitalWrite(I_2, HIGH); digitalWrite(I_3, HIGH); digitalWrite(I_4, LOW); } void stearRight(){ digitalWrite(I_1, HIGH); digitalWrite(I_2, LOW); digitalWrite(I_3, LOW); digitalWrite(I_4, HIGH); } void brake(){ digitalWrite(I_1, LOW); digitalWrite(I_2, LOW); digitalWrite(I_3, LOW); digitalWrite(I_4, LOW); } void loop(){ stearRight(); delay(500); stearLeft(); delay(500); brake(); delay(500); }

Um den Ultraschallsensor zu nutzen, deklarieren wir uns wieder Konstanten für die entsprechenden Ein und Ausgänge, zusätzlich zu denen, die schon da sind. Anschließend legen wir wieder fest, was Ein und Ausgänge sind.

Zusätzlicher Code im Kopfbereich:

//Ultraschallsensor
#define ECHO 5
#define TRIG 6

void setup() {
  //Aus und Eingänge Ultraschall
  pinMode(ECHO, INPUT); 
  pinMode(TRIG, OUTPUT);  
}

Um selbständig fahren zu können, muss der verbaute Ultraschallsensor erkennen, ob vor dem Roboter ein Hindernis ist. Das funktioniert so, dass der Trigger-Eingang des Sensor ganz kurz Spannung bekommt. Dann wird aus der Zeitspanne bis zum Empfang eines Signals am Echo-Eingang, der Weg gemessen, den die Schallwelle zurückgelegt hat. Geteilt durch zwei, bekommen wir so die Entfernung zu einem Objekt. Für die Berechnung des Weges, wird die Ausbreitungsgeschwindigkeit von Schallwellen bei Zimmertemperatur genutzt.

Da wir diesen Vorgang immer wieder durchführen müssen, legen wir uns dafür wieder eine Funktion an, diesmal aber eine, die uns den jeweiligen Distanzwert zurückgibt. Dazu muss der Rückgabetyp festgelegt werden (void zuvor war ohne Rückgabe). Das Schlüsselwort "return" gibt den berechneten Wert an den Aufrufer zurück.

Im geänderten "loop()" können wir dann testen, ob das funktioniert. Der Roboter sollte jetzt gerade aus fahren und vor einem Objekt anhalten.

int getDistance() {
  digitalWrite(TRIG, HIGH);//senden
  delay(5);//warten
  digitalWrite(TRIG, LOW);//ausschalten
  
  int duration = pulseIn(ECHO, HIGH);//zurückkommendes Signal
  int distance = (duration / 2) * 0.03432; //halbe Dauer mal Ausbreitungsgeschwindigkeit
  return distance;
}

void loop() {
  bool stopRobot = getDistance() < 10; //wenn Abstand unter 10=true

  if ( stopRobot ) {
    brake(); //anhalten
  }
  else {
    forward();
  } 
}

Damit das sicher funktioniert, muss sich der Roboter natürlich ständig umsehen, sprich der Sensor muss immer wieder hin und her gedreht werden.

Dazu brauchen wir den Servo. Um diesen zu steuern nutzen wir eine Bibliothek, welche mit #include eingebunden ist. Das Objekt Servo speichern wir uns als Variable, um den Servo steuern zu können. In Setup wird der Ausgang für den Servomotor festgelegt.

Um uns ständig die Drehung des Sensors zur merken, nutzen wir die Variable "angle". Die untere Funktion "rotateUltrasonic()" rotiert den Sensor jetzt hin und her.

Probiere den Code mal aus:

#include <Servo.h> //Bibliothek für Servo nutzen

Servo servo;
int angle = 90;

void setup() {    
   servo.attach(7); //unser Servo ist an I7
}

void rotateUltrasonic() {
 for (angle = 90; angle <= 180; angle++) {  
    servo.write(angle);         
    delay(15);                      
  }
  for (angle = 180; angle >= 0; angle--) { 
    servo.write(angle);    
    delay(15);                    
  }
  for (angle = 0; angle >= 90; angle++) { 
    servo.write(angle);    
    delay(15);                    
  }
}

void loop() {
  rotateUltrasonic();
  delay(500);
}

Gut wäre natürlich, wenn sich der Sensor nicht nur hin her dreht, sondern wenn uns die Funktion auch gleich die Richtung der größten Distanz zurück gibt.

int getBestDirection() {

int bestDirection = 0;
int bestDistance = 0;

for(angle = 90; angle <= 150; angle++){  
   servo.write(angle);   
   
   if(angle%20 == 0)//alle 20 Grad stoppen zum Messen
    { 
      delay(25);
      int dist = getDistance();//Distanz messen

      //falls Distanz größer als eine zuvor gemessene Distanz
      if(dist > bestDistance)
      {
         bestDirection = angle; //neuen besten Winkel speichern
         bestDistance = dist;
      }       
    }    
   delay(10);                      
 }
 
 //zurück auf 30 Grad
 for(angle = 150; angle >= 30; angle--){ 
   servo.write(angle);   
    
   if(angle%20 == 0)
   { 
     delay(25);
     int dist = getDistance();
     if(dist > bestDistance)
     {
        bestDirection = angle;   
        bestDistance = dist;
     }       
   }           
   delay(10);                   
 }
}

Aus den einzelnen Teilen bauen wir nun den kompletten Code zusammen. Der Roboter fährt dabei gerade aus, solange kein Hindernis auftaucht.

Wenn ein Hindernis da ist, hält er an und setzt ein Stück zurück. Anschließend dreht der Sensor sich im Halbkreis zwischen 30 und 150 Grad und gibt den Winkel zurück, in dessen Richtung der größte Abstand zu einem Hindernis gemessen wurde.

Je größer dieser Winkel von der Geradeausrichtung entfernt ist, des stärker lenkt der Roboter in die jeweilige Richtung.

Hier der komplette Quellcode:

#include <Servo.h> //Bibliothek für Servo nutzen

Servo servo; //Servoobjekt
int angle = 90;

#define I_4  4  //Motor rechts 
#define I_3  3  //Motor rechts
#define I_2  2  //Motor links
#define I_1  1  //Motor links

//Ultraschallsensor
#define ECHO 5
#define TRIG 6

void setup() {
  
  //Ausgänge Motor
  pinMode(I_1, OUTPUT);
  pinMode(I_2, OUTPUT);
  pinMode(I_3, OUTPUT);
  pinMode(I_4, OUTPUT);

  //Aus und Eingänge Ultraschallsensor
  pinMode(ECHO, INPUT);
  pinMode(TRIG, OUTPUT);
  
  servo.attach(7); //unser Servo ist an I7
}

void forward() {
  digitalWrite(I_1, HIGH);
  digitalWrite(I_2, LOW);
  digitalWrite(I_3, HIGH);
  digitalWrite(I_4, LOW);
}

void backward() {
  digitalWrite(I_1, LOW);
  digitalWrite(I_2, HIGH);
  digitalWrite(I_3, LOW);
  digitalWrite(I_4, HIGH);
}

void stearLeft() {
  digitalWrite(I_1, LOW);
  digitalWrite(I_2, HIGH);
  digitalWrite(I_3, HIGH);
  digitalWrite(I_4, LOW);
}

void stearRight() {
  digitalWrite(I_1, HIGH);
  digitalWrite(I_2, LOW);
  digitalWrite(I_3, LOW);
  digitalWrite(I_4, HIGH);
}

void brake() {
  digitalWrite(I_1, LOW);
  digitalWrite(I_2, LOW);
  digitalWrite(I_3, LOW);
  digitalWrite(I_4, LOW);
}

int getDistance() {
  digitalWrite(TRIG, HIGH);//senden
  delay(5);//warten
  digitalWrite(TRIG, LOW);//ausschalten
  
  int duration = pulseIn(ECHO, HIGH);//zurückkommendes Signal
  int distance = (duration / 2) * 0.03432; //halbe Dauer mal Ausbreitungsgeschwindigkeit
  return distance;
}

int getBestDirection() {

 int bestDirection = 0;
 int bestDistance = 0;
 
 for(angle = 90; angle <= 150; angle++){  
    servo.write(angle);   
    
    if(angle%20 == 0)////alle 20 Grad stoppen zum Messen
    { 
      delay(25);
      int dist = getDistance();//Distanz messen

      //falls Distanz größer als eine zuvor gemessene Distanz
      if(dist > bestDistance)
      {
         bestDirection = angle; //neuen besten Winkel speichern
         bestDistance = dist;
      }       
    }    
    delay(10);                      
  }
  
  //zurück auf 30 Grad
  for(angle = 150; angle >= 30; angle--){ 
    servo.write(angle);   
     
    if(angle%20 == 0)
    { 
      delay(25);
      int dist = getDistance();
      if(dist > bestDistance)
      {
         bestDirection = angle;   
         bestDistance = dist;
      }       
    }           
    delay(10);                   
  }
  
  //zurück auf 90 Grad
  for(angle = 30; angle <= 90; angle++){ 
    servo.write(angle);   
    delay(10);                   
  }
  
  return bestDirection;//Richtung mit dem größten Abstand
}

void checkBestDistance(){

}
void loop() {

 //wenn Abstand zu Hindernis kleiner 20cm 
 if ( getDistance() < 20 ) {

    //anhalten und ein Stück zurück
    brake(); 
    delay(100); 
    backward(); 
    delay(500); 
    brake();
    delay(100);   
    
    //besten Winkel (mit weitestem Abstand) holen
    int bestDirection = getBestDirection(); 
    if(bestDirection > 90){    
       stearLeft();
       delay(bestDirection*2);//je weiter der Winkel aus der Mitte, desto stärker lenken
       brake();
    }
    else if(bestDirection < 90){
       stearRight();
       delay((180-bestDirection)*2);
       brake();
    } 
  }
  else {
    forward();
  }
}

Wie bereits gesagt ist der Code nicht perfekt, sondern eher ein Anfang. Für dieses Anfängertutorial soll es aber genug sein.

Ich wünsche dir viel Spaß beim Tüfteln und verbessern des Programms und hoffe Du schaust bald wieder rein, zu einem neuen Robotertutorial.

Arduino-Tutorial: Einfachen Roboter aufbauen und programmieren