Robot piloté par un smartphone

Le châssis a été réalisé uniquement avec des matériaux de récupération. Moteur de Gyrophare, morceaux d’alu et vis qui trainent,…

Une fois les différents éléments assemblés, il était important pour moi de savoir si ce proto tenait la route. J’ai donc fait des tests de pilotage avec une alimentation de labo qui disposait de deux voies. J’ai pu facilement et à l’aide de longs câbles, tester les mouvements avants, arrières, droites et gauches.

De chaque côté, j’ai confectionné un système pour tendre ou détendre les chenilles pour qu’elles puissent bien rester en place.

Avant de l’équiper en système de pilotage, j’ai donc décidé d’ajouter des codeurs afin de pouvoir, par la suite, corriger informatiquement les défauts de trajectoire. Un robot fabriqué avec des éléments de récup risquai très probablement de ne pas être symétrique et donc de ne pas rouler droit!

Pour cela, j’ai récupéré des vieilles souris à boule d’ordinateur. Elles sont constituées d’optocoupleurs à fourche qui permettent de fournir des informations de position à l’ordinateur.

Le principe d’un optocoupleur est simple. Il est composé de deux éléments principaux: une led génère une lumière infrarouge et un phototransistor en face qui est réceptif à cette lumière. A chaque fois que le faisceau lumineux est obstrué, le phototransistor modifie la quantité de courant qu’il peut faire passer.

Une fois les composants de la souris dessoudés, je les ai implantés sur une plaque à trous que j’ai elle même fixé sur mon châssis.

Ensuite, j’ai inséré un disque de plastique transparent sur l’axe d’une roue auquel j’ai ajouté des rayons opaques.

En faisant passer mon disque dans la fourche de mon optocoupleur, je peux en déduire ceci:

Distance parcourue entre chaque rayon: 43,56mm

Caractéristiques:

• Diamètre roue avec épaisseur chenille : 111mm
• Distance parcourue avec 1 tour de roue : 2 x pi x R = 348,54mm
• Nombre d’impulsion par tour de roue : 8

L’arduino possède deux entrées d’interruption. Ces entrées vont déclencher une interruption du programme principal et effectuer une tâche que l’on aura préalablement programmé.

Dans mon cas, à chaque impulsion issu de mon capteur, une interruption sera activée.

Dans mon programme, j’intègre ma valeur de 43,56mm et je vais donc pouvoir récupérer une information de distance parcourue. En y ajoutant une information de temps, je dispose d’une information de vitesse.

Mise en place des interruptions dans le code de l’arduino:

void setup()
{
   attachInterrupt(0, GestionInterruptionCodeurGauche, RISING);
   attachInterrupt(1, GestionInterruptionCodeurDroit, RISING);
}

paramètre 1: Entrée à écouter (0 = pin 1; 1=pin 2 )

paramètre 2 :Nom de la fonction à exécuter

paramètre 3: interruption sur un front ou état

Au niveau de l’arduino, il faut mettre en place une communication série pour pouvoir échanger des information avec le PC. Pour cela, rien de bien compliqué:

void setup()
{
   Serial.begin(9600);
}

void loop()
{
   if (Serial.available() > 0)
   {
      donneesRecues = Serial.read();
   }
}

Au niveau du PC, j’ai tout développé en java et j’ai utilisé la librairie RXTXComm pour effectuer cette liaison.

Je ne vais pas mettre des pages entières de code sur ce blog. Voici un lien qui vous aidera si besoin:

http://playground.arduino.cc/Interfacing/Java

Une fois la communication établie, on va s’attaquer aux cartes électroniques de puissance pour commander les moteurs.

Afin de gérer une connexion sans fil et le flux vidéo, j’a utilisé une carte raspberry pi B+.

On trouve sur le net beaucoup de tutos pour installer et configurer l’OS.

J’ai opté pour Raspian et de plus, il intègre nativement une jvm (pour exécuter code du java).

Mon objectif était de pouvoir piloter mon robot avec mon téléphone. (Android)

1- Création d’un point d’accès WIFI

J’ai donc créé un point d’accès WIFI sur le raspberry pour l’utiliser en tant que serveur embarqué pour qu’il puisse scruter les clients entrant et établir la communication.

Pourquoi le WIFI plutôt que le Bluetooth?  Il me semblait plus adéquat une communication WIFI pour gérer un flux vidéo.

Super tutos pour le mettre en œuvre:

http://hardware-libre.fr/2014/02/raspberry-pi-creer-un-point-dacces-wifi/

2- Communication

Une fois le point d’accès opérationnel, j’ai développé un serveur java embarqué et transposé la communication série de mon application PC dans cette appli.

La liaison Android-raspberry-Arduino était établie.

Pour avoir des mouvements haut/bas de ma caméra, j’ai démonté mon premier système pour le remplacer par un servomoteur. Mes sorties de mon arduino étant toutes utilisées, je fût obligé de piloter mon servo par mon raspberry.

Mes premiers tests en java pour contrôler mon servo furent des échecs. Pourquoi? Simplement parce que un servo se pilote de la manière suivante:

Un signal de période 20ms avec une variation de l’état haut du signal de 0.9ms à 2ms (dans mon cas) permet au servo de se positionner sur un angle de 0 à 180°.

Le raspberry n’étant pas RTOS, il ne permet pas d’avoir la stabilité pour générer un tel signal.

Le résultat était que le servomoteur saccadait en permanence. Utilisation impossible.

J’ai solutionné ce problème en installant sur le raspberry: « pi-blaster ». Il permet de piloter des sorties indépendamment de l’OS.

Grâce à des lignes de commandes envoyées depuis mon programme, il est aisé de piloter de manière très stable un ou plusieurs servomoteurs.

J’ai utilisé dans un premier temps une batterie Lipo 12v 2000mA/h mais de mauvaise qualité. Elle ne pouvait absorber suffisamment les pics de courant. De plus, afin de fournir du 5V aux autres éléments, j’ai utilisé un montage à base de 7805 mais il chauffait beaucoup trop en raison du rapport Vs/Ve.

Pour la batterie, j’ai opté pour une Lipo de 5500mA/h 35C. Ce qui a résolu mes problèmes.

Pour l’alimentation régulée, je récupéré une carte électronique à découpage à base de LTM4609V. Ce qui, là aussi, a résolu mes problème de surchauffe.

J’ai ensuite confectionné une petite carte avec des connecteurs ce qui me permet de dispatcher les différentes tensions vers les éléments à alimenter.

1: Tension batterie du robot

2: Avancer

3: Tourner à gauche (demi-tour)

4: Reculer

5: Tourner à droite (demi-tour)

6: Caméra à gauche

7: Caméra en bas

8: Caméra à droite

9: Caméra en haut

10: Témoin gyroscopique. (Incliner le téléphone en avançant pour tourner)

11: Accès au menu. (éteindre le raspberry à distance)

Pour la vidéo, j’ai passé énormément de temps à tester et mettre en place plusieurs solutions pour trouver celle qui me correspondait le plus.

Mon choix fût l’utilisation de GStreamer. GStreamer propose un serveur embarqué qui permet d’envoyer un flux vidéo rtsp.

J’ai pu mettre en place la liaison vidéo grâce au tutoriel 5 de GStreamer pour Android et grâce au lien Koréen ci-dessous.

http://www.aftermath.kr/category/Raspberry Pi

Arrivé à ce stade, mon robot commençait à répondre à mes attentes initiales. Alors, après s’être passé d’un cordon USB pour piloter mon robot, j’ai voulu me passer de mon téléphone.

L’idée, est qu’avec la librairie de traitement d’image opencv, il est assez facile de faire du tracking. (reconnaissance d’objet sur une image). Si j’intègre une reconnaissance de ma silhouette, et que je code le déplacement de mon robot en conséquence, il va me suivre comme un petit chien.

C’est ce que j’ai fait.

A l’heure actuelle, je suis en cours d’amélioration du tracking. Mon robot me suit du regard.

Merci à tous ceux qui ont lu cet article. Pour plus d'infos, vous pouvez consulter mon blog dont ce tutos est issu.

https://myexperimentalrobot.wordpress.com/

A bientôt.

Bertrand