Arduino Ultrasonic Distance & Parking Learning Kit

Every lesson uses this one pin plan, so parts wired in one lesson stay where they are for the next. A dot means the lesson uses that pin. Lesson 9 uses everything at once.

S = Start here · L1-L9 = Lessons. ~ marks a pin that can dim an LED or drive a servo (PWM). The same pins are in every lesson's diagram and code.

Follow these 7 steps before Lesson 1. They take about 30-45 minutes and prove that your computer, cable and UNO all work - so if something goes wrong later, you know it is the wiring, not the setup.

Lessons 1-7 need only the kit, a computer and things from home such as a book and a ruler. Lesson 8 adds the OLED and needs two free libraries (and an adult only if the OLED has no pins). Lesson 9's battery demo needs a 9V battery, which is not in the box.

One "eye" of the sensor sends a short click of ultrasound; the other listens for the echo. The UNO starts it with a 10-microsecond pulse on TRIG.

The sensor then holds ECHO high for as long as the sound took to get there and back. pulseIn() measures that time in microseconds.

Sound needs about 58 microseconds for every centimetre of distance, there and back, so time ÷ 58 = centimetres.

Each line on the screen is the average of 5 pings. One ping can be off; the average of five is steadier. The second number says how many of the 5 echoes came back.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
UNO 5V	+ rail (red line)	Powers the sensor
UNO GND	− rail (blue line)	Shared ground for everything
HC-SR04 VCC	+ rail (5V)	Go by the labels printed on the sensor
HC-SR04 TRIG	UNO pin 9
HC-SR04 ECHO	UNO pin 10
HC-SR04 GND	− rail (GND)

1. Unplug the USB cable from the computer.Watch out: Always unplug the USB cable before you add, move or remove a wire.
2. Put the breadboard next to the UNO. Find the red (+) and blue (−) lines along its edge: those are the rails.
3. Connect a jumper wire from the UNO 5V pin to the + rail, and one from a UNO GND pin to the − rail.Watch out: Never join the + rail straight to the − rail.
4. Push the HC-SR04 into the breadboard near one end, with its two round "eyes" facing out over the edge and each of its 4 pins in its own row.Watch out: Read the labels printed by the pins: VCC, Trig, Echo, Gnd. Some sensors print them in a different order.
5. Wire VCC to the + rail, GND to the − rail, TRIG to UNO pin 9 and ECHO to UNO pin 10.
6. Check every wire against the diagram and the table, then plug the USB cable back in.Watch out: If anything gets hot or smells, unplug straight away.
7. Copy the Lesson 1 code below into the Arduino IDE and click Upload (→).
8. Open Tools → Serial Monitor and set the speed to 9600 baud.
9. Lay a ruler on the table from the front of the sensor. Hold a book upright at 10, 20, 30 and 50 cm and write down the number shown each time.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 1 of 9: Measure Distance with Sound

  WIRING (unplug the USB cable before you wire)
    HC-SR04 VCC  -> 5V   (+ rail)
    HC-SR04 TRIG -> UNO pin 9
    HC-SR04 ECHO -> UNO pin 10
    HC-SR04 GND  -> GND  (- rail)

  WHAT SHOULD HAPPEN
    Open Tools > Serial Monitor and set it to 9600 baud. Twice a second a
    new line shows the distance to whatever is in front of the sensor, and
    how many of the 5 pings came back. Hold a book in front of the sensor
    and compare the number with a ruler.
*/

const int TRIG_PIN = 9;    // we send the "click" from here
const int ECHO_PIN = 10;   // the sensor answers on this pin

const int SAMPLES = 5;                         // pings per line - try 1 and see the numbers jump
const unsigned long ECHO_TIMEOUT_US = 30000;   // give up after 30 ms (about 5 m there and back)
const int MIN_CM = 2;                          // closer than this the sensor cannot measure
const int MAX_CM = 400;                        // further than this is out of range

int lineNumber = 0;

// One measurement in centimetres, or 0 if no echo came back.
long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);   // a 10-microsecond pulse starts one measurement
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // pulseIn() times how long ECHO stays HIGH: the sound's trip there and back.
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;          // no echo

  long cm = us / 58;              // sound needs about 58 microseconds per cm, there and back
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
  Serial.println("Lesson 1: Measure Distance with Sound");
  Serial.println("line, distance_cm, echoes (out of 5)");
}

void loop() {
  long total = 0;
  int echoes = 0;

  for (int i = 0; i < SAMPLES; i++) {
    long cm = readOnceCm();
    if (cm > 0) {             // only count pings that came back
      total = total + cm;
      echoes = echoes + 1;
    }
    delay(60);                // let the last echo die away before the next ping
  }

  lineNumber = lineNumber + 1;
  Serial.print(lineNumber);
  Serial.print(", ");
  if (echoes > 0) {
    long average = total / echoes;  // the average of the pings that came back (whole cm)
    Serial.print(average);
  } else {
    Serial.print("no echo");
  }
  Serial.print(", ");
  Serial.println(echoes);

  delay(200);
}

Each LED has its own pin: red on 5, yellow on 6, green on 7. HIGH turns an LED on and LOW turns it off.

Each LED has its own 220 Ω resistor. Without one, the LED takes too much current and can damage itself or the UNO pin. Sharing one resistor between LEDs makes them glow unevenly.

loop() measures once, then picks one zone: under 20 cm red, under 50 cm yellow, otherwise green. Only one LED is on at a time.

If no echo comes back, the sketch does not know the distance. It blinks yellow instead of showing green: unknown must never look like safe.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
Red LED long leg (+)	220 Ω → UNO pin 5	One resistor for each LED
Yellow LED long leg (+)	220 Ω → UNO pin 6
Green LED long leg (+)	220 Ω → UNO pin 7
All three short legs (−)	− rail (GND)
HC-SR04	As in Lesson 1	TRIG pin 9, ECHO pin 10

1. Unplug the USB cable.Watch out: Always unplug the USB cable before you add, move or remove a wire.
2. Leave the sensor and the rail wires from Lesson 1 where they are.
3. Push the red LED into the breadboard with its two legs in two different rows. Note which row has the long leg.Watch out: The long leg is +. If the legs are cut, the flat edge on the LED's rim marks the − side.
4. Put a 220 Ω resistor (red-red-brown) from the long-leg row to an empty row, and wire that row to UNO pin 5.Watch out: Every LED needs its own resistor.
5. Do the same for the yellow LED (pin 6) and the green LED (pin 7).
6. Wire each LED's short-leg row to the − rail.
7. Check the three LEDs against the diagram, plug in USB, then copy the Lesson 2 code into the IDE and upload it.Watch out: If anything gets hot or smells, unplug straight away.
8. Watch the light test (red, yellow, green), then move a book slowly towards the sensor from about 70 cm away.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 2 of 9: Traffic-Light Distance Indicator

  WIRING (unplug the USB cable before you wire)
    HC-SR04 as in Lesson 1: VCC 5V, TRIG pin 9, ECHO pin 10, GND.
    Red LED    long leg -> 220 ohm resistor -> UNO pin 5
    Yellow LED long leg -> 220 ohm resistor -> UNO pin 6
    Green LED  long leg -> 220 ohm resistor -> UNO pin 7
    All three short legs -> GND (- rail)

  WHAT SHOULD HAPPEN
    Green  = 50 cm or more   (CLEAR)
    Yellow = 20 to 49 cm     (CAUTION)
    Red    = under 20 cm     (NEAR)
    Yellow blinking = no echo: the sensor does not know. Unknown is never shown as green.
    The Serial Monitor (9600 baud) prints the zone and the distance.
*/

const int RED_LED = 5;
const int YELLOW_LED = 6;
const int GREEN_LED = 7;
const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int CLEAR_CM = 50;   // this far or more: green
const int NEAR_CM = 20;    // closer than this: red

const unsigned long ECHO_TIMEOUT_US = 30000;
const int MIN_CM = 2;
const int MAX_CM = 400;

long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;          // no echo
  long cm = us / 58;
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

// Turn each LED on (true) or off (false).
void showLights(bool red, bool yellow, bool green) {
  digitalWrite(RED_LED, red ? HIGH : LOW);
  digitalWrite(YELLOW_LED, yellow ? HIGH : LOW);
  digitalWrite(GREEN_LED, green ? HIGH : LOW);
}

void setup() {
  pinMode(RED_LED, OUTPUT);
  pinMode(YELLOW_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
  Serial.println("Lesson 2: Traffic-Light Distance Indicator");

  // Light test: red, yellow, green, one after another.
  showLights(true, false, false);  delay(300);
  showLights(false, true, false);  delay(300);
  showLights(false, false, true);  delay(300);
  showLights(false, false, false);
}

void loop() {
  long cm = readOnceCm();

  if (cm == 0) {
    // No echo: blink yellow - on for half a second, off for half a second.
    unsigned long halfSeconds = millis() / 500;   // half-seconds since the UNO started
    bool blinkOn = (halfSeconds % 2 == 0);        // even: on, odd: off
    showLights(false, blinkOn, false);
    Serial.println("NO_ECHO");
  } else if (cm < NEAR_CM) {
    showLights(true, false, false);
    Serial.print("NEAR ");
    Serial.println(cm);
  } else if (cm < CLEAR_CM) {
    showLights(false, true, false);
    Serial.print("CAUTION ");
    Serial.println(cm);
  } else {
    showLights(false, false, true);
    Serial.print("CLEAR ");
    Serial.println(cm);
  }

  delay(100);
}

The zones are the same as Lesson 2. Under 20 cm red now beeps slowly (120 ms on, 380 ms off); under 10 cm it beeps fast (100 ms on, 100 ms off).

beep() never waits. Each time round loop() it checks millis(): if it is time to switch, it flips the buzzer and works out when the next switch is due. So the sensor keeps measuring while it beeps.

With no echo, yellow blinks and the buzzer stays silent: a beep would claim the sketch knows the distance when it does not.

Real parking sensors are tested and certified. This one is a desk model for learning - never use it on a vehicle.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
Buzzer I/O (signal)	UNO pin 8	May be labelled S or IN
Buzzer VCC (+)	+ rail (5V)
Buzzer GND (−)	− rail (GND)
LEDs and HC-SR04	As in Lessons 1-2	Pins 5, 6, 7, 9, 10

1. Unplug the USB cable.Watch out: Always unplug the USB cable before you add, move or remove a wire.
2. Look at the buzzer module's 3 pins and read their labels: I/O (or S or IN), VCC and GND.Watch out: Go by the labels, not the position. Some modules put the pins in a different order.
3. Push the female ends of 3 male-to-female jumper wires onto the buzzer pins.
4. Plug the I/O wire into UNO pin 8, the VCC wire into the + rail and the GND wire into the − rail.
5. Check against the diagram, plug in USB, then copy the Lesson 3 code into the IDE and upload it.Watch out: Keep the buzzer away from your ears.
6. Move a book slowly towards the sensor from 60 cm. Listen as you pass 20 cm and 10 cm.Watch out: If the beeping is too much, unplug USB.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 3 of 9: Parking Beeper

  WIRING (unplug the USB cable before you wire)
    Keep the sensor and LEDs from Lessons 1-2.
    Active buzzer module, with 3 male-to-female jumper wires:
      I/O (signal, may be labelled S or IN) -> UNO pin 8
      VCC (+)                               -> 5V  (+ rail)
      GND (-)                               -> GND (- rail)

  WHAT SHOULD HAPPEN
    Green  50 cm or more   silent
    Yellow 20 to 49 cm     silent
    Red    10 to 19 cm     slow beeps
    Red    under 10 cm     fast beeps
    No echo: yellow blinks and the buzzer stays silent.
    A tabletop model of a parking sensor - never use it on a real vehicle.
*/

const int RED_LED = 5;
const int YELLOW_LED = 6;
const int GREEN_LED = 7;
const int BUZZER_PIN = 8;
const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int CLEAR_CM = 50;      // this far or more: green
const int NEAR_CM = 20;       // closer than this: red + slow beeps
const int CRITICAL_CM = 10;   // closer than this: red + fast beeps

const unsigned long SLOW_ON_MS = 120, SLOW_OFF_MS = 380;   // slow beep
const unsigned long FAST_ON_MS = 100, FAST_OFF_MS = 100;   // fast beep

// Most modules beep when the pin is HIGH. If yours beeps in the gaps or
// all the time, change false to true and upload again.
const bool BUZZER_ACTIVE_LOW = false;

const unsigned long ECHO_TIMEOUT_US = 30000;
const int MIN_CM = 2;
const int MAX_CM = 400;

bool buzzerOn = false;
unsigned long nextBeepChange = 0;

long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;
  long cm = us / 58;
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

void showLights(bool red, bool yellow, bool green) {
  digitalWrite(RED_LED, red ? HIGH : LOW);
  digitalWrite(YELLOW_LED, yellow ? HIGH : LOW);
  digitalWrite(GREEN_LED, green ? HIGH : LOW);
}

void buzzer(bool on) {
  buzzerOn = on;
  if (BUZZER_ACTIVE_LOW) digitalWrite(BUZZER_PIN, on ? LOW : HIGH);
  else                   digitalWrite(BUZZER_PIN, on ? HIGH : LOW);
}

// Beep with the given on and off times without stopping the program:
// millis() tells us when it is time to switch.
void beep(unsigned long onMs, unsigned long offMs) {
  unsigned long now = millis();
  if (now >= nextBeepChange) {
    buzzer(!buzzerOn);
    nextBeepChange = now + (buzzerOn ? onMs : offMs);
  }
}

void setup() {
  pinMode(RED_LED, OUTPUT);
  pinMode(YELLOW_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  buzzer(false);
  Serial.begin(9600);
  Serial.println("Lesson 3: Parking Beeper - learning model only");
  Serial.println("cm, zone, buzzer");
}

void loop() {
  long cm = readOnceCm();
  const char *zone;

  if (cm == 0) {
    zone = "NO_ECHO";
    unsigned long halfSeconds = millis() / 500;   // blink yellow, as in Lesson 2
    showLights(false, halfSeconds % 2 == 0, false);
    buzzer(false);                       // unknown: never beep "all clear" or "danger"
  } else if (cm < CRITICAL_CM) {
    zone = "CRITICAL";
    showLights(true, false, false);
    beep(FAST_ON_MS, FAST_OFF_MS);
  } else if (cm < NEAR_CM) {
    zone = "NEAR";
    showLights(true, false, false);
    beep(SLOW_ON_MS, SLOW_OFF_MS);
  } else if (cm < CLEAR_CM) {
    zone = "CAUTION";
    showLights(false, true, false);
    buzzer(false);
  } else {
    zone = "CLEAR";
    showLights(false, false, true);
    buzzer(false);
  }

  Serial.print(cm);
  Serial.print(", ");
  Serial.print(zone);
  Serial.print(", ");
  Serial.println(buzzerOn ? 1 : 0);
  delay(40);
}

Very close up, the echo comes back before the sensor has finished sending, so the reading is wrong or missing. That is the blind zone.

No echo can mean the object is too far, too soft (fabric absorbs sound), too small, or tilted so the echo flies off to the side. It does NOT mean nothing is there.

In this lesson only, the LEDs mean something different: green = a good reading, yellow = too close (under 3 cm), red = no echo.

Three variables count each kind of reading. Type r and press Enter to set them back to 0 before each test.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
No changes	Same as Lesson 3	LEDs 5, 6, 7 · buzzer 8 (kept silent) · TRIG 9 · ECHO 10

1. Upload the Lesson 4 code. No wiring changes are needed.
2. Open the Serial Monitor at 9600 baud with "New Line" selected.
3. Type r and press Enter. Hold a book 30 cm away for 10 seconds: green, and the good count goes up.
4. Type r. Move the book right up to the sensor, 1-2 cm away. Watch for yellow (too close) or red - and wrong numbers.
5. Type r. Point the sensor at a cushion or a soft jumper 30 cm away, then at a pencil, then at the book tilted to 45°.
6. Type r. Point the sensor at an empty part of the room. Write down the counts after 10 seconds for each test.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 4 of 9: Blind Zone & No Echo

  WIRING: the sensor and LEDs from Lessons 1-3 (pins 5, 6, 7, 9, 10).
  The buzzer can stay connected - this sketch keeps it silent.

  IN THIS LESSON THE LEDs MEAN SOMETHING DIFFERENT:
    Green  = a good reading
    Yellow = too close (under 3 cm) - the sensor's "blind zone"
    Red    = no echo came back (too far, too soft, or angled away)
  The Serial Monitor (9600 baud) counts each kind of reading.
  Type r and press Enter to set the counts back to 0.
*/

const int RED_LED = 5;
const int YELLOW_LED = 6;
const int GREEN_LED = 7;
const int BUZZER_PIN = 8;
const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int BLIND_CM = 3;                        // closer than this is the blind zone
const unsigned long ECHO_TIMEOUT_US = 30000;   // after 30 ms we call it "no echo"
const int MAX_CM = 400;

int goodCount = 0;
int blindCount = 0;
int noEchoCount = 0;

// Distance in cm, or 0 if no echo came back in time.
long readRawCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;
  return us / 58;
}

void setup() {
  pinMode(RED_LED, OUTPUT);
  pinMode(YELLOW_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);   // keep the buzzer quiet in this lesson
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
  Serial.println("Lesson 4: Blind Zone & No Echo");
}

void loop() {
  // Type r + Enter to reset the counts.
  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c == 'r' || c == 'R') {
      goodCount = 0;
      blindCount = 0;
      noEchoCount = 0;
      Serial.println("Counts reset");
    }
  }

  long cm = readRawCm();
  bool noEcho = (cm == 0 || cm > MAX_CM);
  bool blind = (!noEcho && cm < BLIND_CM);
  bool good = (!noEcho && !blind);

  digitalWrite(RED_LED, noEcho ? HIGH : LOW);
  digitalWrite(YELLOW_LED, blind ? HIGH : LOW);
  digitalWrite(GREEN_LED, good ? HIGH : LOW);

  if (noEcho) noEchoCount++;
  else if (blind) blindCount++;
  else goodCount++;

  Serial.print("cm=");
  if (noEcho) Serial.print("none");
  else Serial.print(cm);
  Serial.print("  good=");
  Serial.print(goodCount);
  Serial.print("  too_close=");
  Serial.print(blindCount);
  Serial.print("  no_echo=");
  Serial.println(noEchoCount);

  delay(200);
}

You type the true distance from the ruler and press Enter. The sketch reads your digits one by one and builds the number: 2 then 0 makes 20.

It then takes 10 pings and prints one row: ruler_cm, average_cm, error_cm, min_cm, max_cm, spread_cm, echoes.

Error tells you whether the sensor reads too far or too near. Spread tells you how much it wobbles. A good sensor has both small.

Real sensors are often a little off in the same direction. Once you know the error, you could correct for it in code.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
No changes	Sensor as in Lesson 1	TRIG pin 9 · ECHO pin 10

1. Upload the Lesson 5 code. No wiring changes are needed.
2. Open the Serial Monitor at 9600 baud. In the box at the bottom right choose "New Line".
3. Tape a ruler or tape measure to the table, starting at the front of the sensor's eyes.
4. Stand the card upright and square to the sensor at 10 cm. Type 10 and press Enter. A row appears after about a second.
5. Repeat at 20, 30, 50, 75 and 100 cm (as far as your table allows).
6. Select the rows in the Serial Monitor, copy them, and paste them into a spreadsheet. Use Data → Split text to columns if they land in one column.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 5 of 9: Calibrate Your Sensor

  WIRING: the sensor from Lesson 1 (TRIG pin 9, ECHO pin 10).
  The LEDs and buzzer can stay connected; this sketch does not use them.

  HOW TO USE IT
    1. Open the Serial Monitor at 9600 baud. Check the box at the bottom
       right is set to "New Line".
    2. Put a flat card at a ruler mark, for example 20 cm.
    3. Type 20 and press Enter. The UNO takes 10 readings and prints one row:
       ruler_cm, average_cm, error_cm, min_cm, max_cm, spread_cm, echoes
    4. Repeat at 10, 20, 30, 50, 75 and 100 cm. Copy the rows into a spreadsheet.
*/

const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int SAMPLES = 10;                        // readings per row
const unsigned long ECHO_TIMEOUT_US = 30000;
const int MIN_CM = 2;
const int MAX_CM = 400;

long typedNumber = 0;     // the number being typed, digit by digit

long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;
  long cm = us / 58;
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

// Take SAMPLES readings and print one spreadsheet row.
void measureAt(long rulerCm) {
  long total = 0;
  long lowest = 9999;
  long highest = 0;
  int echoes = 0;

  for (int i = 0; i < SAMPLES; i++) {
    long cm = readOnceCm();
    if (cm > 0) {
      total = total + cm;
      echoes = echoes + 1;
      if (cm < lowest) lowest = cm;
      if (cm > highest) highest = cm;
    }
    delay(60);
  }

  Serial.print(rulerCm);
  Serial.print(",");
  if (echoes == 0) {
    Serial.println("NA,NA,NA,NA,NA,0");
    return;
  }
  long average = total / echoes;
  Serial.print(average);            Serial.print(",");
  Serial.print(average - rulerCm);  Serial.print(",");   // error: + means it reads too far
  Serial.print(lowest);             Serial.print(",");
  Serial.print(highest);            Serial.print(",");
  Serial.print(highest - lowest);   Serial.print(",");   // spread: how much it wobbles
  Serial.println(echoes);
}

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
  Serial.println("Lesson 5: Calibrate Your Sensor");
  Serial.println("Put the card at a ruler mark, type the distance in cm and press Enter.");
  Serial.println("ruler_cm,average_cm,error_cm,min_cm,max_cm,spread_cm,echoes");
}

void loop() {
  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c >= '0' && c <= '9') {
      typedNumber = typedNumber * 10 + (c - '0');   // build the number one digit at a time
    } else if (c == '\n' || c == '\r') {
      if (typedNumber > 0) measureAt(typedNumber);
      typedNumber = 0;
    }
  }
  delay(1);
}

Sound bounces off a flat surface at the same angle it arrives, like a ball off a wall. A card facing the sensor sends the echo straight back; a tilted card sends it off to the side.

Soft materials absorb much of the sound, so the echo is weak. Thin or round objects reflect only a little sound back towards the sensor.

Each trial fires 20 pings, 50 ms apart, then prints: trial, echoes back, missed %, average, min and max. You then have 5 seconds to change the target.

This is why real distance sensors are never the only safety check: they can miss things that are really there.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
No changes	Sensor as in Lesson 1	TRIG pin 9 · ECHO pin 10

1. Upload the Lesson 6 code. No wiring changes are needed.
2. Open the Serial Monitor at 9600 baud.
3. Put the flat card 30 cm away, square to the sensor. Wait for a row.
4. After "Change the target now", swap to the next target at the same 30 cm: card tilted about 45°, cushion, bottle, pencil.Watch out: Keep the distance the same: change only the target.
5. Copy the rows into a table or spreadsheet and compare the missed %.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 6 of 9: Angles & Surfaces

  WIRING: the sensor from Lesson 1 (TRIG pin 9, ECHO pin 10).

  HOW TO USE IT
    Every 5 seconds the UNO fires 20 pings at the target and prints one row:
    trial, echoes_back, missed_percent, average_cm, min_cm, max_cm
    Between rows, change the target: flat card, card tilted, a cushion or
    jumper, a bottle, a pencil. Keep it at the same distance (about 30 cm).
    Open the Serial Monitor at 9600 baud.
*/

const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int PINGS = 20;                          // pings per trial
const unsigned long GAP_MS = 5000;             // time to change the target
const unsigned long ECHO_TIMEOUT_US = 30000;
const int MIN_CM = 2;
const int MAX_CM = 400;

int trial = 0;

long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;
  long cm = us / 58;
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
  Serial.println("Lesson 6: Angles & Surfaces");
  Serial.println("trial,echoes_back,missed_percent,average_cm,min_cm,max_cm");
}

void loop() {
  int back = 0;
  long total = 0;
  long lowest = 9999;
  long highest = 0;

  for (int i = 0; i < PINGS; i++) {
    long cm = readOnceCm();
    if (cm > 0) {
      back = back + 1;
      total = total + cm;
      if (cm < lowest) lowest = cm;
      if (cm > highest) highest = cm;
    }
    delay(50);
  }

  trial = trial + 1;
  int missedPercent = (PINGS - back) * 100 / PINGS;
  Serial.print(trial);          Serial.print(",");
  Serial.print(back);           Serial.print(",");
  Serial.print(missedPercent);  Serial.print(",");
  if (back > 0) {
    long average = total / back;
    Serial.print(average);      Serial.print(",");
    Serial.print(lowest);       Serial.print(",");
    Serial.println(highest);
  } else {
    Serial.println("NA,NA,NA");
  }
  Serial.println("Change the target now - next trial in 5 seconds.");
  delay(GAP_MS);
}

Every 80 ms the sketch stores the newest good reading in history[], an array of 5. When it is full, the newest reading replaces the oldest, going round in a circle.

The average adds the 5 and divides by 5. It is smooth, but a single wrong reading pulls it off, and it is slow to catch up when the target really moves.

The median sorts the 5 and takes the middle. One spike sits at the end of the sorted list and is ignored. But it too needs 3 new readings before it follows a real move.

Every filter trades smoothness for delay. Lesson 9 uses the median, because ignoring spikes matters most for a parking beeper.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
No changes	Sensor as in Lesson 1	TRIG pin 9 · ECHO pin 10

1. Upload the Lesson 7 code. No wiring changes are needed.
2. Close the Serial Monitor, then open Tools → Serial Plotter at 9600 baud.Watch out: Only one of the two can be open at a time.
3. Hold a book still 40 cm away: the three lines lie on top of each other.
4. Wave your hand quickly through the beam: watch which line jumps.
5. Now move the book smoothly from 40 cm to 20 cm: watch which line lags behind.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 7 of 9: Smoothing Noisy Readings

  WIRING: the sensor from Lesson 1 (TRIG pin 9, ECHO pin 10).

  WHAT SHOULD HAPPEN
    Open Tools > Serial Plotter at 9600 baud. Three lines follow the target:
      raw     - every single reading (jumpy)
      average - the mean of the last 5 readings (smooth, but slow to react)
      median  - the middle of the last 5 readings (ignores single spikes)
    Wave a hand quickly through the beam and watch which line jumps.
*/

const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int WINDOW = 5;                          // how many readings each filter remembers - try 3 or 9
const unsigned long ECHO_TIMEOUT_US = 30000;
const int MIN_CM = 2;
const int MAX_CM = 400;

long history[WINDOW];     // the last WINDOW good readings
int filled = 0;           // how many slots hold a reading so far
int nextSlot = 0;         // where the next reading goes

long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;
  long cm = us / 58;
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

long averageOfHistory() {
  long total = 0;
  for (int i = 0; i < filled; i++) total = total + history[i];
  long average = total / filled;   // whole centimetres
  return average;
}

long medianOfHistory() {
  long sorted[WINDOW];
  for (int i = 0; i < filled; i++) sorted[i] = history[i];
  for (int i = 1; i < filled; i++) {          // sort, smallest first
    long value = sorted[i];
    int j = i - 1;
    while (j >= 0 && sorted[j] > value) {
      sorted[j + 1] = sorted[j];
      j--;
    }
    sorted[j + 1] = value;
  }
  return sorted[filled / 2];                  // the middle one
}

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
}

void loop() {
  long cm = readOnceCm();
  if (cm > 0) {                                // skip "no echo" readings
    history[nextSlot] = cm;
    nextSlot = (nextSlot + 1) % WINDOW;        // go round in a circle
    if (filled < WINDOW) filled++;

    // "name:value,name:value" is the format the Serial Plotter draws.
    Serial.print("raw:");
    Serial.print(cm);
    Serial.print(",average:");
    Serial.print(averageOfHistory());
    Serial.print(",median:");
    Serial.println(medianOfHistory());
  }
  delay(80);
}

The OLED has its own controller chip, the SSD1306. The Adafruit library knows how to talk to it, so we only call commands like print() and fillRect().

The UNO talks to the display over I2C: SDA on A4 carries the data, SCL on A5 the clock. The display answers at address 0x3C (some at 0x3D) - the sketch tries both.

Drawing happens in the UNO's memory first. Nothing appears until display.display() sends the whole picture. The picture needs 1 KB of the UNO's 2 KB of memory, which is why the text uses F("...").

The zones are the same as Lessons 2 and 3. The bar is full width at 100 cm.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
OLED VCC	+ rail (5V)	Rated 3.3-5V. Go by the labels: the pin order varies
OLED GND	− rail (GND)
OLED SDA	UNO A4	I2C data
OLED SCL	UNO A5	I2C clock
HC-SR04	As in Lesson 1	TRIG pin 9, ECHO pin 10

1. In the Arduino IDE open Tools → Manage Libraries. Search Adafruit SSD1306 and click Install. When asked, choose Install All so Adafruit GFX and BusIO come too.
2. Unplug the USB cable.Watch out: Always unplug the USB cable before you add, move or remove a wire.
3. Check the OLED has 4 header pins. If it has only holes, stop here: an adult must solder the pins first.Watch out: Soldering irons are very hot. Adults only.
4. Read the 4 labels on the OLED: GND, VCC, SCL, SDA (the order varies). Push it into the breadboard with each pin in its own row.
5. Wire VCC to the + rail, GND to the − rail, SDA to UNO A4 and SCL to UNO A5.Watch out: Go by the labels. VCC and GND swapped can damage the display.
6. Check against the diagram, plug in USB, copy the Lesson 8 code into the IDE and upload it.
7. Open the Serial Monitor at 9600 baud: it says "OLED found at 0x3C" (or 0x3D). Move a book towards the sensor and watch the screen.

Easiest: scan the QR code above and press Copy or Download .ino on the lesson page, then paste it into the Arduino IDE and click Upload. The full listing is here for reading along.

/*
  DIY KIT - Arduino Ultrasonic Distance & Parking Learning Kit
  Lesson 8 of 9: OLED Distance Meter

  LIBRARIES (once): Tools > Manage Libraries, search "Adafruit SSD1306",
  click Install, and choose "Install all" so Adafruit GFX and BusIO come too.

  WIRING (unplug the USB cable before you wire)
    The sensor from Lesson 1 (TRIG pin 9, ECHO pin 10) stays.
    OLED display - go by the labels printed on it, the order varies:
      VCC -> 5V  (+ rail)      GND -> GND (- rail)
      SDA -> UNO A4            SCL -> UNO A5
    The LEDs and buzzer can stay; this sketch does not use them.

  WHAT SHOULD HAPPEN
    The OLED shows the zone at the top, the distance in big numbers and a
    bar that grows as the target moves away (full at 100 cm).
    The Serial Monitor (9600 baud) says which address the display answered on.

  F("...") keeps text in the UNO's large program memory instead of its small
  working memory (RAM). The display needs 1 KB of RAM for its picture.
*/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const int TRIG_PIN = 9;
const int ECHO_PIN = 10;

const int CLEAR_CM = 50;      // the same zones as Lessons 2 and 3
const int NEAR_CM = 20;
const int BAR_FULL_CM = 100;  // the bar is full width at this distance

const unsigned long ECHO_TIMEOUT_US = 30000;
const int MIN_CM = 2;
const int MAX_CM = 400;

Adafruit_SSD1306 display(128, 64, &Wire, -1);   // 128 x 64 pixels, no reset pin
bool displayOk = false;

long readOnceCm() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, ECHO_TIMEOUT_US);
  if (us == 0) return 0;
  long cm = us / 58;
  if (cm < MIN_CM || cm > MAX_CM) return 0;
  return cm;
}

// Most of these displays answer at address 0x3C, some at 0x3D. Try both.
bool startDisplay() {
  if (display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("OLED found at 0x3C"));
    return true;
  }
  if (display.begin(SSD1306_SWITCHCAPVCC, 0x3D)) {
    Serial.println(F("OLED found at 0x3D"));
    return true;
  }
  Serial.println(F("OLED not found - unplug USB and check VCC, GND, SDA (A4) and SCL (A5)"));
  return false;
}

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(9600);
  Serial.println(F("Lesson 8: OLED Distance Meter"));
  displayOk = startDisplay();
  if (displayOk) {
    display.clearDisplay();
    display.setTextColor(SSD1306_WHITE);
    display.display();
  }
}

void loop() {
  long cm = readOnceCm();
  Serial.println(cm);                       // 0 means no echo

  if (displayOk) {
    display.clearDisplay();

    // Top line: the zone, in small letters.
    display.setTextSize(1);
    display.setCursor(0, 0);
    if (cm == 0)            display.print(F("NO ECHO"));
    else if (cm < NEAR_CM)  display.print(F("NEAR"));
    else if (cm < CLEAR_CM) display.print(F("CAUTION"));
    else                    display.print(F("CLEAR"));

    // Middle: the distance, 3 times bigger.
    display.setTextSize(3);
    display.setCursor(0, 22);
    if (cm == 0) {
      display.print(F("--"));
    } else {
      display.print(cm);
      display.setTextSize(2);
      display.print(F(" cm"));
    }

    // Bottom: a bar, full width at BAR_FULL_CM.
    if (cm > 0) {
      int width = map(constrain(cm, 0, BAR_FULL_CM), 0, BAR_FULL_CM, 0, 128);
      display.fillRect(0, 56, width, 8, SSD1306_WHITE);
    }
    display.display();                      // nothing appears until display() is called
  }

  delay(150);
}

This is DistanceParkingLab.ino: Lessons 2, 3, 7 and 8 in one sketch. The same zones, beeps and pins, plus a median of the last 5 readings.

Nothing waits with delay() in the main loop. Measuring (every 80 ms), the LEDs, the buzzer, the OLED and the Serial line each check millis() and do their job when it is time.

Three missed echoes in a row switch it to NO_ECHO: yellow blinks, the buzzer goes silent and the OLED says NO ECHO. One missed ping is not enough.

The OLED is optional: if none answers at 0x3C or 0x3D, everything else still works.

Wiring

Connection diagram drawn from the pin plan - not a photo of a tested build. The table says the same in words.

Part / pin	Connect to	Note
Red / yellow / green LED (each through 220 Ω)	UNO pins 5 / 6 / 7	From Lesson 2
Buzzer I/O	UNO pin 8	From Lesson 3
HC-SR04 TRIG / ECHO	UNO pins 9 / 10	From Lesson 1
OLED SDA / SCL	UNO A4 / A5	From Lesson 8 - optional
All VCC and + pins	+ rail (5V)
All GND and − pins, LED short legs	− rail (GND)
9V battery holder plug	UNO DC jack (round socket)	Battery demo only - unplug USB first

1. Check all the wiring from Lessons 1-8 is still in place: compare with the diagram.Watch out: Always unplug the USB cable before you add, move or remove a wire.
2. Plug in USB, copy the Lesson 9 code into the IDE and upload it. It needs the libraries from Lesson 8.
3. Open the Serial Monitor at 9600 baud with "New Line". Type help and press Enter.
4. Type test: red, yellow and green light in turn and the buzzer beeps once.Watch out: Keep the buzzer away from your ears.
5. Move a book from 60 cm to 5 cm and back. Check the LEDs, beeps, OLED and Serial lines all agree.
6. Type sound off: the LEDs still work but the buzzer stays silent. Type sound on to bring it back.
7. Battery demo (optional): unplug the USB cable, put a 9V battery in the holder, then push the holder's plug into the UNO's round DC jack. It runs on its own.Watch out: Unplug the battery before you plug USB back in, and before changing any wire. Never connect the battery wires anywhere else.

Unplug the USB cable first. Every problem below has its fix in the table of the lesson or step named on the right.

Every project in this kit uses the same parts, so you can combine them: add the display to a sensor project, or a buzzer to a measuring one. The project pages on diykit.ae have the code, the parts list and ideas to take each build further.

Most problems are one wire in the wrong hole. Check these first, then the lesson's "If it doesn't work" table:

1. Unplug, then compare every wire with the lesson's diagram and table. One pin off is the most common problem.
2. Sensor: are VCC, TRIG, ECHO and GND wired by their labels, with TRIG on 9 and ECHO on 10?
3. LEDs: is the long leg on the resistor side?
4. Is the − rail connected to a UNO GND pin, and the + rail to 5V?
5. Serial Monitor: is it set to 9600 baud (and "New Line" when you type commands)?
6. Upload problems: is Tools → Board set to Arduino Uno and Tools → Port to your UNO? (Start here, step 5.)

Still stuck? Send us this message on WhatsApp with a photo of your wiring - scan the code to open WhatsApp with it already filled in: