Meet the Servos

Overview

Your robot can drive, sense, and follow lines — but it can’t yet touch the world. To stack cubes, it needs an arm and a claw. Those are run by servos: motors that move to an exact position and hold it. Today you’ll build a demobot arm and claw, learn to move each servo to a precise spot, and — most important — find the safe limits of your servos so you never damage them. Then you’ll try your first pick-up.

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

• Enable and move a servo to an exact position with enable_servo and set_servo_position.
• Use the servo widget to find your arm and claw’s safe minimum and maximum.
• Explain why staying inside the safe range protects the servo from burning out.
• Write a sequence that opens, lowers, closes, and lifts — a first cube pick-up.

Build & Plug In the Servos

Phase 1 — Concept: How a Servo Works

enable_servo(0);              // turn on the servo on port 0
set_servo_position(0, 1024);  // send it to position 1024 (the center)

Phase 2 — Find the Arm’s Safe Range

How did you know you’d reached the arm’s limit? What did you see or hear that told you to stop before forcing it?

Phase 3 — Find the Claw’s Safe Range

A servo position is a measurement. In your own words, what does a bigger claw number mean physically? What does a bigger arm number mean?

Phase 4 — Build: Your First Pick-Up

Type your four safe values at the top, then build the grab sequence: open the claw, lower the arm, close on the cube, and lift. Each move gets a pause so the servo has time to arrive.

// Unit 3, Big Idea 1: Meet the Servos
// Name: _______________________   Date: ___________

#include <kipr/wombat.h>

// YOUR safe values from the widget: never command past these,
// or you can BURN OUT the servo by forcing it into a hard stop.
int ARM_MIN   = ____;   // minimum safe value (arm up)
int ARM_MAX   = ____;   // maximum safe value (arm down)
int CLAW_OPEN = ____;   // safe open claw position
int CLAW_SHUT = ____;   // safe closed-on-cube claw position

int main()
{
	enable_servo(0);    // arm servo on port 0
	enable_servo(1);    // claw servo on port 3
	// (enabling sends each servo to 1024 unless told otherwise)

	set_servo_position(3, CLAW_OPEN);   // 1. open the claw
	msleep(1000);                       // give the servo time to get there

	set_servo_position(0, ARM_MAX);     // 2. lower the arm to the cube
	msleep(1000);

	set_servo_position(3, CLAW_SHUT);   // 3. close on the cube
	msleep(1000);

	set_servo_position(0, ARM_MIN);     // 4. raise the cube up
	msleep(1000);

	return 0;
}

About the msleep(1000): servos don’t move instantly, so you wait for each one to arrive before the next command. We use a full second for safety while you’re learning — once you know your servos, you can shorten it.

Pick-Up Log

Did your robot pick up the cube? If a step didn’t work (claw missed, arm too low/high), which safe value did you adjust, and why?

Phase 5 — Measure the Motion

Servo positions are numbers, so you can measure your robot’s reach the same way you measured driving distance. Use your values to answer these.

Which has more travel — your arm or your claw? Why might one need a bigger range of motion than the other?

Phase 6 — Connect: The AI Literacy Bridge

Before your robot could safely lift anything, you had to teach it the limits of its own arm and claw — how far they can go before they break. Every robot that acts on the world has this problem. A factory arm knows exactly how far each joint can bend; a surgical robot has hard limits built in so it can never over-extend. Knowing your own physical limits isn’t a weakness — it’s what makes safe, precise action possible. A system that doesn’t know its limits will eventually destroy itself.

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

Why is commanding a servo past its hard stop dangerous? Connect this to why a robot must “know its own body.”

Your safe values are probably a little different from a neighbor’s, even with the same parts. Why must each robot find its own limits rather than sharing one set of numbers?

Phase 7 — Individual Reflection

Complete this section on your own.

1. How is a servo different from a regular motor? What does set_servo_position do?

2. What happens the moment you call enable_servo, and why do you need to plan for it?

3. Why is finding the safe minimum and maximum so important? What can happen if you ignore them?

4. Complete this in 2–3 sentences: “Intelligent systems must know the limits of their own bodies to act safely. This means that before a robot uses an arm, it must…”

Extension Challenges

Finished early? Try one or more of these.

Extension A — Set It Down Gently

• Add steps to lower the arm and open the claw to place the cube back down. Does the order matter? Test it.

Extension B — How Slow Can the Pause Go?

• Shorten the msleep after each move (try 700, then 500). What’s the shortest pause where the servo still fully arrives before the next move? What happens if it’s too short?

Extension C — A Middle Height

• Find an arm value between your min and max that holds the cube at a useful “carry” height. Why might you want to carry a cube partway up instead of fully raised?

Extension D — Looking Ahead: Reusing These Moves

• You’ll use “open,” “close,” “raise,” and “lower” over and over in future missions. How could turning each into its own function make stacking cubes easier later? (We’ll build toward a shared library.)

Extension E — What’s the Computer, What’s the Peripheral?

• The Wombat controller has a processor running your compiled program, memory holding that program while it runs, and things it commands — like your servos. Which parts of your robot are “the computer,” and which are peripherals it’s controlling?
• Where does a sensor fit into that picture?

Extension F — Compiled, Typed, and Running on Something

• Extension E called your program “compiled.” Look up what compiling means, and contrast it with an interpreted language (like Python) that runs line-by-line instead. Which would you guess is faster for a robot that needs to react in real time, and why?
• C is a strongly typed language — every variable has a fixed type (double, int, char) that can’t silently change. Some languages are more loosely typed, letting a variable hold different kinds of values over its life. What’s one bug that strong typing might catch for you automatically that a loosely-typed language wouldn’t?
• Your program also runs on top of an operating system on the Wombat controller. Name one thing you’d guess the OS is doing while your program runs, besides running your program.