Perfect Turns

Overview

Every stacking mission needs your robot to turn — left to face a cube, right to face the pallet. But a turn that’s “about 90°” will wreck a mission: after a few turns, the robot is pointing the wrong way entirely. Today you’ll build reliable 90° turns, left and right, by counting encoder ticks — and then you’ll run a clever test that reveals exactly how much error hides in each turn. This is the heart of localization: knowing, and trusting, where your robot is pointed.

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

• Make the robot pivot in place by driving its wheels in opposite directions.
• Use encoder ticks to control how far the robot turns.
• Tune turn_left and turn_right to a true 90° through trial-and-error.
• Run a repeat-test that exposes accumulated error, and correct for it.

Phase 1 — Concept: Pivot Turning

k.motor(0,  50)   # left wheel forward
k.motor(3, -50)   # right wheel backward  -> robot pivots RIGHT

k.cmpc(0)                        # clear the counter
while k.gmpc(0) < TURN_TICKS:     # pivot until we've turned far enough
    k.motor(0, 50)
    k.motor(3, -50)

Phase 2 — Build & Tune the Right Turn

Build turn_right with a tick value you’ll tune. Start with a guess, run it, measure the actual angle with a protractor, and adjust RIGHT_TICKS until it’s a true 90°.

#!/usr/bin/python3

# Unit 3, Big Idea 4: Perfect Turns

# Name: _______________________   Date: ___________

import os, sys
sys.path.append("/usr/lib")
import _kipr as k

RIGHT_TICKS = ____   # Tune this tick count for a 90-degree RIGHT pivot.
LEFT_TICKS  = ____   # Set the tick count for a 90-degree LEFT pivot in Phase 3.

def main():
    turn_right()    # test one right turn, then measure the angle

def turn_right():
    k.cmpc(0)                            # clear the LEFT wheel's counter
    while k.gmpc(0) < RIGHT_TICKS:        # left wheel rolls forward as we pivot right
        k.motor(0,  50)                  # left wheel forward
        k.motor(3, -50)                  # right wheel backward
    k.motor(0, 0); k.motor(3, 0); k.msleep(50)   # brake

main()

Tuning Log — Right Turn

What RIGHT_TICKS value gave you the closest to a true 90°? How did you decide which way to adjust when it was off?

Phase 3 — Build & Tune the Left Turn

Now the left turn. It’s the mirror image — wheels swapped — and it watches the right wheel (k.gmpc(1)), because that’s the one rolling forward this time. Tune LEFT_TICKS the same way.

def turn_left():
    k.cmpc(1)                          # clear the RIGHT wheel's counter this time
    while k.gmpc(1) < LEFT_TICKS:       # right wheel rolls forward as we pivot left
        k.motor(0, -50)                # left wheel backward
        k.motor(3,  50)                # right wheel forward
    k.motor(0, 0); k.motor(3, 0); k.msleep(50)   # brake

Tuning Log — Left Turn

Did your LEFT_TICKS end up the same as RIGHT_TICKS, or different? Why might the two directions need different numbers?

Phase 4 — The Drift Test: Eight Turns

A single 90° turn might look perfect — but a tiny error you can’t see adds up. Here’s how to expose it: turn the same direction 8 times. That’s 8 × 90° = 720°, two full spins, so the robot should end up facing exactly where it started. Any gap is your hidden error, multiplied by eight and now impossible to miss.

i = 0
while i < 8:              # Repeat the turn 8 times for a total of 720 degrees.
    turn_right()
    k.msleep(300)         # brief pause so you can watch each step
    i = i + 1

Mark, Run, Measure

Correction Log

After adjusting, did the eight-turn test land closer to the start? Explain how the 8× test made a tiny per-turn error easy to see and fix.

Phase 5 — Add Your Turns to the Library

Your tuned turns are tools you’ll use in every mission — so they belong in your library. Add turn_left and turn_right (and your LEFT_TICKS/RIGHT_TICKS values) to your library file from Big Idea 3, fully commented.

# turn_right: Pivots the robot 90 degrees to the right in place.

#   Watches the left wheel's encoder (gmpc 0). Tuned with

#   RIGHT_TICKS for a true 90-degree turn. Takes no input.
def turn_right():
    k.cmpc(0)
    while k.gmpc(0) < RIGHT_TICKS:
        k.motor(0, 50); k.motor(3, -50)
    k.motor(0, 0); k.motor(3, 0); k.msleep(50)

# turn_left: Pivots the robot 90 degrees to the left in place.

#   Watches the right wheel's encoder (gmpc 1). Tuned with

#   LEFT_TICKS for a true 90-degree turn. Takes no input.
def turn_left():
    k.cmpc(1)
    while k.gmpc(1) < LEFT_TICKS:
        k.motor(0, -50); k.motor(3, 50)
    k.motor(0, 0); k.motor(3, 0); k.msleep(50)

Now that your turns are in the library, write a single line for main that would drive forward, turn right, and drive forward again (using your library functions).

Phase 6 — Connect: The AI Literacy Bridge

One turn looked fine, but eight turns revealed an error hiding in every single one. This is one of the most important truths in robotics and AI: small errors add up. A self-driving car that misjudges its heading by 1° is fine for a second and lost after a mile. A spacecraft off by a fraction of a degree misses a planet by thousands of miles. Smart systems don’t assume they’re perfect — they constantly measure their drift and correct it. Your eight-turn test is exactly the kind of test real engineers run to catch errors that are invisible at small scale.

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

A single turn was off by just 2°. After 8 turns, how far off was it? Why is an error that’s “too small to notice” still dangerous in a long mission?

Why is running a turn 8 times a smarter test than running it once? What did multiplying the error let you see?

Phase 7 — Individual Reflection

Complete this section on your own.

1. How does a robot pivot in place? Why does a right turn watch k.gmpc(0) but a left turn watch k.gmpc(1)?

2. You found your turn’s tick value by trial-and-error. Describe that process — how did you know which way to adjust?

3. What did the eight-turn (720°) test reveal that a single turn hid?

4. Complete in 2–3 sentences: “Small errors compound, so intelligent systems must measure and correct for drift. This means that in a long mission, a robot should…”

Extension Challenges

Finished early? Try one or more of these.

Extension A — Drive a Square

• Combine Tick_Drive and turn_right to drive a square: forward, turn, four times. Does the robot return to its start? How far off is it?

Extension B — Left Square vs. Right Square

• Drive a square turning left, then one turning right. Is one more accurate than the other? What does that say about your two tick values?

Extension C — A turn(int degrees) Idea

• Right now 90° is baked in. How could a function take the number of degrees as an parameter and compute the ticks? Sketch the idea. (You’ll have the tools for this soon.)

Extension D — Looking Ahead: Stacking

• You now have driving, turning, and an arm. List the steps — in library function calls — to drive to a cube, pick it up, turn, and place it on the pallet.