Ultrasonic Radar Scanner with Rotating Servo, Distance Heatmap and LCD Readout

Seeing how far away things are is one of the most useful things an embedded system can do — from parking sensors to obstacle-avoiding robots — yet students usually test an ultrasonic sensor by pointing it at a wall and reading numbers off the serial monitor. That teaches the sensor, but not the system. This project turns the HC-SR04 into a real instrument: the sensor rides on a servo that sweeps a full 180° arc, and every reading is mapped to its angle, displayed live on a 16×2 LCD as angle, distance and a scrolling heatmap row, and streamed to a PC that draws a radial heatmap of the scanned space. Building it forces the student to work through the genuine engineering of a scanning sensor — echo timing, servo settling, beam width, out-of-range handling and display driving — instead of treating the sensor as a black box. The result is a prototype that visibly "sees" a room, which makes both the demonstration and the viva far stronger than a static sensor demo.

1. At power-up the Arduino centers the servo at 90°, initializes the 16×2 LCD, and prints a ready screen; the sweep starts automatically.
2. The servo horn rotates to the first step (0°) and pauses roughly 120 ms so the horn settles before the measurement.
3. The HC-SR04 is triggered with a 10 µs pulse; it emits eight 40 kHz bursts and the echo pin stays HIGH for the round-trip time, which the Arduino measures with microsecond resolution and converts to centimetres (time ÷ 58.2).
4. The reading is stored against its angle: valid echoes between 2 cm and 400 cm are kept, and timeouts are stored as "no echo" for that bin.
5. The LCD updates immediately — line 1 shows the current angle and distance, while line 2 extends the heatmap row with a bar character sized for that bin.
6. After the 37th reading the Arduino prints the complete angle,cm table over serial; the PC script redraws the radial heatmap, and the next sweep begins from 0°.

Tech stack:

• Arduino UNO (ATmega328P)
• HC-SR04 ultrasonic sensor
• SG90 micro servo
• 16×2 character LCD (HD44780)
• Arduino IDE (C++)
• Python 3 serial heatmap visualizer
• pySerial, Matplotlib
• Breadboard, jumper wires, piezo buzzer

Components & requirements

• Arduino UNO board
• HC-SR04 ultrasonic ranging module
• SG90 180° micro servo with mounting horn
• 16×2 LCD module (HD44780) with I2C backpack or direct 4-bit wiring
• Piezo buzzer, pushbutton (start/stop), breadboard, jumper wires
• USB cable and a computer with Arduino IDE 2.x and Python 3 (for the visualizer)
• 5 V USB power; expected total draw under 500 mA

• [180° Automatic Radar Sweep] The SG90 servo steps the HC-SR04 through 0–180° in 5° steps, triggering one ping per step; the Arduino converts each echo time to distance using the standard time/58.2 cm relation, producing 37 angle–distance readings per sweep.
• [Live LCD Distance Readout] The 16×2 HD44780 LCD shows the current sweep angle and the measured distance in centimetres, updating with every reading so the scan is visible without a computer.
• [On-LCD Sweep Heatmap] As the sweep progresses, the LCD's second row fills with a 16-column heatmap: each column is a custom bar-block character whose height represents the distance at that angle bin, so nearer objects appear as taller bars.
• [PC Radial Heatmap Visualizer] The full sweep table is streamed over USB serial at 9600 baud; the included Python script plots it as a radial heatmap on the PC, giving a radar-screen view of the scanned area.
• [Close-Range Alert Buzzer] A piezo buzzer sounds when any reading falls inside a configurable close-range threshold (default 30 cm), demonstrating threshold-based actuation on sensor data.
• [Adjustable Scan Arc and Step Size] Scan range, step size and buzzer threshold are named constants at the top of the firmware — changing them is a one-line edit and re-upload.
• [Echo-Timeout Handling] Echoes that never return (out of range, absorbed or scattered) are reported as "no echo" instead of junk distances, using the sensor's echo timeout.
• [Single 5V Breadboard Build] The entire system — Arduino UNO, sensor, servo, LCD and buzzer — runs from one shared breadboard and USB power in the standard build, with no external supply needed.

• Assembled and working prototype (Arduino UNO, HC-SR04 on SG90, 16×2 LCD, buzzer, breadboard wiring)
• Arduino firmware source (.ino) with commented constants for scan arc, step size and buzzer threshold
• Python PC heatmap visualizer script with serial reading and radial plot
• Wiring/circuit diagram and complete component list
• Calibration procedure document (temperature compensation, zero-offset check)
• Project report PDF (10 sections), PPT presentation and viva Q&A document
• Demonstration guidance for the final review

Delivery & support

• Delivery information: the prototype is built to order; typical build and testing lead time is communicated at the quotation stage along with courier details for the assembled unit.
• Support and explanation: build walkthrough over a video call, help with Arduino IDE setup and the Python visualizer, and viva preparation support are included with the order.