Piloter un bras robotique en WiFi avec un Gamepad depuis un Raspberry Pi (code Python evdev + requêtes HTTP)

Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

Table des matières

Nous avons vu comment piloter un bras robotique à l’aide d’une connexion WebSocket entre un Raspberry Pi et un ESP8266. C’est une solution technique très bien adaptée pour envoyer des commandes ou des états très rapidement avec un temps de latence très faible. Si vous ne maitrisez pas (encore) le WebSocket, voici le code Python et Arduino qui vous permettra de piloter le bras robotique à l’aide de requêtes HTTP.

 

Pour ce tutoriel, nous utiliserons également le kit ROT2U 6DOF équipé de 6 servomoteurs (5 axes + 1 pince) présenté dans cet article.

A LIRE AUSSI :
Assemblage du kit ROT2U 6DO. Initiation robotique Arduino Raspberry Pi

Un peu de lecture avant de commencer

Avant de commencer, vous pouvez lire ces articles qui expliquent plus en détail les différents aspects techniques abordés dans ce projet.

Pour piloter le bras robotique, vous aurez besoin d’un shield I2C PCA9685 permettant de piloter plusieurs servomoteurs

A LIRE AUSSI :
Déballage du shield Geekcreit PCA9685 I2C 16 servos + 2 moteurs pour Arduino ou ESPDuino (ESP8266)

Vous aurez besoin de connaître les fonctions proposées par la librairie Python evdev qui permet d’intercepter les actions sur les boutons d’un Gamepad (par exemple celui d’une console SNES USB).

A LIRE AUSSI :
Librairie Python evdev sur Raspberry Pi. Récupérer les actions d'un Gamepad dans vos projets DIY (servomoteur, jeux...)

La communication HTTP proposée dans ce tutoriel est facile à mettre en oeuvre mais donne des résultats saccadés. Pour obtenir des déplacements plus fluides, il est préférable d’opter pour une autre technologie de communication. Le Websocket est parfaitement adaptée dans ce cas

A LIRE AUSSI :
Projet kit robotique ROT2U 6DOF WiFi (Websocket) avec Gamepad et Raspberry Pi. Code Python evdev

Les notions abordées dans ce tutoriel

Le bras robotisé peut être un simple jeu mais également un excellent outil d’apprentissage en mécanique, électronique, programmation, communication HTTP. Dans cette série d’articles, nous allons aborder les notions suivantes :

  • En programmation Arduino en C++
    • Comment piloter des servomoteurs
    • Comment connecter un Arduino/ESP8266 à un réseau WiFi
    • Créer un serveur HTTP sur un Arduino ou ESP8266. Réception et envoi de message
  • En programmation en Python
    • Utilisation des packages evdev, ws4py, threading, time
    • Initiation aux threads (fonctions exécutées en parallèle du programme principale)
    • Envoyer et recevoir des requêtes HTTP de façon asynchrone
    • Intercepter les actions sur un Gamepad à l’aide de la librairie evdev pour Linux. Envoyer des ordres de déplacement jusqu’à ce que le bouton soit relâché (à l’aide d’un thread)
  • Matériel

Architecture de communication HTTP

Le Raspberry Pi 3 (ou RPIZero W) permet de récupérer (intercepter) les actions faites sur un Gamepad à l’aide de la librairie Python evdev. Dès qu’une action sur le Gamepad est détectée par la librairie evdev, un message est envoyé au serveur HTTP hébergé sur l’ESP8266. Le code Arduino s’occupe de décoder le message et de déplacer le servomoteur dans la direction demandée.

architecture http raspberry pi espduino esp8266 pca9685 rot2u 6dof

Si on doit se déplacer de 180° sur un axe, avec un pas d’un degré, on serait obligé d’appuyer 180 fois sur la flèche. Heureusement, la librairie evdev permet de savoir lorsqu’un bouton est appuyé (PRESS) et lorsqu’il est relâché (RELEASE). On va utiliser le système de Thread (fonction qui s’exécute en tâche de fond) de Python pour envoyer à intervalle régulier (par exemple toutes les 50ms) un ordre de déplacement dans la direction souhaitée. L’envoi des messages est interrompu dès qu’on relâche le bouton.

Matériel nécessaire

Pour ce projet, vous aurez besoin du matériel suivant pour le bras robotique

  • Un bras robotisé. Je vous conseille le kit ROT2U 6DOF qui est livré avec 6 servomoteurs. Certains kits ne sont pas livrés avec les servomoteurs. Suivez ce tutoriel pour assembler le bras robotique
  • Une carte de développement ESPDuino (présentée ici). C’est une carte au format Arduino Uno basée sur un ESP8266. Il est compatible avec les shields (carte d’extension) pour Arduino Uno
  • Un shield PCA9685 16 servomoteurs (environ 11€) ou une carte PCA9685 (environ 2€). Je vous conseille le shield Geekcreit (Doit.am) parfaitement géré par la librairie Sumotoy. Pour la mise en route, lisez cet article
  • Un jeu de Jumper Dupont (si les câbles fournis sont trop court).

Coté télécommande vous aurez besoin du matériel suivant

Installer les librairies Sumotoy PCA9685 sur l’IDE Arduino

Pour ce projet, vous aurez donc besoin d’installer la librairie Sumotoy. Cette librairie Arduino permet de piloter jusqu’à 16 LED ou 16 servomoteurs PWM à l’aide du circuit PCA9685 à l’aide du bus I2C. Allez sur la page du projet pour télécharger la librairie. Lisez ce tutoriel pour plus de détails sur l’emploi de la librairie. Décompressez l’archive ZIP dans le dossier librairies qui se trouve dans vos Documents. Relancez l’IDE Arduino (surtout par avoir accès aux exemples).

Installer les librairies Python evdev et request sur le Raspberry Pi

Python 2.7 est installé par défaut sur la distribution Raspbian. Pour vous en assurer, ouvrez un Terminal et exécutez la commande suivante

#python --version
Python 2.7.9

Maintenant vérifiez que le paquet pip permettant d’installer facilement des librairies est installé

#pip --version
pip 9.0.1 from /Library/Python/2.7/site-packages/pip-9.0.1-py2.7.egg (python 2.7)

Si pip n’est pas installé, exécutez cette commande

sudo apt-get install python-pip

Installez enfin python-dev et la librairie evdev. La librairie evdev qui permet intercepter les actions d’un Gamepad sur un système Linux (y compris sur un Raspberry Pi). Le dépôt de la librairie se trouve sur cette page GitHub. Lisez ce tutoriel pour plus de détails.

sudo apt-get install python-pip
sudo pip install evdev

Pour connaître le port USB sur lequel est branché le Gamepad, exécutez une première fois la commande ls /dev/input

# ls /dev/input/
by-id  by-path  event0  event1  mice

Maintenant connectez le Gamepad (ou un joystick) et exécutez de nouveau la commande pour identifier le port. Ici, on pourra récupérer les actions du Gamepad sur l’event2.

# ls /dev/input/
by-id  by-path  event0  event1  event2  mice

Exécutez enfin cette commande pour installer la librairie request qui permet de faire très facilement des requêtes HTTP

pip install request

Assemblage : shield PCA9685 Geekcreit, bras robotique ROT2U 6DOF, ESPDuino

Une fois votre bras robotique assemblé, il y a très peu de câblage à réaliser. En effet, en utilisant une carte PCA9685 au format Arduino Uno, il n’y a rien à faire à part brancher les servomoteurs ! Si votre ordinateur délivre une tension trop faible à l’ESPDuino, il est possible d’ajouter une alimentation complémentaire. La carte Geekcreit dispose de deux connecteurs 6-18V. Le premier (VM) est destiné à l’alimentation des 2 moteurs à courant continu. Le second à alimenter les servomoteurs (VS).

Code Python evdev, les ordres de mouvement interceptés du gamepad sont envoyés en HTTP

Nous avons vu en détail comment récupérer les actions sur un Gamepad (flèches et boutons) dans ce tutoriel. Regardons comment envoyer les ordres de mouvement au serveur HTTP hébergé sur l’ESP8266. On va utiliser les Thread Python pour envoyer régulièrement (toutes les 50ms) un ordre de déplacement jusqu’à ce que le bouton (ou la flèche) soit relâchée. Ici, j’ai utilisé des variables globales pour passer des paramètres au Thread :

  • servo, l’axe à déplacer (servo0, servo1…servo5)
  • direction, la direction du déplacement (UP, DIWN, OPEN, CLOSE)
  • send, c’est le booléen qui permet de déclencher ou interrompre l’envoi des requêtes HTTP

On définit le thread t1 qui est chargé d’exécuter la fonction sendRequest(). Une fois définit, on démarre le Thread avec la méthode start()

t1 = Thread(target=sendRequest)
t1.start()

Ensuite, dès qu’une action est détectée sur le Gamepad (event.value == 1 pour les boutons), on modifie les variables servo et direction puis on passe send à True pour déclencher l’envoi des ordres de déplacement. Par défaut la variable httpFreq est réglée à 50ms (.050). Lorsque le bouton est relâché (event.value == 1), on passe send = False pour arrêter l’envoi des requêtes de déplacement. Voici un code qui illustre le fonctionnement général

import requests, time
from evdev import InputDevice, categorize, ecodes
from threading import Thread

# Adresse IP et point d entree de la requete HTTP sur l'ESP8266 | ESP8266 Http and end point
esp8266url = "http://192.168.1.65/cmd"
gamepad = InputDevice('/dev/input/event2')

servo       = ""
direction   = ""
send        = False
httpFreq    = .050

def sendRequest():
  global servo
  global direction
  global send
  while True:
    # Un seul servo a la fois pour le moment | Only one servo in the version
    payload = {
       servo:direction
    }
    # Envoi les ordres de deplacement jusqu a ce que send = false | Send HTTP request until send = False
    if send:
      r = requests.get(esp8266url, params=payload)
      print r.url
      print r.json
      time.sleep(httpFreq)

# Demarre le thread
t1 = Thread(target=sendRequest)
t1.start()

for event in gamepad.read_loop():
    if event.type == ecodes.EV_KEY:
        if event.value == 1:
            if event.code == xBtn:
                servo = "servo2"
                direction = "up"
                send = True
                print("X")
        elif event.value == 0:
          send = False

Voilà, créez maintenant un nouveau script (par exemple nano robothttp.py) et collez le code ci-dessous. Vous devez modifier deux paramètres :

  • L’adresse IP du serveur HTTP et le point d’entrée. Par exemple http://192.168.1.65/cmd.
  • Le port USB sur lequel est branché le Gamepad


La combinaison de touche CTRL + C permet d’interrompre le script à n’importe quel moment.

Mappage des boutons du Gamepad SNES

Voici la correspondance des touches du script Python. Libre à vous de le modifier. Comme le mappage est réalisé coté Raspberry Pi, inutile de modifier le code Arduino. Le servo0 correspond à l’axe de rotation de la base. Le servo 5 correspond à la pince.

Servo0 (base) gauche
Servo0 (base) droite
Servo1 monter – up
Servo1 descendre – down
X Servo2 monter – up
B Servo2 descendre – down
Y Servo3 monter – up
A Servo3 descendre – down
L Servo4 monter – up
R Servo4 descendre – down
Select Servo5 (pince) ouvrir – open
Start Servo5 (pince) fermer – close

espduino esp8266 pca9685 rot2u 6dof gamepad mapping

 

Code Arduino compatible ESP8266 ou ESPDuino, serveur HTTP et contrôle des axes

L’ESP8266 va donc héberger un serveur HTTP. Le code ci-dessous illustre le principe de fonctionnement du serveur HTTP :

On créé un objet server qui écoute le port 80 (le port HTTP par défaut)

Dans le setup, on branche la fonction callback (moveServos) à appeler à chaque nouvelle requête entrante sur le point d’entrée. Ici /cmd. Ce n’est rien d’autre qu’une page dans un navigateur internet.

Dans la boucle loop(), on actualise le serveur. Il ne faut donc pas y mettre de delay pour ne pas le ralentir

La fonction moverServos() est appelée à chaque fois que le client (le script Python) envoi une demande de mouvement. Les paramètres sont encodés dans l’url. On décode les paramètres à l’aide de la fonction arg(n° du paramètre).

Par exemple, si on veut tourner la base du robot sur la droite, on devra envoyer http://192.168.1.65/cmd?servo0=right. Vous pourrez d’ailleurs le tester après avoir téléversé le programme complet.

Après, il ne reste plus qu’à tester chaque cas et incrémenter un compteur d’angle pour chaque axe du bras robotique.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
ESP8266WebServer server ( 80 );
int posServo0 = 0;

void setup() {
  server.on("/cmd", moveServos);
  server.begin();
}

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

void moveServos(){
  String numServo = server.argName(0);
  String dirServo = server.arg(0);
  if ( numServo == "servo0" ) {
      if ( dirServo == "left" ) {
        if ( posServo0 == 0 ) {
          posServo0 = 0;
        } else {
          posServo0 = posServo0 - SERVO_SPEED;
          servo.moveServo(0,posServo0);
        }
      } else if ( dirServo = "right" ) {    
        if ( posServo0 == 180 ) {
          posServo0 = 180;
        } else {
          posServo0 = posServo0 + SERVO_SPEED;
          servo.moveServo(0,posServo0);
        }
      }
  } else {
    Serial.print("Unknown servo!"); Serial.println(numServo);
  }
}

On pourra également installer la librairie client si on veut envoyer la position des axes à un logiciel de pilotage par exemple.

Créez un nouveau croquis et collez le code ci-dessous. Plusieurs paramètres doivent être adaptés à votre configuration :

  • ssid, identifiant du réseau WiFi
  • password, mot de passe réseau
  • SERVO_SPEED, par défaut, le servo fait un pas de 1 degré à chaque mouvement (précis mais pas rapide)
  • posServo0 à 5, angle de la position garage (Home)
  • pinServo0 à 5, broche sur lequel est branché le servomoteur

Inutile de rentrer dans les détails du code. Tout a déjà été expliqué précédemment. Ici, tous les axes sont gérés.


Attention. Si vous décochez l’appel de la fonction GoHome, assurez vous qu’aucun objet ne se trouve sur la trajectoire des bras avant de téléverser le projet.

Démo

Téléversez le programme et ouvrez le moniteur série pour connaître l’adresse IP attribuée au module ESP8266. Vous pouvez la reporter coté client dans le code Python. Dès que le module est connecté au réseau WiFi, vous devez entendre le “ronronnement” des servomoteurs qui sont maintenant alimentés. Lancez le script Python avec la commande python robothttp.py . Vous pouvez commercer à jouer avec le bras robotique à l’aide du Gamepad.

 

Comme vous pourrez le constater, la communication HTTP donne des mouvements un peu plus saccadés par rapport au Websocket. Rien d’insupportable toutefois. En fonction de la qualité de votre réseau WiFI, il faut chercher le temps de pause qui donne le meilleur résultat.

Avez-vous aimé cet article ?
[Total: 0 Moyenne: 0]
Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

Vous avez aimé ce projet ? Ne manquez plus aucun projet en vous abonnant à notre lettre d’information hebdomadaire!

quel modèle esp8266 choisir
Quel modèle d'ESP8266EX choisir en 2020 ?
guide choix esp32 development board
Quel ESP32 choisir en 2020 ?

Vous rencontrez un problème avec ce sujet ?

Peut-être que quelqu’un a déjà trouvé la solution, visitez le forum avant de poser votre question

Nous serions ravis de connaître votre avis

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Calculateurs
×
Calculateur loi d'Ohm
Tension (U) - en Volt
Courant (I) - en Ampère
Résistance (R) - en Ohms
Puissance (P) - en Watts

Ce calculateur permet de calculer les relations entre le courant, la tension, la résistance et la puissance dans les circuits résistifs.

Saisir au moins deux valeurs puis cliquer sur calculer pour calculer les valeurs restantes. Réinitialisez après chaque calcul.

Rappel sur la Loi d'Ohm
La loi d'Ohm explique la relation entre la tension, le courant et la résistance en déclarant que le courant traversant un conducteur entre deux points est directement proportionnel à la différence de potentiel entre les deux points.
La loi d'Ohm s'écrit U = IR, où U est la différence de tension, I est le courant en ampère et R est la résistance en Ohms (symbole Ω).
Loi d'Ohm (U=RI)
×
Déchiffrer le code couleur d'une résistance à 4 bandes
Bande 1 Bande 2 Multiplicateur Tolérance
   

Résistance:  

1 000 Ω ±5%

Comment déchiffrer le code couleur d'une résistance à 4 anneaux
Formule : ab*cΩ ±d%
Les deux premières bandes (a, b) permettent de déterminer le chiffre significatif. La première bande correspond au chiffre de la dizaine, le second anneau le chiffre de l'unité. Par exemple Brun(1), Noir (0) donne le nombre 10.
La troisième bande (c) est un coefficient multiplicateur. Par exemple, l'anneau rouge est un coefficient multiplicateur de 100, ce qui donne 10 X 100 = 1000Ω.
Le quatrième anneau (d) indique la tolérance de la valeur nominale de la résistance. Par exemple l'anneau Or correspond à ±5%. Donc le fabricant de la résistance s'engage à ce que sa valeur soit comprise entre 950 Ω et 1050 Ω.
Déchiffrer code couleur 4 bandes
×
Déchiffrer le code couleur d'une résistance à 5 bandes
Bande 1 Bande 2 Bande 3 Multiplicateur Tolérance

Résistance:  

1 000 Ω ±5%

Comment déchiffrer le code couleur d'une résistance à 5 anneaux
Formule : abc*dΩ ±e%
Les trois premières bandes permettent de déterminer le chiffre significatif. La première bande correspond au chiffre de la dizaine, le second anneau le chiffre de l'unité. Par exemple Brun(1), Noir (0), Noir (0) donne le nombre 100
La quatrième bande est un coefficient multiplicateur. Par exemple, l'anneau brun correspond au coefficient multiplicateur 10, ce qui donne 100 X 10 = 1000Ω.
Le cinquième anneau indique la tolérance de la valeur nominale de la résistance. Par exemple l'anneau Or correspond à ±5%. Donc le fabricant de la résistance s'engage à ce que la valeur de la résistance soit comprise entre 950 Ω et 1050 Ω.
Déchiffrer code couleur 5 bandes
×
Calculateur de résistance série pour une ou plusieurs LED
Tension d'alimentation en Volt
Tension directe en Volt
Courant en mA
Résistance calculée en Ω
Puissance estimée en W

Ce calculateur permet de déterminer la résistance requise pour piloter une ou plusieurs LED connectées en série à partir d'une source de tension à un niveau de courant spécifié.

Remarque. Il est préférable d'alimenter le circuit avec une puissance nominale comprise entre 2 et 10 fois la valeur calculée afin d'éviter la surchauffe
Couleur Longueur d'onde (nm) Tension (V) pour LED ⌀3mm Tension(V) pour LED ⌀5mm
Rouge 625-630  1,9-2,1 2,1-2,2
Bleu 460-470 3,0-3,2 3,2-3,4
Vert 520-525 2,0-2,2 2,0-2,2
Jaune 585-595 2,0-2,2 3,0-3,2
Blanc 460-470 3,0-3,2 1,9-2,1
Résistance en série pour une ou plusieurs LED
×
Calculateur durée de vie d'une batterie
Capacité de la batterie
Consommation de l'appareil ou objet connecté

Ce calculateur estime la durée de vie d'une batterie, en fonction de sa capacité nominale et du courant ou de la puissance qu'une charge en tire.

La durée de vie de la batterie est une estimation idéalisée. La durée de vie réelle peut varier en fonction de l'état de la batterie, de son âge, de la température, du taux de décharge et d'autres facteurs. C'est le mieux que vous pouvez espérer obtenir.

Autonomie de la batterie = capacité de la batterie en mAh / courant de charge en mA

Durée de vie batterie
Publicité
À lire aussi
Composants
Sur le Forum
Derniers Sujets
Domotique et objets connectés à faire soi-même
Domotique et objets connectés à faire soi-même
Vous avez aimé ce tutoriel

Ne manquez plus les prochains projets

Recevez chaque semaine le récapitulatif des tutoriels et projets.

Vous pouvez vous désabonner à tout moment. 

Shopping cart