Story#

During November 2024, I had the unique opportunity to travel from Poland to Madrid to participate in a one-week “ATHENS” course on physical computing at Universidad Politécnica de Madrid. This experience combined intensive hands-on technical learning with cultural insights, allowing me to deepen my knowledge in Arduino, Processing, and sensor-based prototyping while practicing English in an international academic setting.

Working in pairs, we were challenged to translate theoretical concepts into practical projects. My team decided to develop a rotating lidar radar system, exploring both hardware integration and software visualization. This project became the culmination of the course, pushing us to troubleshoot real-world electronics, implement serial communication protocols, and design an interactive graphical interface. Beyond technical skills, the experience enriched my problem-solving abilities, teamwork, and confidence in working within an international, multidisciplinary environment.

Idea#

Our initial idea was to create a rotating lidar system designed to measure 2D spaces. The primary goal was to create a functional, simple, and visually appealing system capable of collecting spatial data and displaying it in an interactive graphical user interface, that would be heavily inspired by systems that look like this:

Implementation#

High-level overview#

We have decided to break the system into 2 main parts: the GUI would run on a PC, and the radar would be controlled by a microcontroller. Communication between the 2 components would be accomplished using a serial connection over USB. Using a USB connection to the microcontroller also automatically provides power to the microcontroller.

Microcontroller component#

For the microcontroller component, we have decided to use the Arduino Nano Every board, as we have used it in the course introduction, and we should not need anything more powerful for our components. To implement the radar we have decided to use two components: a lidar time-of-flight distance sensor mounted on a servo motor. This allows us to take distance measurements at different angles. The microcontroller waits for the GUI to request an angle at which to take a measurement, it rotates the servo to the desired position and takes a distance reading. To drive the components we are using common libraries available for the Arduino ecosystem: Adafruit VL53L0X for the lidar sensor and Servo for the servo motor.

Encountered issues#

There were a couple of issues with the microcontroller implementation. Initially, we have left the XSHUT pin of the lidar sensor unconnected, which has caused the sensor to randomly reboot. We have later realized that XSHUT needs to be tied high (through a resistor); who would have thought that we have to ensure that the shutdown signal is not floating. At the beginning, we were using the “single reading” mode of the VL53L0X sensor. It gave more-or-less correct values, but measurements out of range would take very long time to complete. We have then switched to the “continuous” mode of the lidar, which solved the timing problem, but first readings returned by the library were completely wrong. Therefore, we are taking two distance measurements and simply discarding the first one. We have not encountered any big issues with the servo motor. Our main issue with the microcontroller was the Arduino board itself. It kept randomly crashing without any explicit reason, the lidar sensor would fail to initialize. We have added pull-up resistors to the I2C lines (from our previous experiences they usually were not necessary), reduced the baud rate of the serial connection, started connecting our laptops to chargers to ensure more power is available, and even replaced the Arduino board at some point, to no avail. In the end we have deleted all our Arduino code and rewrote it from scratch. This seemed to help, but the board still crashes, although very rarely.

Final result#

PC component#

The UI program displays the distance measurements as properly-scaled lines on a half-circle (the servo mechanism range is 180 degrees).

Older readings are faded dynamically, and they appear dimmer. The GUI starts sweeping the radar back and forth, but there is also a manual mode available. Pressing space toggles between automatic sweeping and manual control. In manual mode, the user can press left and right arrows to manually move the servo left and right. The GUI is written in Processing. As we have developed the GUI and microcontroller parts simultaneously, we have used more advanced features of the language. The microcontroller connection is abstracted into an interface, with 2 implementations: one which actually communicates with the Arduino and one which fakes any reading, for prototyping. Other than that, we have not encountered major issues with the implementation, as Processing is a straightforward language.

PC-Microcontroller communications#

The protocol over Serial is pretty straightforward. The GUI sends the angle plus one and in ASCII followed by a newline, and then the microcontroller sends the actual angle (in ASCII), space and the measured distance in mm (also in ASCII), followed by a newline. The plus one comes from a peculiarity of Arduino’s Serial.parseInt(). This function returns 0 on failure, and we need to be able to distinguish error conditions from “rotate to zero degrees” command, hence the plus one; the microcontroller simply reads Serial.parseInt() - 1, thus error conditions can be easily detected as negative requests.

Conclusion#

We were able to accomplish what we have set out at the beginning of the project, even if we have encountered a lot of issues during the implementation. The two components successfully display distance measurements.

Code#

Microcontroller#

1
#include <Adafruit_VL53L0X.h>
2
#include <Servo.h>
3

4
Adafruit_VL53L0X distance_sensor = {};
5
Servo servo = {};
6

7
int current_angle = 0;
8
constexpr pin_size_t servo_pin = 3;
9
constexpr int servo_ms_per_deg = 3;
10

11
void init_distance_sensor() {
12
    if (!distance_sensor.begin()) {
13
        Serial.println(F("# distance sensor failed to initialize"));
14
        while (1);
15
    }
16
    distance_sensor.setMeasurementTimingBudgetMicroSeconds(200000);
17
    distance_sensor.startRangeContinuous();
18
}
19

20
unsigned int read_from_distance_sensor() {
21
    while (!distance_sensor.isRangeComplete()) {
22
        delayMicroseconds(100);
23
    }
24
    return distance_sensor.readRange();
25
}
26

27
void init_servo() {
28
    servo.attach(servo_pin);
29
    servo.write(90);
30
    current_angle = 90;
31
    delay(180 * servo_ms_per_deg);
32
}
33

34
void move_servo(int new_angle) {
35
    int angle_delta = abs(new_angle - current_angle);
36
    servo.write(new_angle);
37
    delay(angle_delta * servo_ms_per_deg);
38
    current_angle = new_angle;
39
}
40

41
void setup() {
42
    // Initialize serial connection
43
    Serial.begin(9600);
44
    while (!Serial)
45
        delay(10);
46
    init_distance_sensor();
47
    init_servo();
48
    // Write on serial that initialization is done
49
    Serial.println(F("# initialization completed"));
50
    Serial.flush();
51
    pinMode(LED_BUILTIN, OUTPUT);
52
    digitalWrite(LED_BUILTIN, HIGH);
53
}
54

55
void loop() {
56
    // Try to read a requested angle from serial.
57
    // As `parseInt` returns 0 on timeout/invalid values,
58
    // the user sends (angle + 1).
59
    int angle = Serial.parseInt(SKIP_WHITESPACE) - 1;
60
    if (angle >= 0 && angle <= 179) {
61
        move_servo(179 - angle);
62
        (void)read_from_distance_sensor(); // The first readout is not accurate, ignore it
63
        unsigned int distance_mm = read_from_distance_sensor();
64
        5 Serial.print(angle);
65
        Serial.print(' ');
66
        Serial.println(distance_mm);
67
        Serial.flush();
68
    }
69
}

GUI#

1
import java.util.Map;
2
import processing.serial.*;
3

4
int old_readout_ms = 18000;
5
int window_width = 1500;
6
int window_height = 800;
7
int radar_radius = 700;
8
int radar_root_x = window_width / 2;
9
int radar_root_y = window_height - 50;
10
int angle_step = 2;
11
int text_offset_x = 0;
12
int text_offset_y = 20;
13
int manual_direction = 0;
14

15
class Readout {
16
    public int angle;
17
    public int distance_mm;
18
    public int capture_ms;
19

20
    Readout(int angle, int distance_mm) {
21
        this.angle = angle;
22
        this.distance_mm = distance_mm;
23
        this.capture_ms = millis();
24
    }
25

26
    boolean is_old() {
27
        return (millis() - capture_ms) > old_readout_ms;
28
    }
29
}
30

31
interface RadarController {
32
    void start_readout(int readout);
33

34
    Readout get_readout();
35
}
36

37
class SerialRadarController implements RadarController {
38
    Serial serial_port;
39

40
    SerialRadarController(PApplet parent) {
41
        var port = Serial.list()[0];
42
        println("Port: " + port);
43
        serial_port = new Serial(parent, port, 9600);
44
    }
45

46
    void start_readout(int new_angle) {
47
        angle = new_angle;
48
        serial_port.write((angle + 1) + "\n");
49
    }
50

51
    Readout get_readout() {
52
        while (serial_port.available() > 0)
53
        {
54
            6 String readout = serial_port.readStringUntil(0xA);
55
            if (readout == null || readout.charAt(0) == '#')
56
                return null;
57
            String[] parts = split(trim(readout), ' ');
58
            int angle = int(parts[0]);
59
            int distance_mm = int(parts[1]);
60
            return new Readout(angle, distance_mm);
61
        }
62
        return null;
63
    }
64
}
65

66
class FakeRadarController implements RadarController {
67
    int angle = 0;
68
    int request_time = 0;
69
    boolean pending = false;
70

71
    FakeRadarController() {
72
    }
73

74
    void start_readout(int new_angle) {
75
        angle = new_angle;
76
        request_time = millis();
77
        pending = true;
78
    }
79

80
    Readout get_readout() {
81
        if (!pending || (millis() - request_time) < 100)
82
            return null;
83
        pending = false;
84
        return new Readout(angle, int(random(100, 1000)));
85
    }
86
}
87

88
enum Status {
89
    SweepingForward,
90
    SweepingBackward,
91
    Manual,
92
}
93

94
Status status = Status.SweepingForward;
95
RadarController radar;
96
HashMap<Integer, Readout> readouts;
97
int angle;
98

99
void setup() {
100
    size(1500, 800);
101
    randomSeed(millis() % 256);
102
    status = Status.SweepingForward;
103
    // radar = new FakeRadarController();
104
    radar = new SerialRadarController(this);
105
    readouts = new HashMap<Integer, Readout>();
106
    angle = 0;
107
    delay(500);
108
    radar.start_readout(angle);
109
}
110

111
void draw() {
112
    // Check if a readout is available
113
    Readout pending_readout = radar.get_readout();
114
    if (pending_readout != null) {
115
        7 readouts.put(pending_readout.angle, pending_readout);
116
        // Advance the angle, depending on current status
117
        switch (status)
118
        {
119
        case SweepingForward:
120
            angle += angle_step;
121
            if (angle >= 179)
122
            {
123
                status = Status.SweepingBackward;
124
                angle -= angle_step;
125
                angle -= angle_step;
126
            }
127
            break;
128
        case SweepingBackward:
129
            angle -= angle_step;
130
            if (angle <= 0)
131
            {
132
                status = Status.SweepingForward;
133
                angle += angle_step;
134
                angle += angle_step;
135
            }
136
            break;
137
        case Manual:
138
            angle += manual_direction;
139
            if (angle >= 179)
140
            {
141
                angle = 179;
142
            }
143
            else if (angle <= 0)
144
            {
145
                angle = 0;
146
            }
147
            break;
148
        }
149
        radar.start_readout(angle);
150
    }
151
    // Draw the UI
152
    background(#222222);
153
    stroke(#ffffff);
154
    noFill();
155
    textAlign(LEFT);
156
    textSize(16);
157
    text(status.toString() + " | Angle: " + angle, 0, 16);
158
    stroke(#999999);
159
    arc(
160
        radar_root_x, radar_root_y,
161
        2 * radar_radius, 2 * radar_radius,
162
        PI, TWO_PI);
163
    line(
164
        radar_root_x - radar_radius, radar_root_y,
165
        radar_root_x + radar_radius, radar_root_y);
166
    textAlign(CENTER);
167
    text("0", radar_root_x + text_offset_x, radar_root_y + text_offset_y);
168
    drawDistanceScale(1000);
169
    drawDistanceScale(750);
170
    drawDistanceScale(500);
171
    drawDistanceScale(250);
172
    8 drawDegreeScale(150);
173
    drawDegreeScale(120);
174
    drawDegreeScale(90);
175
    drawDegreeScale(60);
176
    drawDegreeScale(30);
177
    int now = millis();
178
    for (Readout readout : readouts.values()) {
179
        if (readout.is_old())
180
            continue;
181
        float angle_rad = radians(float(readout.angle) + 0.5);
182
        float distance_px = map(
183
            constrain(readout.distance_mm, 0, 1000),
184
            0, 1000,
185
            0, radar_radius);
186
        int x = int(-distance_px * cos(angle_rad)) + radar_root_x;
187
        int y = int(-distance_px * sin(angle_rad)) + radar_root_y;
188
        int grey = int(map(
189
            float(now - readout.capture_ms),
190
            0, old_readout_ms, 255, 34));
191
        stroke(0, grey, 0);
192
        line(radar_root_x, radar_root_y, x, y);
193
    }
194
}
195

196
void keyPressed() {
197
    if (key == ' ') {
198
        if (status == Status.Manual) {
199
            status = Status.SweepingForward;
200
        } else {
201
            status = Status.Manual;
202
        }
203
    } else if (key == CODED) {
204
        if (keyCode == LEFT) {
205
            manual_direction = -angle_step;
206
        } else if (keyCode == RIGHT) {
207
            manual_direction = angle_step;
208
        }
209
    }
210
}
211

212
void keyReleased() {
213
    manual_direction = 0;
214
}
215

216
void drawDistanceScale(int distance) {
217
    textAlign(CENTER);
218
    var offset = (distance / 1000.0) * radar_radius;
219
    text(
220
        String.valueOf(distance),
221
        radar_root_x + text_offset_x - offset,
222
        radar_root_y + text_offset_y);
223
    text(
224
        String.valueOf(distance),
225
        radar_root_x + text_offset_x + offset,
226
        9 radar_root_y + text_offset_y);
227
    arc(radar_root_x, radar_root_y, 2 * offset, 2 * offset, PI, TWO_PI);
228
}
229

230
void drawDegreeScale(int degrees) {
231
    pushMatrix();
232
    translate(radar_root_x, radar_root_y);
233
    rotate(PI / 2 + degrees / 180.0 * PI);
234
    line(0, 0, 0, radar_radius);
235
    popMatrix();
236
    pushMatrix();
237
    translate(radar_root_x, radar_root_y);
238
    rotate(-PI / 2 + degrees / 180.0 * PI);
239
    text(String.valueOf(degrees) + "°", 0 - text_offset_x, -radar_radius - text_offset_y);
240
    popMatrix();
241
}

Madrid Lidar Project