Drive by the Numbers

Overview

Until now, your robot drove for a set time and hoped it went the right distance — and last lab proved how inconsistent that can be. Today the robot measures its own wheels. Each motor has a built-in counter that ticks up as it turns. By watching that counter, the robot can drive an exact distance instead of an exact time. You’ll use this to drive out from the starting box and touch Botguy — Mission 9.

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

• Read a motor’s encoder with gmpc() and reset it with cmpc().
• Write a while loop that exits on a number you choose, not just a button.
• Distinguish a function’s parameter from the argument supplied when you call it.
• Drive a measured distance from the starting box to touch Botguy.

First: Meet the Motor Graph on the Controller

Turn the port-0 wheel one full turn by hand. About how many ticks did the counter change? Write the number you saw.

New This Time: Encoders and a Numeric Loop

cmpc(0);    // CLEAR: reset port 0's counter back to 0
gmpc(0);    // GET: read how many ticks port 0 has turned

cmpc(0);                  // start counting from 0
while (gmpc(0) < 2000)     // while we haven't gone 2000 ticks yet...
{
	motor(0, 50);          // ...keep driving
	motor(3, 50);
    msleep(10);
}

void Tick_Drive(int ticks);   // PARAMETER: the named input is ticks

Tick_Drive(2000);   // ARGUMENT: pass in the value 2000
Tick_Drive(1000);   // ARGUMENT: pass in 1000 instead

Phase 1 — Activate: Counting Your Own Steps

Imagine you’re told “walk to the door.” You could guess at the time it takes — or you could count your steps. If the door is 10 steps away, you walk until your step count reaches 10, then stop. You’re not timing yourself; you’re measuring your own movement and stopping at a number.

How is counting your steps to a target like the robot counting encoder ticks to a target? Why does measuring movement beat guessing at time?

Phase 2 — Concept: Feedback, Parameters, and Arguments

An Encoder Is the Robot Sensing Itself

Earlier sensors told the robot about the outside world — a wall, a button. An encoder is different: it tells the robot about itself — how far its own wheels have turned. This is called feedback: the robot watches the result of its own action and uses it to decide when to stop.

A Parameter and Its Arguments Make One Function Flexible

You’ve built functions that always did exactly the same thing. In void Tick_Drive(int ticks), ticks is the parameter: the named input in the function. In Tick_Drive(2000), 2000 is the argument: the value supplied at that call. Tick_Drive(2000) and Tick_Drive(1000) call the same function with different arguments, so it drives two different distances.

In your own words: what is the parameter in void Tick_Drive(int ticks), and what is the argument in Tick_Drive(2000)? How does changing the argument change what the function does?

Phase 3 — Plan

The Mission

Your goal today is simply to touch Botguy. The bonus mission requires removing Botguy from his enclosure and getting him to the warehouse floor. That needs an arm, which is a manipulation task for a future lesson.

Step 1 — Find Your Target Number

You need to know how many ticks it takes to reach Botguy. Use the motor graph: clear the counter, drive toward Botguy by hand or with a short test, and read the tick count when the robot reaches him. Write your best target.

Step 2 — Plan in Plain English

Describe your program in order — including clearing the counter, the loop, and the brake.

Phase 4 — Build & Run

Starting Code Template

Type this program. Notice that int ticks is the parameter in the Tick_Drive prototype and definition. The value in a call such as Tick_Drive(2000) is the argument. Prototype above main(), definition below, as always.

// Unit 2, Big Idea 3: Drive by the Numbers
// Name: _______________________   Date: ___________

#include <kipr/wombat.h>

void Tick_Drive(int ticks);   // PROTOTYPE: ticks is the parameter

int main()
{
	Tick_Drive(2000);   // CALL: 2000 is the argument
	                         // (use YOUR target number from Phase 3)
	return 0;
}

void Tick_Drive(int ticks)       // DEFINITION: ticks receives the argument
{
	cmpc(0);                     // clear port 0's counter to 0

	while (gmpc(0) < ticks)       // while we haven't reached the target...
	{
		motor(0, 50);            // ...keep driving
		motor(3, 50);
		msleep(10);
	}

	motor(0, 0);                 // BRAKE (from last lab)
	motor(3, 0);
	msleep(50);                  // let the brake settle
}

Tune to Botguy

Run it, see where the robot stops, and adjust the number you pass to Tick_Drive() until it reaches Botguy. Record each try.

Checklist

• ticks is the parameter in (int ticks) in both the prototype and the definition
• The number in a call such as Tick_Drive(2000) is the argument
• cmpc(0) clears the counter before the loop
• The loop condition is gmpc(0) < ticks
• The robot brakes with motor(0,0); motor(3,0); msleep(50); after the loop
• You changed only the number passed in to tune the distance — not the function itself

Phase 5 — Debug & Extend

Debugging Log

Once Botguy works, try calling Tick_Drive() twice with different numbers in a row. What happened? Why is one flexible function better than writing a separate function for each distance?

Phase 6 — Connect: The AI Literacy Bridge

Your robot didn’t just act — it watched itself act and stopped at exactly the right point. That’s feedback, and it’s everywhere in intelligent systems. A 3D printer counts the steps of its motors to place plastic precisely; a robot arm in a factory knows the angle of every joint; a self-driving car tracks its own wheel rotation to know how far it’s gone. None of them guess — they measure their own motion and adjust. Today your robot joined them: it sensed its own wheels and used that number to reach a goal.

Read each scenario. Think it through, then write your answer.

A delivery robot needs to stop exactly at a doorway. Why is “count my own wheel turns” more reliable than “drive forward for 4 seconds”? What could change between runs that time can’t account for?

An encoder is a system sensing itself, not the outside world. Why is it powerful for an intelligent system to have information about its own actions, not just its surroundings?

Phase 7 — Individual Reflection

Complete this section on your own.

1. What do cmpc(0) and gmpc(0) each do? Why must you clear before you read in a loop?

2. What is the difference between a parameter and an argument? Identify each one in void Tick_Drive(int ticks) and Tick_Drive(2000), then explain how one function can drive many distances.

3. This loop exits on a number climbing to a target, not an on/off button. How is that different from the touch-sensor loop you wrote before?

4. Complete this in 2–3 sentences: “Intelligent systems sense their own actions and use that feedback to act precisely. This means a robot that can measure its own movement can…”

Extension Challenges

Finished early? Try one or more of these.

Extension A — Two Legs to Botguy

• Call Tick_Drive() with one number, then a turn, then Tick_Drive() with another number, to reach Botguy on an L-shaped path.
• How does having an argument make the two-leg path easy to write?

Extension B — How Many Ticks Per Inch?

• Drive a known distance (say 12 inches) and read the tick count. How many ticks is one inch on your robot?
• Now you can turn any distance in inches into a tick number. Try it.

Extension C — Read Both Wheels (a peek ahead)

• Print gmpc(0) and the other drive motor’s counter side by side as the robot drives. Do they climb at exactly the same rate?
• If they don’t, what might that tell you about why the robot drifts? (We’ll use this idea later.)

Extension D — A Backward Version

• Could Tick_Drive() handle backward too? Think about what the counter does when the wheel turns backward, and what your loop condition would need.