Information Must Be Interpreted

Overview

Your touch sensor gave a clean yes-or-no. Today’s sensor is different. A Tophat sensor shines infrared light at the floor and measures how much bounces back — white reflects a lot, black line reflects little. But it doesn’t return 0 or 1. It returns a number from a big range, and that number is noisy — it jumps around even when nothing moves. Before this sensor is useful, you have to interpret it: figure out what counts as “black” and what counts as “white.” That work is most of this lab, and almost all of it happens before you write a single line of code.

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

• Read an analog sensor with analog(0) and explain why its values are noisy.
• Calibrate the sensor: measure black and white, and find the best mounting height.
• Calculate a threshold (midpoint) that separates “black” from “white.”
• Use if/else on the live reading to steer a robot along a line.

Phase 1 — Mount the Sensor & Find Its Values

Mount It

Find It on the Controller

Hold the sensor still over white and watch the port-0 value for a few seconds. What was the lowest number you saw, and the highest? How much did it bounce?

Why is a sensor that bounces around a problem if you wanted to check for one exact value like analog(0) == 2000?

Phase 2 — Find the Best Height

The sensor’s height off the floor changes how well it can tell black from white. Too close or too far, and black and white start to look the same. You want the height where the difference between a black reading and a white reading is as big as possible — a big gap is easy to split; a small gap is not.

Step 1 — Read at Different Heights Over WHITE

Hold the sensor at each height over a plain white area. Record the value you see (pick the middle of the bounce).

Step 2 — Read at Different Heights Over BLACK

Now the same heights, over black line.

Step 3 — Find the Biggest Difference

For each height, subtract: black value − white value. The bigger the difference, the easier it is to tell them apart.

Which height gave the biggest difference between black and white? Why is a bigger gap better for telling the line from the floor?

Phase 3 — Calibrate & Find the Midpoint

Now mount the sensor firmly at your best height (around 1/4 inch). With it mounted exactly where it will drive, take your real readings — these are the numbers your code will trust.

Step 1 — Mounted Readings

Step 2 — Calculate the Midpoint

The midpoint is the value exactly halfway between black and white. It’s your threshold: above it means black, below it means white. Add your two readings and divide by 2.

Write your final midpoint value here, and explain in one sentence what it means.

Phase 4 — Concept: Threshold & Steering

if (analog(0) > MIDPOINT)     // reading is HIGH: that's BLACK
{
	// ...we're on the line
}
else                           // reading is LOW: that's WHITE
{
	// ...we're on the floor
}

Phase 5 — Build the line_follow Function

You’ll reuse the encoder skeleton from Tick_Drive — clear the counter, loop to a tick target, brake at the end — but inside the loop you’ll put the if/else that steers. Type your own MIDPOINT from Phase 3 at the top. Prototype above main(), definition below.

// Unit 2, Big Idea 4: Reading the Line
// Name: _______________________   Date: ___________

#include <kipr/wombat.h>

int MIDPOINT = ____;   // YOUR midpoint from Phase 3 (black + white) / 2

void line_follow(int ticks);   // PROTOTYPE: drive this far while steering on the line

int main()
{
	line_follow(3000);         // follow the line for this many ticks
	return 0;
}

void line_follow(int ticks)
{
	cmpc(0);                       // clear the wheel counter

	while (gmpc(0) < ticks)           // keep going until we've driven far enough
	{
		if (analog(0) > MIDPOINT)   // HIGH reading means BLACK, so steer right
		{
			motor(0, 50);          // left motor faster
			motor(3, 20);          // right motor slower
		}
		else                       // LOW reading means WHITE, so steer left
		{
			motor(0, 20);          // left motor slower
			motor(3, 50);          // right motor faster
		}
	}

	motor(0, 0);                   // brake (from Big Idea 2)
	motor(3, 0);
	msleep(50);
}

Tuning Log

Run it on the line. Adjust your speeds (the 50 and 20) and re-test. Record what you tried.

Checklist

• You typed your own measured MIDPOINT at the top
• The if tests analog(0) > MIDPOINT
• The black branch and white branch set the two motors to different speeds
• The loop still uses cmpc(0) and gmpc(0) < ticks to control distance
• The robot brakes at the end

Phase 6 — Connect: The AI Literacy Bridge

Your sensor handed you a noisy, jumpy number. On its own, it meant nothing. You turned it into meaning by calibrating and setting a threshold — and only then could the robot act on it. Every intelligent system does this. A voice assistant gets a messy sound wave and has to decide “was that a word?” A medical device reads a noisy heartbeat signal and decides “is that a real beat?” The raw data is always messy; the intelligence is in interpreting it well. A bad threshold makes a bad decision, no matter how good everything else is.

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

Your midpoint was different from your neighbor’s, even with the same kind of sensor. Why must each robot be calibrated for itself instead of using one number for everyone?

Imagine you set your threshold too low, so the robot calls almost everything “black.” What would the robot do wrong? Now too high — what goes wrong then?

A raw sensor value is just a noisy number until it’s interpreted. Name another machine that has to turn messy raw data into a clear decision, and say what its “threshold” decides.

Phase 7 — Individual Reflection

Complete this section on your own.

1. What is the difference between a digital sensor (the touch button) and an analog sensor (the Tophat)?

2. What is a threshold, and how did you calculate yours? Why is the midpoint a good choice?

3. In Unit 1, your if/else tested a number you typed. Today it tested a live sensor. Why is testing a real sensor more powerful?

4. Complete this in 2–3 sentences: “Intelligent systems transform raw sensor data into meaningful information. This means that before a robot can trust a sensor, someone must…”

Extension Challenges

Finished early? Try one or more of these.

Extension A — Smoother Steering

• Your robot probably wiggles. Try making the fast/slow speeds closer together (like 45 and 30). Does it wobble less? What’s the trade-off?

Extension B — Re-calibrate Under Different Light

• Move to a brighter or darker spot and re-read black and white. Did your midpoint change? What does that tell you about trusting old calibration data?

Extension C — Make is_on_black()

• Write a small helper function (prototype above, definition below) that returns whether the sensor sees black, using your threshold. How could that make line_follow easier to read?

Extension D — Two Sensors (a peek ahead)

• If you had a Tophat on the left AND the right, how could the robot follow the line more smoothly? Sketch the idea in words. (We’ll build toward this.)