Straight-line driving robot with wheel encoders: design worksheet and code

A ₹1,610 two-wheel robot that drives straight using wheel encoders. Two slotted speed sensors count the pulses from each wheel’s encoder disc. A simple proportional correction slows the faster wheel and speeds up the slower one, so the robot holds a line instead of curving. The page includes the pin map, a complete sketch without third-party libraries, a method to tune the gain, and a test plan that measures drift over a fixed distance.

Scope: intermediate. This is a design worksheet with illustrative costs. It has not been bench-tested by this site; the pulse count per wheel turn, the gain and the speeds in the sketch are starting values that you measure and tune on your own chassis.

Why two identical motors still drift

Two TT gear motors given the same PWM value do not turn at the same speed. Friction, the battery, the gearbox and the wheel all differ a little, so the robot curves to one side. Most beginner robots hide this with a human holding the controller. An encoder measures how far each wheel has actually turned, so the controller can correct the difference in software. This build is also the base for later work: odometry, fixed-distance moves and square-path driving all start with counted wheel pulses.

Prices are illustrative figures for Indian sellers in November 2026, before shipping, and have not been checked against current listings. The encoder discs are small slotted wheels that fit on the motor shaft or the wheel axle; some chassis kits include them, so check before you buy.

Pin map

Fitting the encoders

1. Fit one slotted disc on each wheel axle or motor shaft. Count the slots; that number is your pulses per turn if the sensor gives one pulse per slot.
2. Mount each slotted sensor so the disc passes through its gap without touching. Rub marks mean it is too close.
3. If the disc is on the motor shaft rather than the wheel, remember the gearbox sits between the disc and the wheel, so the count per wheel turn is higher.
4. Turn each wheel by hand and watch the count on the Serial Monitor to confirm that one full turn gives the pulses you expect.

The sketch

// Straight-line driving with wheel encoders: Uno + L298N + 2 slotted speed sensors
// Design worksheet: measure PULSES_PER_TURN and tune KP on your own robot.

const int LEFT_ENC = 2;    // interrupt 0
const int RIGHT_ENC = 3;   // interrupt 1

const int IN1 = 4;
const int IN2 = 5;
const int IN3 = 6;
const int IN4 = 7;
const int ENA = 9;
const int ENB = 10;

const int BASE_SPEED = 150;      // PWM 0 to 255
const float KP = 0.6;            // PWM change per pulse of difference
const int MAX_CORRECTION = 60;

volatile long leftCount = 0;
volatile long rightCount = 0;

void leftPulse()  { leftCount++; }
void rightPulse() { rightCount++; }

void setup() {
  Serial.begin(9600);
  pinMode(LEFT_ENC, INPUT_PULLUP);
  pinMode(RIGHT_ENC, INPUT_PULLUP);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(ENA, OUTPUT);
  pinMode(ENB, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(LEFT_ENC), leftPulse, RISING);
  attachInterrupt(digitalPinToInterrupt(RIGHT_ENC), rightPulse, RISING);
  delay(2000);               // time to put the robot down
}

void loop() {
  noInterrupts();
  long l = leftCount;
  long r = rightCount;
  interrupts();

  long error = l - r;        // positive: the left wheel is ahead
  int correction = (int)(KP * error);
  correction = constrain(correction, -MAX_CORRECTION, MAX_CORRECTION);

  int leftPwm = constrain(BASE_SPEED - correction, 0, 255);
  int rightPwm = constrain(BASE_SPEED + correction, 0, 255);

  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  analogWrite(ENA, leftPwm);
  analogWrite(ENB, rightPwm);

  Serial.print(l);
  Serial.print(" ");
  Serial.print(r);
  Serial.print(" ");
  Serial.println(error);
  delay(50);
}

The controller compares the two running totals, so any difference builds up until the correction removes it. That is a proportional controller on position, not speed: the slow wheel is pushed to catch up, and the faster wheel is held back. If the robot swerves back and forth, lower KP. If it still curves, raise it. Cheap slotted sensors can double-count when a slot edge is slow or the disc wobbles, so check the pulse counts by hand before tuning.

Tuning the gain

1. Set KP to 0 and drive a fixed distance, for example 2 m along a taped line. Note the drift at the end. This is your uncorrected baseline.
2. Set KP to 0.3 and repeat three times. Note the drift each time.
3. Raise KP in steps until the path starts to snake, then back off to about half that value.
4. Repeat on a different floor and with a different battery charge, because both change the motors.

Test plan

1. Count check: turn each wheel by hand through ten full turns and confirm the printed count is ten times your pulses per turn. A drifting count means a bad disc or a loose sensor.
2. Motor direction: confirm both wheels drive forward with the wheels off the ground. Swap motor leads, not code, if a side is reversed.
3. Uncorrected drift: run with KP at 0 along a 2 m taped line and measure the sideways error.
4. Corrected drift: run with your tuned KP over the same line three times and compare the errors with the baseline.
5. Battery effect: repeat with a part-discharged pack. A good controller still holds the line as the speed falls.
6. Stall: hold one wheel briefly. The error grows and the correction saturates at MAX_CORRECTION. Release it quickly so the motor does not overheat.

What usually goes wrong

Upgrades

• Fixed-distance moves: convert pulses to centimetres using the wheel diameter, then stop after a set number of pulses.
• Speed control: measure pulses per interval and control speed, not position, for smoother motion.
• Direction sensing: use quadrature encoders so the count rises and falls with direction.
• Odometry: combine both counts with the wheel base to track position, as in the differential drive odometry guide.

Cost and parts notes

The ₹1,610 total is an illustration for the parts above and does not include shipping. The L298N guide explains the voltage drop that makes a 7.4 V pack behave like a 5.8 V one at the motors. Use the cost calculator to compare sellers.

Common questions

Last reviewed: November 2026. This is a design worksheet with illustrative costs. It has not been bench-tested by this site; pulse counts, gain and speeds are starting values, and measurements from your build are welcome.