DU LERNST HIER...

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

ROBOTER "mbRobot"

ROBOTER "BUGGY"

Mit wenig Aufwand kannst du einen fahrenden Roboter mit Motoren und Lichtsensoren auch selbst zusammenbauen. 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 t_on 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)   

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)

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)   

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)   

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)

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)

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