Dokumentation
Programmierung von Strukturen
Übersicht
Grundbefehle
Programmierung von Strukturen
- comment
- loops
- if-structures
- procedures
- end
Beispiel-Programme
Ausbildung

Programmierung von Strukturen

Here you'll find the grammatical structures that are allowed to define the behaviour of the robot.

Comments

# free text that will not be evaluated

All text that appears after a hash, '#', will not be interpreted as instructions. The robot will proceed to read the next line in the script. Use this possibility to annotate parts of the script, just for yourself, as documentation about how these parts work

Loops

wiederhole(n){...instructions...}
repeats the instructions between curly brackets exactly n times.

Example:

# a square of 2x2
wiederhole(4)
{
    vorwärts(2)
    rechts()
}
                  

wiederhole(){...instructions...}
just keeps repeating the instructions between curly brackets for ever.

Example:

# just goes vorwärts
# (but eventually will stay hitting a wall)
wiederhole()
{
    vorwärts()
}

wiederholeSolange(condition){...instructions...}
repeats the instructions between curly brackets as long as the condition holds. This condition must be a perception/seeing instruction (for example vorneIstFrei)

Example:

# keeps going vorwärts, 
# but stops when it can't go any further
wiederholeSolange(vorneIstEinHindernis)
{
    vorwärts(1)
}

brecheAb
allows you to jump out of the loop (e.g. a repeat() section) so it stops performing the instructions between curly brackets. The robot will resume performing the instructions left after the closing curly bracket of the loop.

Example:

# keep going vorwärts, until yu can't go any further
wiederhole()
{
    wenn(vorneIstEinHindernis())    {    
        brecheAb
    }
    sonst
    {    
        vorwärts(1)
    }
}
                  

If-structures

wenn(condition){...instructions...}
will perform the the instructions between curly brackets, only if the condition holds. Else the robot immediatly steps to the instructions written after the closing curly bracket.The condtion must be a perception/seeing instruction (for example: vorneIstFrei())

Example:

# if you see white paint on your links, make it black
wenn(linksIstWeiß())
{
    links()    
    vorwärts(1)
    maleSchwarz()
    beendeMalen()
    rückwärts(1)
    rechts()
}
                  

wenn(condition){...instructions...}sonst{...instructions...}
will perform the the instructions between the first pair of curly brackets, only if the condition holds. Then it will not perform the instructions of the else block (second pair of instructions). When the condition does not hold, the robot will only perform the instructions in between the second pair of curly brackets. After it performed one of the instruction blocks, it will read the instructions after the last curly bracket.The condtion must be a perception/seeing instruction (for example: vorneIstFrei())

Example:

# if you see white paint on your left, make it black
# else drive a few steps forward
wenn(linksIstWeiß())
{
    links()    
    vorwärts(1)
    maleSchwarz()
    beendeMalen()
    rückwärts(1)
    rechts()
}
sonst
{
    vorwärts(3)
}
                  

Logical
expressions

The conditions of if- and repeatWhile-structures is a so-called logical expression. Such an expression will result in the value wahr or falsch, which is then used to decide to step to the appropriate part of the code to resume execution.

A logical expression can be a perception instruction, e.g.: wahr(). Grundbefehle may also be composed with the boolean operators ~, &, |.

Example:

wenn(linksIstWeiß())
{
    links()    
    vorwärts(1)    
}

The condition can however also be refined to more indicate more precisely when the corresponding instructions should be executed by using (a combination of) the following operators.

Operation
Alternative
notation
Number of
arguments
Explanation
nicht ~ 1

Negates the value of the argument :

Truth table :
~ wahr = falsch
~ falsch = wahr

Example:
~ vorneIstFrei()

und & 2

Only true when both arguments are true.

Truth table:
wahr & wahr = wahr
wahr & falsch = falsch
falsch & wahr = falsch
falsch & falsch = falsch

Example:
vorneIstFrei() & rechtsIstWeiß()

oder | 2

True when at least one of the arguments is true.

Truth table:
wahr | wahr = wahr
wahr | falsch = wahr
falsch | wahr = wahr
falsch | falsch = falsch

Example:
vorneIstFrei() | rechtsIstWeiß()

The values wahr and falsch can also be applied directly as if it was a perception instruction.

The order of the operators is of importance (just like multiplying and adding numbers). The operation ~ binds strongest, followed by &, followede by |. Brackets can be used to influence the order of evaluation.

Examples:

				
wiederholeSolange(nicht vorneIstFrei() und (linksIstWeiß() oder rechtsIstWeiß())){
    vorwärts(1)
}

wenn(wirfMünze() und nicht rechtsIstWeiß())
{
    rechts()
    rückwärts(1)
}

wenn(wahr und falsch){
    # this instruction is never executed
    vorwärts(1)
}
              

Procedures

prozedur name(par1, par2, ... , parN){...instructions...}
defines a new procedure with the name you want. The procedure can have zero or more parameters, which you may also give useful names. Here they are called par1, par2, . . . , parN. These are the variables you can use in the instruction beteen curly brackets. The code in a procedure will not be performed automatically, you have to write a 'procedure call' every time you want to perform the instructions in the definition (See next instruction).
Tip: create a new procedure when when you you use a sequence of instructions more than once.

Example:

# define how to draw a rectangle
prozedur rectangle(width, height)
{
    maleWeiß()
    wiederhole(2)
    {
        vorwärts(height)
        rechts()
        vorwärts(width)
        rechts()
    }
    beendeMalen()
}
                  

name(arg1, arg2, . . . , argN)
is the call to the procedure with the corresponding name and the same amount parameters as you have arguments. The argument, here called arg1, arg2, . . . , argN, are the particular values that will be used in the procedure definition.

Example:

# these instructions will be performed
vorwärts(1)
rectangle(3,2) # a call to the 'rectangle' prozedur
vorwärts(3)
rectangle(1,4) # another call with other arguments


# this is the definition of 'rectangle'
prozedur rectangle(width, height)
{
    maleWeiß()
    wiederhole(2)
    {
        vorwärts(height)
        rechts()
        vorwärts(width)
        rechts()
    }
    beendeMalen()
}                   

End

ende
will cause the entire program to stop when this instruction is performed.

Example:

# stop after 5 steps, oder earlier when you encouter a beacon on the rechts
wiederhole(5)
{
    vorwärts(1)
    wenn(rechtsIstEineSonde())
    {
        ende # stops execution of the program
    }
}
# normal ende of the program
                  
RoboMind - Copyright © 2005 - 2016 - Research Kitchen