Piloter un bras robotique en WiFi avec un Gamepad depuis un Raspberry Pi (code Python evdev + requêtes HTTP) • Domotique et objets connectés à faire soi-même

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.

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

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).

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

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.

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).

131,61€

En Stock

actualisé le 19 août 2020 3 h 00 min

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

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 
#include 
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.

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.

131,61€

En Stock

actualisé le 19 août 2020 3 h 00 min

Avez-vous aimé cet article ?

[Total: 0 Moyenne: 0]