TigerJython4Kids
HomeTurtlegrafikRobotikDatenbanken
infrarotsensor

5. INFRAROTSENSOREN

 

 

DU LERNST HIER...

 

wie der Roboter mit seinen Infrarotsensoren die Helligkeit der Unterlage erkennen kann.


 

WIE FUNKTIONIERT EIN INFRAROTSENSOR?

 

Ein Infrarotsensor besteht aus einer Leuchtdiode (LED), welche Licht im Infrarotbereich aussendet und einer Fotodiode, welche die Intensität des reflektierenden Lichtes misst.

 

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

Der Callibot verfügt über 2 Infrarotsensoren. Man findet sie auf der unteren Seite des Boards. Da das Infrarotlicht an hellen bzw. dunklen Flächen unterschiedlich reflektiert, können diese Sensoren zwischen einer hellen und dunklen Unterlage unterscheiden und geben einen digitalen Wert 0 (dunkel) oder 1 (hell) zurück.


 

MUSTERBEISPIELE

 

Beispiel 1: Kante folgen
Der Roboter soll mit seinem linken Infrarotsensor einer dunklen Fläche fahren. Je nachdem, ob er dunkel oder hell "sieht", korrigiert er die Fahrtrichtung mit einem Rechts- oder Linksbogen. Die Sensorwerte werden in einer Endlos-Schleife mit der Messperiode von 100 ms abgefragt.

Mit der Anweisung v = irLeftValue() der Sensorwert in der Variablen v gespeichert.

 


from callibot import *

setSpeed(30)
repeat:
   v = irLeftValue()
   if v == 0:
      rightArc(0.1)
   else: 
      leftArc(0.1)
   delay(100)
► In Zwischenablage kopieren

Du kannst das Programm auch im Simulationsmodus ausführen. Dazu musst du nach der Zeite from callibot import * folgende zwei Zeilen einfügen:

RobotContext.useBackground("sprites/blackarea.gif") 
RobotContext.setStartPosition(430, 350)

Die erste Zeile fügt das Hintergrundbild "blackarea.gif" hinzu, die zweite Zeile bestimmt die Position, an der der Roboter zu Beginn erscheint. (Das Grafikfenster ist 500 x 500 Pixel gross, die Koordinate (0,0) ist oben links). Alle Bilder, die in den Beispielen und Aufgaben verwendet werden, sind in der TigerJython-Distribution enthalten (Bilderbibliothek). Du kannst auch eigene Hintergrundbilder verwenden

Wenn du das Programm danach wieder im Realmodus ausführen willst, musst du die Zeilen mit RobotContext deaktivieren (# voranstellen). Du siehst bereits im Simulationsmodus, dass die Robotersteuerung vom Radius des Links- bzw. Rechtsbogen abhängig ist. Ist er zu klein (z.B. 0.05), bewegt sich der Roboter sehr langsam und unruhig. Ist er zu gross (z.B. 0.6), so verliert er oft die Spur.


Beispiel 2: Einem Weg folgen
Um einem Weg zu folgen, so wie es selbstfahrende Autos tun, braucht man mehrere Sensoren. In einer stark vereinfachten Version eines autonomen Fahrzeuges verwendest du zwei Infrarotsensoren.

Die Messwerte des rechten und des linken Sensors speicherst du in den Variablen vR und vL
vR = irRightValue()
vL =irLeftValue()

Danach entwickelst du ein Algorithmus, mit dem der Roboter den Weg möglichst genau folgen kann.

 

 
from callibot import *

#RobotContext.useBackground("sprites/trail.gif")

setSpeed(20)
repeat:
    vR = irRightValue()
    vL = irLeftValue()   
    if vL == 0 and vR == 0:
        forward()  
    elif vL == 1 and vR == 0:
        rightArc(0.1)        
    elif vL == 0 and vR == 1:
        leftArc(0.1)    
    delay(100)
► In Zwischenablage kopieren

Für die Simulation verwendest du das Hintergrundbild trail.gif. Im Realmodus musst du je nach grösse der nachgebauten Vorlage die Geschwindigkeit und den Radius der Kreisbögen anpassen.



Beispiel 3: Quadrat fahren

Im realen Modus ist es schwierig Motoren so zu steuern, dass der Roboter eine längere Zeit auf einer quadratischen Bahn bleibt. Mit Hilfe derInfrarotsensoren kann der Roboter seine Richtung selbst korrigieren. Um das Programm besser zu strukturieren, definierst du eine Funktion keepOnTrack(), die die Bewegung des Roboters auf den geraden Wegstücken steuert. Eine rechtwinklige Richtungsänderung erfolgt, wenn der Roboter mit beiden Sensoren hell "sieht". Dann dreht er 90° nach links und setzt seine Fahrt auf dem Streifen fort.

 

 
from callibot import *

RobotContext.useBackground("sprites/field1.gif")
RobotContext.setStartPosition(380, 400)

def keepOnTrack():
    if vL == 0 and vR == 0: 
        forward()
    elif vL == 0 and vR == 1: 
        leftArc(0.1)
    elif vL == 1 and vR == 0:
        rightArc(0.1)
        
repeat:
    vR = irRightValue()
    vL = irLeftValue()
    if vL == 1 and vR == 1:
        left()
        delay(500)
    else:    
        keepOnTrack()
    delay(100)        
► In Zwischenablage kopieren

Für die Simulation verwendest du das Hintergrundbild field1.gif.

 

 

MERKE DIR...

 

Mit den Inrarotsensoren kannst du die Helligkeit der Unterlage messen. Der Befehl irLeft.read_digital() liefert den Wert des linken Infrarotsensors, als Wert 0, falls die Unterlage dunkel oder 1, falls sie hell ist.

 

 

ZUM SELBST LÖSEN

 

 


1.


Der Roboter soll sich endlos auf einem quadratischen Tisch mit einem weissem Innenkreis bewegen, ohne herunterzufallen. Dabei startet er in der Mitte und fährt geradeaus. Erkennt er den Rand, so fährt er rückwärts, dreht um ungefähr 90 Grad nach links und fährt dann wieder vorwärts.

Für die Simulation kannst du das Hintergrundbild circle.gif verwenden.

 
 
RobotContext.useBackground("sprites/circle.gif")

2.

Beim folgen der Pfade mit Kreuzungen verliert der Roboter oft die Spur, insbesondere, wenn du ihn schneller fahren lässt. Ergänze das Programm aus dem Beispiel 2 für den Fall, dass der Roboter die Spur verliert (hell-hell "sieht"). Überlege, was er in diesem Fall tun kann.

Für die Simulation kannst du das Hintergrundbild track.gif verwenden:

 
RobotContext.useBackground("sprites/track.gif")

3.

Der Roboter soll auf weisser Unterlage starten und dann beim Erkennen des ersten schwarzen Streifens 2 Sekunden anhalten und weiterfahren (wie bei einer Haltestelle). Beim Erkennen des zweiten Streifens stoppt er definitiv (Endbahnhof).

 

Für den Simulationsmodus benötigst du folgenden Context:

RobotContext.useBackground("sprites/blacktapes.gif")
RobotContext.setStartPosition(10, 250)
RobotContext.setStartDirection(0)

Bemerkung: Die Lösung ist nicht ganz einfach, denn wenn der Roboter bei der Haltestelle anhält, weil er schwarz "sieht", so "sieht" er immer noch schwarz, auch wenn er über den Streifen weiterfährt. Du musst dir mit einer Variablen s merken, in welchem Zustand der Roboter gerade ist, z.B.
s = 0: erstes Fahren auf weiss,
s = 1: Haltestelle angehalten,
s = 2:  zwischen Haltestelle und Endbahnhof auf weiss.
Falls du beim Programmieren stecken bleibst, so kannst du hier ein wenig spicken.

4.

 

Ein Roboter soll quer über fünf dunkle Streifen fahren und diese mit seinen Infrarotsensoren detektieren. Beim Erkennen des vierten Streifens soll er anhalten.

 

Für die Simulation verwendest du folgenden Context:

RobotContext.setStartPosition(0, 250)
RobotContext.setStartDirection(0)
RobotContext.useBackground("sprites/panels.gif")
Bemerkung: Du musst wieder einen ähnlichen Trick wie in der vorhergehenden Aufgabe finden. Du kannst z.B. die Anzahl zurückgelegten Streife in der Variable s speichern. Der Wert dieser Variable wird aber nur dann um 1 erhöht, wenn der Roboter von hell auf dunkel wechselt. Du brauchst also eine zweite Variable, in der du den Zustand hell bzw. dunkel speicherst.

5.

 

Dein Programm soll den Roboter so steuern, dass er mit Hilfe seiner beiden Infrarotsensoren möglichst genau der Kante entlang fährt.

Für die Simulation kannst du das Hintergrundbild oval.gif benutzen

 
RobotContext.useBackground("sprites/oval.gif")
RobotContext.setStartPosition(400, 400)

 

   

 

5-3
Fachliche Hinweise:

Einige Hintergrundbilder für die Simulation stehen im TigerJython zur Verfügung (siehe "Hilfe/APLU-Dokumentation/Bilderbibliothek").

Du kannst auch eigene Hintergrundbilder erstellen. Sie müssen 500x500 Pixel gross und im gif- oder png-Format sein. Du kannst sie im beliebigen Ordner auf deinem Computer speichern. Im Programm gibst du du den Pfad der Bilddatei an:
Unter Windows z.B.
RobotContext.useBackground("c:/users/UrsMeier/desktop/bilder/mybackgroundgif")
oder RobotContext.useBackground("d:/bilder/bild.gif") 

Unter MacOS z.B.
RobotContext.useBackground("/Users/UrsMeier/Desktop/Bilder/mybackground.gif")  

Unter Windows kannst du die eigenen Hintergrundbilder auch im Unterverzeichnis sprites des Unterverzeichnisses /bin des Installationsverzeichnisses speichern. Dann werden die Bilder mit
RobotContext.useBackground("sprites/mybackground.gif")
automatisch in deinem Programm integriert.

5-4
Fachliche Hinweise:

Zu Beginn wird die Zustandsvariable s auf null gesetzt. In der while-Schleife schaltet man den Zustand um:

....

s = 0
forward()
repeat:
    v = irLeft.read_digital()
    if v == 0 and s == 0:
        # Bei Haltestelle
        s = 1
        ...
    if v == 1 and s == 1:   
        # Auf weisser Zwischenfahrt
        s = 2
    if v == 0 and s == 2:
        # Am Endbahnhof
        ...