Teaching Your Robot New Moves

Try It — Brain Dump

Without looking anything up, write down every command you know. Fill as many boxes as you can.

What do all of them have in common? Find at least two things.

Count your own repetition

Open your Project 11 program. Go through it and count.

Learn It — Three Parts, In This Order

Writing your own function is like adding a word to a dictionary. You need the word listed, you need its meaning written down, and then you can use it in a sentence.

1. Prototype: The prototype goes on the line after #include, before int main(). It is the word in the vocabulary list — it tells the compiler this name exists.
2. Definition: Goes after the last closing brace of your program. This is the definition of the word — what the robot actually does.
3. Call: Inside main, where you would have typed all those lines. This is using the word in a sentence.

What void means

Void means the function does a job but hands nothing back. ao() is like that — it stops the motors, it does not give you an answer.

You have seen the other kind too. digital(0) and gmpc(0) hand you a number. Yours will not, so yours say void.

Naming rules

• Make it obvious. drive_forward, not thing2.
• No spaces — use an underscore: drive_forward.
• It cannot start with a number.
• It cannot have the same name as a command that already exists. You cannot call yours motor.

The whole thing, side by side

Before — twice

int main()
{
	cmpc(left);
	while (gmpc(left) < 4000)
	{
		motor(left, 50);
		motor(right, 50);
	}
	motor(0, 0);
	motor(3, 0);
	msleep(30);
	msleep(500);

	cmpc(left);
	while (gmpc(left) < 4000)
	{
		motor(left, 50);
		motor(right, 50);
	}
	motor(0, 0);
	motor(3, 0);
	msleep(30);
	msleep(500);

	return 0;
}

After — a function

#include <kipr/wombat.h>

// 1. Prototype
void drive_forward();

int main()
{
	// 3. Call
	drive_forward();
	drive_forward();

	return 0;
}

// 2. Definition
void drive_forward()
{
	cmpc(left);
	while (gmpc(left) < 4000)
	{
		motor(left, 50);
		motor(right, 50);
	}
	motor(0, 0);
	motor(3, 0);
	msleep(30);
	msleep(500);
}

Arguments — one function, many distances

drive_forward() always drives 4000 ticks. That is fine until you need 2000.

Put a variable in the parentheses and you can decide the number every time you call it. That variable is an argument — the same word you met back in Project 3.

// Prototype says what it needs
void drive_forward(int ticks);

...

// Call: go 4000
drive_forward(4000);
// Call: go 1200
drive_forward(1200);

...

// Definition uses the name
void drive_forward(int ticks)
{
	cmpc(left);
	while (gmpc(left) < ticks)
	{
		motor(left, 50);
		motor(right, 50);
	}
	motor(0, 0);
	motor(3, 0);
	msleep(30);
	msleep(500);
}

Two arguments? Separate them with a comma — exactly like motor(port, power) does.

A function can call another function

Once drive_forward() and turn_right() exist, a bigger function can just use them.

void drive_square()
{
	drive_forward(4000);
	turn_right();
	drive_forward(4000);
	turn_right();
	drive_forward(4000);
	turn_right();
	drive_forward(4000);
	turn_right();
}

Now drive_square(); is one line. This is how a whole match run eventually becomes a short, readable list of things your robot does.

Do It — Build Your Own Commands

Step 1 — My first function

Create a new project called Functions. Take your working drive-forward code from Project 11 and turn it into a function with all three parts.

Call it twice in main. The robot should drive the distance, then drive it again.

• My function compiles and the robot drives twice
• Prototype has a semicolon, definition does not

Step 2 — Break the prototype on purpose

Delete the prototype line. Compile.

Put it back. Now add a semicolon to the end of the definition line and compile again.

Fix it. You have now seen both of the mistakes everyone makes here.

Step 3 — A turn function

Same three parts, using your 90° turn from Project 11.

• My turn function works

Step 4 — The square — one more time

You have now driven this square three times. Do it once more, using only function calls.

Step 5 — Add an argument

Change your drive function so the distance comes from an argument. Then drive a rectangle — two long sides, two short ones — with the same function called four times.

drive_forward(4000);
turn_right();
drive_forward(2000);
turn_right();
drive_forward(4000);
turn_right();
drive_forward(2000);
turn_right();

• My robot drives a rectangle using one drive function

Step 6 — Wrap the grab

The six-step grab sequence from Project 8 is your best candidate. Turn it into grab() and release().

void grab()
{
	set_servo_position(arm, down);
	msleep(700);
	set_servo_position(claw, closed);
	msleep(700);
	set_servo_position(arm, up);
	msleep(700);
}

Now write a bigger function that uses them:

void fetch_pom()
{
	drive_forward(2000);
	grab();
	turn_right();
	drive_forward(1500);
	release();
}

• I have a function that calls my other functions

Step 7 — Mission 15 — one blue pom for 9 points

Build the run out of the functions you just wrote. Your whole main should read like a list of instructions, not a wall of code.

• One blue pom is IN a basket and stays there

Step 8 — Mission 15 Bonus — do it again for 9 points

Here is the payoff for the whole project. To score the bonus you need a second blue pom in the same basket.

You do not write any new code. You call your function a second time.

fetch_pom();
fetch_pom();

The second pom is somewhere different from the first, so your function will need a way to handle that — an argument, or a small drive between the two calls.

How did you get the second call to reach a different pom?

• Two blue poms are in the same basket at the end

Step 9 — Run it five times

Score It — Checkpoint

My score

My function list

Write down every function you built. This list is the start of something you will finish in Project 16.

Where does each part go?

Can you do it again?

• I can name the three parts of a function and say where each one goes
• I know which one gets a semicolon and which one does not
• I can explain what void means
• I can name a function so a teammate knows what it does without reading it
• I can write a function that takes an argument and use it with different values
• I can write a function that calls my other functions
• My main reads like a list of what the robot does

Think about it

Your robot’s turn is 15 ticks off. With functions, how many places do you edit? Without them, how many?

In Project 9 you gave names to numbers. Here you gave names to actions. What is the same about those two ideas?

A new teammate joins and opens your program. They see fetch_pom(); and have no idea how it works. Is that a problem?

Next

Your robot follows the same plan every time, no matter what it finds. If a cube is not where you expected, it grabs at nothing and carries on regardless.

In Project 13 — Deciding What to Do, it stops following orders blindly and starts choosing.

KIPR · Botball Explorer — Discovery Projects · © KISS Institute for Practical Robotics 1997–2026