TigerJython4Kids
HomeTurtlegrafikRobotikDatenbanken
buggy

10. FAHRENDE ROBOTER

 

 

DU LERNST HIER...

 

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

 

 

ROBOTER "CALLIOPY"

 

Mit wenig Aufwand kannst du einen fahrenden Roboter mit Motoren und Lichtsensoren zusammenbauen.

Die wichtigste Komponente des Buggy-Roboters ist der Calliope. 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 Calliopy-Roboter.

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

 

 

ANSTEUERUNG VON DC-MOTOREN

 

Ein DC-Motor (DC = Direct Current = Gleichstrom) besitzt zwei Anschlüsse P und Q. Legt man eine Gleichspannung mit dem Pluspol an P und dem Minuspol an Q, so dreht er in der einen Richtung, und zwar umso schneller,  je höher die Spannung ist. Kehrt man die Polarität um, so dreht er in der anderen Richtung.

Zur Ansteuerung eines Motors (oder anderer Verbraucher mit bis zu maximal 1 A Strom) hat der Calliope einen Stromverstärker (H-Brücke DRV8887), dessen zwei Ausgänge mit Pin 2 und Pin 3 des Headers JP1 verbunden sind. Pin 5 ist der Eingang einer externen Spannung bis maximal 10 V zur Versorgung der des Motors und Pin 1 und Pin 4 sind Masseanschlüsse (GND = Ground). Einen einzelnen Motor hängst du wie folgt an:

 



 

Eingelötete Stiftleisten

Als Batterie/Akku kannst du eine PowerBank verwenden, die eine Spannung von 5V abgibt. Dazu ein kurzes USB-Kabel auftrennen und die 5V separat herausführen.

 

Das so prepariertes Micro-USB-Kobel kanst du auch für die Stromversorgung des Calliope verwenden.

(Falls du einen ganz kleinen Motor hast, der bei 3.3V nicht mehr als 20 - 30 mA zieht, kann die externe Spannungsquelle entfallen, da der Calliope dann automatisch die interne Spannungsversorgung verwendet.)

Der Stromverstärker wird mit den Prozessorpins 29 und 30 angesteuert, wobei du mit dem Pin 28 den Verstärker einschaltest. Dies ergibt folgende Schaltungslogik für die 0/1-Pegel der Prozessorpins.

Pin 28
Pin 29
Pin 30
P
Q
Motor
0
x
x
kein Strom
kein Strom
Stop
1
1
0
VM
GND
Vorwärts
1
0
1
GND
VM
Rückwärts

x: 0 oder 1 hat keine Auswirkung, vorwärts und rückwärts hängen vom Einbau des Motors ab.

Mit dem folgenden Programm dreht der Motor je 5 Sekunden vorwärts und rückwärts bevor er stoppt.

Programm:

from calliope_mini import *

def move():
    pin28.write_digital(1)
    pin29.write_digital(1)
    pin30.write_digital(0)

def rewind():
    pin28.write_digital(1)
    pin29.write_digital(0)
    pin30.write_digital(1)

def stop():
    pin28.write_digital(0)

move()
sleep(5000)
rewind()
sleep(5000)
stop()
► In Zwischenablage kopieren

Es ist erstaunlich, dass du mit dieser Schaltung sogar die Rotationsgeschwindigkeit des  Motors wählen kannst. Wenn du nämlich den Pin 28 nur während einer bestimmten Zeit einschaltest und dann wieder ausschaltest, so dreht der Motor langsamer. Dazu verwendest du den Befehl pin28.write_analog(v) mit einem Wert v = 0..1023.

Im folgenden Programm dreht der Motor mit wählbarer Geschwindigkeit v (im Bereich 0..1023).

Programm:

from calliope_mini import *

def move():
    pin28.write_analog(v)
    pin29.write_digital(1)
    pin30.write_digital(0)

def revind():
    pin28.write_analog(v)
    pin29.write_digital(0)
    pin30.write_digital(1)

def stop():
    pin28.write_digital(0)

v = 500
move()
sleep(5000)
rewind()
sleep(5000)
stop() 
► In Zwischenablage kopieren

 

 

VERWENDUNG VON DC-MOTOREN

 

Leider besitzt der Calliope nur eine einzige H-Brücke. Willst du zwei Motoren verwenden, wie dies bei einem üblichen Rover der Fall ist, so musst du Kompromisse eingehen. Du kannst die Motoren entweder gleichzeitig vorwärts bzw. rückwärts laufen lassen, indem du sie parallel schaltest:

Wenn du den einen Motor zwischen OUT1 und VM und den anderen zwischen OUT2 und VM hängst, kannst du die beiden Motoren unabhängig voneinander vorwärts schalten. Wenn der Pegel von OUT1 auf GND liegt, läuft Motor  A vorwärts, wenn OUT2 auf GND liegt, läuft Motor B vorwärts.

Es ergibt sich also folgende Schaltungslogik:

Pin 28
Pin 29
Pin 30
PA
PB
Motor A
Motor B
0
x
x
kein Strom
kein Strom
Stop
Stop
1
1
0
VM
GND
Stop
Vorwärts
1
0
1
GND
VM
Vorwärts
Stop
1
1
1
GND
GND
Vorwärts
Vorwärts

Sind die beiden Motoren in einem 2 rädrigen Rover eingebaut, so bewegt sich dieser mit folgendem Programm zuerst vorwärts, dann dreht er auf die eine Seite und dann auf die andere Seite. Schliesslich bewegt er sich wieder vorwärts und stoppt.

Programm:

from calliope_mini import *

def forward():
    pin28.write_analog(v)
    pin29.write_digital(1)
    pin30.write_digital(1)

def left():
    pin28.write_analog(v)
    pin29.write_digital(0)
    pin30.write_digital(1)

def right():
    pin28.write_analog(v)
    pin29.write_digital(1)
    pin30.write_digital(0)

def stop():
    pin28.write_digital(0)

v = 500
forward()
sleep(3000)
left()
sleep(1000)
right()
sleep(1000)
forward()
sleep(3000)
stop() 
► In Zwischenablage kopieren

Um die Programme zu vereinfachen, enthält die Python-Distribution von Calliope das Modul cprover mit den oben definierten Funktionen forward(), right(), left(), stop() und setSpeed(v) (v im Bereich 0..100).

 

 

MERKE DIR...

 

DC-Motoren drehen je nach Polarität der Spannung vor- oder rückwärts. Der Calliope hat einen Stromverstärker, der für den Betrieb eines einzelnen Motors vorgesehen ist. Werden  zwei Motoren benötigt, so kann man diese entweder parallel vorwärts und rückwärts schalten oder man kann sie einzeln vorwärts, aber nicht rückwärts schalten.

 

 

 

ZUSATZSTOFF

 

DISTANZ MESSEN MIT INFRAROT-SENSOR

 

Der Infrarotsensor TCRT5000 enthält eine Fotodiode (IR-LED), die Infrarotlicht (mit einer Wellenlänge von von ungefähr 1000 nm) erzeugt und einer Fotodiode, welche die Intensität des reflektierenden Lichtes messen kann.  Es gibt mehrere Bezugsquellen (z.B. 4tronix oder Ebay).

 
Durch diese Konstruktion können Infrarotsensoren die Änderungen im näheren Sichtfeld registrieren und werden in der Praxis häufig als Bewegungsmelder eingesetzt.
 


In der Schaltung benötigst du zwei Widerstände von 10 kOhm und 100 Ohm, die du beispielsweise auf einer kleinen Lochplatte aufbaust. Den Ausgang E des Fototransistors verbindest du mit einem der Analog-Eingangspins P1 oder P2 des Calliope. Du kannst also für die Detektion einer Streifenbahn zwei nach unten zeigende Sensoren verwenden.

 

 

 

MUSTERBEISPIEL

 

Der Calliopy soll mit seinem Infrarotsensor ein Hindernis detektieren und darauf reagieren. In deinem Beispiel wird der Roboter mit run() in Vorwärtszustand versetzt. Dabei wird in einer endlosen Wiederholungsschleife mit pin1.red_analog() der Sensorwert ständig abgefragt. Wenn der Sensorwert grösser als 100 ist , fährt fährt der Roboter 3000 Millisekunden rückwärts  und danach erneut vorwärts. Der Sensor misst die Intensität des reflektierenden Lichtes, dh. je näher ein Hinderniss ist, umso grösser ist der Sensorwert. Helle Gegenstände reflektieren stärker. Du musst also den Schwellenwert an deine Situation anpassen.

Unter der Verwendung des Moduls cprover ist das Programm sehr einfach:

Programm:

from calliope_mini import *
from cprover import *

run()
while True:
    v = pin1.read_analog()
    if v > 100:
        back()
        sleep(3000)
        run() 
► In Zwischenablage kopieren

Das Modul cprover.py kannst du auf deinen Calliope herunterladen und auch in weiteren Anwendungen mit einem fahrenden Roboter verwenden. Dabei gehst du wie folgt vor: du nimmst das Programm wie üblich in den TigerJython-Editor und wählst "Tools/Modul hinunterladen".

Programm:

# cprover.py
                                             
from calliope_mini import pin28, pin29, pin30

def forward():
    pin28.write_analog(v)
    pin29.write_digital(1)
    pin30.write_digital(1)

def left():
    pin28.write_analog(v)
    pin29.write_digital(0)
    pin30.write_digital(1)

def right():
    pin28.write_analog(v)
    pin29.write_digital(1)
    pin30.write_digital(0)

def stop():
    pin28.write_digital(0)

def move():
    left()

def rewind():    
    right()

def setSpeed(speed):
    global v
    v = int(speed / 100 * 1023)

setSpeed(100)
► In Zwischenablage kopieren


 

 

ZUM SELBST LÖSEN

 

 

1. Baue einen fahrenden Roboter ähnlich dem oben gezeigten Calliopy  mit zwei Motoren und einer Rollkugel als Lenkrad  auf. (Bezugsquelle für das Roboter-Chassis STS-PI: www.pimoroni.com) Als Spannungsversorgung für den Calliope und die Motoren kannst du einen PowerBank verwenden. Die 5V für die Motoren kriegst du durch Auftrennen des USB-Kabels und herausführen von GND (normalerweise schwarze Litze) und 5V (normalerweise rote Litze).

Hinweis: Viele PowerBanks schalten bei kleinen Belastungen noch einer bestimmten Zeit ab.  Bei der Verwendung von IR-Distanzsensoren ist die Belastung normalerweise gross genug. Sonst kann ein zusätzlicher Belastungswiderstand von 100 Ohm zwischen 5V und GND das Abschalten verhindern.

2.

Der Roboter kann mit seinem Infrarotsensor auch helle und dunkle Gegenstände unterscheiden. Montiere den Infrarotsensor so, dass er nach unten zeigt und damit einen hellen oder dunklen Untergrund unterscheiden kann.
Baue eine Schwarz-Weise Bahn und schreibe ein Programm, damit der Calliopy der Kante entlang fährt.

Verwende die Befehle leftArc(r) bzw. rightArc(r), um den Roboboter zu steuern.

 

 

3.

Montiere zwei zwei Infrarotsensoren, die nach unten zeigen. Jetzt kann der Roboter auf einem beliebigen Streifen fahren. bei guter Programmierung sogar auf einer Bahn in Form einer Acht.

 

4.

Fernsteuerung mit zweitem Calliope
Baue einen Roboter, der vorwärts, links und rechts fahren kann. Der Roboter soll mit einem zweiten Caliope (oder mirco:bit) mit folgenden Befehlen ferngesteuert werden.

- rechter Buton: fahre rechts
- linker Button: fahre links
- beide Buttons: fahre vorwärts
- kein Button: stop

 

Optimiere die unterstehenden Programme für deinen Calliopy-Rover:

Programm für den Roboter:

Programm:

from calliope_mini import *
from cprover import *
import radio

radio.on()

display.show(Image.YES)
while True:
    rec = radio.receive()
    if rec != None:
        display.show(rec)
    if rec == "F":
        forward()
    elif rec == "L":
        left() 
    elif rec == "R":
        right() 
    elif rec == "S":
        stop() 
    sleep(10)
► In Zwischenablage kopieren

 

Programm für den zweiten Calliope (Steuerung):

Programm:

import radio
from calliope_mini import *

radio.on()
while True:
    if button_a.is_pressed() and button_b.is_pressed():
        state = "F"
    elif button_a.is_pressed() and not button_b.is_pressed():
        state = "L"
    elif not button_a.is_pressed() and button_b.is_pressed():
        state = "R"
    elif not button_a.is_pressed() and not button_b.is_pressed():
        state = "S"
    radio.send(state)
    display.show(state)
    sleep(10)
► In Zwischenablage kopieren

 

10-1
Fachliche Hinweise:

Der Befehl write_analog(v) erzeugt ein PWM-Signal (Pulse-Width-Modulation) mit der Frequenz von rund 40 kHz zwischen 0 und 100 % (bei v = 1023). Mehr dazu siehe unter micro:bit/buggy