Final project

Embedded Systems

PCB Design – Planning

A total of three PCB designs will be made.

Brain Board Design

The XIAO ESP32C6 will be used as the brain of the project. Connected to it will be the VL53L0X sensors, WiFi for XBOX controller input, QR code processing, navigation logic, and the transmission of speed or direction commands. This board will be manufactured once.

Components

• Connected sensors (3× VL53L0X)
• QR reader (GM65) – subject to change
• 4.7kΩ pull-up resistors on SDA and SCL
• 10kΩ pull-up resistors on each XSHUT
• 100nF capacitors (3 per sensor)
• 10µF capacitor (to stabilize 3.3V)

Motor Board Design

A board based on the XIAO RP2350 will be created to connect the motors and receive commands from the ESP32C6 to independently control the four motors. This board will be manufactured once.

• 100µF and 100nF capacitors in parallel on the motor power supply.
• 4-output connector toward the 4 driver boards.

H-Bridge Driver Board Design

The DRV8251A driver will be used. This board will be manufactured 4 times, one per motor.

• DRV8251A
• 100nF capacitor between VCC and GND
• 10µF capacitor on VM (motor power supply)

The development of the motor control system represented one of the main challenges of this project. During the initial stages, I experienced several issues related to the electronic design and component selection.

My original intention was to use the DRV8251A motor driver. However, after reviewing the electrical requirements of the motors, I determined that their operating voltage was below the minimum voltage required by the DRV8251A to function correctly. Because of this limitation, I selected the TB67H451AFNG motor driver instead.

To achieve independent control of each motor, a dedicated TB67H451AFNG was used. As an additional precaution during assembly, electrical insulating tape was placed underneath each IC to prevent accidental conduction paths or undesired electrical contacts with the supporting surface. After assembly, each driver was tested individually to verify proper operation before integrating it into the complete system.

Design with Altium

This was my procedure for creating my boards. For this, Altium was used and the previously established criteria in the tables were followed, where my schematics were the following:

❮ ❯

Brain Board Schematic Process

Motor Board Schematic

PCB Manufacturing

Regarding the manufacturing of my boards, once the designs were obtained, exactly the same procedure from week 8 was followed. The same parameters were used for each of the tools. In this way, the three main boards were successfully manufactured.

The procedure inside the Monofab:

Finally, once the boards were obtained, the remaining components were soldered, where the result was the following:

Finally, this was the final result:

❮ ❯

Inputs and Outputs

VL53L0X Sensor Testing – Individual and Combined

There are different types of distance-measuring sensors; among them is the VL53L0X. First, it was necessary to test a single sensor. For this purpose, the following code was used:

#include <Wire.h>
#include <VL53L0X.h>

#define SENSOR_SDA  6
#define SENSOR_SCL  7
#define XSHUT_PIN   2

VL53L0X sensor;

void setup() {
  Serial.begin(115200);
  Wire1.setSDA(SENSOR_SDA);
  Wire1.setSCL(SENSOR_SCL);
  Wire1.begin();
  pinMode(XSHUT_PIN, OUTPUT);
  digitalWrite(XSHUT_PIN, LOW);
  delay(10);
  digitalWrite(XSHUT_PIN, HIGH);
  delay(50);
  sensor.init(true);
  sensor.setTimeout(500);
  sensor.startContinuous();
  Serial.println("Sensor ready!");
}

void loop() {
  int distance = sensor.readRangeContinuousMillimeters();
  if (sensor.timeoutOccurred()) {
    Serial.println("Error: Timeout occurred");
  } else {
    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" mm");
  }
  delay(100);
}

Motion Programming

For the wheel programming, research was first conducted on the basic movements possible with the purchased wheel type. Based on these observed movements, a code was written to instruct the robot to perform the following maneuvers: forward, backward, left and right lateral translation, clockwise and counterclockwise rotation, full 360° clockwise and counterclockwise turns, diagonal forward-left, forward-right, backward-left, backward-right, and pivoting around both the front and rear axles.

The programming structure is as follows: first, a single motor is controlled; then multiple motors are combined; next, advanced speed calculations are performed; and finally, movements are executed. The first developed code is:

Here you can download the Brain Board code in .zip

This code was loaded into Arduino following the steps learned in the corresponding week, which enabled the observation of the robot's movements.

Robot Kinematics

It is important to understand the kinematic model of the robot. This robot uses standard inverse kinematics. The table below shows the movement direction of each wheel type and the combined motion they produce. Each motor receives a signed value: positive means the wheel spins forward, negative means backward, and 0 means the motor is stopped.

The following obstacle scenarios and corresponding responses are proposed:

For the integration of three VL53L0X sensors, the proposed program you can find them here: .zip

Rear Wheel Connection Issue and ESP32C6 UART Overheating Investigation

During system integration, I encountered a problem related to the rear wheel movement. To identify the source of the issue, I performed a systematic debugging process in which each subsystem was tested independently.

After verifying the motors, drivers, and software behavior, I concluded that the fabricated PCB contained an unreliable connection between the board and the microcontroller. As a consequence, movement commands were not being transmitted correctly.

To solve this problem, I refabricated the PCB and introduced a minor modification to the original design. The only change consisted of replacing the lower-right pin header arrangement so that it matched the configuration used throughout the rest of the board.

At the same time, I investigated an overheating issue involving the UART communication wiring between the XIAO RP2350 and the XIAO ESP32C6. To isolate the cause, I tested every UART connection individually and then verified communication using dedicated Arduino test programs.

The following code was uploaded to the RP2350:

#define UART_BAUD 115200

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);
  Serial1.begin(UART_BAUD);
  delay(500);
  Serial.println("RP2350 listo — esperando PINGs...");
}

void loop() {
  if (Serial1.available()) {
    String msg = Serial1.readStringUntil('\n');
    msg.trim();

    Serial.printf("Recibido: '%s'\n", msg.c_str());

    if (msg == "PING") {
      Serial1.println("PONG");
      Serial.println("Respondido: PONG");
    } else {
      Serial.printf("Mensaje desconocido: '%s'\n", msg.c_str());
    }
  }
}
   
        

The following code was uploaded to the ESP32C6:

#define UART_BAUD 115200

#define UART_TX D6
#define UART_RX D7

uint8_t contador = 0;

void setup() {
  Serial.begin(115200);
  Serial1.begin(UART_BAUD, SERIAL_8N1, UART_RX, UART_TX);
  delay(500);
  Serial.println("ESP32C6 listoenviando PINGs...");
}

void loop() {
  Serial1.println("PING");
  Serial.printf("[%d] Enviado: PING\n", contador++);

  unsigned long t = millis();
  while (millis() - t < 500) {
    if (Serial1.available()) {
      String resp = Serial1.readStringUntil('\n');
      resp.trim();
      if (resp == "PONG") {
        Serial.println("PONG");
      } else {
        Serial.printf("Respuesta inesperada: '%s'\n", resp.c_str());
      }
      break;
    }
  }

  if (millis() - t >= 500) {
    Serial.println("Sin respuesta");
  }

  delay(1000);
}

   
        

Once UART communication was verified, I continued testing the system to determine whether the overheating issue was related to power distribution. The boards were connected together with the motor drivers while keeping the motors disabled. Under these conditions, none of the ICs exhibited abnormal temperature increases.

After further investigation, I determined that the root cause was an incorrect pin connection. Once the new PCB arrived and the connections were corrected, all four wheels responded properly and the robot was able to move as expected.

With the hardware issues resolved, I proceeded to upload the final firmware to both boards. UART communication was used to coordinate the behavior required for obstacle detection and autonomous reactions. The software architecture was distributed between the following boards:

• XIAO ESP32C6
• XIAO RP2350

As an additional feature, I implemented several demonstration routines to showcase the omnidirectional movement capabilities of the platform. These demonstrations were executed directly from the RP2350.

After validating the sensor readings using objects positioned at different distances, I confirmed that the measured values were consistent with the robot's reactions. Once the sensing and response system was operating reliably, I performed practical tests on different surfaces to evaluate overall system performance.

Finally, I assembled the external structure and permanently secured the motors in place. Screws were used to fasten each component, improving mechanical stability and ensuring reliable operation during movement.

Interface and Application Programming

The original objective for the user interface was to control the robot using an Xbox controller connected through Bluetooth. However, the specific controller available for testing could not be updated to a firmware version compatible with the libraries required for communication with the ESP32 platform.

Because of this limitation, I decided to design and develop a custom digital controller using a XIAO ESP32C6.

This decision was influenced by previous experience acquired during an earlier Fab Academy assignment, where I had already experimented with wireless communication interfaces. Since this type of development is particularly interesting to me, creating a dedicated controller for the omnidirectional robot became an exciting extension of the project.

Considering that the primary objective of the robot was obstacle avoidance, I implemented two different operating modes.

The first mode allows the user to manually control the vehicle through directional commands. In this configuration, the robot behaves as a conventional remote-controlled platform.

The second mode enables autonomous obstacle avoidance. When activated, manual control is automatically disabled and the robot takes control of its own navigation by using data acquired from the distance sensors to avoid collisions.

The first stage of development consisted of creating the graphical controller interface without integrating any functional logic. This allowed me to verify the layout and communication structure independently from the vehicle control algorithms.

Here is the link for the programming of the html in the XIAO ESP32C6 .zip

Once the interface was operating correctly, I used artificial intelligence as a development support tool. Rather than generating the project from scratch, AI was employed to help organize the codebase and ensure that previously implemented movement functions remained intact while integrating new features.

Using Claude, I created a prompt requesting the integration of the different software modules developed throughout the project while preserving functionality, structure, and readability. The resulting implementation was the following:

"I am carrying out an omnidirectional robot project. I use two microcontrollers. The first one is a XIAO ESP32C6 that creates a web interface where a controller is generated to operate the omnidirectional robot. It also reads data from VL53L0X sensors and transmits these instructions through UART communication to my second microcontroller, a XIAO RP2350. I have the following codes. I need you to integrate the ESP32C6 web interface code with the instructions that it previously had so that they are consistent with each other. Likewise, I would like you to review and correct (if necessary) the XIAO RP2350 code so that it matches the information being sent from the ESP32."

Of course, the codes explained previously were copied and pasted.

This was the final result:.zip