Build a Working Radar: Mapping Rooms with Arduino, Ultrasonics, and Servos

The Wiring

We are combining the wiring from Day 21 and Day 22. CRITICAL: We now have TWO power-hungry devices. The Servo draws current when moving. The Sensor draws current when pinging. If you try to power both from the Arduino 5V pin, you might get Noise or Brownouts.

• Best Practice: Use an external 4xAA battery pack (6V) to power the Servo. Connect the Battery GND to Arduino GND (Common Ground).
• Good Practice: Use a 470uF Capacitor on the power rails.

Pinout:

• Servo Signal: Pin 9.
• Sensor Trig: Pin 10.
• Sensor Echo: Pin 11.

The Math (Polar Coordinates)

This is where High School Math finally becomes useful. The sensor gives us two numbers:

• Theta (θ): The Angle of the servo (e.g., 45 degrees).
• Radius (r): The Distance to the object (e.g., 50 cm).

This is called the Polar Coordinate System. But computers screens (and graph paper) use the Cartesian Coordinate System (X, Y). To plot a dot on the screen, we need to convert Polar to Cartesian.

The Formula:

• $X = r \times \cos(\theta)$
• $Y = r \times \sin(\theta)$

Note: Arduino’s sin() and cos() functions expect Radians, not Degrees. We must convert using the radians() helper.

The Arduino Code

We need a loop that:

• Moves to Angle 0.
• Waits for the servo to settle.
• Pings distance.
• Prints “Angle,Distance” to the Serial Monitor.
• Increases Angle.
• Repeats until 180.
• Sweeps back.

#include <Servo.h>
#include <NewPing.h>

#define TRIG_PIN 10
#define ECHO_PIN 11
#define MAX_DIST 200 // Max distance 200cm

Servo radarServo;
NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DIST);

void setup() {
  Serial.begin(9600); // Fast communication
  radarServo.attach(9);
}

void loop() {
  // Sweep from 15 to 165 degrees
  // We avoid 0 and 180 as they often stretch the wires too much
  for (int i = 15; i <= 165; i++) {
    radarServo.write(i);
    delay(30); // Speed of rotation. Smaller = Faster
    // Calculate distance
    int distance = sonar.ping_cm();
    // Print for the Plotter: "Angle,Distance"
    Serial.print(i); 
    Serial.print(","); 
    Serial.println(distance);
  }
  // Return Sweep
  for (int i = 165; i >= 15; i--) {
    radarServo.write(i);
    delay(30);
    int distance = sonar.ping_cm();
    Serial.print(i);
    Serial.print(",");
    Serial.println(distance);
  }
}

Advanced Physics: The Speed Limit of Scanning

Why did I use delay(30)? Can we go faster? Let’s do the math.

• Speed of Sound: 343 m/s (34,300 cm/s).

• Max Distance: 200 cm (Round trip = 400 cm).

• Time of Flight: $400 / 34300 \approx 0.011$ seconds (11 ms). If we ping every 5 ms, the previous echo might return while we are listening for the current ping. This creates “Ghost echoes”. We must wait at least 20-30 ms between pings to let the air “clear”. Maximum Scan Rate:

• 30ms per degree x 180 degrees = 5400 ms (5.4 seconds per sweep). If you scan faster, your data becomes garbage. Physics has a speed limit.

Hacker’s Corner: Non-Blocking Radar (millis())

The code above uses delay(), which freezes the Arduino. If you want your robot to drive while scanning, you must use millis(). We will master this in Phase 5, but the concept is:

• Check currentMillis.
• If 30ms has passed since lastPingTime:
• Move Servo 1 degree.
• Ping.
• Update lastPingTime. This allows the loop() to run thousands of times per second, checking other sensors in between radar pings.

Visualization (The Serial Plotter)

Upload the code. Open Tools > Serial Plotter. You won’t see a Radar Map yet. You will see a temporal graph.

• Red Line: The Angle (Triangle Wave).
• Blue Line: The Distance (The “Landscape” of your room). If you put a box in front of the radar, the Blue line will dip (short distance) when the Red line (Angle) crosses the box’s position. It is an abstract view, but it proves the data is real.

Deep Dive: How the Serial Plotter Works

The Serial Plotter is a “dumb” tool. It listens for numbers separated by commas or spaces.

• Serial.println(50); -> Draws 1 line at Y=50.
• Serial.print(10); Serial.print(","); Serial.println(50); -> Draws 2 lines (Y=10, Y=50).
• The Legend: The colors are auto-assigned.
• The Y-Axis: Auto-scales to fit your data.
• The X-Axis: Sample Number (Time). This is why we cannot draw a true Radar Circle inside the Arduino IDE. The Plotter only does Time-Series graphs (like an Oscilloscope). To get X/Y mapping, we NEED external software.

Deep Dive: Data Flow and Processing

How do we get the “Cool Sci-Fi Radar Screen” (like the first image)? The Arduino cannot display complex graphics. We need to offload the rendering to a powerful computer. Data Flow Architecture:

• Sensor gathers raw physics data.
• Arduino packages it into a protocol (Angle,Distance\n).
• USB Cable transmits it via UART.
• PC Application (written in Python, Processing, or Unity) reads the stream and draws the pixels.

The Processing Language

For years, the go-to tool for Arduino visualization has been Processing. It is a Java-based coding environment built for visual arts. It has a Serial library that can read the Arduino’s output. Writing a Processing sketch to draw a fading green radar line is a classic project. We will cover Processing in depth in Phase 6 (Interfacing).

Hacker’s Corner: The “Processing” Code Logic

Even though we haven’t learned Processing yet, here is the logic you would write in Java:

• Setup: Create a window $800 \times 600$. Black background.
• Draw Loop:
  • Fade the background slightly. This creates the “Phosphor Fade” trail effect.
  • Read the Serial Port (Angle, Distance).
  • Convert Polar to Cartesian (X, Y).
  • Draw a Green Line from Center to Edge (The Sweep).
  • If Distance < Max: Draw a Red Dot at (X, Y). This logic creates that classic movie radar look where old contacts slowly fade away.

Advanced Physics: LIDAR vs SONAR vs RADAR

Why did we use Sound? Why not Light?

• SONAR (Sound Navigation and Ranging): Uses Sound. Good for water and simple robotics. Slow speed of sound limits refresh rate. Wide beam (poor resolution).
• LIDAR (Light Detection and Ranging): Uses Lasers. Extremely fast. Extremely narrow beam (Pinpoint accuracy). Used in Self-Driving Cars and iPhones.
• RADAR (Radio Detection and Ranging): Uses Radio Waves. Can see through clouds and rain. Used by airports and military.

For a hobby robot, Ultrasonic is cheap and easy. But its Beam Width (15 degrees) means everything appears blurry and larger than it is.

Science Class: The Speed of Sound and Temperature

We treat the Speed of Sound as a constant (343 m/s). But in Day 21, we learned it changes with air temperature. In a Radar application, accuracy matters. Speed = $331.3 + (0.606 \times Temperature)$

• AT $0^\circ\text{C}$ (Freezing): $331.3\text{ m/s}$.
• AT $20^\circ\text{C}$ (Room Temp): $343.4\text{ m/s}$.
• AT $40^\circ\text{C}$ (Hot Desert): $355.5\text{ m/s}$. This is a 7% difference. If your radar says an object is at 100cm in a cold room, it might actually be at 107cm in a hot room. Professional sonar systems (like on submarines) constantly measure water temperature and salinity to correct their math. You can add a DHT11 temperature sensor (Phase 3) to your Radar Bot to make it biologically accurate!

Project Extension: The Stealth Fighter Experiment

Try this experiment:

• Place a flat book standing up. The sensor sees it clearly.
• Now, Angle the book back by 45 degrees.
• The sensor will likely map “Infinity” (No obstacle). Why? The sound wave hits the angled book and bounces Up towards the ceiling, never returning to the Echo pin. This is exactly how Stealth Aircraft (like the F-117 Nighthawk) work. They don’t absorb radar; they deflect it away from the receiver. You just built a Stealth Technology demonstrator on your desk.

Power Management: The Common Ground Issue

I mentioned this in the wiring section, but it is the #1 cause of failure in this project. If you use a battery for the servo and USB for the Arduino… YOU MUST CONNECT THE NEGATIVE TERMINALS TOGETHER. Electricity needs a return path. Without a Common Ground, the Servo Signal (which is relative to Arduino Ground) means nothing to the Servo (which is relative to Battery Ground). The servo will jitter or do nothing. Always tie the grounds.

Troubleshooting: Ghost Echoes and Crosstalk

In a real room, you might see “Ghost Objects” that don’t exist. Why?

• Multi-path Propagation: Sound bounces off multiple objects before returning.
• Crosstalk: One robot hears another robot’s ping.
• Soft Objects: Materials that absorb sound become “invisible”. The Fix for Noise: Average your readings. Instead of 1 ping per degree, take 3 pings and average them. It slows down the sweep, but increases reliability.

History: The Battle of Britain

Radar (Radio Detection and Ranging) changed the world in 1940. The Royal Air Force (RAF) built a chain of radar towers (“Chain Home”) along the coast. They could see German bombers gathering over France, 100 miles away. This allowed the RAF to scramble their Spitfires exactly where they were needed, instead of patrolling randomly. It was the first time in history that humans extended their vision beyond the horizon. Your little robot is a tribute to that technology.

Physics Deep Dive: Absorption and Reflection

Why can’t our robot see the carpet? Sound behaves like light.

• Specular Reflection: Sound bounces off smooth, hard surfaces.
• Diffuse Reflection: Sound scatters off rough surfaces.
• Absorption: Soft materials convert sound energy into heat. Stealth Engineering: If you want to make your robot invisible to other radar bots, wrap it in felt or cotton wool!

Future Upgrades: Making it Standalone

Right now, you need a PC to see the map. How can we make it portable?

• Add an LCD Screen (Day 20): Display target data locally.
• Add a Buzzer (Day 16): Distance-based alarm.
• Add Wheels (Day 17): Autonomous navigation.

The Bill of Materials (BOM)

The Engineer’s Glossary (Day 23)

• Polar Coordinate: A system defining a point by Distance and Angle.
• Cartesian Coordinate: A system defining a point by X and Y.
• Point Cloud: A collection of data points representing a 3D shape.
• FOV (Field of View): The angular extent of the observable world.
• UART: The hardware protocol used for Serial communication.

Conclusion

You have built a perceive-act system. Your Arduino is no longer just blinking; it is sensing spatial data. This represents the end of the “Components” phase. We have covered Input (sensors), Output (displays, motors), and Logic.

Next, we start Advanced Communication. We are going to learn how chips talk to each other.

• I2C: The 2-wire network.

• SPI: The high-speed data hose.

• UART: The classic serial.

See you on Day 24, where we will learn the language of chips: I2C Protocol.