Gyro Turns

The Problem With Timed Turns

Here is a scenario that every VEX competitor has experienced:

You program a 90-degree turn using drivetrain.turn_for(RIGHT, 1.2, SECONDS). It works perfectly in your garage. You get to the competition. Same program. The robot turns 82 degrees instead of 90. The entire routine falls apart.

What happened? The motors run at different speeds depending on battery charge. The field tiles have different grip than your floor. The robot was carrying a slightly different load. Any of these factors can throw off a timed turn by 5-15 degrees.

The inertial sensor measures actual rotation. It does not care about battery level, floor friction, or motor variation. It just asks: how many degrees has the robot rotated? That is a fact that cannot be argued with.

The Inertial Sensor

The VEX IQ Inertial Sensor is a combination gyroscope and accelerometer built into the Brain. You do not need an external sensor — just import it:

Blocks Python

from vex import *

brain = Brain()
left_motor = Motor(Ports.PORT1, False)
right_motor = Motor(Ports.PORT6, True)
inertial = Inertial(Ports.PORT3)  # PORT3 is the Brain's built-in port

# ALWAYS calibrate before using
inertial.calibrate()
wait(2, SECONDS)  # Must wait for calibration to complete

# Now you can read heading (0-359.99 degrees)
current = inertial.heading()
brain.screen.print(current)

Heading vs Rotation

The inertial sensor has two modes:

• inertial.heading() — returns 0 to 359.99, wraps around like a compass
• inertial.rotation() — returns total rotation, can go past 360 (e.g., 450 after 1.25 turns)

For most autonomous turns, use heading. It is easier to work with — just say “turn until heading equals 90°.”

Simple Gyro Turn (No PID)

The most basic gyro turn: spin the robot until the heading matches the target.

Blocks Python

def simple_turn(target_heading, speed=40):
    """Turn to a heading at constant speed. Simple but not smooth."""
    current = inertial.heading()

    # Decide which direction to turn (shortest path)
    diff = target_heading - current
    if diff > 180:
        diff -= 360
    elif diff < -180:
        diff += 360

    if diff > 0:
        # Turn left
        left_motor.spin(REVERSE, speed, PERCENT)
        right_motor.spin(FORWARD, speed, PERCENT)
        while inertial.heading() < target_heading - 2:
            wait(10, MSEC)
    else:
        # Turn right
        left_motor.spin(FORWARD, speed, PERCENT)
        right_motor.spin(REVERSE, speed, PERCENT)
        while inertial.heading() > target_heading + 2:
            wait(10, MSEC)

    left_motor.stop(BRAKE)
    right_motor.stop(BRAKE)

This works, but notice the problem: the robot turns at full speed until it is 2 degrees away, then abruptly stops. This overshoot and jerk is acceptable for practice but unreliable in competition. PID fixes this.

The Angle Wrapping Problem

Before implementing PID turns, you must understand angle wrapping. The heading goes from 0 to 359. What happens when you want to turn from 350° to 10°?

• The “naive” error is 10 - 350 = -340° (turn 340 degrees backward)
• The correct error is +20° (turn 20 degrees forward, crossing the 0/360 boundary)

This bug will make your robot spin in circles if you do not handle it. The fix is always:

error = target - current
if error > 180:
    error -= 360   # Take the shorter path backward
elif error < -180:
    error += 360   # Take the shorter path forward

This ensures error is always between -180 and +180 (shortest path to target).

PID Gyro Turn

# Here is a full PID turn using the PIDController class from the PID Control tutorial:
from vex import *

brain = Brain()
left_motor = Motor(Ports.PORT1, False)
right_motor = Motor(Ports.PORT6, True)
inertial = Inertial(Ports.PORT3)

class PIDController:
    def __init__(self, kp, ki, kd, max_integral=50):
        self.kp = kp
        self.ki = ki
        self.kd = kd
        self.max_integral = max_integral
        self.integral = 0
        self.prev_error = 0

    def calculate(self, error):
        self.integral += error
        self.integral = max(-self.max_integral, min(self.max_integral, self.integral))
        derivative = error - self.prev_error
        self.prev_error = error
        return self.kp * error + self.ki * self.integral + self.kd * derivative

    def reset(self):
        self.integral = 0
        self.prev_error = 0


turn_pid = PIDController(kp=1.5, ki=0.003, kd=0.25)


def turn_to_heading(target_heading):
    """
    Turn to an absolute heading using PID control.
    target_heading: degrees (0-360)
    """
    turn_pid.reset()
    settled = 0  # Count consecutive loops where error is small

    while True:
        current = inertial.heading()

        # Shortest-path error (handles 0/360 wrap)
        error = target_heading - current
        if error > 180:
            error -= 360
        elif error < -180:
            error += 360

        # Check if settled: error small for 5 consecutive loops
        if abs(error) < 1.5:
            settled += 1
            if settled >= 5:
                break
        else:
            settled = 0

        power = turn_pid.calculate(error)
        power = max(-80, min(80, power))  # Cap at 80% for turns

        left_motor.spin(FORWARD, power, PERCENT)
        right_motor.spin(REVERSE, power, PERCENT)
        wait(20, MSEC)

    left_motor.stop(BRAKE)
    right_motor.stop(BRAKE)


# --- Initialize ---
inertial.calibrate()
wait(2, SECONDS)
inertial.set_heading(0)  # Start facing 0 degrees

# --- Test Turns ---
turn_to_heading(90)   # Turn to face right
wait(500, MSEC)
turn_to_heading(180)  # Turn to face back
wait(500, MSEC)
turn_to_heading(270)  # Turn to face left
wait(500, MSEC)
turn_to_heading(0)    # Turn back to start

The Settled Check

Notice the settled counter. Instead of stopping the moment error < 1.5°, the robot must stay within 1.5° for 5 consecutive loops (about 100ms). This prevents the robot from stopping when it momentarily passes through the target heading on its way to oscillating.

This is called a settle condition and is essential for reliable PID turns.

Tuning Gyro Turns

Turn tuning works the same as drive tuning, but the values are different:

1. Start with kp=1.0, ki=0, kd=0 — run a 90° turn test
2. If it oscillates: reduce kp. If it barely moves: increase kp
3. Once stable: add kd=0.1 to smooth out the approach
4. If still stopping short: add ki=0.002

Typical competition values:

• kp: 1.2 to 2.5
• ki: 0 to 0.005
• kd: 0.15 to 0.4

Note that turn tuning values are very robot-specific. A heavy robot needs different values than a light one. Always tune on your actual competition robot.

Setting Heading at the Start

Always tell the inertial sensor what heading to start at. If your robot begins facing 0° (toward the scoring goal), use:

inertial.set_heading(0)

Call this after inertial.calibrate() and before any movement. This anchors your coordinate system so turn_to_heading(90) always means “face 90° from where I started.”

Common Mistakes

Not waiting for calibration: inertial.calibrate() takes 2 full seconds. If you start moving before it finishes, the sensor gives garbage readings.

Relative vs absolute headings: turn_to_heading(90) is absolute — face 90°. There is no concept of “turn 90 degrees from wherever I am” in this function. If you want relative turns, calculate: turn_to_heading(inertial.heading() + 90 % 360).

Moving the robot during calibration: The inertial sensor must be stationary during the 2-second calibration period. Do not touch or move the robot.

Next Steps

You now have the two core building blocks of a competitive autonomous routine: pid_drive() and turn_to_heading(). With these, you can program any sequence of movements accurately.