Repeating Without Retyping

Try It — Thirty Small Hops

Back in Project 9 you moved a servo in three big jumps and were asked what it would take to move it in thirty small ones. Here is the answer you were promised.

#include <kipr/wombat.h>

int main ()
{
	int arm = 0;
	int position = 200;

	enable_servos();
	while (position < 1800)
	{
		position = position + 10;
		set_servo_position(arm, position);
		msleep(5);
	}
	disable_servos();
	return 0;
}

Read it with a partner before you run it, and answer these from the code alone.

How is this different from set_servo_position(arm, 1800); on its own?

Where the counting lives

Look at that loop again. The three things that control the counting are in three different places:

• The start is on line 6, above the loop.
• The stopping point is on line 9, in the condition.
• The step is on line 11, buried inside the block.

Learn It — All Three on One Line

A for loop does exactly the same job, but it puts the start, the stop, and the step together where you can see all three at once.

for (position = 200; position < 1800; position++)
      ↑              ↑                  ↑
    start          stop               step

Two semicolons inside the parentheses, and none after the closing one. Same rule as while and if — the braces finish the statement.

The same loop, both ways

while

int position = 200;

while (position < 1800)
{
	set_servo_position(arm, position);
	msleep(5);
	position++;
}

Three pieces in three places. Forget the last one and it never ends.

for

int position;

for (position = 200; position < 1800; position++)
{
	set_servo_position(arm, position);
	msleep(5);
}

All three in one place. Hard to forget the step when it is right there.

Which one, when?

Counting repeats, not values

The counter does not have to control anything. It can just count how many times you have gone round.

int count;

for (count = 0; count < 4; count++)
{
	drive_forward(4000);
	turn_right();
}

That is a square. Four sides, four corners, four lines of code — and to make it a pentagon you change one number.

Do It — Do It Again, Automatically

Step 1 — Convert the smoother

Take the while version from Try It and rewrite it as a for loop. The arm should move identically.

• My for version moves the arm exactly like the while version did

Step 2 — A square in four lines

The square, for the last time. Use a for loop and your library functions.

• My robot drives a square from a four-iteration loop

Step 3 — Mission 11 Bonus — two orange poms for 7 points

The second pom is somewhere different, so your function needs an argument or a short drive between trips. Same problem you solved for Mission 15 in Project 12.

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

Step 4 — Missions 16 and 17 Bonuses — stack them higher for 22 points

• Two spilled cubes are on the Large Green Cube at the end
• Two unstraight cubes are on the Large Brown Cube at the end

Did the second delivery ever knock the first one off? What fixed it?

Step 5 — Mission 7 Bonus — a second enclosure · 9 pts

• Two enclosures each hold a blue and an orange pom

Step 6 — Put the loops in your library

Anything you wrapped in a loop that worked — deliver_poms(int howMany), smooth_arm(int from, int to) — belongs in your library file. Add it, save, and note it in your comment block.

• My new loop functions are in my library and documented

Step 7 — Run it five times

Score It — Checkpoint

My score

Which loop?

How many times?

Can you do it again?

• I can name the three parts of a for loop and say what each does
• I put two semicolons inside the parentheses and none after them
• I can work out how many times a for loop will run
• I can choose between while and for and explain why
• I can rewrite a while loop as a for loop
• I can repeat a whole function call with a loop
• I can move a servo smoothly instead of snapping it

Every point on the field

Add up what you scored across the whole strand. The right-hand column is what was available.

Think about it

You have written four kinds of loop condition now — a switch, a tick count, a brightness, and a plain count. Which was hardest to get right, and why that one?

In Project 1 you ran a program somebody else wrote and did not understand a line of it. Go back and read that program now. What does it say to you?

Your robot does exactly what it is told, every time, and has no idea what any of it means. After seventeen projects, does it seem intelligent to you? Say what makes you answer that way.

That Is the Coding Strand

Seventeen projects ago your robot could not be switched on. It now drives measured distances, turns to an angle, grabs and stacks and places, feels for walls, counts its own wheels, reads light and dark, follows a line, checks its own work, and decides what to do when something goes wrong.

All of it built from about a dozen commands and four ideas: do this, do it if, do it while, do it again.

Take your library with you. Next season the field will be different and most of what is in that file will still work.

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