RoboMind Documentation
Documentation
Programming structures
Overview
Introduction
Basisinstructies
Programming structures
- comment
- loops
- if-structures
- logical expressions
- procedures
- end
Example scripts

Programming structures

Here you'll find the grammatical structures that are allowed to define the behavior 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

くりかえす(n){...instructions...}
repeats the instructions between curly brackets exactly n times.

Example:

# a square of 2x2
くりかえす(4)
{
	すすむ(2)
	みぎ
}
                  

くりかえす{...instructions...}
just keeps repeating the instructions between curly brackets for ever.

Example:

# just goes forward
# (but eventually will stay hitting a wall)
くりかえす
{
	すすむ(1)
}

つぎのあいだずっと(condition){...instructions...}
repeats the instructions between curly brackets as long as the condition holds. This condition must be a perception/seeing instruction (for example まえになにもない)

Example:

# keeps going forward, 
# but stops when it can't go any further
つぎのあいだずっと(まえになにもない)
{
	すすむ(1)
}

ぬける
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 forward, until you can't go any further
くりかえす
{
	もし(まえがじゃま)
    {
		ぬける
	}
	そうでなければ
	{	
		すすむ(1)
	}
}
                  

If-structures

もし(condition){...instructions...}
will perform the the instructions between curly brackets, only if the condition holds. Else the robot immediately steps to the instructions written after the closing curly bracket. The condition must be a perception/seeing instruction (for example: まえになにもない)

Example:

# if you see white paint on your left, make it black
もし(ひだりがしろ)
{
	ひだり
	すすむ(1)
	くろでぬる
	ぬるのをやめる
	もどる(1)
	みぎ
}
                  

もし(condition){...instructions...}そうでなければ{...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 condition must be a perception/seeing instruction (for example: まえになにもない)

Example:

# if you see white paint on your left, make it black
# else drive a few steps forward
もし(ひだりがしろ)
{
	ひだり
	すすむ(1)
	くろでぬる
	ぬるのをやめる
	もどる(1)
	みぎ
}
そうでなければ
{
	すすむ(3)
}
                  

Logical
expressions

The conditions of if- and repeatWhile-structures is a so-called logical expression. Such an expression will result in the value ただしい or ただしくない, 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.: ただしい. Basic instructions may also be composed with the boolean operators ~, &, |.

Example:

もし(ひだりがしろ)
{
    ひだり
    すすむ(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
ひてい ~ 1

Negates the value of the argument :

Truth table :
~ ただしい = ただしくない
~ ただしくない = ただしい

Example:
~ まえになにもない

かつ & 2

Only true when both arguments are true.

Truth table:
ただしい & ただしい = ただしい
ただしい & ただしくない = ただしくない
ただしくない & ただしい = ただしくない
ただしくない & ただしくない = ただしくない

Example:
まえになにもない & みぎがしろ

または | 2

True when at least one of the arguments is true.

Truth table:
ただしい | ただしい = ただしい
ただしい | ただしくない = ただしい
ただしくない | ただしい = ただしい
ただしくない | ただしくない = ただしくない

Example:
まえになにもない | みぎがしろ

The values ただしい and ただしくない 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 &, followed by |. Brackets can be used to influence the order of evaluation.

Examples:

				
つぎのあいだずっと(ひてい まえになにもない かつ (ひだりがしろ または みぎがしろ)){
    すすむ(1)
}

もし(こいんをはじく かつ ひてい みぎがしろ)
{
    みぎ
    もどる(1)
}

もし(ただしい かつ ただしくない){
    # this instruction is never executed
    すすむ(1)
}
              

Comparing numbers
Another type of logical expressions is number comparison. Then you can make decision based on a given value. For example, only go to the right if a given variable is less than 5.

Example:

すすむ
maybeToRight(8)
すすむ

ぷろしーじゃ maybeToRight(n){
    もし(n < 5){
        みぎ
    }
}
            
This is the complete list of comparators.
Comparator Example: true Example: false Explanation
== 3 == 3 1 == 2 Check for equality
~= 1 ~= 2 3 == 3 Check for inequality
< 1 < 2 3 < 3 Compare values with "less than"
<= 3 <= 3 2 <= 1 Compare values with "less than or equals"
> 2 > 1 3 > 3 Compare values with "greater than"
>= 3 >= 3 1 >= 2 Compare values with "greater than or equals"

Procedures

ぷろしーじゃ 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 between 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
ぷろしーじゃ rectangle(width, height)
{
	しろでぬる
	くりかえす(2)
	{
		すすむ(height)
		みぎ
		すすむ(width)
		みぎ
	}
	ぬるのをやめる
}
                  

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
すすむ(1)
rectangle(3,2) # a call to the 'rectangle' procedure
すすむ(3)
rectangle(1,4) # another call with other arguments


# this is the definition of 'rectangle'
ぷろしーじゃ rectangle(width, height)
{
	しろでぬる
	くりかえす(2)
	{
		すすむ(height)
		みぎ
		すすむ(width)
		みぎ
	}
	ぬるのをやめる
}                  

もどる
To stop executing a procedure before it reaches the end, use もどる from within a ぷろしーじゃ definition. The program continues executing the commands after the corresponding call.

Example:

# these instructions will be performed
toWall()
みぎ
すすむ

# go forward until you reach a wall
ぷろしーじゃ toWall()
{
    くりかえす
    {
        もし(まえがじゃま)
        {
            # stop "toWall" procedure,
            # continue with right and forward
            もどる
        }
        そうでなければ{
            すすむ
        }
    }
}                  

もどる(arg)
To stop executing a procedure before it reaches the end, use もどる from within a ぷろしーじゃ definition. The program continues executing the commands after the corresponding call.

By default, a procedure return the value zero. You can change this by returning an expression.

Example:

# this instruction will be performed
すすむ(double(3))

# double the given amount
ぷろしーじゃ double(n)
{
    もどる(2 * n)
}                  

Recursion
Procedures can be defined recursively. That means that you use the procedure you are defining in the procedure definition itself, by calling it. It takes a while to comprehend, but turns out to be a powerfull tool.

Example:

# these instructions will be performed
toWall()
みぎ
すすむ

# go forward until you reach a wall
ぷろしーじゃ toWall()
{
      # notice that no loops are used
      もし(まえがじゃま)
      {
          # stop "toWall" procedure
          もどる
      }
      そうでなければ{
          # do one step
          すすむ
          # and do a recursive call!
          toWall()
      }
}                 

Arithmetic

+,-,*,/
With these operations, you can add, subtract, multiply an divide numbers. Note that the numbers have to be integers (whole numbers).

Example:

# using some arithmetic in expressions
すすむ(2+3)
もし(3*4 < 13){
    x = 3
    ひだり(x-2)
}
もどる(-(3+4)/2)
                  

Variables

x = ...
With variables you can remember values under a name you can choose yourself. The values of these variables are available later in the entire script. You can get these values, by using the name again. You can remember values of any expression (so: numbers, calculations, logical expressions, see commands, return values).

Example:

# store a number
x = 42

# store another number, based on x
y = x / 2

# store a logical expression
clear = ひだりになにもない & まえになにもない & みぎになにもない

# store the actual number of steps taken
# until you bumped (returned by "forward")
actual = すすむ(100)

もし(clear){
     みぎ(2)
     すすむ(actual) # go back
}
ひだり(y)

                  

End

おわる
will cause the entire program to stop when this instruction is performed.

Example:

# stop after 5 steps, or earlier when you encounter a beacon on the right
くりかえす(5)
{
	すすむ(1)
	もし(みぎがびーこん)
	{
		おわる # stops execution of the program
	}
}
# normal end of the program
                  
RoboMind - Copyright © 2005 - 2016 - Research Kitchen