TigerJython4Kids
HomeTurtlegrafikRobotikDatenbanken
buggy

8. FAHRENDE ROBOTER

 

 

DU LERNST HIER...

 

wie du einen Roboter programmierst, damit dieser bestimmte Tätigkeiten selbständig ausführt.

 

 

ROBOTER "BUGGY"

 

Mit wenig Aufwand kannst du einen fahrenden Roboter zusammenbauen, der Motoren und Lichtsensoren hat. Eine Bauanleitung findest hier.

Die wichtigste Komponente des Buggy-Roboters ist der micro:bit. Dieser übernimmt die Funktion eines Gehirns, das auf Grund der Sensordaten, z.B. Hell-Dunkel-Werte von Lichtsensoren, Aktoren (Motoren, Display) betätigt.

 

Das folgende Blockbild für eine automatisierte Maschine ist darum sehr allgemein gültig und du erkennst diese Komponenten leicht bei deinem Buggy-Roboter.

Da der micro:bit in der Maschine integriert ist, nennt man sie auch ein "eingebettetes System" (embedded system).

 

 

MUSTERBEISPIELE

 

Bevor du ein anspruchsvolleres Problem anpackst, solltest du immer einige Tests durchführen, um das richtige Funktionieren der Komponenten einzelnen zu überprüfen und den Code zur Ansteuerung der Hardware kennen zu lernen.

1. Tests mit dem linken und rechten Motor
Die Motoren besitzen zwei Anschlüsse. Wenn du sie mit einer Spannung von 3 V versorgst,, so drehen sie in der einen oder anderen Richtung, je nachdem, wo der positive und negative Pol ist. Um die Geschwindigkeit der Motoren zu regeln, werden sie  nur in bestimmtem Intervallen mit 3 V versorgt, in der restlichen Zeit ist die Spannung 0 V. Das Ansteuerungssignal hat also für den linken Motor mit den Anschlüssen P0 und P16 folgenden zeitlichen Verlauf (der rechte Motor hat die Anschlüsse P12 und P8):

Solche Signale werden als Puls-Width-Modulation (PWM) bezeichnet und du erzeugst ein PWM-Signal beispielsweise am Pin0  mit dem Befehl:  pin0.write_analog(duty), wo duty eine Zahl zwischen 0 und 1023 ist, welche die Einschaltdauer ton festlegt. Mit folgendem Programm dreht der linke Motor zuerst 2000 Millisekunden vorwärts und dann 2000 Millisekunden rückwärts. Damit die Motoren mit den Batterien versorgt werden, musst du den kleinen Schalter auf der unteren Seite des Buggys auf on stellen. Mit diesem Schalter kannst du die Motoren auch jederzeit ausschalten.

from microbit import *

pin0.write_analog(200)
sleep(2000)
pin0.write_analog(0)   
 
pin16.write_analog(100)
sleep(2000)
pin16.write_analog(0)   
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Führe den gleichen Test auch mit dem rechten Motor durch, indem du die Pins 12 und 8 verwendest.

 

2. Tests mit den Lichtsensoren
Die Lichtsensoren geben eine kleinere oder grössere Spannung ab, je nachdem, ob sich der Roboter auf einer hellen oder dunklen Unterlage befindet.  

Wenn sich der Buggy auf einer dunklen Unterlage befindet, leuchten zusätzlich die beiden roten LEDs auf, auf der hellen sind sie ausgeschaltet. Der linke Sensor ist an Pin1, der rechte an Pin2 angeschlossen. Dein Programm "pollt" die Spannung an diesen Anschlüssen und schreibt den Messwert im Terminal aus.

from microbit import *

while True:
    left = pin1.read_analog()
    right = pin2.read_analog()
    print("L: " + str(left) + " - R: " + str(right))
    sleep(500)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Mit einem kleinen Schraubenzieher kannst du am Potentiometer drehen und den Schaltpegel zwischen hell und dunkel verändern. Stelle ihn so ein, dass dein Programm feststellt, wenn sich unter dem Buggy ein heller bzw. ein dunkler Untergrund befindet.  

3. Roboter steuern

Im nächsten Programm lernst du einige Steuerungsmöglichkeiten kennen. Du startest die Bewegung mit Klick auf den Button A. Dies ist vor allem praktisch, wenn du den Roboter am Boden fahren lässt. Damit der Roboter vorwärts fährt, musst du beide Motoren vorwärts rotieren lassen. Schaltest du den rechten Motor ab, dreht der Buggy nach rechts, schaltest den rechten Motor wieder ein, fährt er wieder vorwärts. Auf einer dunklen Unterlage soll der Roboter anhalten.

 

from microbit import *

while not button_a.was_pressed():
    sleep(10)
pin0.write_analog(150)
pin12.write_analog(150)
sleep(2000)
pin12.write_analog(0)   
sleep(2000)
pin12.write_analog(150)

while True:
    left = pin1.read_analog()
    print(left)
    if left > 100:   
        pin0.write_analog(0)  
        pin12.write_analog(0)
    sleep(10)   
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

4. Befehle aus dem Modul mbutils verwenden

Noch einfacher kannst du den Buggy steuern, wenn du die Befehle aus dem Modul mbutils verwendest (siehe auch Dokumentation):

buggy_forward()
buggy_backward()
buggy_right()
buggy_left()
buggy_stop()
buggy_leftArc(r)
buggy_rightArc(r)
buggy_setSpeed(speed)
isDark(ldr)


Für eine langsame Richtungsänderung sind die Befehle buggy_rightArc(r) und buggy_leftArc(r) geeignet, wobei du für r Zahlen zwischen 0 und 1 wählen kannst. (r ist der Reduktionsfaktor, um den das eine Rad langsamer dreht.)

Der Buggy soll auf dem Rand der schwarzen Fläche fahren. Die Strategie ist einfach: Du musst geradeaus fahren, wenn der linke Sensor dunkel und der rechte Sensor hell sieht. Du fährst einen Rechtsbogen, wenn beide Sensoren dunkel sehen und einen Linksbogen, wenn beide Sensoren hell sehen.

 

from microbit import *
from mbutils import *

display.show(Image.YES)
while not button_a.was_pressed():
    sleep(10)
buggy_setSpeed(15)
buggy_forward()

while not button_b.was_pressed():
    if isDark(ldrL) and not isDark(ldrR):
        buggy_forward()
    elif isDark(ldrL) and isDark(ldrR):
        buggy_rightArc(0.6)
    elif not isDark(ldrL) and not isDark(ldrR):    
        buggy_leftArc(0.6)
    sleep(10)
buggy_stop() 
display.show(Image.NO)   
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

5. Buggy mit einem zweiten micro:bit fernsteuern

Du willst den Buggy via Bluetooth fernsteuern. Dazu verwendest du als Fernsteuerung einen zweiten micro:bit. Wenn du den linken Button A drückst, wird die Message "LEFT" gesendet und der Buggy fährt nach links. Drückst du den rechten Button, so wird "RIGHT" gesendet und er biegt nach rechts, drückst du beide Buttons gleichzeitig, wird "FORWARD" gesendet und der Buggy fährt gerade aus. Wenn du die Button löslässt, wird "STOP" gesendet und der Buggy hält an.

 

Das Programm für den Buggy:

from microbit import *
from mbutils import *
import radio

radio.on()
display.show(Image.YES)
buggy_setSpeed(20)
while True:
    rec = radio.receive()    
    if rec == "FORWARD":
        buggy_forward()    
    elif rec == "LEFT":
        buggy_leftArc(0.6)
    elif rec == "RIGHT":
        buggy_rightArc(0.6) 
    elif rec == "STOP":
        buggy_stop()     
    sleep(10)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Das Programm für die Steuerung:

import radio
from microbit import *

radio.on()
display.show(Image.YES)
state = "STOP"
oldState = ""
while True:
    if button_a.is_pressed() and button_b.is_pressed():
        state = "FORWARD" 
    elif button_a.is_pressed():
        state = "LEFT"
    elif button_b.is_pressed():
        state = "RIGHT"
    else:
        state = "STOP"
    if oldState != state:
        radio.send(state)
        oldState = state   
    sleep(10)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

Das Programm für die Fernsteuerung ist ein typisches Beispiel für die Zustandsprogrammierung. Da der die Buttons in einer endlosen while-Schleife alle 10 Millisekunden überprüft werden, muss du darauf achten, dass nur bei einer Zustandsänderung (oldState != state) eine Message gesendet wird. Sonst wird alle 10 ms ein überflüssiger Befehl gesendet und damit das System unnötig belastet .

 

 

MERKE DIR...

 

Um ein komplexes System in Betrieb zu setzen, muss man einzelne Komponenten einem Test unterziehen und erst dann alle miteinander betreiben. Ein Motor bleibt so lange in einem Zustand, bis du ihn in einen anderen Zustand versetzt.

Für die Steuerung kannst du auch Befehle aus dem Modul mbutils verwenden.

 

 

ZUM SELBST LÖSEN

 

 

1.

Ein heller Untergrund wechselt wie bei einer Barriere auf einen dunklen Untergrund. Der Buggy fährt geradeaus auf die Barriere zu und hält dann 3 s an. Nachher fährt er 3 s zurück und hält an.

a) Löse die Aufgabe, indem du die Motoren und Lichtsensoren direkt über die einzelnen Pin-Ausgänge ansprichst.

b) Löse die Aufgabe mit den Befehlen aus dem Modul mbutils.

 

2.
Du erstellst auf einem grossen Blatt Papier einen weiss-schwarzen Kreisring. Der Buggy soll endlos (bis du einen Button klickst) ausgehend von der Mitte zum Ring, dann wieder zurück fahren, etwas drehen und wieder vorwärts fahren.  


3.
Erstelle auf einem grossen Blatt Papier eine geschlossene Bahn (am besten mit schwarzem, selbstklebendem Filz, den du auf Rollen im Hobbymarkt findest). Schreibe ein Programm so, dass sich der Buggy längs der Bahn bewegt, bis du einen der Buttons klickst.  


4.
Du willst den Buggy via Bluetooth fernsteuern. Dazu verwendest du als Fernsteuerung einen zweiten micro:bit und die Fahrrichtungen werden durch dessen Lage bestimmt: Bei horizontaler Lage soll der Buggy anhalten. Kippst du die Fernsteuerung nach vorne, fährt der Buggy vorwärts, kippst du sie nach hinten, fährt er rückwärts, kippst du sie nach links, so fährt er nach links und kippst du sie nach rechts, so fährt er nach rechts.  


 
     
5.
PWM-Signale werden auch zum Dimmen von Beleuchtungen (LED-Lampen) verwendet. Schliesse an Stelle eines Motors eine kleine LED mit einem Vorwiderstand von 1 kOhm an und schreibe ein Programm, das die Helligkeit der LED endlos hoch und wieder runter regelt. Vergiss den in Serie geschalteten Vorwiderstand nicht, sonst wird die LED zerstört.  

 

1-1
Fachliche Hinweise:

Der micro:bit wurde von der BBC entwickelt, um die britischen Schülerinnen und Schülern für das Programmieren zu begeistern. Eine Million Siebtklässler in Grossbritanien wurden mit diesem Gerät ausgerüstet.

Das Board kostet ungefähr 20 Fr.

Bezugsquellen:

www.educatec.ch

www.pimoroni.com