Zum Inhalt springen
Anilsharma26 / Pixabay

Ein autonomes Auto bauen

Ein autonom fahrendes Auto zu bauen, ist ein schwieriges und komplexes Unterfangen. Vielleicht verfolgst du die Nachrichten zu dem Thema oder interessierst dich generell dafür. Große und namhafte Hersteller versuchen sich seit Jahren daran und investieren viel Geld in Forschung und Entwicklung. Wir werden also kein Auto auf die Straßen bringen, sondern ein kleines Vehikel basteln, das zumindest nicht direkt auf eine Wand zufahren soll. Mit etwas mehr Forschung, schaffen wir auch mehr …

Die Grundlagen

Einen Plan machen

Jetzt geht es so richtig los! Anders als bei der Übung zu den LEDs wird es jetzt wirklich handwerklich. Ich hoffe, du freust dich darauf! Befolge die Schritte unten ganz genau, dann solltest nur wenige Hindernisse zu überwinden haben.

Werkzeug und Material: Statte dich mit dem unten aufgeführten Werkzeug und Material aus, bevor du loslegst.

  • Auto-Kit von Joy-IT (4 Motoren)
  • Schraubendreher (im Kit enthalten)
  • Kabelentmanteler (eine Art Zange, um den Plastikmantel von leitenden Drähten zu trennen)
  • L298N Motorsteuerung
  • 4 mal AA-Batterie bzw. -Akku
  • evtl. Lötmaterial (in der Schule löten wir die Teile derzeit nicht)
  • Raspberry Pi + Zubehör für Bedienung

Grundgerüst aufbauen

Wir statten uns aus mit einem Kit, das die wichtigsten Teile bereithält. Aktuell verwenden wir ein Produkt der Marke Joy-IT. Baue das Auto nach der folgenden Anleitung (des Herstellers) auf, bevor wir mit den Programmierübungen anfangen:

Tipps: Du solltest die Drähte zuerst mit den Motoren verbinden. In der Packung sind in der Regel pro Rad ein schwarzes und ein rotes Stück Draht. Lege mit dem Entminterer so viel Draht frei, so dass du es zusammenzwirbeln und um die Kontakte des Motors wickeln kannst.

Einen Motor steuern

Ja, richtig gelesen! Du wirst erst einmal nur einen Motor steuern, um die Grundlagen zu verstehen.

Verbinde die Bauteile nach dem Schema unten. Dafür benötigst du verschiedene Kabel. Kabel, die du einklemmst, nimmst du aus der Spule und verwendest dafür möglichst keine Jumper-Kabel, weil sie nur dünne Nadeln haben. Gehe wie folgt vor:

  1. Den Raspberry Pi noch nicht einschalten!
  2. Verbinde den Motor eines(!) Rades mit der Motorsteuerung. Die Motorsteuerung ist eine eigene kleine Platine, in unserem Fall ist es eine rote Platine des Modells L298N. In den folgenden Übungen wirst du diesen Motortreiber (motor driver) besser kennenlernen.
  3. Verbinde die Motorsteuerung mit dem Raspberry Pi. Nutze bitte ganz genau die Pins im Bild, der Code in den Übungen wird sich auf diese beziehen.
  4. Verbinde die Motorsteuerung mit dem Batteriehalter. 2 Batterien sollten zunächst ausreichen. Beachte: Der Motor wird von den Batterien angetrieben. Die Energie des Raspberry Pi reicht nicht dafür aus, sich selbst und Motoren zu steuern.
  5. Du nutzt das Auto oben, das heißt sobald du den Code ausführst, wird sich das Auto auch bei einem Rad bewegen. Damit nicht alles im Chaos endet, sollte das Rad in der Luft sein! Lege entweder etwas unter das Auto oder das Auto auf die Seite, auf der sich nichts bewegen wird.
  6. Verbinde den Raspberry Pi mit dem Monitor und danach mit der Stromversorgung.

Probelauf mit einem Rad

  1. Lege einen Ordner auf dem Raspberry Pi an, unter Documents. In diesen Ordner legst du alle Projektdateien ab. Achte darauf, dass die Dateinamen nicht zu umständlich sind. Wir werden später ein mal per Command Line auf den Pi zugreifen, also ohne Bildschirm. Da brauchen wir keine langen Namen…
  2. Erstelle die Datei motors.py mit diesem Inhalt:
# motors.py
import RPi.GPIO as gpio
import time

def initBoard():
    gpio.setmode(gpio.BOARD)
    # gpio.setwarnings(False)

def initMotors():
    initBoard()
    gpio.setup(11, gpio.OUT) #IN1
    gpio.setup(13, gpio.OUT) #IN2
    gpio.setup(12, gpio.OUT) #pwm0 (hardware) EN1: controls M1-speed with IN1 and IN2

def forward(tf,speed):
    print("start forward")
    initMotors()
    pwm1 = gpio.PWM(12,100) #arg1: pin, arg2: frequenz in Hz
    pwm1.start(speed) #min 20, max 100
    gpio.output(11, 0) #IN1
    gpio.output(13, 1) #IN2
    time.sleep(tf)
    gpio.cleanup()
    print("clean up")

forward(3,50)
  1. Führe das obige Python-Skript aus. Was beobachtest du?
  2. Nun betrachten wir diesen Block etwas genauer:
def forward(tf,speed):
    initMotors()
    pwm1 = gpio.PWM(12,100) #arg1: pin, arg2: frequenz in Hz
    pwm1.start(speed) #min 20, max 100
    gpio.output(11, 0) #IN1
    gpio.output(13, 1) #IN2

Was bewirkt dieser Block genau? Analysiere den Code Zeile für Zeile. Die zwei markierten Zeilen sind wichtig für die Motorsteuerung. Tausche die 0 mit der 1. Führe den Code erneut aus. Was stellst du fest?

4 Räder steuern

Oben hast du gelernt, wie man ein einziges Rad steuert. Mithilfe des Diagrams unten kannst du die übrigen Motoren anschließen. Beachte insbesondere die Notiz, die dich auf die Verkabelung überkreuz hinweist.

Für diesen Teil gebe ich dir nur minimale Hinweise, damit du alles, was du bisher gelernt hast, konzentrieren und das Problem selbst lösen kannst.

  • Erstelle Code, mit dem du alle Räder bewegen kannst. Mit diesem Setting ist es nicht möglich, jedes Rad einzeln anzusteuern. Du siehst bereits am Diagramm, welche Räder zusammengefasst werden!
  • Erstelle Code, mit dem du vor und zurück fahren kannst sowie das Auto nach rechts und links drehen kannst.
  • Tipp: Verwende Funktionen wie beispielsweise forward, Reverse, left, right.
  • Es gibt bestimmte PINs, mit denen sogenanntes PWM möglich ist. Was das genau ist, kannst du hier nachlesen. Wir nutzen das hier einfach. So wie in dem Code oben.

Einen Ultraschallsensor für Abstandsmessungen nutzen

import RPi.GPIO as gpio
import time 

gpio.setmode(gpio.BOARD)
gpio.setwarnings(False)
gpio_trigger = 16
gpio_echo = 18

gpio.setup(gpio_trigger, gpio.OUT)
gpio.setup(gpio_echo, gpio.IN)

def distance():
    # set Trigger High
    gpio.output(gpio_trigger, True)
 
    # set Trigger after 0.1ms low
    time.sleep(0.00001)
    gpio.output(gpio_trigger, False)
 
    startTime = time.time()
    endTime = time.time()
 
    # store start time
    while gpio.input(gpio_echo) == 0:
        startTime = time.time()
 
    # store arrival
    while gpio.input(gpio_echo) == 1:
        endTime = time.time()
 
    # elapsed time
    TimeElapsed = endTime - startTime
    # multiply with speed of sound (34300 cm/s)
    # and division by two
    distance = (TimeElapsed * 34300) / 2
 
    return distance
 

while True:
    dist = distance()
    #print ("Entfernung = %.1f cm" % dist)
    if dist > 50:
        print("vor")
    else:
        print("crash")
    time.sleep(0.2)

Den Raspberry Pi für SSH einrichten

In der Regel sind nicht alle folgenden Schritte notwendig, um per SSH auf einen Raspberry Pi zuzugreifen. In der Anleitung unten schalten wir zunächst die Energiesparfunktion des Raspberry Pi aus, damit WLAN auch dann funktioniert, wenn die Energieversorgung knapp ist. Danach finden wir die IP-Adresse (Adresse im Netzwerk, IP steht für Internetprotokoll) des Raspberry Pi heraus, um von einem anderen Computer auf den Raspberry Pi zuzugreifen.

  1. Melde dich mit einem Admin-Account auf dem Raspberry Pi an, die Zugangsdaten erhältst du von mir.
  2. Öffne das Terminal und gib folgende Befehle nacheinander ein:
# Öffne die Datei /etc/rc.local mit Superuser Privilegien
sudo nano /etc/rc.local # bei Aufforderung PW eingeben

# Scrolle nach unten und schreibe VOR exit 0 das folgende
/sbin/iwconfig wlan0 power off

# Beende den Vorgang mit Ctrl+X und gib y ein, um zu bestätigen

Wir haben damit nun sichergestellt, dass du dich mit dem WLAN verbinden kannst. Bisher hat der RPi diese Funktion blockiert, wenn die Stromversorgung knapp war. Mit dem Code oben wurde die Stromsprafunktion abgestellt.

  1. Jetzt verbinde dich mit einem WLAN-Netz. In diesem Netzwerk kannst du dich von einem anderen Rechner aus mit dem Raspberry Pi verbinden. Das funktioniert mithilfe von SSH (Secure Shell). Dazu benötigst du die IP-Addresse des RPi, diese findest du mit dem Befehl ip addr heraus.
  2. Verbinde dich an dem anderen Rechner (=Host) mit dem gleichen WLAN. Öffne am Host die Konsole oder das Terminal. Fahre dort wie folgt vor:
ssh user@192.168.172.15 # dabei ersetze user durch den Admin auf dem Raspberry Pi und die IP-Adresse durch die echte IP-Adresse

Sobald du das Passwort für user auf dem Zielrechner (Server) eingibst, bist du damit verbunden! Nun kannst du auf dem Server remote (also von der Ferne, hier per WLAN) arbeiten.

Code-Gerüst für das autonome Auto

Dieses Code-Gerüst soll dir nur eine grobe Idee geben, wie dein Code aussehen kann.

Ziel: Das Auto soll eine vorgegebene Zeit lang autonom und ohne Unfälle fahren.

  • Das Auto fährt x Sekunden lang.
  • Das Auto fährt gerade aus, sofern kein Hindernis per Ultraschall erkannt wird (empfohlener Sicherheitsabstand: 50cm).
  • Das Auto dreht nach links, wenn ein Hindernis erkannt wird.
import time
import RPi.GPIO as gpio

# GPIO-Einstellungen
# Inputs und Outputs einstellen

# diese Funktion erstellt ein Timer-Ende, also einen Zeitpunkt in der Zukunft
def timer(sekunden):
    now = time.time()
    return now+sekunden

# Funktion für Abstandsmessung, s. Ultraschall
def distance():
    pass

# Funktion für Fahrt nach vorne (muss noch erstellt werden)
def forward():
    pass

# Funktion für eine Linksdrehung (muss noch erstellt werden)
def turn_left():
    pass

end = timer(20) # setzt den Endzeitpunkt

# solange der Endzeitpunkt nicht erreicht ist, ist der Code gültig
while time.time() < end:
    # distance d messen per Funktion
    # falls d > 80 (in cm) , fahren
    # sonst turn left

# gpio.cleanup() am Ende nicht vergessen!
Abonnieren
Benachrichtige mich bei
guest
0 Comments
Inline-Feedback
Sieh alle Kommentare
0
Freue mich auf deine Ideen, kommentiere!x