Final Project

Project Silde :

Project Video

MY FINAL PROJECT IDEA

This week I worked on defining my final project idea and started to getting used to the documentation process. The aim of this project is to simplify internal logistics and increase operational efficiency in industrial or creative environments. By using an automated courier robot to transport tools, we can significantly reduce the time lost by employees who need to move to fetch or return tools. This solution could also contribute to better organization of the workspace, reducing clutter caused by poorly stored or lost tools.

The robot will be equipped with sensors and a line-tracking navigation system, which will follow marked lines on the floor to move autonomously within the work environment. It will be programmed to respond to real-time requests through an intuitive user interface. The robot’s carrying capacity must be adapted to the tools commonly used in the relevant sector.

Project Name: MecaMate

Objective: Develop an autonomous robot capable of following floor lines and executing navigation commands to transport parcels between various points in an industrial, port, or commercial environment.

Mateials Required

• Chassis and wheels
• DC motors and gearbox
• Adeept 3-CH line sensor
• ToF VL53L1X sensor
• XIAO ESP32C3 (INPUT BOARD) and RP2040 (OUTPUT BOARD) development boards
• Batteries and energy management systems
• Communication components (Wi-Fi)
• L293D drivers (x2) and SN74HC595 shift register

Part 1 : Mechanical Structure

Gearbox

CAD Gearbox

In order to reduce the motor Speed and increase the motor torque, because Mecamate to work need more torque than speed, I decided to design and prnt my own Gearbox.

The Type of Gearbox I choose is Planetary Gearbox because of they precision and efficiency. Here’s is a 1:16 ratio.

I used SolidWorks to design it, as below :

A small Animation to show an explode view of my Gearbox Structure :

Printing

You have to notice that there were a lot of test before coming to an optimal and functional version of the Gearbox.

The Printing parameters are really important here to have an working Gearbox fully functionnal.

Here’s How one mounted stage of the Planetary Gearbox look like after printing !!

Testing

After testing with one gearbox motor and working fine we can now validate the good parameter and start producing the others gearboxes !!!

Other Gearboxe printed parts :

All mounted on motors :

NB:

• For each Gearbox you will need some Bearings the references are in the design files attached below.
• To connect the motor shaft to the gearbox shaft I print a Hole which a bit smaller than the motor shaft and then use a Hot Air gun with glue to fix the motor to the Gearbox.
• Printing parameters with Ultimaker Cura Slicer for the Gear parts of the Gearboxes have to be set to Super Quality and fill at 100%;
• All the shaft for the motor part and for the wheel have to be printed in an Horizontal position, to make them more solid and do not break.

Design Files

• Gearbox SolidWorks Design Parts separated;
• Gearbox Solidworks Assembly Part

Chassis

CAD Chassis

Robust design in fusion 360

In this part you have to pay attention on the system Integration in order to prepare the right space for each component in the chassis, it’s very very important.

You can refere to the image in the System integration week for the images, were you can see that exported all the different component in the original design file in order to cdefine their location and make the holes if necessary to help an easy fixed parts on the robot chassis and assembly once mounting the final robot.

Here’s the link System Integration.

Here’s an Assembly Chassis CAD animation, to show you how in put each component and mounte them on the chassis

Chassis and mounting parts using 3D printing, Laser cut and CNC milling.

• 3D Printing :

• Laser Cut :

• CNC Milling :

Design Files

• MecaMate Chassis Design - Fusion 360;

Wheels

Four driven wheels with good grip for following floor lines, so I opted to make some arrow patterns on the wheels surface in order to have a good adhesion with the ground.

NB

• The good Way to print wheels, is to use TPU Filament bcause it offer the good properties for adhesion but in this project i’m not using it because it’s unavailable in my lab, it’s the reason why i used arrow patterns to help PLA printed wheels be adhesive. It’s one of the enhancement I have to do on the project.

Print results !!

I also design and print a wheel blocker to maintain the wheel on the gearbox output shaft.

Here’s a photo of the wheels successfully mounted on the robot :

Design Files

• Wheels blocker Solidworks Design ;
• Wheels Design Files ;

Motors

Four DC 12V motors (AUTOTOOLHOME MODEL:JYCRS390H). For each motors i made a Motor Holder :

here’s the 3D Design part :

• Motor Holder Bottom part

• Motor Holder Top Part :

• I also designed a Gearbox Holder :

Image Holders fully integrated in the robot :

Here are the differents files :

• Motor Top/Bottom parts Solidworks Design;
• Gearbox Holder.

Part 2 : Development Boards:

Input Board

• XIAO ESP32C3 (INPUT BOARD) for receiving information via Wi-Fi from the mobile application, managing sensors, and sending commands to the OUTPUT BOARD.
• Line Sensor: Adeept 3-CH tracking module, integrating three sensors in one.
• Obstacle Sensor: ToF VL53L1X sensor for obstacle detection.

You can refere to my Input Devices week assignement to see more informations about it.

Output Board

• XIAO RP2040 (OUTPUT BOARD) for controlling the motors and LEDs.

Part 3 : Communication and Control

Mobile Application

Developed with MIT App Inventor to enter commands and find the shortest path using a path-finding algorithm.

• Communication Protocol: Wi-Fi for communication between the mobile application and the robot.
• Inter-communication: I2C between the ESP32C3 (INPUT BOARD) and RP2040 (OUTPUT BOARD) boards.

MecaMate Control App Demo !

Test with the robot Input board and it works !!! The App successfully send the command array to the input board via Wifi !

You can refere to my Interface and application programming week assignement to see more informations about it.

Command System

Navigation Algorithm: - The mobile application generates a command array (e.g., go straight, turn left, etc.) based on the shortest path. - The robot uses the line sensor to follow the instructions in the array, using a node logic (e.g., execute the instruction as long as one of the sensors detects a line, if two or three sensors detect a line, stop and execute the next instruction).

Part 4 : Final Assembly and Testing

With all this work my OUTPUT Board isn’t working ! And paased a long time looking for the error in the circuit once I find that :

• First L293D are not enough powerfull to control my 1A motors;
• Second, one of the two L293D drivers I have isn’t working because it has been destroyed by a mistake;

But good news, actually I test my mortors with the L298N Driver and it actually working, so i’m actually working on other different OUTPUT Board than the one i made in order to integrate the L298N drivers in the circuit to finish my MecaMate Robot.

here is a video of the test :

Here’s my input board final code :

#include <Wire.h>
#include <WiFi.h>
#include <Adafruit_VL53L0X.h>
#include <Adafruit_NeoPixel.h>
#include <PubSubClient.h> // Bibliothèque pour MQTT

#define LEFT_SENSOR_PIN 2
#define CENTER_SENSOR_PIN 3
#define RIGHT_SENSOR_PIN 4
#define I2C_SLAVE_ADDRESS 9

// LED ring parameters
#define LED_PIN 6
#define NUM_LEDS 24

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

const char* ssid = "********"; 
const char* password = "***********"; 
WiFiServer server(80);

const char* mqttServer = "broker.hivemq.com"; // Serveur MQTT (par exemple, HiveMQ public broker)
const char* mqttUserName = "";  // Laisser vide si pas d'authentification
const char* mqttPwd = "";       // Laisser vide si pas d'authentification
const char* clientID = "ESP32Client";
const char* topic = "travel"; // Topic pour recevoir le chemin

WiFiClient espClient;
PubSubClient client(espClient);

// Initialiser le capteur VL53L0X
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
#define VL53L0X_ADDRESS 0x29

String path = ""; // Chemin à suivre, reçu via MQTT
unsigned long previousMillis = 0;
unsigned long pathMillis = 0;
unsigned long interval = 1000; // Intervalle de 1 seconde entre chaque étape du chemin
int currentStep = 0;

void callback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (unsigned int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  Serial.print("Message arrived in topic: ");
  Serial.println(topic);
  Serial.print("Message: ");
  Serial.println(message);

  path = message;
  followPath();
}

void setup() {
  Serial.begin(9600);
  pinMode(LEFT_SENSOR_PIN, INPUT);
  pinMode(CENTER_SENSOR_PIN, INPUT);
  pinMode(RIGHT_SENSOR_PIN, INPUT);

  strip.begin();
  strip.show(); // Initialize all pixels to 'off'

  showConnectingAnimation();
  setupWiFi();
  setupMQTT();
  setupI2C();
  setupDistanceSensor();
}

void setupWiFi() {
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi...");
  showConnectingAnimation();
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  showConnectedAnimation();
  Serial.println();
  Serial.println("Connected to WiFi");
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  unsigned long currentMillis = millis();

  if (currentMillis - pathMillis >= interval && path.length() > 0) {
    pathMillis = currentMillis;
    followPathStep();
  }

  readLineSensors(); // Lire les capteurs de ligne
  readObstacleSensor(); // Lire le capteur de distance
  handleAnimations(); // Gérer les animations LED
}

void setupMQTT() {
  client.setServer(mqttServer, 1883);
  client.setCallback(callback);
  reconnect();
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect(clientID, mqttUserName, mqttPwd)) {
      Serial.println("Connected to MQTT");
      client.subscribe(topic);
      Serial.println("Subscribed to topic");
    } else {
      Serial.print("Failed to connect, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void setupI2C() {
  Wire.begin(); // Initialiser en tant que maître
  Serial.println("I2C initialized");
}

void setupDistanceSensor() {
  if (!lox.begin()) {
    Serial.println(F("Echec de l'initialisation du capteur VL53L0X"));
    while (1);
  }
  Serial.println(F("Capteur VL53L0X initialisé"));
}

void followPath() {
  showDeliveryInProgressColor();
  pathMillis = millis(); // Réinitialiser le compteur de temps pour suivre le chemin
}

void followPathStep() {
  if (currentStep < path.length()) {
    char step = path.charAt(currentStep);
    int command = determineCommand(step);
    sendCommand(command);
    currentStep++;
  } else {
    showDeliveryCompleteColor();
    path = ""; // Réinitialiser le chemin une fois terminé
  }
}

int readLineSensors() {
  int leftSensor = digitalRead(LEFT_SENSOR_PIN);
  int centerSensor = digitalRead(CENTER_SENSOR_PIN);
  int rightSensor = digitalRead(RIGHT_SENSOR_PIN);

  if (leftSensor == HIGH && centerSensor == HIGH && rightSensor == HIGH) {
    return 'P'; // Point d'arrêt détecté
  }
  if (centerSensor == HIGH && leftSensor == LOW && rightSensor == LOW) {
    return 'F'; // Le robot est sur la ligne
  }
  if (leftSensor == HIGH && centerSensor == LOW && rightSensor == LOW) {
    return 'L'; // Le robot doit tourner à gauche
  }
  if (rightSensor == HIGH && centerSensor == LOW && leftSensor == LOW) {
    return 'R'; // Le robot doit tourner à droite
  }
  return 'S'; // Par défaut, arrêter si aucun capteur ne détecte la ligne
}

int readObstacleSensor() {
  VL53L0X_RangingMeasurementData_t measure;

  lox.rangingTest(&measure, true);
  if (measure.RangeStatus != 4) {  
    Serial.print("Distance (mm) : ");
    Serial.println(measure.RangeMilliMeter);
    if (measure.RangeMilliMeter < 200) return 'S'; // Obstacle détecté, arrêt
  } else {
    Serial.println("Hors de portée");
  }
  return -1; // Pas d'obstacle
}

int determineCommand(char step) {
  int obstacleCommand = readObstacleSensor();
  if (obstacleCommand != -1) {
    return obstacleCommand; // Priorité à l'obstacle
  }

  int lineCommand = readLineSensors();
  if (lineCommand != 'S') {
    if (lineCommand == 'P') {
      if (step == 'P') {
        return 'S';
      } else {
        return 'F';
      }
    }
    return lineCommand;
  }

  switch (step) {
    case 'A':
      return 'R';
    case 'B':
      return 'L';
    case 'C':
      return 'F';
    case 'D':
      return 'S';
    default:
      return 'S';
  }
}

void sendCommand(int command) {
  Wire.beginTransmission(I2C_SLAVE_ADDRESS); 
  Wire.write(command);                       
  Wire.endTransmission();

  Serial.print("Command sent: ");
  Serial.println((char)command);
}

void handleAnimations() {
  // Fonction pour gérer les animations LED de manière non bloquante
  // Par exemple, si une animation est en cours, continuer à l'exécuter étape par étape
  // Ajouter le code de gestion des animations ici
}

// Animation de connexion
void showConnectingAnimation() {
  for(int i=0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(0, 0, 255)); // Bleu
    strip.show();
    delay(50);
  }
  strip.clear();
  strip.show();
}

// Animation de connexion réussie
void showConnectedAnimation() {
  for(int i=0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(0, 255, 0)); // Vert
  }
  strip.show();
}

// Animation de réception du chemin
void showReceivingPathAnimation() {
  for(int i=0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(255, 255, 0)); // Jaune
    strip.show();
    delay(50);
  }
  strip.clear();
  strip.show();
}

// Couleur pendant la livraison
void showDeliveryInProgressColor() {
  for(int i=0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(0, 0, 255)); // Bleu
  }
  strip.show();
}

// Couleur après la livraison
void showDeliveryCompleteColor() {
  for(int i=0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(255, 0, 0)); // Rouge
  }
  strip.show();
}

Here’s my OUTPUT Board code for L293D drivers with the Shftregister :

#include <Wire.h>

#define PIN_DS 10   //pin 14  75HC595
#define PIN_STCP 9  //pin 12  75HC595
#define PIN_SHCP 8  //pin 11  75HC595
#define ENABLE_A 0
//#define ENABLE_B 1
#define ENABLE_C 2
//#define ENABLE_D 3

#define I2C_SLAVE_ADDRESS 9
/*

void executeCommand(char command) {
  switch (command) {
    case 'F': // Avancer
      MOVE_FORWARD(50);
      break;
    case 'B': // Reculer
      MOVE_BACKWARD(50);
      break;
    case 'L': // Tourner à gauche
      TURN_LEFT(50);
      break;
    case 'R': // Tourner à droite
      TURN_RIGHT(50);
      break;
    case 'S': // Stop
      STOP_MECAMATE();
      break;
    default:
      STOP_MECAMATE();
      break;
  }
}

void receiveEvent(int howMany) {
  while (Wire.available()) {
    char command = Wire.read();
    executeCommand(command);
  }
}
*/

#define numberOf74hc595 1

// nombre total de pin de registre a decalage
#define numOfRegisterPins numberOf74hc595 * 8

boolean registers[numOfRegisterPins];

void setup() {
  pinMode(PIN_DS, OUTPUT);
  pinMode(PIN_STCP, OUTPUT);
  pinMode(PIN_SHCP, OUTPUT);
  pinMode(ENABLE_A, OUTPUT);
  pinMode(ENABLE_B, OUTPUT);
  pinMode(ENABLE_C, OUTPUT);
  pinMode(ENABLE_D, OUTPUT);

  //Wire.begin(I2C_SLAVE_ADDRESS);
  //Wire.onReceive(receiveEvent);

  Serial.begin(9600);
  clearRegisters();
  // on applique les valeurs au registre a decalage
  writeRegisters();
}

// Mettre toutes les valeurs a 0 pour le resigtre
void clearRegisters() {
  for (int i = numOfRegisterPins - 1; i >= 0; i--) {
    registers[i] = LOW;
  }
}

void writeRegisters(){

 // Tant que LOW les modifications ne seront pas affectés
  digitalWrite(PIN_STCP, LOW);

 // boucle pour affecter chaque pin des 74hc595
  for(int i = numOfRegisterPins - 1; i >=  0; i--){

    //doit etre a l'etat bas pour changer de colonne plus tard
    digitalWrite(PIN_SHCP, LOW);

    // recuperation de la valeur dans le tableau registers
    int val = registers[i];

    //affecte la valeur sur le pin DS correspondant a un pin du 74hc595
    digitalWrite(PIN_DS, val);

    //colonne suivante
    digitalWrite(PIN_SHCP, HIGH);
  }
  //applique toutes les valeurs au 74hc595
  digitalWrite(PIN_STCP, HIGH);

}

// enregistre une valeur pour un registre etat haut ou bas
void setRegisterPin(int index, int value){
  registers[index] = value;
}

void MOVE_FORWARD(int speed) {
  setRegisterPin(0, HIGH);
  setRegisterPin(1, LOW);
  // setRegisterPin(2, HIGH);
  // setRegisterPin(3, LOW);
  // setRegisterPin(4, HIGH);
  // setRegisterPin(5, LOW);
  // setRegisterPin(6, HIGH);
  // setRegisterPin(7, LOW);
  analogWrite(ENABLE_A, speed);
  analogWrite(ENABLE_B, speed);
  analogWrite(ENABLE_C, speed);
  analogWrite(ENABLE_D, speed);
// appelle la fonction pour appliquer les valeurs
  writeRegisters();  

}

void MOVE_BACKWARD(int speed_b) {
  digitalWrite(PIN_STCP, LOW);
  shiftOut(PIN_DS, PIN_SHCP, LSBFIRST, 0B01010101);
  analogWrite(ENABLE_A, speed_b);
  analogWrite(ENABLE_B, speed_b);
  analogWrite(ENABLE_C, speed_b);
  analogWrite(ENABLE_D, speed_b);
  digitalWrite(PIN_STCP, HIGH);
}

void TURN_RIGHT(int speed_r) {
  digitalWrite(PIN_STCP, LOW);
  shiftOut(PIN_DS, PIN_SHCP, LSBFIRST, 0B01100110);
  analogWrite(ENABLE_A, speed_r);
  analogWrite(ENABLE_B, speed_r);
  analogWrite(ENABLE_C, speed_r);
  analogWrite(ENABLE_D, speed_r);
  digitalWrite(PIN_STCP, HIGH);
}

void TURN_LEFT(int speed_b) {
  digitalWrite(PIN_STCP, LOW);
  shiftOut(PIN_DS, PIN_SHCP, LSBFIRST, 0B10011001);
  analogWrite(ENABLE_A, speed_b);
  analogWrite(ENABLE_B, speed_b);
  analogWrite(ENABLE_C, speed_b);
  analogWrite(ENABLE_D, speed_b);
  digitalWrite(PIN_STCP, HIGH);
}

void STOP_MECAMATE() {
  digitalWrite(PIN_STCP, LOW);
  shiftOut(PIN_DS, PIN_SHCP, LSBFIRST, 0B00000000);
  digitalWrite(PIN_STCP, HIGH);
}

void loop() {
  MOVE_FORWARD(50);
}

Phase 2 FABAcademy : Improve my final project

I’m currently catching up for FABacademy, the objectcif for me is to make my robot move because my biggest challenge on this project was to make it move.

I had a lot of trouble finding the right DC motors for my use here, finding drivers to drive the motors efficiently, powering the robot, and being able to print the wheels in TPU for good adhesion to the track.

In this second phase, I managed to solve several of these challenges, and I’ll quickly explain how I did it.

Spiral Development

I have, this time, learned lessons from my past mistakes and have therefore accurately estimated what I am capable of achieving within the given timeframe. I used the spiral development method to continue working on my project. My spirals are structured as follows:

• 1st spiral: Ensure that the robot moves forward and turns.
• 2nd spiral: Ensure that the robot follows black lines.
• 3rd spiral: Send commands from the app to the robot, and the robot handles the commands autonomously.

For this second phase of the FABAcademy, I will be able to reach up to the 2nd spiral at most; the 3rd spiral will be for a slightly more advanced phase.

Improve the motors and drivers

The motors I used were indeed DC motors, but unfortunately they didn’t fit mecamate’s case, as these motors are high-speed motors and therefore required the production of Gearboxes, which was not an easy task in itself, but also posed a lot of assembly constraints.

The use of these motors was not by choice, but according to what was available and accessible in my country.

For this second phase, I succeeded in finding motors with high torque and low speed that met Mecamate’s requirements.

The motor model used is the following: Gear motor JGA25-370 625rpm

For the new version of Mecamate, with the replacement of the motors, I have designed a new Output board. For the previous version, I have directly used motors drivers L298 integrated circuits, and it has been a high challenge to manage the power distribution and efficiently control the motors. Then I chose to use a module designed around the same L298 motors driver but which have the advantage to include all the necessary components for a good power management. In addition, the printed circuit of this module is very good and support a high current rate. The module is in the picture below. As its schematic showed it, the module can support two motors. Then we have use for of them to manage all the four motors with a high precision.

Another update in the Output board is the use of XIAO ESP32C3 as microcontroller board to be the brain of this board. This board is more resistive than the XIAO RP2040 that I have been using. Here below is the new schematic of the PCB. It includes the XIAO ESP32C3 , the shift register 75HC595, a 5V Low Drop Out Regulator AMS1117 ** and pin header connectors. This board as the previous version will communicate with the Input Board** through I2C protocol.

After drawing the schematic, I have designed the printed circuit that you can see here below. While designing it, I have taken a special look at the disposition of the SIL connectors and the terminal blocks in order to ease the connections in the body of Mecamate.

When I finished my design, I make tests on breadboard and like everything was going well, I have produced the board with the CNC machine on copper board. The following pictures are respectively the board before soldering the components, the bottom view after soldering and the below view after soldering. As you can see, there are electronic components on each side of the board. The board mixes Surface Mounted and Through Hole Components. It has been a great challenge to put them on the same single-face copper board.

Redesign Parts

Wheels

For the wheels this time, in terms of improvement, I decided to make them in two parts: a PLA rim and a TPU band to achieve better adhesion to the ground. For the connection between the motor and the wheels, I opted for hex-head output shaft couplers to ensure a fixed and rigid connection. Below, you will find images of the various parts related to the wheels:

• Coupler

Testing the new features

Yeah !!! I’m relly proud of it. It finally worked after a lot of try, failling and resilience. I juste achieve the 1st and 2st spirale that was the goal of this journey !!

NB: I have a small problem to correct with the wheels for more precision for the movement. There is a small gap.

---

Last update: December 1, 2024