Obstacle-avoiding robot

This robot drives around a room by itself and turns away from whatever is in its way. An ultrasonic sensor at the front measures the distance ahead. When something is closer than 25 cm, the robot drives backwards, turns right and drives forward again. You will learn how the HC-SR04 measures distance, how a state machine organises what the robot does, and how millis() lets the robot measure while it moves. It is an easy project and takes about 60 minutes.

#What you need

This is the car from First drive with an HC-SR04 ultrasonic sensor at the front. If you already have the car, see the obstacle add-on in the Market.

#How it works

#How the HC-SR04 measures distance

The HC-SR04 has two round parts on its front. One sends ultrasound: sound at 40 kHz, too high for people to hear. The other one listens for the echo. One measurement works like this:

1. The Uno sets TRIG HIGH for 10 µs, and the sensor sends a short burst of ultrasound.
2. The sensor sets ECHO HIGH and listens.
3. When the echo comes back, the sensor sets ECHO LOW again.

So ECHO stays HIGH for as long as the sound needs to travel to the object and back. Sound travels about 343 m/s at 20 °C. For each centimetre of distance, the sound travels 2 cm, there and back, and that takes about 58 µs. So the distance in centimetres is the ECHO time in microseconds divided by 58. For example, 1450 µs means 1450 / 58 = 25 cm.

The sensor has limits:

#A state machine

At every moment, the robot does exactly one of three things. Each of them is a state:

A state machine is a program built this way: a list of states, what the robot does in each one, and the rules for moving to the next. Each state is separate, so the behaviour is easy to read and easy to change.

#Measuring without waiting

loop() never calls delay(). It runs thousands of times per second, and each time it does two jobs:

1. Measure, if it is time. If 60 ms have passed since the last measurement, it measures the distance and prints it.
2. Run the current state. It sets the motors and checks whether the state should end.

To know how much time has passed, the sketch uses millis(), the number of milliseconds since the Uno started. Only the measurement itself waits a little, because pulseIn() waits for the echo. For an obstacle 25 cm away, that takes about 1.5 ms. With nothing in range, it gives up after 25 ms. The motors keep running during this short wait.

Why not simply write delay(300) for the Back state? Because the robot would be blind during that wait. With the state machine, it measures every 60 ms in every state. This sketch does not use the readings during Back and Turn yet, but you can: the first challenge makes the robot stop turning as soon as the way is clear.

#Build it

#1. Get the robot in the simulator

Obstacle avoider, the car that comes with the game, already has the HC-SR04 at the front of the upper deck. Its wires are not the ones on this page, so you redo them in step 2.

Real build: start from your car from First drive. Mount the HC-SR04 at the front, level, with both round parts looking straight ahead. If it points down, it sees the floor. If it points up, it misses low obstacles.

#2. Wire the sensor

The car's wiring stays as in First drive. Four wires connect the sensor: VCC to the L298N's +5V, GND to a GND pin of the Uno, TRIG to D9 and ECHO to D10. The L298N's +5V is the same 5 V that powers the Uno, because a wire joins it to the Uno's 5V pin.

Real build: the +5V terminal already holds the wire to the Uno. Put the sensor's VCC wire into the same terminal, next to it, then tighten the screw. Check TRIG and ECHO twice, because they are easy to swap.

#3. Upload and test

Open Code, paste the ObstacleAvoider sketch from this page, press Verify, then Upload.

Real build: set the car on a box with the wheels in the air, connect the USB cable and upload. Open the Serial Monitor at 9600 baud. Move your hand in front of the sensor: the numbers follow your hand. When your hand is closer than 25 cm, the wheels turn backwards and then spin right.

#4. Let it drive

Start a run in an arena with obstacles. The robot drives until something is closer than 25 cm, then drives backwards, turns and drives forward again. Open the Serial Monitor: the robot prints one distance in centimetres every 60 ms. A reading of 400 means that no echo came back, so nothing is within about 4 m. The live readout shows the distance too.

Real build: unplug the USB cable and put the car on the floor between a few boxes or books. Hard, flat objects give the best echoes.

#5. Adjust the numbers

A faster robot needs a bigger STOP_CM, because it needs more distance to stop.

#The code

#The state and the timers

enum class State : byte { Drive, Back, Turn };
State state = State::Drive;
unsigned long stateStart = 0;
unsigned long lastPing = 0;
int distanceCm = 400;

enum class State gives the three states names, and : byte stores a state in one byte. state holds the current state, and the robot starts in Drive. stateStart remembers when the current state began, and lastPing when the last measurement was taken. Both are unsigned long, the type that millis() returns. distanceCm starts at 400, which means "nothing seen".

#readDistanceCm(): one measurement

  digitalWrite(TRIG, HIGH);            // a 10 microsecond pulse starts a measurement
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  unsigned long us = pulseIn(ECHO, HIGH, 25000UL);  // wait at most 25 ms
  if (us == 0) return 400;
  return us / 58;                      // sound goes there and back: 58 us per cm

Before these lines, TRIG is held LOW for 2 µs, so the pulse starts clean. pulseIn() measures how long ECHO stays HIGH, in microseconds. If no echo comes back within 25 ms, it returns 0, and the function returns 400. Otherwise, it divides by 58 to get centimetres.

#enter(): changing state

void enter(State next) {
  state = next;
  stateStart = millis();
  if (next == State::Drive) lastPing = 0;  // measure again before driving on
}

Every change of state goes through enter(). It saves the new state and the time when it started. When the robot returns to Drive, lastPing = 0 forces a new measurement on the next pass through loop(). So the robot decides with a fresh distance, measured after the turn.

#loop(): measure, then act

  unsigned long now = millis();
  if (now - lastPing >= PING_MS) {
    lastPing = now;
    distanceCm = readDistanceCm();
    Serial.println(distanceCm);
  }

now - lastPing >= PING_MS asks: "Have 60 ms passed?" Written as a subtraction, it stays correct even when millis() starts again from 0 after about 49.7 days.

Then comes a switch with one case for each state. Drive sets both motors to CRUISE and enters Back when distanceCm is below STOP_CM. Back drives backwards at 160 and enters Turn after BACK_MS. Turn spins right, with the left wheel forwards and the right wheel backwards, and enters Drive after TURN_MS. setMotor() and drive() are the same as in First drive.

#If it does not work

• The Serial Monitor always shows 400. Nothing is in range, or the sensor is not wired correctly. Check VCC and GND, and check that TRIG goes to D9 and ECHO to D10.
• The Serial Monitor shows strange characters (real build). Set it to 9600 baud, the same speed as Serial.begin(9600).
• The robot drives into walls that it meets at an angle. A slanted wall reflects the sound away from the sensor. Soft things, such as curtains, absorb it. Raise STOP_CM or lower CRUISE.
• It drives backwards with nothing in front. The sensor may see the floor, so mount it level. A wire hanging in front of the sensor can also send back an echo.
• It hits chair legs or the corner of a box. Thin things send back little sound, and things beside the narrow beam are not seen. This is a limit of the sensor.
• A wheel turns the wrong way. Swap that motor's two leads, as in First drive.
• The robot resets when it starts to drive backwards. Changing from forwards to backwards at once needs a big current, and the battery voltage dips. Use new batteries and short power wires. Add a 100-470 µF capacitor across +12V and GND near the driver, with its - leg on GND. See why robots reset.

#Next steps

This robot only answers "yes or no": closer than 25 cm, or not. The next project uses the distance itself to choose the speed: the keep-distance robot.

Learn more about timers and states in the lesson on millis() and states. For the sensor, read the lesson on the HC-SR04 and the article on how ultrasonic sensors see.