The Double Stack

Overview

This is it — the moment everything comes together. Over this unit you built a whole toolbox: driving a measured distance, turning a reliable 90°, and lifting with a safe, smooth arm and claw. Today you’ll compose those tools into a complete mission. Your robot will drive to a cube, pick it up, stack it on a cube of the opposite color — then reposition itself and do it a second time for the bonus. No new commands today. The challenge is planning: putting your tested tools in exactly the right order.

By the end of this activity you will be able to:

• Plan a full multi-step mission before writing any code.
• Compose your library functions into a working stack sequence.
• Reposition the robot to line up with a second target using turns and driving.
• Complete Mission 3 — two cubes stacked on opposite-color cubes.

Phase 1 — Understand the Mission

Say the mission back in your own words. What makes the second stack harder than the first?

Phase 2 — Build a Missing Tool: Back_Drive

Your library can drive forward a measured distance with Tick_Drive — but a real stack needs the robot to back away after placing a cube, so it doesn’t knock the stack over. You don’t have a backward version yet. Let’s build one, and the trick is in the encoder math.

forward:    0  ->  1  ->  2  ->  3  ... up to +1000
backward:   0  -> -1  -> -2  -> -3  ... down to -1000

void Back_Drive(int ticks)
{
	cmpc(0);                         // clear the counter to 0
	while (gmpc(0) > -ticks)         // count DOWN until we reach -ticks
	{
		motor(0, -50);             // both wheels backward
		motor(3, -50);
	}
	motor(0, 0); motor(3, 0); msleep(50);   // brake
}

Explain in your own words why the loop uses > -ticks instead of < ticks. What is the encoder count doing as the robot backs up?

Test it: call Back_Drive(1000) right after a Tick_Drive(1000). Did the robot return to about where it started? Add Back_Drive to your library when it works.

Phase 3 — Plan: Map the Field

Before a single line of code, draw your plan. Mark your starting box (drawn for you), both cube pairs (the cube to lift and the cube to stack on), and the path your robot will travel. This map is what your whole program will be built from.

Sketch: starting box, both cube pairs, and your path

Draw on the printed copy, or describe the layout in the box below.

Phase 4 — Plan: Write the Sequence for Stack 1

Now turn your map into an ordered list of moves — in plain English first, then the library function each one becomes. Think through the whole grab: arm up and claw open to start, drive to the cube, lower, grab, lift, carry, lower onto the base cube, release.

Phase 5 — Plan: Reposition to the Second Stack

With stack 1 done, your robot has to move over and line up with the second pair of cubes. You’ll do this with the tools you have: turn, drive, turn back. Turn to face the direction of the second stack, drive over to it, then turn back to face the cubes — squared up and ready to repeat.

turn_right();      // face sideways toward stack 2
Tick_Drive(____);  // drive over to line up with it
turn_left();       // turn back to face the cubes

Which way does your robot need to shift for stack 2 — left or right? Write the three calls (turn, drive, turn back) you’ll use, with your tick value. (You can use Tick_Drive or Back_Drive depending on your path.)

Phase 6 — Build: The Whole Mission in main()

Now write it for real. Here is the frame — nothing more. Include your library, enable your servos, and you’ll fill each section with the calls from your own planning tables in Phases 4 and 5. There are no answers to copy here on purpose: the sequence lives in your plan, and only you have it.

#include <kipr/wombat.h>

#include <yourname.h>     // all your tuned tools

int main()
{
	enable_servo(0);          // arm
	enable_servo(1);          // claw

	// ===== STACK 1 =====
	// (write your calls from your Phase 4 plan)


	// ===== REPOSITION to stack 2 =====
	// (your turn / drive / turn-back from Phase 5)


	// ===== STACK 2 =====
	// (your calls)


	return 0;
}

Translate your plan line by line. Each row of your Phase 4 table is one function call. If you skipped the planning, this is where it catches up with you — go back and finish your map first.

Before you run it: read your main() out loud as a list of actions. Does it match the path you mapped in Phase 3? Fix any step that’s out of order.

Phase 7 — Run, Test, and Tune

Run the mission. It almost certainly won’t be perfect the first time — that’s normal for a full mission. Test it in pieces: get stack 1 working first, then the reposition, then stack 2. Record what you fix.

Mission Checklist

Which part of the mission was hardest to get right — a stack, or the reposition? Why?

Phase 8 — Connect & Reflect

You just completed a real mission — and you did it without writing a single new low-level command. Every piece was a tool you’d already built and tested. That’s how all complex automation works: a warehouse robot fulfilling an order, a factory line assembling a product, a Mars rover collecting a sample — each is a sequence of reliable, reusable behaviors, planned carefully and run in order. The intelligence is in the planning and the trust you’ve earned in each part.

Complete the reflection on your own.

1. You wrote a whole mission using only library functions. Why was planning the sequence the hardest part, not the code itself?

2. Explain how the reposition (turn, drive, turn back) lined the robot up with the second stack without changing the direction it faced.

3. If one library function (say turn_right) was slightly off, how would that affect the whole mission? Connect this to why you tuned each tool carefully first.

4. Complete in 2–3 sentences: “Complex tasks are accomplished by sequencing reliable, reusable behaviors. This means that to build a hard mission, I should first…”

Extension Challenges

Finished early? Try one or more of these.

Extension A — Make the Stacks Opposite Colors

• Mission 3’s top bonus is making the two stacks opposite colors from each other. Plan how your cube choices would change to earn it.

Extension B — Speed It Up

• Where is your mission slowest? Could a shorter msleep in your servo moves, or a faster drive, save time without losing reliability? Test it.

Extension C — Recover From a Miss

• If the robot drops a cube, what could it do to try again? Sketch an idea using your existing tools.

Extension D — Add a Third

• If there were a third pair of cubes, what would you add to your mission? Write the plan for reaching and stacking it.

Extension E — Beyond the Classroom

• This course leads to a real KIPR Botball tournament, where your robot competes against other schools’ teams — a real event beyond your classroom.
• In 2-3 sentences, what’s one way your work in this course could be useful or interesting to someone outside your school — a younger student, a parent, a future employer?