Beispiel-Programme

In den folgenden Beispiel-Programmen wirst du sehen, wie Grundbefehle und Programmstrukturen zu interessantem Verhalten des Roboters führen können. Versuche zu verstehen wie das Programm arbeitet. Noch besser ist es, wenn du den Programm-Code kopierst und in das RoboMind Befehlsfenster einfügst. Vergewissere dich vor dem Start, dass du die richtige Karte verwendest.

• Beispiel 1: Schreibe deinen Namen
• Beispiel 2: Finde die Signalleuchte
• Beispiel 3: Linien-Verfolger
• Beispiel 4: Labyrinth-Läufer

Beispiel 1 : Schreibe deinen Namen

Weil der Roboter malen kann, kannst du auch einfache Mal-Programme erstellen. Benutzte die Befehle maleWeiß() und beendeMalen() um dem Roboter zu befehlen, dass er den Pinsel benutzen oder verstauen soll. Wenn du den Roboter fahren lässt, wird er eine weiße Linie auf den Boden malen. Auf diese Weise kannst du Buchstaben wie ein 'A' malen. In der Karte 'openArea.map' wirst du genügend Platz für ein kleines Kunstwerk haben. Versuche mit der Fernbedienung (Start / Fernbedienung) den Roboter malen zu lassen.  Weitere Infos: Grundbefehle: malen, fahren

#Buchstabe 'A'
maleWeiß()


vorwärts(2)
rechts()
vorwärts(1)
rechts()
vorwärts(2)
rückwärts(1)
rechts()
vorwärts(1)


beendeMalen()

top

Beispiel 2 : Finde den weißen Punkt

Auf der Karte findSpot1.map, die du im Hauptordner der Karten findest, findest du irgendwo auf der linken Seite eine Nische mit einem weißen Punkt. Nehmen wir an, dass du vorher nicht weißt, in welcher Entfernung sich die Nische mit dem Punkt befindet. Wie kann der Roboter ihn finden, wenn er irgendwo neben der Wand startet? Natürlich kannst du die Schritte zählen, die der Roboter benötigt. Aber es gibt bessere Möglichkeiten. Lasse den Roboter jedes Mal einen Schritt vorwärts fahren und lassen ihn prüfen, ob es links schon einen weißen Punkt gibt. Wenn er einen Punkt sieht, soll er dort hinfahren, drauf stehen bleiben und dann ist er fertig. Ansonsten sollte er einen weiteren Schritt fahren und wieder prüfen ob schon ein Punkt neben ihm ist. Dies kann man in einer Schleife wiederholen. Siehe auch: Grundbefehle: fahren, schauen, Programmstrukturen: Schleifen, Wenn-Bedingungen, Ende

wiederhole(){
    wenn(linksIstWeiß()){
        # auf der linken Seite gibt es einen weißen Punkt
        links()
        vorwärts(1)
        ende
    }
    sonst{
        # Es gibt noch keinen weißen Punkt
        vorwärts(1)
    }
}

Eine andere Möglichkeit mit dem selben Ergebnis zeigt folgendes Programm:

wiederholeSolange(linksIstEinHindernis()){
    vorwärts(1)
}


links()
vorwärts(1)
            

top

Bespiel 3 : Linien-Folger

Auf der Karte default.map findest du im Osten eine weiße Linie. Diese Linie verläuft durch den Raum. Wie kannst du den Roboter dieser Spur folgen lassen? Die Lösung ist dem vorherigen Beispiel etwas ähnlich. Nachdem der Roboter an den Anfang der Spur gebraucht wird, entscheidet er nach und nach was er tun muss.  Siehe auch: Grundbefehle: fahren, schauen, Programmierstrukturen: Schleifen, Prozduren, Wenn-Bedingungen, Ende

# Fahre zum Anfang der Linie
rechts()
vorwärts(8)


# Bleibe jedes Mal auf der Spur 
wiederhole()
{
    wenn(vorneIstWeiß()){	
        vorwärts(1)
    }
    sonst wenn(rechtsIstWeiß()){
        rechts()
    }
    sonst wenn(linksIstWeiß()){
        links()
    }
    sonst wenn(vorneIstEinHindernis()){
        ende
    }
}
      

Eine andere Möglichkeit verwendet so genannte rekursive Prozeduren. Prozeduren sind kleine Programme, die sich selbst (rekursiv) aufrufen können. In dem folgenden Programm findest du die Prozedur folgen(). Nach dem der richtige Schritt durchgeführt wurde, siehst du, dass in der Prozedur folgen() die eigene Prozedur folgen() wieder aufgerufen wird. Dadurch erhältst du eine Reihe von  folgen(...folgen(...folgen(...)...)...), die jedes Mal die richtige Anweisung ausführt. Dieser zyklische Aufruf der eigenen Prozedur wird Rekursion genannt und beim ersten Mal wird es dir sicher etwas sonderbar vorkommen. Aber keine Angst, probiere es einfach aus und spiele damit, dann wirst du die Funktionsweise verstehen.

# Fahre zum Anfang der Linie
rechts()
vorwärts(8)


# Starte Verfolgung
folgen()


# Rekursiver Aufruf der Verfolgung
prozedur folgen(){
    wenn(vorneIstWeiß()){	
        vorwärts(1)
        folgen()
    }
    sonst wenn(rechtsIstWeiß()){
        rechts()
        folgen()
    }
    sonst wenn(linksIstWeiß()){
        links()
        folgen()
    }
    sonst wenn(vorneIstEinHindernis()){
        # Beende den aktuellen Aufruf
        # (weil es gibt nichts mehr nach diesem  
        # return (zurück), alle Aufrufe werden beendet
        # und das Programm stoppt.)
        return
    }
}

top

Besispiel 4 : Labyrinth-Läufer

Wie findet man normaler Weise den Weg aus einem Labyrinth? Es scheint, dass diese schwierige Aufgabe eine einfache Lösung hat. Wenn du dich immer rechts an der Wand hältst (oder immer links), wirst du den Ausgang auf jeden Fall finden. Das folgende Programm lässt den Roboter das Signallicht finden (Karte: maze1.map)   Siehe auch: Grundbefehle:fahren, schauen, Programmstrukturen: Schleifen, Wenn-Bedingungen, Ende

wiederhole(){	
    wenn(rechtsIstEinHindernis()){
        wenn(vorneIstFrei()){
            vorwärts(1)
        }
        sonst{
            links()
        }
    }
    sonst{
        rechts()
        vorwärts(1)
    }

    wenn(vorneIstEineSonde()){	
        nimmAuf()
        ende
    }
}