Bras robotisé MATLOG

En collaboration avec notre partenaire MATLOG, nous avons consacré de nombreux ateliers à la création d’une maquette robotisée à base de composants XBee et d’un contrôleur Rabbit puis d’une Arduino.

Mise à jour de mars 2012 : une nouvelle vidéo montre la seconde version du bras.

Le projet a servi à des démonstrations sur différentes manifestations publiques :
 les rencontres "sciences et techniques" d’Antibes
 la Fête de la Science à Valbonne
 le salon du modélisme de Mougins
 le colloque des IUT GEII de France
 le Real Time System, salon Parisien majeur

Une plate-forme robotisée réagit en temps réel à son environnement en utilisant des capteurs sans-fil pour la détection

 Elle saisit des objets pour les montrer
 Elle joue des musiques selon les phases du programme
 Elle réagit à une présence

 Matériel nécessaire

L’électronique

 1 carte programmable Rabbit MiniCore RCM5700 ou 1 carte programmable Arduino
 1 XBee ZB serie 2 avec antenne RPSMA (réf. Matlog XBP24-Z7SIT-004J) pour la plate-forme Rabbit
 1 antenne RPSMA 2,4 GHz (réf. Matlog A24-HASM-450)
 2 XBee Sensors (réf. Matlog XS-Z16-CB1R) pour capteurs de lumière et de température.

Nous avons conçu un circuit électronique fait-maison pour fixer les différents composants et supporter la mécanique.

Des rubans à leds RGB pilotés par PWM permettent de changer de couleur.

La mécanique

Le projet était initialement prévu pour un système simple :

 deux servomoteurs standard 3 kg.cm
 mécanique "pan & tilt" Zartronic
 un plateau 25x25 cm en plexiglas

Mais nous avons ensuite opté pour un bras à 6 degrés de liberté dont vous pouvez suivre les étapes de construction.

L’alimentation

Le robot n’est pas mobile, on peut donc utiliser une alimentation secteur 9 volts et 4 ampères connectée à des régulateurs de tension :

 alimentation de 5 ou 6 volts pour les servomoteurs
 alimentation de 3,3 volts pour l’électronique de contrôle
 batteries pour les capteurs (déjà intégrées pour les Xbee Sensors)

 Détails techniques

Résistance aux parasites

Pour pouvoir utiliser ce montage dans un environnement "bruité", il faut bien choisir la fréquence, la puissance et l’emplacement sur le circuit. En effet le montage peut être affecté (perte de signal, débit réduit ou freeze de la réception pendant plusieurs secondes) à cause de parasites venant d’appareils électroniques fonctionnant dans la même gamme de fréquence, comme du Wifi, du Bluetooth, des talkies-walkies..

On choisit donc pour ce projet un modèle à 2,4 GHz mais avec une puissance de 10 mW (autorisée en Europe) et une antenne RPSMA.

 Réalisation

Fabrication

Menuiserie bois et PVC

Polycarbonate pour le dessus

On soigne les détails

Les rubans de leds

Fixation des cartes

Les derniers éléments

La musique adoucit les moeurs

Test de la liaison XBee

Résultat

Une fois sous tension, on peut tester les mouvements du bras et

Le bras et son capteur

Lumière !

La pince attrape un objet

Le bras en place

Prêt pour l’envoi !

Et c’est fini !

 Programmation

Le contrôle du bras

Il y a 6 servomoteurs pour le bras. Chaque servo peut tourner de 180 degrés avec le code de la bibliothèque Servo du langage Arduino (C++) mais bien entendu pour des raisons mécaniques, l’angle de débattement est restreint et dépend de chaque articulation.

Un fichier bras.h est créé pour gérer le bras et lui faire prendre différentes positions pré-programmées. C’est lui aussi qui gère les couleurs prises par la plate-forme, ce qui facilitera le débogage.

On commence par déclarer les bibliothèques utilisées, les fonctions utiles de la carte Arduino et les fonctions spécifiques aux servomoteurs :

#include "Arduino.h"
#include "Servo.h"

Ensuite on déclare une variable pour chaque servomoteur :

Servo s1 ;
Servo s2 ;
Servo s3 ;
Servo s4 ;
Servo s5 ;
Servo s6 ;

Et on assigne les pattes (p) à une variable de chaque couleur :

int prouge = 4 ;
int pvert = 5 ;
int pbleu = 6 ;

Un tableau gère différentes positions, après qu’on s’est assuré que les enchaînements ne mettent pas en péril l’équilibre du bras. En effet les efforts peuvent être importants, et c’est pour cela qu’on a utilisé du polycarbonate pour la plaque, bien plus rigide que du plexiglas.

int positions[][9] =
0, 15,180, 60,165,170, 0, 0, 0, // stable coté
80, 15,180, 60,165,170, 0, 0, 0, // stable devant
120, 80,110, 60,165,170,255, 0, 0,
120,120, 90, 30, 0,170,255, 0, 0,
120,120, 90, 30, 0,170,255, 0, 0, // au-dessus
120,120, 90, 30, 0, 60,255, 0, 0, // ouvrir
120,137, 80, 30, 0, 60,255, 0, 0, // baisser
120,137, 80, 30, 0,180, 0,255, 0, // serrer
120, 80, 80, 30, 0,180, 0,255, 0,
120, 80, 80, 60, 0,180, 0,255, 0,
80, 60,120, 60, 165,180, 0, 0,255, // milieu
80, 60,120,120, 0,180, 0, 0,255,
80, 60,120, 80, 0,180, 0, 0,255,
0, 80,120, 80, 0,180, 0, 0,255, // 12
0, 80, 90, 30, 0,180, 0,255, 0,
0, 80,130, 30, 0,180, 0,255, 0,
0, 90,165, 60, 0,180, 0,255, 0, // 15 au dessus
0, 90,165, 60, 0, 60,255, 0, 0, // 16 ouvrir
0, 95,160, 60, 0, 60, 0, 0,255, // 17 descendre
0, 95,160, 60, 0, 180, 0, 0,255, // 18 fermer
 ;

Les 6 premières valeurs gèrent les servomoteurs, tandis que les 3 dernières gèrent les couleurs.

Au cas où ça vous ait échappé, "ouvrir" et "serrer" désigne la pince, tandis que les autres commentaires désignent différents mouvements du bras.

Une fonction d’initialisation (setup en anglais) permet de déclarer la patte de la carte Arduino Roméo à laquelle est attachée un servomoteur.

void setup_bras()

s1.attach(10) ;
s2.attach(9) ;
s3.attach(12) ;
s4.attach(8) ;
s5.attach(7) ;
s6.attach(11) ;

Une seule fonction permet de commander depuis le programme principal l’une des autres positions.

void position_bras(int i)

// changer les servos
s1.write(positions[i][0]) ;
s2.write(positions[i][1]) ;
s3.write(positions[i][2]) ;
s4.write(positions[i][3]) ;
s5.write(positions[i][4]) ;
s6.write(positions[i][5]) ;
// changer les couleurs
analogWrite(prouge,positions[i][6]) ;
analogWrite(pvert,positions[i][7]) ;
analogWrite(pbleu,positions[i][8]) ;

Gestion du son

Un fichier son.h regroupe les fonctions permettant de gérer le son. Le module utilisé se pilote avec des sorties numériques tout ou rien selon le protocole suivant :

 une patte pour remettre l’indice à zéro
 une patte pour sélectionner le fichier à jouer

Les fichiers sont des sons de robot (ben oui, on se refait pas...) au format PCM spécifique à la carte.

Comme pour le bras, on appelle la bibliothèque de fonctions Arduino :

#include "Arduino.h"

Puis on initialise la carte, avec les différentes pattes en sortie pour signaler à la carte le mode souhaité :

int indice_son = 0 ; // indice du morceau joué

void setup_son()

pinMode(14,OUTPUT) ;
pinMode(15,OUTPUT) ;
pinMode(16,OUTPUT) ;
pinMode(17,OUTPUT) ;
pinMode(18,OUTPUT) ;
pinMode(19,OUTPUT) ;

digitalWrite(14,HIGH) ;
digitalWrite(15,HIGH) ;
digitalWrite(16,HIGH) ;
digitalWrite(17,HIGH) ;
digitalWrite(18,HIGH) ;
digitalWrite(19,HIGH) ;

digitalWrite(16,LOW) ;
delay(1000) ;

Jouer un son est très simple : on initialise le lecteur avec la patte 16, et on passe rapidement les morceaux jusqu’à trouver le bon.

void jouer_son(int i)

int j = i ;
digitalWrite(16,LOW) ;
delay(200) ;
digitalWrite(16,HIGH) ;
delay(200) ;
while (j > 0)
digitalWrite(17,LOW) ;
delay(200) ;
digitalWrite(17,HIGH) ;
delay(200) ;
j— ;

La gestion du XBee

On en arrive à la partie la plus intéressante : interroger le XBee Sensor. On communique avec lui par la liaison série sans-fil. La configuration par défaut lorsqu’on commande le module à MATLOG permet une utilisation directe avec un second XBee de même série mais cette-fois connecté au micro-contrôleur par l’UART.

Ce code est placé dans le programme principal (fichier .ino ou .pde). On commence par quelques initialisations : on utilise le capteur pour passer du mode DEMO au mode DETECT lorsqu’un obstacle passe devant le capteur de luminosité du XBee Sensor.

int xbee_count = 0 ;
int xbee_val = 0 ;

int index = 0 ;

#define DEMO 0
#define DETECT 1

int mode = 0 ;

L’initialisation consiste simplement à démarrer une communication série à 9600 bauds comme on ferait avec un câble USB.

void setup()

Serial.begin(9600) ;

Le module envoie automatiquement une trame API du protocole XBee : cette trame est très bien décrite dans la documentation, mais nous avons uniquement besoin de savoir qu’elle commence par 0x7E et qu’il y a 21 octets avant d’avoir l’information de présence. Tout ce qui vient entre ou après peut être jeté.

void loop()

// lecture du port série
while ( Serial.available() > 0)
char val = Serial.read() ;
if (val == 0x7E)
// remettre à zéro la lecture de la trame
xbee_count = 0 ;

else
xbee_count++ ;
if (xbee_count == 21 && val == 0x00)
// changer de mode
mode = DETECT ;

Et c’est fini !! Le mode DETECT se charge d’exécuter une séquence particulière et de repasser en mode démo.

Une petite astuce : le XBee Sensor envoyant automatiquement les messages, il faut les supprimer quand on n’est pas intéressé (avant de repasser en mode démo par exemple) :

// vider le buffer série pour toutes les détections ayant eu lieu
while (Serial.available() > 0)
Serial.read() ;

Programme complet pour le bras

Vous voilà prêt à explorer les réseaux domotiques avec toute la gamme de capteurs sans-fil commercialisée par MATLOG sur son site Internet.