Robot Arduino avec manette PS2 (Joystick PlayStation 2)

Une fois l'objet défini, il doit être lié aux broches d'E/S de l'Arduino à l'aide de la fonction suivante :

error =ps2x.config_gamepad(horloge, commande, attention, données, pression ?, grondement ?);  

Cette fonction peut renvoyer des erreurs s'il y a un problème avec les connexions ou avec le contrôleur lui-même.

Les principales fonctions utilisées à partir de la bibliothèque sont celles de lecture des entrées numériques et analogiques. Pour la lecture et l'entrée numérique, la méthode suivante est utilisée :

ps2x.Button(bouton);  

Dans quel bouton est le nom du bouton à lire. Chaque bouton est mappé comme suit :

Boutons directionnels :

• PSB_PAD_UP =bouton D-pad haut ;
• PSB_PAD_DOWN =bouton bas du D-pad ;
• PSB_PAD_LEFT =bouton gauche du D-pad
• PSB_PAD_RIGHT =bouton droit du D-pad

Boutons d'action :

• PSB_GREEN ou PSB_TRIANGLE =bouton triangle vert
• PSB_RED ou PSB_CIRCLE =bouton cercle rouge
• PSB_BLUE ou PSB_CROSS =bouton x bleu
• PSB_PINK ou PSB_SQUARE =​​bouton carré rose

Déclencheurs :

• PSB_L1 =bouton de déclenchement latéral gauche 1
• PSB_R1 =bouton de déclenchement latéral droit 1
• PSB_L2 =bouton de déclenchement latéral gauche 2
• PSB_R2 =bouton de déclenchement latéral droit 2

Bâtons :

• PSB_L3 =bouton poussoir du stick gauche (oui, vous pouvez appuyer sur le stick comme un bouton poussoir)
• PSB_R3 =bouton poussoir du joystick droit

Menu :

• PSB_SELECT =bouton de sélection
• PSB_START =bouton de démarrage

Pour lire la valeur analogique (avec whill be convertisseur en un entier compris entre 0 et 255) des sticks utilisez la méthode suivante :

ps2x.Analog(stick_axis);  

Dans quel stick_axis représente le bâton et la direction à lire, comme suit :

• PSS_LY =position y du joystick gauche
• PSS_LX =position x du stick analogique gauche
• PSS_RY =position y du joystick droit
• PSS_RX =x-position du joystick droit

Avec ces fonctions de base, vous serez prêt à utiliser la manette PS2 sur votre projet ! Sur les étapes suivantes, je montre quelques exemples de croquis Arduino combinant ces boutons !

Étape 6 : Esquisse 1 - Boutons Dpad

Les anciens jeux vidéo, tels que SEGA Master System et Mega Drive et Nintendo SNES, n'avaient pas de boutons sensibles à la force. Les boutons directionnels n'étaient que des boutons marche/arrêt. Pour ce premier exemple, je voulais émuler le type de commandes que l'on aurait dans les anciens jeux vidéo de ces consoles.

Pour ce premier Sketch, j'ai utilisé les boutons Dpad comme entrées pour le robot. Chaque bouton était utilisé par le robot pour effectuer l'un des mouvements de base :avancer, tourner à droite, tourner à gauche ou reculer.

Ces boutons ont des sorties binaires. De cette façon, le microcontrôleur comprendra seulement que les boutons ont été enfoncés, mais ne comprendra pas à quel point ils ont été enfoncés. De cette façon, une fois qu'un bouton donné est cliqué, les moteurs tourneront à pleine vitesse.

Si vous avez tout connecté selon mes schémas, vous aurez les sorties suivantes :

• PSB_PAD_UP =avancer
• PSB_PAD_DOWN =reculer
• PSB_PAD_LEFT =tourner à gauche
• PSB_PAD_RIGHT =tourner à droite

Comme je l'ai déjà dit, le moteur se déplacera à une vitesse fixe. En tournant à gauche ou à droite, les moteurs fonctionneront dans des directions opposées, de sorte que le robot tournera autour de son axe.

Code Arduino :

Téléchargez le code et ouvrez-le sur Arduino IDE. Si vous utilisez le même brochage que moi, vous n'aurez probablement rien à changer sur le code (bien que cela puisse être nécessaire, si l'orientation des moteurs est différente

Pour télécharger le code, sélectionnez la carte « Arduino/Genuino Uno », sélectionnez le bon port COM, branchez la carte sur le port USB de votre ordinateur et téléchargez le code.
Une fois le téléchargement terminé, débranchez le câble USB et placez le batteries. Le code commencera à s'exécuter et la carte Arduino connectera automatiquement le joystick PS2. Ouvrez le moniteur série à la première utilisation et vérifiez l'état de la connexion. S'il ne parvient pas à se connecter avec le joystick, vous devez faire quelque chose :

• Réinitialisez la carte Arduino Uno. Essayez-le plusieurs fois (pour moi, cela fonctionne généralement après la troisième réinitialisation);
• Vérifiez si le joystick est allumé (et avec des batteries chargées). Le récepteur possède des LED qui indiqueront si le joystick a été appairé. Vérifiez également si les broches RX et TX d'Arduino clignotent lorsqu'il reçoit de nouvelles commandes (et met à jour l'état sur le port série) ;
• Vérifiez les connexions... il se peut qu'il y ait un problème dans les cavaliers entre les composants.

Explication du code :

Dans ce projet, je n'ai eu qu'à utiliser la bibliothèque PS2X_lib.h. I est ajouté au début du code.

#include   

Définissez les broches de l'Arduino connectées au pont en h. Si vous utilisez les mêmes connectios que moi, vous aurez la configuration suivante. Si vous choisissez d'utiliser des broches différentes, mettez à jour cette partie du code.

// Ceux-ci sont utilisés pour définir la direction du pilote de pont. #define ENA 3 //ENA #define MOTORA_1 4 //IN3 #define MOTORA_2 5 //IN4 #define MOTORB_1 8 //IN1 #define MOTORB_2 7 //IN2 #define ENB 6 //ENB  

Certaines variables globales ont été déclarées avant l'installation (p2sx , erreur , tapez et vibrer ). Le premier est une instance de la classe PS2X. L'état d'erreur lors de la connexion sera stocké sur erreur entier. Tapez et vibrer indiquera le type de contrôleur (contrôleur DualShock ou GuitarHero) et s'il est censé vibrer sur une commande donnée.

La première chose que j'ai faite pendant la configuration a été de configurer l'état des broches d'E/S (en tant que sortie) et de définir les broches d'activation sur LOW. De cette façon, vous désactiverez les deux moteurs au démarrage et le robot ne se déplacera pas au hasard en attendant le reste du code.

// Configurer les broches de sortie pinMode(ENA, OUTPUT); pinMode(MOTORA_1, SORTIE); pinMode(MOTORA_2, SORTIE); pinMode(ENB, SORTIE); pinMode(MOTORB_1, SORTIE); pinMode(MOTORB_2, SORTIE); // Désactiver les deux moteurs digitalWrite(ENA,0) ; écriture numérique (ENB, 0);  

Ensuite, j'ai commencé la communication par port série (utile pour déboguer le code). Choisissez une vitesse de transmission appropriée et réglez la même vitesse sur le moniteur série.

// Démarrer la communication série Serial.begin(57600);  

Enfin, configurez l'objet ps2x avec les broches de l'Arduino qui étaient connectées au récepteur du joystick (horloge, commande, attention et données respectivement). Il peut renvoyer une erreur (à afficher sur le moniteur série). Le type de contrôleur sera également affiché (même si vous connaissez probablement déjà le type de contrôleur que vous avez entre les mains à ce stade :D).

error =ps2x.config_gamepad(13,11,10,12, true, true); //configuration des broches et des paramètres :GamePad (horloge, commande, attention, données, pressions ?, Rumble ?) recherche d'erreur // recherche d'erreur if(error ==0){ Serial.println("Contrôleur trouvé, configuré avec succès" ); } else if(error ==1) Serial.println("Aucun contrôleur trouvé, vérifiez le câblage ou réinitialisez l'Arduino"); else if(error ==2) Serial.println("Contrôleur trouvé mais n'acceptant pas les commandes"); else if(error ==3) Serial.println("Le contrôleur refusant d'entrer en mode Pressions, peut ne pas le prendre en charge."); // Vérifiez le type de contrôleur type =ps2x.readType(); switch(type) { case 0:Serial.println("Type de contrôleur inconnu"); Pause; cas 1 :Serial.println("DualShock Controller Found"); Pause; cas 2:Serial.println("Contrôleur GuitarHero trouvé"); Pause; }  

Pendant la boucle principale, l'Arduino lira chaque bouton D-pad (HAUT, BAS, GAUCHE et DROIT) et définira les différentes valeurs pour les broches de sortie, afin de déplacer les roues. Après un bref délai, une nouvelle boucle est lancée.

La section suivante montre comment faire avancer le robot si le bouton HAUT a été enfoncé. Les broches MOTORA_1 et MOTORA_2 définissent le sens de rotation du moteur A. ENA définira si le mouvement est activé ou non (moteur ON/OFF). Notez qu'il s'agit d'une sortie "analogique" (en fait une PWM). Sa valeur doit être comprise entre 0 et 1023. Cela modulera le PWM et changera la tension moyenne à la sortie du pont en h (entre 0 et 12V). Si la tension moyenne est trop basse, le moteur ne pourra pas du tout bouger.

// AVANCER if(ps2x.Button(PSB_PAD_UP)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Avancer"); }  

* J'ai utilisé des sorties PWM pour les broches ENA et ENB. De cette façon, 1023 représenterait une impulsion avec la plus grande longueur (broche toujours allumée) et 0 l'absence d'impulsions (broche toujours éteinte). Si une valeur différente (plus petite) est utilisée ici, les moteurs devraient fonctionner plus lentement, car la tension moyenne à leurs bornes sera plus petite.

Étape 7 : esquisse 2 : Bâton analogique et boutons numériques (L2 et R2)

A un moment donné, toutes les consoles ont adopté des joysticks avec deux sticks analogiques. Ces nouvelles entrées ont permis des entrées sensibles à la force qui ont créé des actions à vitesse variable et sont devenues populaires dans tous les types de jeux vidéo.

Dans ce deuxième exemple, je voulais utiliser un commutateur analogique pour diriger le réservoir et une paire de boutons poussoirs comme accélérateur et freins/marche arrière. Ce genre de configuration est très populaire dans beaucoup de jeux de course, comme Mario Kart par exemple. Appuyez sur le bouton R2 pour l'accélération du réservoir, L2 pour la marche arrière et définissez la direction du mouvement en fonction de la position x du stick gauche.

Le type de kit robotique que j'ai utilisé n'a pas beaucoup d'inertie (si la tension sur les moteurs est réglée sur 0V, cela ne bougera pas pendant un certain temps). De cette façon, il n'était pas nécessaire de définir une commande pour freiner le robot.

La plupart du code a déjà été expliqué à l'étape précédente. Une différence est que j'ai défini deux variables qui stockent la vitesse de chaque moteur (de 0 à 1023).

int motor_right_speed =0;
int motor_left_speed =0;  

Dans la boucle principale, l'Arduino lira la position x du stick gauche. Il recevra une valeur comprise entre 0 et 255 et la mappera entre -1023 et 1023.

Cette valeur sera ajoutée (ou soustraite) à la vitesse de chaque moteur, afin de créer une différence entre la vitesse de chaque piste et faire tourner le robot à gauche ou à droite.

int nJoyL =ps2x.Analog(PSS_LX); // lecture joystick gauche nJoyL =map(nJoyL, 0, 255, 1023, -1023); motor_right_speed =1023 ; motor_left_speed =1023; if (nJoyL <0) { motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) { motor_left_speed =motor_left_speed - nJoyL; }  

Si le bouton R2 est enfoncé, le réservoir doit avancer. De cette façon, l'Arduino définit les valeurs appropriées pour les broches du moteur. ENA et ENB créent des sorties « analogiques » pour chaque moteur, avec une valeur proportionnelle à la vitesse souhaitée pour chaque moteur (basée sur la position x du joystick gauche).

L2 fera quelque chose de similaire, mais inversera le sens du moteur.

if(ps2x.Button(PSB_R2)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(ps2x.Button(PSB_L2)) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(!ps2x.Button(PSB_L2) ​​&&!ps2x.Button(PSB_R2)) { analogWrite(ENA, 0); analogWrite(ENB, 0); }  

Si aucun des boutons n'a été enfoncé, les moteurs seront désactivés.

Étape 8 : esquisse 3 : sticks analogiques gauche et droit (entraînement différentiel)

Celui-ci est ma façon préférée de contrôler le char (bien qu'il ne soit pas optimal en termes de ressources) ! J'ai l'impression de contrôler une vraie grosse machine à deux mains !

Dans ce code, j'ai utilisé les deux manettes pour régler la direction et la vitesse de chaque piste. Le stick gauche commandera la piste gauche et le stick droit contrôlera la piste droite.

Le code est presque le même que celui décrit précédemment. Mais cette fois, je voulais lire la position y des deux bâtons :

int nJoyL =ps2x.Analog(PSS_LY); // lecture du stick gauche int nJoyR =ps2x.Analog(PSS_RY); // lecture joystick droit nJoyL =map(nJoyL, 0, 255, 1023, -1023); nJoyR =map(nJoyR, 0, 255, -1023, 1023);  

Selon la position du bâton, le code définira les broches numériques pour définir la direction de chaque moteur.

J'ai utilisé une valeur fixe à l'activation (1023), mais j'utiliserais une valeur variable basée sur la valeur réelle du stick analogique. J'ai défini une zone morte (+-50) dans laquelle le microcontrôleur désactivera les moteurs.

// Effectuez des mouvements basés sur les deux sticks analogiques if(nJoyR>50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); analogWrite(ENA, 1023); } if(nJoyR<-50) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); analogWrite(ENA, 1023); } if (abs(nJoyR)<50) { analogWrite(ENA, 0); }  

Étape 9 : esquisse n° 4 : stick analogique gauche uniquement

Dans cette dernière application Sketch, j'ai utilisé un seul joystick pour contrôler le robot. C'est optium en terme d'utilisation des ressources (il vous restera plein de boutons pour paramétrer différentes actions), mais c'est assez difficile à comprendre.

La vitesse de chaque piste est définie en fonction des positions x et y du joystick. De cette façon, il est possible d'appliquer différentes vitesses sur chaque piste et de déplacer le robot avec différentes vitesses/directions. Le code utilisé ici est dérivé du tutoriel suivant. Vérifiez-le !

https://www.impulseadventure.com/elec/robot-differential-steering.html

Étape 10 :Considérations finales

J'ai mis beaucoup d'efforts dans ce projet, pour qu'il soit le plus clair et pédagogique possible. Si vous l'avez aimé, n'oubliez pas d'"aimer" et de "partager". Votre soutien est très important pour moi ! :D

Si vous ne suivez toujours pas mes tutoriels, jetez un œil à ces autres tutoriels sur la robotique ! J'espère qu'ils vous plaisent !

https://www.hackster.io/igorF2/joy-robot-robo-da-alegria-bba54f

https://www.hackster.io/igorF2/widc-wi-fi-Controlled-fpv-robot-8f1e09

https://www.hackster.io/igorF2/nunchuk-controled-robotic-arm-with-arduino-b1c0fa

https://www.hackster.io/igorF2/wi-fi-browser-driven-robotic-arm-89b63d

Pensez à soutenir mes futurs projets avec un petit don Bitcoin ! :D

Adresse de dépôt BTC :1FiWFYSjRaL7sLdr5wr6h86QkMA6pQxkXJ