Bonjour à tous !

Et bienvenue sur mon blog!

J’ai décidé de créer ce blog pour faire part à ceux qui le désirent, ma passion pour l’informatique embarqué, l’automatique et la robotique.

Dans un premier temps je vais vous présenter mon projet de robot à chenille muni de cartes électroniques de puissances, d’Arduino, de Raspberry pi et de mon téléphone Android.

Le but de ce projet? Pouvoir piloter un robot muni d’une caméra via une tablette ou un téléphone Android.

Vous avez la possibilité de me laisser des messages pour vos questions ou sur vos impressions. N’hésitez pas. Dans la mesure du possible et suivant mon temps disponible, je me ferai un plaisir de vous répondre.

1. Conception du châssis

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.

Mon robot tenait relativement bien la route…J’ai donc pu passer à la suite:

2. Fabrication des codeurs

Oui, mon robot tient la route, mais il est loin d’être fiable… 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.

Opocoupleur à fourche

Schéma

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.

led infrarouge + phototransistor

ASTUCE: Pour vérifier que la led fonctionne correctement, filmez-la avec un téléphone ou appareil photo numérique et vous verrez au niveau de la led sur votre écran une lumière légèrement violette. Voir ci-dessous:

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

3. Interprétation des données: Connexion a l’arduino

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

A ce stade, je récupère mes informations sur les entrées d’interruption mais ces valeurs sont complètement incohérentes. Et pour cause:

Signaux de sortie de mes capteurs à fourche sans filtre

Mes signaux sont parasités par de multiples sources. Frottements mécanique, défauts de blindage, perturbations moteurs,…

J’ai donc ajouté un premier filtrage grâce à un simple montage RC.

Signaux de sortie de mes capteurs à fourche avec filtre du 1er ordre

C’est mieux mais pas suffisant. Donc, ajout d’un deuxième filtre RC (filtre du second ordre). Et puisque je voulais des beaux signaux exploitables, j’y ai ajouté un montage à transistor et voici le résultat:

Signaux de sortie de mes capteurs à fourche avec filtre du sec. ordre + transistor

Je peux maintenant attaquer mes entrées d’interruption sereinement.

 

4. Pilotage des moteurs

Maintenant, nous allons passer au pilotage des moteurs via une application PC.

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.

Synoptique de ma carte électronique.

Afin de pouvoir gérer la vitesse de rotation des moteurs on leur applique des signaux PWM. Pour un moteur, on va utiliser deux sorties de l’arduino: une sortie PWM et une sortie « tout ou rien ».

Pour générer un signal PWM, j’ai utilisé la librairie TimerOne car les fonctions PWM arduino ont une fréquence non réglable de 500Hz. Pour attaquer un BTS, une fréquence de 100Hz est préconisée.

Voici la mise en place des fonctionnalités de la librairie TimerOne dans le code de l’arduino:

#include <TimerOne.h>

void setup()
{
   Timer1.initialize(10000);//100Hz
}

//MA FONCTION PWM
void Pwm(int RC,int DG)
{
   //PWM timer1 car fréquence de 100Hz Pour les BTS
   Timer1.pwm(DG, RC);
   //DG = No de sortie, RC= Rapport cyclique
}

A ce stade, le robot dispose des éléments essentiels pour être piloté via une application PC connectée en USB.

Sur le même principe de pilotage (PMW, carte électronique, communication série) j’ai ajouté un plateau tournant ainsi qu’une plateforme pour y placer par la suite une caméra.

5. L’alimentation

Je commence à m’amuser avec mon robot, mais j’y vois aussi des failles qui surviennent.

Et l’une d’entre elle est l’alimentation. Les moteurs consomment du courant souvent par « pics » et l’arduino et autres transistors/capteurs demandent une alimentation stable et régulée de 5V.

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.

6. Intégration du raspberry pi

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.

3- Développement d’une application Android pour piloter mon robot.

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)

4- Activation de la vidéo

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%20Pi

INSERER UNE VIDEO

7. Gestion d’un servomoteur par un raspberry.

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.

8. Intégration d’opencv

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.

 

 

MAKER FAIRE PARIS 2016

A bientôt.

 

Bertrand