Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Manufacturing Technology >> Processus de fabrication

WiDC :Robot FPV contrôlé par Wi-Fi

Composants et fournitures

Arduino UNO
× 1
Espressif ESP8266 ESP-01
× 1
Arduino Proto Shield
× 1
Moteur à courant continu avec roue
× 1
Pont en H
× 1

Applications et services en ligne

Autodesk Fusion 360
Arduino IDE

À propos de ce projet

Et si vous utilisiez un robot télécommandé pour explorer votre environnement, atteindre des endroits inaccessibles, espionner, prendre des photos, faire des films ou diffuser une vidéo ? Ce tutoriel va vous montrer comment faire un objet inestimable pour toutes ces fins !

Ce tutoriel est une amélioration de mon tutoriel précédent (https://www.instructables.com/id/Wi-fi-Controlled-FPV-Rover-Robot-with-Arduino-ESP8/), dans lequel je présente une maison plus rapide- fait robot. Il montre comment concevoir un robot à deux roues télécommandé sur un réseau Wi-Fi, en utilisant deux moteurs à courant continu, un Arduino Uno et un module Wi-Fi ESP8266.

Le robot peut être contrôlé à partir d'un navigateur Internet ordinaire, en utilisant une interface conçue en HTML. Un smartphone Android peut être utilisé pour diffuser de la vidéo et de l'audio du robot vers l'interface de contrôle.

Comme dans mon tutoriel précédent, je montre comment concevoir et construire un cadre à faible coût pour un projet robotique, en utilisant uniquement des outils ordinaires (pas besoin d'imprimante 3D, de découpeuse laser ou de routeur CNC).

On peut remarquer que les composants utilisés ici peuvent ne pas être optimisés pour son objectif. Un NodeMCU peut être utilisé à la place de la combinaison Arduino + ESP8266, par exemple. Un Rapsberry Pi avec un appareil photo remplacerait le smartphone et contrôlerait également les moteurs. Il est même possible d'utiliser un smartphone Android comme "cerveau" de votre robot. C'est vrai...

Ce tutoriel est dérivé d'un autre projet dont je fais partie :Joy Robot (https://hackaday.io/project/12873-rob-da-alegria-joy-robot ou https://www.hackster.io/igorF2/ robo-da-alegria-joy-robot-85e178), et le même matériel a été utilisé ici pour plus de simplicité. Un Arduino Uno a été choisi car il est très accessible et facile à utiliser pour tout le monde, et nous avons voulu concevoir un shield simple pour lui. Dans notre projet d'origine, nous contrôlons également certains servos et matrices LED, et des interfaces avec l'ESP. Le smartphone est en fait remplacé par une tablette, qui exécute également d'autres applications. Vous pouvez trouver d'autres tutoriels liés à ce robot dans les liens ci-dessous :

Contrôler la matrice de matrice LED avec Arduino Uno :

https://www.instructables.com/id/Controlling-a-LED-Matrix-Array-With-Arduino-Uno/

Servomoteurs contrôlés par navigateur Wi-Fi :

https://www.instructables.com/id/Wi-Servo-Wi-fi-Browser-Controlled-Servomotors-with/

Ce guide peut être adapté et avoir sa forme ou son interface de contrôle modifiée pour s'adapter à vos besoins.

Dans cet autre tutoriel, je présente un moyen de contrôler un robot depuis un smartphone en utilisant l'application Blynk ! Vérifiez-le :

https://www.hackster.io/igorF2/wi-fi-controlled-robot-using-wemos-d1-esp8266-and-blynk-464198

Étape 1 : Outils

Les outils suivants ont été utilisés pour la construction de ce prototype :

Outils :

  • Scie à main (pour couper des feuilles acryliques)
  • Tournevis (pour placer les boulons et les écrous)
  • Règle (pour mesurer les dimensions du modèle)
  • Couteau utilitaire (pour découper la structure et faire des trous)
  • Perceuse (utilisée pour percer l'acrylique pour l'installation des vis)
  • Papier de verre (pour lisser les bords rugueux)
  • Fer à souder (pour souder les bornes du moteur)
  • Un ordinateur (pour compiler et télécharger le code Arduino)

Ces outils ont été utilisés pour la production de la structure mécanique du robot, l'assemblage du robot et la connexion des composants électroniques. Certains des outils ne sont pas nécessaires si vous choisissez d'acheter une structure au lieu de construire la vôtre.

Vous pouvez même utiliser d'autres équipements (une imprimante 3D ou une découpeuse laser, par exemple), en fonction des outils disponibles dans votre makerspace.

Étape 2 :Structure mécanique et matériaux

Les matériaux suivants ont été utilisés sur la structure mécanique :

Matériaux mécaniques :

  • Feuille acrylique 2mm
  • Motoréducteur à courant continu avec roue (x2)
  • Roue pivotante de 30 mm (x1)
  • Vis M2 x 10mm (x5)
  • Écrous M2 x 1,5mm (x5)
  • Vis M3 x 10mm (x9)
  • Vis M3 x 10mm (x9)
  • Vis M3 x 40 mm (x4)
  • Écrous M3 x 1,5mm (x12)
  • Vis 5/32" x 1" (x4)
  • Écrous 5/32" (x12)
  • Support de téléphone universel
  • Équerre en acier en forme de "L" (30 x 30 mm) (x4)

Étape 3 : Composants électroniques

Les composants électroniques suivants ont été utilisés dans ce robot :

• Arduino Uno (acheter/acheter)

• ESP8266 (acheter)

• Protoshield (pour une version plus compacte) ou une planche à pain ordinaire (acheter)

• Résistance de 1 kohm (x2)

• Résistance de 10 kohms (x1)

• Motoréducteur à courant continu avec roue (x2) (acheter)

• Module pont en H (achat)

• Quelques cavaliers

• Banque d'alimentation USB 5 V

Vous pouvez trouver tous les composants en ligne facilement sur votre boutique e-commerce préférée.

Comme cela a été souligné dans l'introduction de ce tutoriel, le choix des composants a été dérivé d'un autre projet que j'ai conçu, et peut être optimisé à l'aide d'un autre microcontrôleur, par exemple.

Étape 4 :Conception de la structure

J'ai d'abord dû concevoir la structure mécanique de mon robot. Vous pouvez également acheter la structure complète en ligne si vous ne souhaitez pas créer votre propre structure personnalisée (il existe de nombreux kits robotiques disponibles en ligne). Dans ce cas, vous pouvez passer à l'étape 6. Pour ce didacticiel, un cadre acrylique à faible coût a été conçu pour la fixation des moteurs et autres composants. La structure présentée dans ce didacticiel a été conçue en 3D à l'aide du logiciel de CAO Fusion 360 et construite avec des outils ordinaires (aucune imprimante 3D, découpeuse laser ou routeur CNC nécessaire). Vous pouvez utiliser les mêmes principes décrits ci-dessous pour concevoir une structure personnalisée qui correspond à vos besoins.

J'ai d'abord dû faire un modèle 3D des principaux composants, afin de décider de l'agencement de la structure. Certains d'entre eux ont été téléchargés à partir de la bibliothèque communautaire GrabCAD (https://grabcad.com/library ):

  • Arduino Uno (https://grabcad.com/library/arduino-uno-13)
  • Moteur à engrenages (https://grabcad.com/library/bomotor-1)
  • Pont en H (https://grabcad.com/library/motor-driver-l9110-1)
  • Banque d'alimentation (https://grabcad.com/library/power-bank-7)
  • Support de téléphone universel (https://grabcad.com/library/universal-phone-holder-for-the-gopro-accessories-1)

Les composants électroniques ont été disposés dans un plan, afin que je puisse déterminer l'encombrement nécessaire pour mon robot. Après cela, j'ai dû choisir la position des moteurs et des roues pour créer une structure stable.

Sur la base de ces positions, la structure principale a été conçue, qui est composée de trois plaques (une plaque de base et deux plaques latérales) qui sont reliées à l'aide de supports.

base.pdf base.svg

Étape 5 : Construire et assembler la structure

La construction de la structure de la base est divisée en les étapes suivantes :1. Découpez la base acrylique selon les dimensions du dessin 2D : Cela peut être fait avec un cutter laser (si vous en avez un) ou, comme dans mon cas, avec des outils ordinaires.

Vous devrez d'abord transférer les dimensions de votre modèle sur la feuille acrylique. Imprimez votre dessin 2D à l'aide d'une imprimante ordinaire sur un papier adhésif, puis découpez le papier aux dimensions appropriées et appliquez ce masque sur la surface de l'acrylique.Avec un cutter et à l'aide d'une règle ou d'une échelle, découpez l'acrylique en lignes droites. Vous n'aurez pas besoin de couper tout le long de la feuille, il suffit de la marquer pour créer des pistes où la pièce sera ensuite coupée. Placez l'acrylique sur une surface plane, maintenez-le en place avec des pinces et appliquez une certaine pression jusqu'à ce que la feuille se brise en deux. Répétez ce processus jusqu'à ce que toutes les coupes soient faites. Après cela, vous pouvez utiliser un papier de verre pour lisser les bords rugueux. Vous pouvez également utiliser une scie à main pour couper l'acrylique.2. Percez les trous dans les positions indiquées sur le dessin 2D : Percez les trous dans les positions indiquées sur le dessin 2D (indiqué dans le masque) avec une perceuse. L'acrylique est relativement facile à percer. Donc, si vous ne disposez pas d'une perceuse, vous pouvez percer les trous manuellement avec un outil tranchant, comme un couteau universel. Vous pouvez également l'utiliser pour agrandir de petits trous pour s'adapter à la taille des vis. Retirez le masque et votre base sera prête.

3. Montez les composants avec des vis et des écrous selon le dessin 3D : Montez les composants avec des vis et des écrous selon la vidéo, et votre structure sera prête à fonctionner. Des vis M3 sont utilisées pour l'installation des supports et des moteurs à courant continu. Les vis M2 ont été utilisées pour l'installation des composants électroniques, tandis que celles de 5/32" sont utilisées pour l'installation de la roue avant et du clip du smartphone. Maintenant, faites une pause et commencez à assembler le circuit à l'étape suivante...

base.pdf

Étape 6 :Assemblage de l'électronique

Le circuit proposé ici utilise un Arduino Uno comme contrôleur principal, qui s'interface avec un ESP8266 pour la communication Wi-Fi. L'Arduino contrôle les moteurs à courant continu à l'aide d'un circuit de commande H-brige, capable de contrôler jusqu'à deux moteurs, tournant indépendamment dans les deux sens.

Une banque d'alimentation a été utilisée pour alimenter l'électronique, connectée directement au port USB d'Arduino. C'est un moyen simple d'alimenter votre Arduino :facile à charger, peut être facilement remplacé et fournit une tension sûre de 5 V.

Connectez tous les composants selon le schéma. Vous aurez besoin de câbles de connexion pour connecter le module ESP8266, qui n'est pas compatible avec les protoboards, les moteurs à pont en H et à courant continu. Vous pouvez utiliser un protoshield (pour un circuit plus compact), une planche à pain ordinaire ou concevoir votre propre shield Arduino.

Vous remarquerez que l'ESP8266-1 n'est pas compatible avec les maquettes. Il sera connecté à l'aide de fils de liaison, mais il ne sera pas attaché à la structure.

Branchez un câble USB sur la carte Arduino et passez à l'étape suivante.

wiDC_Esquem_C3_A1tico.pdf wiDC.fzz wiDC_bb.pdf

Étape 7 : Code Arduino

Installez le dernier IDE Arduino. Aucune bibliothèque n'était nécessaire pour la communication avec le module ESP-8266 ou le contrôle des moteurs.Veuillez vérifier le débit en bauds de votre ESP8266 et le définir correctement dans le code.Téléchargez le code Arduino (WiDC.ino) et remplacez le XXXXX par votre routeur wifi SSID et AAAA par mot de passe du routeur. Connectez la carte Arduino au port USB de votre ordinateur et téléchargez le code.

Branchez un câble USB sur la carte Arduino et passez à l'étape suivante.

//include library#include SoftwareSerial esp8266(3, 2); //Broche RX =3, broche TX =2//définition des variables#define DEBUG true //afficher les messages entre ESP8266 et Arduino dans l'état de portint série =5; //définir l'état initial du robot (5 =stand-by)//définir les broches du moteurconst int motor1Pin1 =5;const int motor1Pin2 =6;const int motor2Pin1 =9;const int motor2Pin2 =10;//définir la vitesse du moteurint motorSpeed ​​=150 ; //vitesse du moteur (PWM)//*****//SETUP//*****void setup(){ //définir les modes de broche pinMode(motor1Pin1, OUTPUT); pinMode(motor1Pin2, OUTPUT); pinMode(motor2Pin1, OUTPUT); pinMode(motor2Pin2, OUTPUT); //démarrer la communication Serial.begin(9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); //réinitialiser le module sendData("AT+CWMODE=1\r\n", 1000, DEBUG); //définir le mode de la station sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); //connectez le réseau wi-fi (remplacez XXXXX par le SSID de votre routeur Wi-Fi et YYYYY par son délai de mot de passe (5000); //attendez la connexion sendData("AT+CIFSR\r\n", 1000, DEBUG); / /show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //autoriser plusieurs connexions sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); / / démarrer le serveur web sur le port 80}//*********//MAIN LOOP//*********void loop(){ if (esp8266.available()) //verify données entrantes { if (esp8266.find("+IPD,")) // s'il y a un message { String msg; esp8266.find("?"); //recherche le message msg =esp8266.readStringUntil(' ' ); // lire tout le message String command =msg.substring (0, 3); // 3 premiers caractères =commande Serial.println (commande); // avancer if (commande =="cm1") { état =1; } //recule if(commande =="cm2") { état =2; } //tourne à droite if(commande =="cm3") { état =3; } //tourne à gauche if(commande ==" cm4") { état =4; } //ne rien faire if(commande =="cm5") { état =5; } } } //ÉTAT 1 :avancer si (état ==1) { analogWrite(m otor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //ÉTAT 2:recule if (état ==2) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //ÉTAT 3 :déplacez-vous vers la droite if (état ==3) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //ÉTAT 4 :déplacez-vous vers la gauche if (état ==4) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //ÉTAT 5 :ne rien faire si (état ==5) { digitalWrite(motor1Pin1, LOW); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); digitalWrite(motor2Pin2, LOW); } }//*******************//Fonctions auxiliaires//*******************Chaîne sendData (Commande de chaîne, délai d'attente const int, débogage booléen){ Réponse de chaîne ="" ; esp8266.print(commande); long int temps =millis(); while ( (temps + délai d'attente)> millis()) { while (esp8266.available()) { char c =esp8266.read(); réponse +=c; } } if (debug) { Serial.print(response); } renvoyer la réponse ;}  

Code expliqué :

Le code utilise un port série pour la communication entre l'Arduino et l'ESP8266, et un autre pour la communication entre l'Arduino et un ordinateur. Une fois que l'Arduino Uno n'avait qu'un seul port série, la bibliothèque SoftwareSeial a été utilisée pour créer un port secondaire, en utilisant les broches numériques 2 et 3.

//include library#include SoftwareSerial esp8266(3, 2); //Broche RX =3, broche TX =2 

Pendant la configuration, les deux communications série doivent être démarrées et leur vitesse de transmission définie (une entre l'Arduino et votre moniteur série, et l'autre pour correspondre à la vitesse ESP8266). Notez que mon ESP8266 était réglé sur 9600 kbps. Par défaut, la plupart de ces modules ont une vitesse de 115 200 kbps, mais la bibliothèque SoftwareSerial ne peut pas fonctionner à cette vitesse et vous devrez modifier sa vitesse de transmission. Pour moi, 9600 kbps ont bien fonctionné.

Dans ce projet, je n'ai pas utilisé de bibliothèque spécifique pour la communication avec le module Wi-Fi. Au lieu de cela, seules les commandes AT ordinaires suivantes (un ensemble d'instructions définies sur le firmware par défaut ESP8266) ont été utilisées :

  • AT+RST :réinitialiser le module ESP8266
  • AT+CWMODE :mettre le module en mode station ou point d'accès
  • AT+CWJAP :connecter un réseau Wi-Fi donné par son SSID et son mot de passe
  • AT+CIPMUX :définir le module pour plusieurs connexions ou une seule connexion
  • AT+CIPSERVER :démarre le serveur Web sur un port donné //lance la communication
 Serial.begin(9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); //réinitialiser le module sendData("AT+CWMODE=1\r\n", 1000, DEBUG); //définir le mode de la station sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); //connectez le réseau wi-fi (remplacez XXXXX par le SSID de votre routeur Wi-Fi et YYYYY par son délai de mot de passe (5000); //attendez la connexion sendData("AT+CIFSR\r\n", 1000, DEBUG); / /show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //autoriser plusieurs connexions sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); / / démarrer le serveur web sur le port 80 

Une fonction auxiliaire (sendData) est utilisée pour envoyer des données (d'Arduino à ESP8266), lire et afficher la réponse sur Serial Monitor.

String sendData(String command, const int timeout, boolean debug){ String response ="" ; esp8266.print(commande); long int temps =millis(); while ( (temps + délai d'attente)> millis()) { while (esp8266.available()) { char c =esp8266.read(); réponse +=c; } } if (debug) { Serial.print(response); } renvoyer la réponse ;} 

L'utilisation du code ci-dessus permet à l'Arduino de réinitialiser le module, de rejoindre un réseau, d'attendre la connexion, puis d'afficher son adresse IP et de démarrer un serveur Web. Après cela, la boucle principale sera lancée et le microcontrôleur attendra les commandes.

void loop(){ if (esp8266.available()) //vérifier les données entrantes { if (esp8266.find("+IPD,")) //s'il y a un message { String msg; esp8266.find("?"); // recherchez le message msg =esp8266.readStringUntil(' '); //lire tout le message String command =msg.substring(0, 3); //les 3 premiers caractères =commande Serial.println(commande); // avance if(commande =="cm1") { état =1; } //recule if(commande =="cm2") { state =2; } //tourner à droite if(commande =="cm3") { état =3; } //tourner à gauche if(commande =="cm4") { état =4; } //ne rien faire if(commande =="cm5") { état =5; } } } 

Cinq commandes possibles ont été définies (cm1 à cm5). Chaque fois que l'Arduino reçoit l'une de ces commandes, il entre dans l'un des cinq états possibles (avancer, reculer, aller à droite, aller à gauche et rester en veille) et continuer dans cet état jusqu'à ce qu'il reçoive une commande différente.

Chaque état définit les signaux pour les broches des moteurs. J'ai utilisé digitalWrite(pin, LOW) quand je voulais régler une broche sur 0V et analogWrite(pin, motoSpeed) quand je voulais activer une broche. L'utilisation d'analogWrite m'a permis de modifier la vitesse du moteur et de ralentir le mouvement du robot.

//STATE 1 :avancer si (état ==1) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //ÉTAT 2:recule if (état ==2) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //ÉTAT 3 :déplacez-vous vers la droite if (état ==3) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //ÉTAT 4 :déplacez-vous vers la gauche if (état ==4) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //ÉTAT 5 :ne rien faire si (état ==5) { digitalWrite(motor1Pin1, LOW); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); digitalWrite(motor2Pin2, LOW); } 

Notez que les moteurs fonctionnent entre 3 et 6V. Une fois qu'une source d'alimentation 5V est utilisée, vous pouvez moduler la tension moyenne des moteurs (en utilisant PWM) entre 3 et 5V, modifiant ainsi sa vitesse. Cela ne vous permettra pas de contrôler finement la .vitesse du robot

WiDC.ino

Étape 8 :Interface de contrôle Web

Une interface html a été conçue pour le contrôle du robot.Télécharger interface.rar et extraire tous les fichiers dans un dossier donné. Ensuite, ouvrez-le sur Firefox. Un formulaire de zone de texte est utilisé dans cette interface pour saisir les adresses IP du module ESP et du serveur vidéo/audio (à partir de l'application Android IP Webcam). Il y a un test mais, qui fera tourner le robot jusqu'à ce qu'une autre commande soit reçue. Les touches fléchées du clavier sont utilisées pour déplacer le robot vers l'avant ou vers l'arrière, et pour le faire pivoter à gauche ou à droite. Un smartphone Android a été utilisé pour diffuser la vidéo et l'audio du robot vers l'interface de contrôle. Vous pouvez trouver l'application sur Google Play Store (https://play.google.com/store/apps/details?id=com.pas.webcam). Installez-la et passez à l'étape suivante.

Code HTML expliqué :

L'interface html comporte deux divisions :une pour l'audio et la vidéo (à partir du serveur Android IP Webcam) et une pour les commandes.

La division audio et vidéo a un formulaire avec une zone de texte un bouton. Ceci est utilisé comme entrée pour spécifier l'adresse IP du serveur de webcam et la charger. Il est livré avec une adresse IP standard (192.168.0.5), mais l'utilisateur peut saisir une adresse IP différente. La vidéo et l'audio sont chargés dans des objets sous la zone de texte.

IP Webcam ( IP) :

L'autre division a une autre forme avec une zone de texte, afin que l'utilisateur puisse informer son adresse IP ESP8266.

Adresse IP Arduino :

Appuyez et maintenez les touches fléchées du clavier pour déplacer le robot

JavaScript est utilisé pour gérer l'interface et envoyer des données à l'Arduino. Ces scripts sont codés dans différents fichiers, et ajoutés sur l'en-tête html.

   Interface de contrôle   

Javascript expliqué :

Une fonction (readUrlAV) permet de lire l'adresse IP depuis le formulaire html et de la charger dans des objets "vidéo" et "audio".

function readUrlAV (form) { TextVar =form.inputbox.value; VideoVar ="http://"+TextVar+":8080/video" ; AudioVar ="http://"+TextVar+":8080/audio.opus" ; document.getElementById("vidéo").setAttribute('données', VideoVar); document.getElementById("audio").setAttribute('data', AudioVar);} 

Le script lit périodiquement le clavier, en attendant que l'utilisateur appuie sur n'importe quelle touche. Si l'utilisateur appuie sur n'importe quelle touche fléchée (gauche ='37', haut ='38', droite ='39' ou 'bas' =40), il envoie une commande ("cm1" à "cm4") pour une IP donnée adresse. Notez qu'il existe une fonction de verrouillage, qui évite de répéter indéfiniment la même commande. Les données ne seront transférées que lorsque la touche est enfoncée.

var latch =false;document.onkeydown =checkKeyDown;function checkKeyDown(e) { e =e || fenêtre.événement; if (e.keyCode =='38') { // flèche vers le haut if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80" ; $.get( ArduinoVar, { "cm1":1000 }) ; {Connexion :fermer} ; verrou =vrai ; } } else if (e.keyCode =='40') { // flèche vers le bas if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80" ; $.get( ArduinoVar, { "cm2":1000 }) ; {Connexion :fermer} ; verrou =vrai ; } } else if (e.keyCode =='37') { // flèche gauche if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80" ; $.get( ArduinoVar, { "cm3":1000 }); {Connection:close}; latch =true; } } else if (e.keyCode =='39') { // right arrow if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm4":1000 }); {Connection:close}; latch =true; } }} 

When any arrow key is released, doNothing function is executed, which sends command "cm5" (stop the motors), and resets the latch, allowing interface to send differente commands.

document.onkeyup =checkKeyUp;function checkKeyUp(e) { e =e || fenêtre.événement; if ((e.keyCode =='38')||(e.keyCode =='40')||(e.keyCode =='37')||(e.keyCode =='39')) { setTimeout(doNothing, 200); }}function doNothing(){ TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm5":1000 }); {Connection:close}; latch =false;}  
interface.rar

Step 9:Usage

When the Arduino is restarted, it will try to connect your wi-fi network automatically. Use the Serial Monitor to check if the connection was successfull, and to obtain which IP was assigned to your ESP-8266 by your router. Open the html file in an internet browser (Firefox) and inform this IP address in the textbox.You might also user other means to find out which IP address you router assigned to your device. Disconnect the the Arduino Uno from your computer and connect it to the power bank. Wait for it to connect again. Launch IP Webcam app in the smartphone attached to the robot. Type the video/audio IP on your control interface and connect to the server and you'll be ready to go. You might need to reduce the resolution of the video in the app to reduce the delay between during the transmission. Click and hold the arrow buttons of your keyboar to rotate the robot or move it forward/backward and have fun exploring your environment.

Notice that robot runs on open loop. This way, it's quite difficult to make it move straight forward. Small difference between the motors, aligment, etc. will cause cumulative deviations.

The robot start moving when it receives a given command ("cm1" to "cm4"), and keep that state until a different command is received ("cm1" to "cm5"). Sometimes the ESP8266 loses some messages, and that might cause some trouble. If, for instance, a "cm5" command is lost, the robot will keed moving even after any arrow key was released. I'm still dealing with this problem. Feel free to change the way the commands are interpreted to avoid this kind of problem.

Code

  • Code Arduino
  • Interface
Code ArduinoArduino
//include libraries#include SoftwareSerial esp8266(3, 2); //RX pin =3, TX pin =2//definition of variables#define DEBUG true //show messages between ESP8266 and Arduino in serial portint state =5; //define initial state of the robot (5 =stand-by)//define motor pinsconst int motor1Pin1 =5;const int motor1Pin2 =6;const int motor2Pin1 =9;const int motor2Pin2 =10;//define motor speedint motorSpeed =150; //motor speed (PWM)//*****//SETUP//*****void setup(){ //set pin modes pinMode(motor1Pin1, OUTPUT); pinMode(motor1Pin2, OUTPUT); pinMode(motor2Pin1, OUTPUT); pinMode(motor2Pin2, OUTPUT); //start communication Serial.begin(9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); //reset module sendData("AT+CWMODE=1\r\n", 1000, DEBUG); //set station mode sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); //connect wi-fi network (replace XXXXX by your Wi-Fi router SSID and YYYYY by its password delay(5000); //wait for connection sendData("AT+CIFSR\r\n", 1000, DEBUG); //show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //allow multiple connections sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // start web server on port 80}//*********//MAIN LOOP//*********void loop(){ if (esp8266.available()) //verify incoming data { if (esp8266.find("+IPD,")) //if there is a message { String msg; esp8266.find("?"); //look for the message msg =esp8266.readStringUntil(' '); //read whole message String command =msg.substring(0, 3); //first 3 characters =command Serial.println(command); //move forward if(command =="cm1") { state =1; } //move backward if(command =="cm2") { state =2; } //turn right if(command =="cm3") { state =3; } //turn left if(command =="cm4") { state =4; } //do nothing if(command =="cm5") { state =5; } } } //STATE 1:move forward if (state ==1) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //STATE 2:move backward if (state ==2) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //STATE 3:move right if (state ==3) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //STATE 4:move left if (state ==4) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //STATE 5:do nothing if (state ==5) { digitalWrite(motor1Pin1, LOW); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); digitalWrite(motor2Pin2, LOW); } }//*******************//Auxiliary functions//*******************String sendData(String command, const int timeout, boolean debug){ String response =""; esp8266.print(command); long int time =millis(); while ( (time + timeout)> millis()) { while (esp8266.available()) { char c =esp8266.read(); response +=c; } } if (debug) { Serial.print(response); } return response;}
InterfaceHTML
Aucun aperçu (téléchargement uniquement).

Pièces et boîtiers personnalisés

base_7JLgOpcox6.svg

Schémas


Processus de fabrication

  1. Robot Raspberry Pi contrôlé par Bluetooth
  2. Dés numériques Arduino
  3. Contrôleur de jeu Arduino
  4. Robot suiveur de ligne
  5. Robot à commande vocale
  6. MobBob :Robot Arduino DIY contrôlé par smartphone Android
  7. Jeu Pixel Chaser
  8. Lévitation électromagnétique répulsive Arduino
  9. Robot piano contrôlé par Arduino :PiBot