Robot de voiture Wi-Fi télécommandé ESP32 (Arduino)

Dans ce projet, vous apprendrez étape par étape comment construire un robot de voiture télécommandé Wi-Fi ESP32. Vous contrôlerez le robot à l’aide d’un serveur Web pour le faire avancer, reculer, droite, gauche et s’arrêter. Il existe également une option pour contrôler la vitesse du robot. L’ESP32 sera programmé à l’aide de l’IDE Arduino.

Conditions préalables

Avant de continuer, assurez-vous de vérifier les conditions préalables suivantes.

1. L’EDI Arduino

L’ESP32 sera programmé à l’aide de l’IDE Arduino. Assurez-vous donc que les cartes ESP32 sont installées. Vous pouvez suivre le tutoriel suivant comme référence :

2. Pièces requises :

Voici une liste des pièces nécessaires pour construire le robot automobile télécommandé Wi-Fi ESP32 :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

3. Moteurs à courant continu et pilote de moteur LN298

Pour construire le robot, nous utiliserons deux moteurs à courant continu contrôlés via un pilote de moteur LN298. Familiarisez-vous avec le contrôle de la vitesse et de la direction d’un moteur à courant continu avec l’ESP32 :

4. Le kit de châssis du robot

Nous utiliserons le kit de châssis de robot intelligent. Pour obtenir des instructions sur la façon de l’assembler, consultez le didacticiel suivant :

Aperçu du projet

Avant de démarrer le projet, nous mettrons en évidence les fonctionnalités et composants les plus importants pour créer le projet.

Wi-Fi

Le robot sera contrôlé via Wi-Fi à l’aide de votre ESP32. Nous allons créer une interface Web pour contrôler le robot, accessible sur n’importe quel appareil de votre réseau local.

Contrôles des robots

Le serveur Web dispose de cinq options de contrôle : avant, arrière, droite, gauche et arrêt. Il y a aussi un curseur pour contrôler la vitesse.

Kit de châssis de robot intelligent

Nous allons utiliser le kit de châssis de robot présenté dans la figure ci-dessous. Il s’agit du kit de châssis de robot intelligent. Vous pouvez le trouver dans la plupart des boutiques en ligne. Le kit coûte environ 10 $ et est facile à assembler. Vous pouvez utiliser n’importe quel autre kit de châssis à condition qu’il soit livré avec deux moteurs à courant continu.

Pilote de moteur L298N

Il existe de nombreuses façons de contrôler les moteurs à courant continu. Nous utiliserons le pilote de moteur L298N qui offre un moyen simple de contrôler la vitesse et la direction de 2 moteurs à courant continu.

Pouvoir

Les moteurs consomment beaucoup de courant, vous devez donc utiliser une alimentation externe. Cela signifie que vous avez besoin de deux sources d’alimentation différentes. L’un alimentera les moteurs à courant continu et l’autre l’ESP32. Nous alimenterons l’ESP32 à l’aide d’un petit chargeur portable (comme ceux utilisés pour recharger votre smartphone).

Les moteurs seront alimentés par 4 piles AA 1,5 V. Vous pouvez envisager d’utiliser des piles rechargeables ou toute autre alimentation appropriée.

Contrôlez les moteurs à courant continu avec le L298N

Pour vous familiariser avec le driver du moteur L298N, nous vous recommandons de lire le tutoriel suivant :

Jetons un coup d’œil rapide à la façon d’utiliser le pilote de moteur L298N pour contrôler la vitesse et la direction du robot.

Les broches d’activation

Les broches d’activation sont comme un interrupteur ON et OFF pour vos moteurs. Par exemple:

Si vous envoyez un signal HIGH pour activer 1 broche, le moteur A est prêt à être contrôlé et à la vitesse maximale. Si vous envoyez un signal BAS à la broche d’activation 1, le moteur A s’éteint.

Si vous envoyez un signal PWM, vous pouvez contrôler la vitesse du moteur. La vitesse du moteur est proportionnelle au rapport cyclique. Cependant, notez que pour les petits cycles de service, les moteurs peuvent ne pas tourner et émettre un bourdonnement continu.

Les broches d’entrée

Les broches d’entrée contrôlent la direction dans laquelle les moteurs tournent. Entrée 1 et entrée 2 du moteur de commande A et entrées 3 et 4 du moteur de commande B.

Si vous appliquez LOW à l’entrée 1 et HIGH à l’entrée 2, le moteur tournera vers l’avant. Si vous appliquez l’alimentation dans l’autre sens : HIGH à l’entrée 1 et LOW à l’entrée 2, le moteur tournera vers l’arrière. Le moteur B est contrôlé selon la même méthode.

Donc, si vous voulez que votre robot avance, les deux moteurs doivent tourner vers l’avant. Pour le faire reculer, les deux doivent tourner vers l’arrière.

Pour faire tourner le robot dans une direction, vous devez faire tourner le moteur opposé plus rapidement. Par exemple, pour faire tourner le robot à droite, nous allons activer le moteur de gauche et désactiver celui de droite.

Câblage du circuit

Après avoir assemblé le châssis du robot, vous pouvez câbler le circuit en suivant le schéma suivant.

Commencez par connecter l’ESP32 au pilote du moteur comme indiqué dans le schéma. Vous pouvez utiliser une mini planche à pain ou une planche à découper pour placer votre ESP32 et construire le circuit.

Après cela, connectez chaque moteur à ses borniers. Nous vous recommandons de souder un condensateur céramique de 0,1 uF aux bornes positives et négatives de chaque moteur, comme indiqué dans le schéma, pour aider à atténuer les pics de tension.

De plus, vous pouvez souder un interrupteur coulissant au fil rouge provenant de la batterie. De cette façon, vous pouvez allumer et éteindre les moteurs et le pilote de moteur. Enfin, alimentez les moteurs en connectant une batterie de 4 AA aux blocs d’alimentation du pilote de moteur. Puisque vous souhaitez que votre robot soit portable, l’ESP32 sera alimenté à l’aide d’un chargeur portable. Vous pouvez fixer le chargeur portable au châssis du robot à l’aide de velcro, par exemple.

Ne connectez pas encore la banque d’alimentation, car vous devez d’abord télécharger le code sur l’ESP32.

Votre robot devrait ressembler à la figure suivante :

Construire le serveur Web

Créons maintenant le serveur Web. La figure suivante montre le serveur Web que nous allons construire. Vous disposez de cinq commandes pour faire avancer le robot, reculer, droite, gauche et arrêter. Vous disposez également d’un curseur pour contrôler la vitesse. Vous pouvez sélectionner 0, 25, 50, 75 ou 100 % pour contrôler la vitesse du moteur.

Code Arduino – Robot de voiture Wi-Fi télécommandé ESP32

Pour créer le serveur Web, nous utiliserons la bibliothèque Webserver.h qui est automatiquement installée lorsque vous installez les cartes ESP32 dans l’IDE Arduino.

/*  
  Rui Santos & Sara Santos - Raspberryme.com
  https://Raspberryme.com/esp32-wi-fi-car-robot-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

#include 
#include 

// Replace with your network credentials
const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create an instance of the WebServer on port 80
WebServer server(80);

// Motor 1
int motor1Pin1 = 27; 
int motor1Pin2 = 26; 
int enable1Pin = 14;

// Motor 2
int motor2Pin1 = 33; 
int motor2Pin2 = 25; 
int enable2Pin = 32;

// Setting PWM properties
const int freq = 30000;
const int resolution = 8;
int dutyCycle = 0;

String valueString = String(0);

void handleRoot() {
  const char html[] PROGMEM = R"rawliteral(
  
  
    
    
    
    
  
  
    
    
FORWARD
    
    
REVERSE
    
Motor Speed: 0
    
  
  )rawliteral";
  server.send(200, "text/html", html);
}

void handleForward() {
  Serial.println("Forward");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, HIGH); 
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, HIGH);
  server.send(200);
}

void handleLeft() {
  Serial.println("Left");
  digitalWrite(motor1Pin1, LOW); 
  digitalWrite(motor1Pin2, LOW); 
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, HIGH);
  server.send(200);
}

void handleStop() {
  Serial.println("Stop");
  digitalWrite(motor1Pin1, LOW); 
  digitalWrite(motor1Pin2, LOW); 
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, LOW);   
  server.send(200);
}

void handleRight() {
  Serial.println("Right");
  digitalWrite(motor1Pin1, LOW); 
  digitalWrite(motor1Pin2, HIGH); 
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, LOW);    
  server.send(200);
}

void handleReverse() {
  Serial.println("Reverse");
  digitalWrite(motor1Pin1, HIGH);
  digitalWrite(motor1Pin2, LOW); 
  digitalWrite(motor2Pin1, HIGH);
  digitalWrite(motor2Pin2, LOW);          
  server.send(200);
}

void handleSpeed() {
  if (server.hasArg("value")) {
    valueString = server.arg("value");
    int value = valueString.toInt();
    if (value == 0) {
      ledcWrite(enable1Pin, 0);
      ledcWrite(enable2Pin, 0);
      digitalWrite(motor1Pin1, LOW); 
      digitalWrite(motor1Pin2, LOW); 
      digitalWrite(motor2Pin1, LOW);
      digitalWrite(motor2Pin2, LOW);   
    } else { 
      dutyCycle = map(value, 25, 100, 200, 255);
      ledcWrite(enable1Pin, dutyCycle);
      ledcWrite(enable2Pin, dutyCycle);
      Serial.println("Motor speed set to " + String(value));
    }
  }
  server.send(200);
}

void setup() {
  Serial.begin(115200);

  // Set the Motor pins as outputs
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  pinMode(motor2Pin1, OUTPUT);
  pinMode(motor2Pin2, OUTPUT);

  // Configure PWM Pins
  ledcAttach(enable1Pin, freq, resolution);
  ledcAttach(enable2Pin, freq, resolution);
    
  // Initialize PWM with 0 duty cycle
  ledcWrite(enable1Pin, 0);
  ledcWrite(enable2Pin, 0);
  
  // Connect to Wi-Fi
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected.");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

  // Define routes
  server.on("/", handleRoot);
  server.on("/forward", handleForward);
  server.on("/left", handleLeft);
  server.on("/stop", handleStop);
  server.on("/right", handleRight);
  server.on("/reverse", handleReverse);
  server.on("/speed", handleSpeed);

  // Start the server
  server.begin();
}

void loop() {
  server.handleClient();
}

Afficher le code brut

Comment fonctionne le code ?

Continuez à lire pour découvrir comment fonctionne le code ou passez à la section Démonstration.

Y compris les bibliothèques

Commencez par inclure les bibliothèques requises. Nous utilisons la bibliothèque WiFi.h pour gérer la connexion Internet et la bibliothèque WebServer.h pour créer le serveur Web. Les deux bibliothèques sont incluses par défaut.

#include 
#include 

Instance de serveur Web

Créez une instance de serveur Web de la bibliothèque WebServer sur le port 80 appelé serveur.

// Create an instance of the WebServer on port 80
WebServer server(80);

Définition de vos informations d’identification réseau

Commencez par saisir vos informations d’identification réseau dans les variables suivantes afin que l’ESP32 puisse se connecter à votre réseau local.

const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = " REPLACE_WITH_YOUR_PASSWORD";

Création de variables pour les broches du pilote de moteur

Ensuite, créez des variables pour les broches d’entrée du moteur et les broches d’activation du moteur. Ces broches sont connectées au pilote de moteur L298N, qui contrôle la direction et la vitesse des moteurs.

// Motor 1
int motor1Pin1 = 27;
int motor1Pin2 = 26;
int enable1Pin = 14;
// Motor 2
int motor2Pin1 = 33;
int motor2Pin2 = 25;
int enable2Pin = 32;

Définition des propriétés PWM

Pour contrôler la vitesse des moteurs, vous enverrez des signaux PWM aux broches d’activation. Définissez les paramètres PWM comme suit :

// Setting PWM properties
const int freq = 30000;
const int resolution = 8;
int dutyCycle = 0;

Lecture recommandée : ESP32 PWM avec Arduino IDE (sortie analogique)

Valeur du curseur

Créez une variable appelée valueString pour maintenir la valeur du curseur afin de contrôler la vitesse du moteur.

String valueString = String(0);

installation()

Dans setup(), vous définissez les broches du moteur comme sorties :

// Set the Motor pins as outputs
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(motor2Pin1, OUTPUT);
pinMode(motor2Pin2, OUTPUT);

Configurez les broches d’activation en tant que sorties PWM avec les propriétés PWM définies précédemment.

// Configure PWM Pins
ledcAttach(enable1Pin, freq, resolution);
ledcAttach(enable2Pin, freq, resolution);

Générez le signal PWM avec un rapport cyclique défini à l’aide de la fonction ledcWrite(). Lorsque le code démarre pour la première fois, nous voulons que les moteurs soient éteints par défaut, nous envoyons donc un rapport cyclique de 0 %.

// Initialize PWM with 0 duty cycle
ledcWrite(enable1Pin, 0);
ledcWrite(enable2Pin, 0);

Le code suivant dans setup() connecte votre ESP32 à votre réseau local et imprime l’adresse IP dans le moniteur série.

// Connect to Wi-Fi network with SSID and password
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();

Contrôler le robot

Chaque action motrice, comme avancer, tourner à gauche, s’arrêter, etc., est gérée par des itinéraires spécifiques. Sur le serveur web, lorsque vous cliquez sur les boutons, il fera différentes requêtes sur différents itinéraires.

// Define routes
server.on("/", handleRoot);
server.on("/forward", handleForward);
server.on("/left", handleLeft);
server.on("/stop", handleStop);
server.on("/right", handleRight);
server.on("/reverse", handleReverse);
server.on("/speed", handleSpeed);

Les fonctions handleForward(), handleLeft(), handleStop(), handleRight() et handleReverse() activeront et désactiveront les GPIO appropriés pour obtenir le résultat souhaité.

void handleForward() {
  Serial.println("Forward");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, HIGH);
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, HIGH);
  server.send(200);
}
void handleLeft() {
  Serial.println("Left");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, LOW);
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, HIGH);
  server.send(200);
}
void handleStop() {
  Serial.println("Stop");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, LOW);
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, LOW);  
  server.send(200);
}
void handleRight() {
  Serial.println("Right");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, HIGH);
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, LOW);   
  server.send(200);
}

void handleReverse() {
  Serial.println("Reverse");
  digitalWrite(motor1Pin1, HIGH);
  digitalWrite(motor1Pin2, LOW);
  digitalWrite(motor2Pin1, HIGH);
  digitalWrite(motor2Pin2, LOW);         

  server.send(200);
}

La combinaison des signaux HAUT et BAS nécessaire pour déplacer le robot dans une direction spécifique a été expliquée précédemment.

Contrôler la vitesse

Pour contrôler la vitesse du moteur à l’aide d’un curseur, la valeur du curseur est envoyée au serveur, qui ajuste le rapport cyclique PWM en conséquence.

Il s’agit de la partie du code javascript qui envoie une requête au serveur avec la valeur actuelle du curseur lorsque vous déplacez le curseur vers une nouvelle position :

function updateMotorSpeed(pos) {
  document.getElementById('motorSpeed').innerHTML = pos;
  fetch(`/speed?value=${pos}`);
}

Il fera une demande au format suivant :

/speed?value=SELECTED_SPEED_VALUE

Sur l’ESP32, sur la fonction handleSpeed(), on commence par récupérer la valeur du slider et on l’enregistre sur la variable value comme suit.

void handleSpeed() {
  if (server.hasArg("value")) {
    valueString = server.arg("value");
    int value = valueString.toInt();

Si la valeur du curseur est nulle, les moteurs sont arrêtés. Nous avons donc réglé le cycle de service sur 0 et toutes les broches du moteur sur FAIBLE.

if (value == 0) {
  ledcWrite(enable1Pin, 0);
  ledcWrite(enable2Pin, 0);
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, LOW);
  digitalWrite(motor2Pin1, LOW);
  digitalWrite(motor2Pin2, LOW);  
}

Sinon, nous réglons la vitesse des moteurs en ajustant le rapport cyclique en tenant compte de la valeur du curseur.

} else {
  dutyCycle = map(value, 25, 100, 200, 255);
  ledcWrite(enable1Pin, dutyCycle);
  ledcWrite(enable2Pin, dutyCycle);
  Serial.println("Motor speed set to " + String(value));
}

Nous calculons le rapport cyclique en fonction de la valeur du curseur à l’aide de la fonction map() (en savoir plus sur la fonction Arduino map()). Dans ce cas, nous avons défini le cycle de service pour qu’il commence à 200, car des valeurs inférieures ne feront pas bouger le robot et les moteurs émettront un bourdonnement étrange, que vous devrez peut-être ajuster en fonction du comportement de vos moteurs.

Affichage de la page Web

La partie suivante du code affiche une page Web avec 5 boutons pour contrôler le moteur et un curseur pour régler la vitesse du moteur. Nous utilisons la fonction javascript fetch() pour effectuer des requêtes lorsqu’un bouton est cliqué.

void handleRoot() {
  const char html[] PROGMEM = R"rawliteral(
  
  
    
    
    
    
  
  
    
    
FORWARD
    
    
REVERSE
    
Motor Speed: 0
    
  
  )rawliteral";
  server.send(200, "text/html", html);
}

boucle()

La ligne suivante dans loop() garantit que l’ESP32 est toujours à l’écoute des demandes client entrantes.

server.handleClient();

Vous pouvez maintenant tester le serveur Web. Assurez-vous d’avoir modifié le code pour inclure vos informations d’identification réseau. N’oubliez pas de vérifier si vous avez sélectionné la bonne carte et le bon port COM. Ensuite, cliquez sur le bouton de téléchargement. Une fois le téléchargement terminé, ouvrez le moniteur série à un débit en bauds de 115 200.

Appuyez sur le bouton ESP32 Enable (EN) et vous obtiendrez l’adresse IP de l’ESP32.

Déconnectez l’ESP32 de votre ordinateur et alimentez-le avec le chargeur portable.

Assurez-vous que les 4 piles AA sont également en place et que l’interrupteur coulissant est allumé. Ouvrez votre navigateur et collez l’adresse IP ESP32 pour accéder au serveur Web. Vous pouvez utiliser n’importe quel appareil doté d’un navigateur au sein de votre réseau local pour contrôler le robot.

Désormais, vous pouvez contrôler votre robot.

Important : Si les moteurs tournent dans le mauvais sens, vous pouvez simplement inverser les fils du moteur. Par exemple, commutez le fil qui va à OUT1 avec OUT2. Ou OUT3 avec OUT4. Cela devrait résoudre votre problème.

Félicitations! Le robot de voiture télécommandé Wi-Fi ESP32 est terminé ! Vous pouvez faire avancer, reculer, droite et gauche votre robot. Vous pouvez l’arrêter en appuyant sur le bouton STOP. Une fonctionnalité intéressante de ce robot est que vous pouvez également régler la vitesse avec le curseur.

Le robot fonctionne plutôt bien et répond instantanément aux commandes.

Conclusion

Maintenant, nous vous encourageons à modifier le robot avec quelques améliorations. Par exemple:

• Ajoutez une LED RVB qui change de couleur en fonction de la direction dans laquelle le robot se déplace ;
• Ajoutez un capteur à ultrasons qui arrête le robot lorsqu’il détecte un obstacle ;

Nous espérons que vous avez eu du plaisir à construire le robot. Voici d’autres projets similaires qui pourraient vous plaire :

Apprenez-en plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :