Dans le dernier article de blog, l'araignée bionique a été contrôlée à l'aide d'un contrôleur artisanal via le protocole ESPNOW.

Cela permet une connexion simple d'appareil à appareil, sans qu'il soit nécessaire de les connecter à un réseau.

Dans ce blog, nous utilisons le protocole Internet UDP pour échanger les paquets de données entre les microcontrôleurs. Pour cela, la télécommande et l'araignée doivent se trouver sur le même réseau.

Mais cette petite restriction a aussi l'avantage que la portée avec les répéteurs et les points d'accès de votre réseau domestique est la plupart du temps plus large et plus étendue et qu'il est ainsi possible d'établir une connexion même sur une distance plus longue que la portée visuelle.

 

Matériel informatique

Si vous avez déjà installé le contrôleur dans le Blog de Spider Controller vous pouvez sauter la partie suivante et continuer avec le logiciel.

 

Deux versions sont disponibles comme joystick, d'une part le KY-023 module peut être utilisé. Mais comme cela nécessiterait à nouveau un certain câblage, il est recommandé d'utiliser le Bouclier de joystick PS2qui peut aussi être utilisé directement sur un microcontrôleur avec Uno de la mise en page.

Comme le microcontrôleur doit communiquer avec le robot, un microcontrôleur avec fonctionnalité WiFi est nécessaire. En outre, deux CAN sont nécessaires pour les axes X et Y, c'est pourquoi un ESP32 doit être utilisé.

(Le ESP8266 ne dispose que d'une entrée ADC).

 

Pour la réalisation du projet, vous avez besoin de

ESP32 NodeMCU D1 R32

Bouclier de joystick PS2

(en option) pile monobloc 9V + Clip de batterie

et bien sûr un assemblé Kit robot araignée bionique

 

Comme les entrées analogiques des deux axes du joystick sont connectées aux GPIO 2 et 4, qui sont reliés au CAN2, elles ne peuvent pas être utilisées simultanément avec le module WLAN. Les connexions IO 34 et IO35 (ADC1) se trouvent cependant directement à côté de celles-ci, ce qui permet d'établir très facilement la fonctionnalité via un pont de fil.

Figure 1 : Pont de fil entre les connexions

 

Reliez les connecteurs comme indiqué ci-dessus.

Comme la LED on-board est connectée au GPIO 2, la broche doit être retirée ici, sinon la connexion influencerait la valeur de la tension de l'axe des X.

Il en va de même pour la broche D12, car elle perturbe le processus de boot et ne permettrait donc pas de booter avec le shield enfiché. Le bouton-poussoir central du joystick se trouve sur cette connexion, il n'est donc plus utilisable. Si vous souhaitez tout de même l'implémenter, il doit être à nouveau relié à un port libre.

 

Figure 2 : Bouclier avec modifications

 

Le shield peut être facilement enfiché sur le D1 R32. Veillez à ce que le petit interrupteur dans le coin gauche soit positionné sur 3v3 sinon l'ESP32 pourrait être endommagé par une tension trop élevée de 5V.

 

Logiciel

Si c'est la première fois que vous programmez un ESP32/ESP8266 dans l'IDE Arduino, copiez les URLs suivantes dans l'IDE Arduino sous : File->Preferences->Additional boards manager URLs :  https://dl.espressif.com/dl/package_esp32_index.json

http://arduino.esp8266.com/stable/package_esp8266com_index.json

 

et installez le paquet ESP32 et ESP8266 dans la gestion de la carte.

 

Pour la communication, les paquets de données sont échangés via UDP. Avec ce protocole de communication, les paquets sont simplement envoyés sans savoir si le paquet a été reçu.

De ce fait, l'échange de données est certes très rapide, mais aussi peu sûr, car il n'est pas possible de déterminer si le destinataire a effectivement reçu les données.

 

La bibliothèque pour la communication UDP est déjà incluse dans les paquets de carte complets pour le ESP8266 et le ESP32.

 

Dans le blog ESPnow, l'adresse MAC des microcontrôleurs était nécessaire pour la communication.
Lors de la communication via UDP, seule l'adresse IP du récepteur est nécessaire. Celle-ci est attribuée automatiquement par le serveur DHCP du routeur lors de la connexion au réseau domestique (WLAN).
L'adresse IP peut être déterminée soit via l'interface utilisateur de votre routeur, mais elle est également affichée sur le moniteur série au début du programme du récepteur.

 

Code bionic Spider

Chargez le code suivant sur le ESP8266 du kit Bionic Spider en choisissant le bon port et la bonne carte dans l'IDE Arduino.

 

#include <ESP8266WiFi.h> #include <WiFiUdp.h> #include "commands.h" const char* ssid = "Name"; const char* password = "PSWD"; String cmd; //recieved Command WiFiUDP udp; void setup() {   Serial.begin(115200);   Serial.println();   WiFi.begin(ssid, password);   while (WiFi.status() != WL_CONNECTED) {     delay(500);     Serial.print(".");     if(millis() > 30000) ESP.restart();   }   udp.begin(4210);   Serial.println("ESP8266 ready (Reciever)");   Serial.print("IP:");   Serial.println(WiFi.localIP());   servo_14.attach(14, SERVOMIN, SERVOMAX);// Connect the servo to pin 14   servo_12.attach(12, SERVOMIN, SERVOMAX);// Connect the servo to pin 12   servo_13.attach(13, SERVOMIN, SERVOMAX);// Connect the servo to pin 13   servo_15.attach(15, SERVOMIN, SERVOMAX);// Connect the servo to pin 15   servo_16.attach(16, SERVOMIN, SERVOMAX);// Connect the servo to pin 16   servo_5.attach(5, SERVOMIN, SERVOMAX);// Connect the servo to pin 5   servo_4.attach(4, SERVOMIN, SERVOMAX);// Connect the servo to pin 4   servo_2.attach(2, SERVOMIN, SERVOMAX);// Connect the servo to pin 2   Servo_PROGRAM_Zero();// Reset the servo program to zero } void loop() {   //Serial.print("IP:");   //Serial.println(WiFi.localIP());   int pSize = udp.parsePacket();   if (pSize) {     char buf[20];     int len = udp.read(buf, 20);     buf[len] = 0;     cmd = String(buf);     Serial.println(cmd);   }   if(cmd.length() > 0) {     if(cmd.indexOf("CMD_FWD") >= 0) {       Serial.println("FWD");       forward();     }     else if(cmd.indexOf("CMD_BWD") >= 0) {       Serial.println("BWD");       back();     }     else if(cmd.indexOf("CMD_RGT") >= 0) {       Serial.println("RGT");       rightmove();     }     else if(cmd.indexOf("CMD_LFT") >= 0) {       Serial.println("LFT");       leftmove();     }     else if(cmd.indexOf("BTN_A") >= 0) {       Serial.println("A");       dance1();     }     else if(cmd.indexOf("BTN_B") >= 0) {       Serial.println("B");       dance2();     }     else if(cmd.indexOf("BTN_C") >= 0) {       Serial.println("C");       hello();     }     else if(cmd.indexOf("BTN_D") >= 0) {       Serial.println("D");       pushup();     }     else if(cmd.indexOf("BTN_E") >= 0) {       Serial.println("D");       turnright();     }     else if(cmd.indexOf("BTN_F") >= 0) {       Serial.println("D");       turnleft();     }     cmd = "";     // send ready to controller to recieve new commands     udp.beginPacket(udp.remoteIP(), udp.remotePort());     udp.print("RDY");     udp.endPacket();     Serial.println("ACK gesendet");   }   }

Explication :

Pour commencer, les bibliothèques nécessaires sont intégrées. Le fichier commands.h avec les déroulements des mouvements se trouvent avec le code dans le téléchargement à la fin de la section.

Ensuite, les données d'accès WLAN sont définies et une variable est déclarée pour la commande reçue. L'objet pour la bibliothèque UDP est également créé.

Dans setup(), le microcontrôleur est connecté au WLAN et les différents servomoteurs sont initialisés.

Dans loop(), les paquets de données entrants sont envoyés par l'émetteur dans le cmd chaîne de caractères. Celle-ci est ensuite évaluée par les requêtes if et la commande correspondante est exécutée. Une fois la commande exécutée, une confirmation est renvoyée au contrôleur.

 

Vous pouvez télécharger le code complet ici télécharger.
Dans le programme, saisissez vos données d'accès WLAN à la place des caractères génériques.

 

Après le téléchargement sur le microcontrôleur, ouvrez le moniteur série et notez l'adresse IP qui s'affiche.
Si celle-ci n'est pas affichée au début, vous pouvez utiliser les deux lignes du début dans loop() pour la sortie.

 

Contrôleur de code

 

#include <WiFi.h> #include <esp_wifi.h> #include <WiFiUdp.h> #define X 34 #define Y 35 #define A 26 #define B 25 #define C 17 #define D 16 #define E 27 #define F 14 const char* ssid = "name"; const char* password = "pswd"; const char* rcvIP = "192.168.178.xxx"; int calibY, calibX; bool status = true; long sentTime; String msg; WiFiUDP udp; void setup() {   Serial.begin(115200);   delay(2000);   WiFi.begin(ssid, password);   while (WiFi.status() != WL_CONNECTED) {     delay(500);     Serial.print(".");     if(millis() > 7000) ESP.restart();   }   Serial.println("ESP32 ready (Controller)");   calibX = analogRead(X); //calibrating current Position to zero   calibY = analogRead(Y);   pinMode(A, INPUT_PULLUP);   pinMode(B, INPUT_PULLUP);   pinMode(C, INPUT_PULLUP);   pinMode(D, INPUT_PULLUP);   pinMode(E, INPUT_PULLUP);   pinMode(F, INPUT_PULLUP); } void loop() {   int valX = analogRead(X) - calibX;   int valY = analogRead(Y) - calibY;   //Serial.println(valX);   //Serial.println(valY); //no acknowledgement recieved after 10 sec. -> set marker to true; reenable sending   if((millis() - sentTime) > 10000) {     status = true;   }   if(status) {     //threshold values     if(valX < -50 || valY < -50 || valX > 50 || valY > 50) {       Serial.println("trig");       //choose dominant coordinate       if(abs(valX) > abs(valY)) {         if(valX < 0) {           Serial.println("LEFT");           msg = "CMD_LFT";         }         else {           Serial.println("Right");           msg = "CMD_RGT";         }       }       else {         if(valY < 0) {           Serial.println("BWD");           msg = "CMD_BWD";         }         else {           Serial.println("FWD");           msg = "CMD_FWD";         }       }       status = false; //marking sent       sentTime = millis(); //store time for limitation     }     //check buttons     else {       if(!digitalRead(A)) {         Serial.println("A");         msg = "BTN_A";         status = false; //marking sent         sentTime = millis(); //store time for limitation       }       else if(!digitalRead(B)) {         Serial.println("B");         msg = "BTN_B";         status = false; //marking sent         sentTime = millis(); //store time for limitation       }       else if(!digitalRead(C)) {         Serial.println("C");         msg = "BTN_C";         status = false; //marking sent         sentTime = millis(); //store time for limitation       }       else if(!digitalRead(D)) {         Serial.println("D");         msg = "BTN_D";         status = false; //marking sent         sentTime = millis(); //store time for limitation       }       else if(!digitalRead(E)) {         Serial.println("E");         msg = "BTN_E";         status = false; //marking sent         sentTime = millis(); //store time for limitation       }       else if(!digitalRead(F)) {         Serial.println("F");         msg = "BTN_F";         status = false; //marking sent         sentTime = millis(); //store time for limitation       }           }     udp.beginPacket(rcvIP, 4210);     udp.print(msg);     udp.endPacket();     msg = "";   }     int pSize = udp.parsePacket();   if (pSize) {     char buf[20];     int len = udp.read(buf, 20);     buf[len] = 0; //termination     if (String(buf) == "RDY") {       status = true;       Serial.println("ACK");           }   }   delay(100); }

Explication :

Pour commencer, les bibliothèques nécessaires sont intégrées, des macros sont créées pour les broches des différents boutons et les données d'accès WLAN et l'adresse IP du récepteur sont déclarées. Ensuite, les variables globales pour le calibrage des axes du joystick, la commande à envoyer et la conversion du message de confirmation sont déclarées.

Dans setup(), le microcontrôleur est connecté au WLAN, les axes du joystick sont calibrés et les entrées numériques sont définies.

Dans loop(), la position du joystick est d'abord lue comme valeur analogique et enregistrée dans les variables correspondantes.

Il s'ensuit une vérification par laquelle l'état de l'envoi est réinitialisé après un délai de 10 secondes.

L'algorithme d'évaluation pour la direction du mouvement vérifie si les valeurs des axes dépassent une valeur limite de 50, ce qui est nécessaire car tant les potentiomètres, par lesquels la position des axes est lue, que les convertisseurs analogique-numérique (CAN) se déplacent au minimum autour de la valeur zéro, même dans la position zéro (ce qu'on appelle la dérive).

Si un axe se trouve au-dessus de la valeur seuil, les valeurs de l'amplitude des deux axes sont comparées. Cela permet de déterminer l'axe qui a été le plus déplacé et qui est donc directif.

En outre, les entrées numériques sont encore lues et, lorsqu'un bouton est pressé, l'instruction correspondante (désignation du bouton) est enregistrée dans la variable msg.

Enfin, la commande est envoyée au robot sous forme de paquet UDP.

Lorsque le récepteur a exécuté la commande, il renvoie un accusé de réception à l'émetteur. Si celle-ci est reçue, la variable état de nouveau sur true ce qui permet une nouvelle transmission.

 

Vous pouvez consulter le programme complet ici télécharger.

Téléchargez-le avec les données d'accès WLAN et l'adresse IP correctes sur l'ESP32 D1 R32 en sélectionnant le bon port.

 

Conclusion

Dans cet article de blog, vous avez appris comment le robot bionique Spider peut être piloté au moyen du protocole de communication UDP.

Bien entendu, ce projet ne fait que poser les bases de vos propres extensions et modifications. Par exemple, pour ne pas dépendre d'un routeur externe, vous pouvez faire fonctionner un microcontrôleur en mode AP.

Ainsi, vous avez appris à connaître, outre le protocole de communication ESPnow propre à ESP, un protocole très répandu avec UDP qui est utilisé dans de nombreuses applications à temps critique.

 

Amuse-toi bien à les reproduire :)