Dans le kit robot Bionic Spider, vous avez déjà appris comment fonctionne l'araignée bionique et avez déjà réalisé quelques projets avec elle. Plus récemment, le contrôle du robot via une application pour smartphone a été ajouté.

Le contrôle via l'écran tactile n'étant pas particulièrement agréable, cet article de blog présentera une commande alternative avec un joystick.

 

Matériel

Il existe deux versions disponibles en joystick, on peut KY-023 module peut être utilisé. Toutefois, étant donné que beaucoup de câblage serait nécessaire ici, ceci est recommandé Bouclier de manette PS2, qui est également directement connecté à un microcontrôleur Uno La mise en page peut être insérée.

Puisque le microcontrôleur doit communiquer avec le robot, un microcontrôleur doté de la fonctionnalité WiFi est requis. De plus, deux CAN sont nécessaires pour chacun des axes X et Y, c'est pourquoi un ESP32 doit être utilisé ici.

(L'ESP8266 n'a qu'une seule entrée ADC.)

 

Pour réaliser le projet il vous faut :

Noeud ESP32MCU D1 R32

Bouclier de manette PS2

(en option) Pile bloc 9V + Pince à batterie

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

 

Les entrées analogiques des deux axes du joystick se trouvant sur les GPIO 2 et 4, qui sont connectés à l'ADC2, elles ne peuvent pas être utilisées en même temps avec le module WLAN. Les connexions IO 34 et IO35 (ADC1) sont situées directement à côté, de sorte que la fonctionnalité peut être facilement établie à l'aide d'un pont filaire.

Figure 1 : Pont métallique entre les connexions

Connectez les connecteurs comme indiqué ci-dessus.
Puisque la LED embarquée 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 X.

La même chose s'applique à la broche D12, car elle perturbe le processus de démarrage et donc le démarrage avec le blindage connecté ne serait pas possible. Le bouton central du joystick se trouve au niveau de cette connexion, ce qui signifie qu'il ne peut plus être utilisé. Si vous souhaitez quand même l'implémenter, il faut le reconnecter à un port libre.

 

Figure 2 : Bouclier avec modifications

 

Le blindage peut simplement être branché sur le D1 R32. Assurez-vous que le petit interrupteur dans le coin gauche est allumé 3v3 sinon l'ESP32 pourrait être endommagé par la tension excessive de 5V.

Logiciel

Si c'est la première fois que vous programmez un ESP32/ESP8266 dans l'IDE Arduino, copiez les URL suivantes dans l'IDE Arduino sous : Fichier->Préférences->URL du gestionnaire de cartes supplémentaires :  https://dl.espressif.com/dl/package_esp32_index.json

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

 

et installez les packages ESP32 et ESP8266 dans l'administration de la carte.

 

Le protocole ESPNOW, simple à utiliser grâce à la bibliothèque intégrée, est adapté au transfert de données entre les microcontrôleurs.

L'avantage de ce protocole est que les paquets de données peuvent également être transmis sans serveur ni WLAN, ce qui signifie que la communication est possible à n'importe quel endroit et sans matériel supplémentaire.

De plus, les paquets sont envoyés simplement, sans authentification compliquée comme avec le WLAN, ce qui permet une transmission très rapide presque en temps réel.

 

Les adresses matérielles, appelées adresses MAC (Media Access Control), des deux appareils sont nécessaires à la communication. Ceux-ci se trouvent dans une partie protégée de la mémoire et peuvent être clairement attribués à un appareil.

Les colis peuvent être envoyés au bon destinataire via celui-ci.

 

1 Déterminez les adresses MAC

Comme les adresses se trouvent dans une mémoire protégée, elles peuvent également être lues avec un programme court séparé, car cela ne change pas lors de la réécriture de la mémoire.

 

Chargez le programme sur les deux microcontrôleurs :

#ifdef ESP32   #include <WiFi.h> #endif #ifdef ESP8266   #include <ESP8266WiFi.h> #endif void setup() {   WiFi.mode(WIFI_STA);   Serial.begin(115200);   delay(2000);   Serial.println(); } void loop() {   Serial.print("Mac Adress:");   Serial.println(WiFi.macAddress());   delay(5000); }

 

Vous pouvez obtenir le code ici (macAdress.ino) télécharger.

 

Une fois les programmes chargés sur le microcontrôleur, l'adresse MAC correspondante est désormais affichée sur le moniteur série (débit en bauds : 115 200). Notez-les pour le programme suivant.

 

2 contrôleurs de codes

Le module joystick dispose de 6 boutons individuels et d'un joystick à deux axes et d'un bouton intégré.

Afin de garder le projet aussi simple que possible, seul le sens de déplacement ou les boutons enfoncés sont transmis sous forme de chaîne comme suit :

Manette levée : CMD_FWD

Manette vers le bas : CMD_BWD

Joystick à droite : CMD_RGT

Joystick à gauche : CMD_LFT

 

Bouton A : BTN_A

Bouton B : BTN_B

etc....

 

Pour garantir qu'une nouvelle commande ne peut être envoyée que si la précédente a été exécutée, un accusé de réception est envoyé par le destinataire. Ce n'est que lorsque celle-ci a été reçue qu'une nouvelle commande peut être envoyée.
Afin de garantir que la communication ne soit pas complètement bloquée en cas d'erreur, un retour d'information n'est requis qu'après une transmission réussie des données au destinataire. De plus, le statut sera automatiquement réinitialisé après 10 secondes si aucune confirmation n'a été soumise.

 

Code :
Par souci de clarté, seuls des extraits sont présentés ici à titre d’explication. Le code complet peut être téléchargé à la fin.

#define X 34 #define Y 35 #define A 26 #define B 25 #define C 17 #define D 16 #define E 27 #define F 14 uint8_t receiverAddress[] = {0xA4, 0xCF, 0x12, 0xDC, 0xCF, 0x3A}; int calibY, calibX; bool status = true; long sentTime;

Au début, les broches GPIO des axes bouton/joystick respectifs sont définies afin qu'elles puissent être utilisées plus facilement et plus clairement plus tard dans le programme.
L'adresse MAC du récepteur est alors définie ; celui-ci doit être au format hexadécimal affiché avec 0x comme préfixe :
A4:CF:... -> 0xA4, 0xCF,...

Les variables suivantes sont utilisées pour l'étalonnage et le contrôle pour envoyer les commandes uniquement si la précédente a déjà été exécutée.

void onDataRecv(const esp_now_recv_info_t *info, const uint8_t *data, int data_len) {   char dataTemp[data_len];   memcpy(dataTemp, data, data_len);//Copy data bytes in char Array   Serial.println(dataTemp);   if(String(dataTemp).indexOf("RDY") >= 0) {//data contains RDY     Serial.println("RST");     status = true;   } } void onDataSent(const wifi_tx_info_t *tx_info, esp_now_send_status_t sendStatus) {     Serial.print("Sendestatus: ");     Serial.println(sendStatus == ESP_NOW_SEND_SUCCESS ? "Success" : "Error");     if(sendStatus == ESP_NOW_SEND_SUCCESS) {       status = false; //marking sent       sentTime = millis(); //store time for limitation     } }

Ces deux méthodes sont les méthodes de rappel pour la réception et l'envoi via ESPNOW.

Les données reçues de la fonction de réception sont d'abord stockées dans un char Tableau copié afin de vérifier ensuite le contenu du mot-clé. Si ceci est reçu, le statut sera restauré vrai réglé et les commandes peuvent être envoyées à nouveau.

La fonction de rappel d'envoi vérifie l'état de l'envoi et définit la variable d'état faux.faux, afin qu'une commande ne soit pas renvoyée immédiatement après. De plus, la durée d'exécution actuelle du programme est mise en mémoire tampon à l'aide de la fonction millis(), car l'état doit être réinitialisé après 10 secondes.

 

Dans setup() seules les commandes de configuration de la bibliothèque ESPNOW sont appelées, suivies du calibrage des axes du joystick et de la configuration GPIO.

Dans loop() les valeurs des axes du joystick sont mesurées et l'état est réinitialisé au bout de 10 secondes.

La logique suivante évalue la position des axes du joystick :

if(status) {     if(valX < -50 || valY < -50 || valX > 50 || valY > 50) {       Serial.println("trig");       if(abs(valX) > abs(valY)) {         if(valX < 0) {           Serial.println("LEFT");           String msg = "CMD_LFT";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }         else {           Serial.println("Right");           String msg = "CMD_RGT";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }       }       else {         if(valY < 0) {           Serial.println("BWD");           String msg = "CMD_BWD";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }         else {           Serial.println("FWD");           String msg = "CMD_FWD";           esp_now_send(receiverAddress, (uint8_t *)msg.c_str(), msg.length());         }       }     }

Tout d'abord, il est vérifié si les valeurs des axes dépassent une valeur limite de 50. Cela est nécessaire car les potentiomètres par lesquels la position des axes est lue et le convertisseur analogique-numérique (ADC) se déplacent de manière minimale autour de la valeur zéro (appelée dérive), même en position zéro.

Si un axe est au-dessus de la valeur seuil, les valeurs de grandeur des deux axes sont comparées entre elles. De cette façon, il est possible de déterminer l'axe qui a été le plus déplacé et qui est donc indicatif.

Après avoir sélectionné l'axe, il vous suffit de vérifier si la valeur est positive ou négative afin de fournir l'instruction de direction exacte ESPNOW pour pouvoir envoyer.

 

Vous pouvez voir le programme complet ici (Controller.ino) Téléchargez-le et chargez-le sur l'ESP32 en sélectionnant la carte et le port appropriés.

3 robots codeurs

La structure de base et en particulier le ESPNOW Les méthodes de rappel sont presque équivalentes au programme de contrôleur précédent.
La principale différence ici est que dans la méthode de rappel de réception, les données ne sont pas comparées directement mais sont stockées dans une chaîne.

cmd = String(dataTemp);

puis évalué dans loop().

 

Dans setup(), les servomoteurs sont également initialisés et mis en position zéro.

 

L'évaluation suit ensuite dans la boucle() cmd Cordes :

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 = "";     const char* ack = "RDY";     esp_now_send(senderAddress, (uint8_t*)ack, strlen(ack));     Serial.println("ACK gesendet");   }

Si la longueur de la chaîne est supérieure à 0, cela signifie qu'une nouvelle commande a été écrite dans la chaîne. Le contenu est ensuite comparé à nouveau avec la commande correspondante et la fonction correspondante du robot est exécutée.

Après l'évaluation, la confirmation est renvoyée au contrôleur.

 

En particulier, les fonctions des 6 boutons peuvent être attribuées à n'importe quelle fonction du robot.

 

Les méthodes de mouvements du robot bionique se trouvent dans un fichier séparé de la dernière leçon de robot. Tu peux faire ça ici (Commandes.h) Téléchargez-le puis copiez-le dans le répertoire du projet.

 

Vous pouvez voir le programme complet ici (Spider.ino) Téléchargez-le et chargez-le sur l'ESP8266 en sélectionnant la carte et le port appropriés. N'oubliez pas de copier le fichier des mouvements du robot mentionné ci-dessus dans le répertoire

 

Conclusion

Dans cet article de blog, le bouclier du joystick et un ESP32 D1 R32 sont devenus un contrôleur entièrement fonctionnel pour le Araignée bionique construit, qui peut transmettre des commandes au robot via WiFi avec ESPNOW.

Le projet laisse également beaucoup de potentiel pour votre propre refonte, par exemple d'autres commandes peuvent être exécutées à l'aide des boutons individuels, mais des schémas de mouvement programmés peuvent également être exécutés par simple pression sur un bouton.

Amusez-vous à le reproduire :)