mise en oeuvre du robot - ensta paris

Philippe Meyne – 02/04/2012

Mise en œuvre du robot

2

Sommaire

��

I– ARCHITECTURE DU ROBOT ............................................................................................................................ 3

1.1 – STRUCTURE GENERALE...................................................................................................................................... 3 1.2 – ACTIONNEUR : AX-12 ....................................................................................................................................... 4 1.3 – CAPTEUR : AX-S1 ............................................................................................................................................. 5 1.4 – PARTIE COMMANDE CM-5 ................................................................................................................................ 5 1.5 – COMMUNICATION INTER-MODULE ..................................................................................................................... 6

II – PROGRAMMATION DU ROBOT – OUTILS DE DEVELOPPEME NT...................................................... 7

2.1 – SOUS WINDOWS ................................................................................................................................................ 7 2.2 – SOUS LINUX ...................................................................................................................................................... 8 2.3 – EXEMPLE DE PROGRAMMATION : GESTION DES LEDS......................................................................................... 9 2.4 – EXEMPLE DE PROGRAMMATION : GESTION DU BUS DE LA CARTE CM-5 ............................................................ 9 2.5 – NOTION DE MACHINE D’ETAT .......................................................................................................................... 11

ANNEXE 1 : ACTIONNEUR AX-12 ....................................................................................................................... 13

ANNEXE 2 : ACTIONNEUR AX-S1 ....................................................................................................................... 20

ANNEXE 3 : INSTRUCTIONS DE GESTION DES ACTIONNEURS ET DES CAPTEURS .......................... 31

ANNEXE 4 : REGISTRES DU PROCESSEUR ATMEG128 ............................................................................... 34

SOURCES................................................................................................................................................................... 36

3

La mise en œuvre du robot utilise le système Bioloid de Robotis. Il s’agit d’un ensemble de pièces mécanique, de servomoteurs et de capteurs permettant de mettre en œuvre différents types de robots. Cette partie a pour objectifs de donner quelques pistes sur la structure générale d'un système automatisé appliquée au robot, la description des éléments constituants du système Bioloid et des informations techniques relatives à la mise en œuvre du robot.

I– Architecture du robot

1.1 – Structure générale La structure générale d'un système automatisé de type robot est construite autour de trois éléments constituants :

• Partie Commande • Actionneur • Capteur

Ces trois constituants communiquent entre eux, généralement, via un bus de terrain. Il s'agit d'un réseau bas niveau qui permet d'interconnecter les constituants. Le plus souvent ce bus est construit selon un modèle de type maître esclave. Ce bus de terrain peut être soit une solution propriétaire, soit normalisé comme I2C, MODBUS, CAN, PROFIBUS ou, dans les cas plus complexes, ETHERNET.

Les actionneurs sont des dispositifs destinés à réaliser une action. Ils sont constitués d'un dispositif électromécanique comme un moteur à courant continu, synchrone ou asynchrone ou encore d’un vérin hydraulique associé à une servocommande, d'une électronique de commande réalisant l'asservissement du dispositif, et d'une interface qui permet de mettre en œuvre la communication via un bus de terrain. Les capteurs sont des dispositifs qui permettent au robot d'obtenir des informations sur le milieu dans lequel il évolue. Ils sont constitués de transducteurs qui convertissent une grandeur physique comme la pression, la force, la lumière en une grandeur électrique : tension, courant, résistivité. Le transducteur est associé à un conditionneur. Ce conditionneur est un dispositif électronique

4

qui permet de traiter la grandeur électrique. Une interface réseau permet de réaliser la communication avec la partie commande. La partie commande permet au robot de piloter les actionneurs en fonction des informations issues des capteurs. La partie commande est construite autour d'une carte processeur plus ou moins perfectionnée en fonction de la complexité des tâches à réaliser par le robot.

1.2 – Actionneur : AX-12 Les actionneurs disponibles dans la boîte BIOLOID BEGINNERS sont des servomoteurs. Ils sont constitués d'un moteur à courant continu asservi en vitesse et en position. Ces moteurs sont associés à un engrange de précision et à une interface réseau qui permet à l'actionneur de communiquer avec la partie commande.

Les caractéristiques principales de ces actionneurs sont :

5

1.3 – Capteur : AX-S1 Le module AX-S1 contient plusieurs fonctionnalités associées à des capteurs. La première fonctionnalité permet de gérer des sons. Elle est constituée d'un micro et d'un buzzer. La seconde fonctionnalité est constituée de trois diodes électroluminescentes infrarouges et de trois photodiodes infra rouge.

Dans la figure ci-dessus, une seule paire de diodes infrarouges a été représentée.

1.4 – Partie Commande CM-5 La partie commande est constituée d'une carte processeur insérée dans un boîtier. Ce boîtier possède une entrée sortie (PC-link) permettant de piloter ce module via un ordinateur, d’une borne d’alimentation 12V DC, de deux boutons permettant la commande de l’état du module (START et MODE), de 7 leds permettant de connaître l’état du module et d’un connecteur (BUS) permettant la commande des actionneurs et des capteurs. Ce boîtier contient en plus des accumulateurs constituant l’alimentation du système.

Elle est construite autour d'un microcontrôleur Atmel Atmega 128. Le cœur du microcontrôleur est un processeur RISC 8 bits. Il possède 133 instructions. Ce processeur est associé à 128 Ko de mémoire flash destinée à accueillir le code de l'application, 4ko de mémoire EEPROM et 4ko de mémoire RAM statique. En outre, il dispose de plusieurs périphériques. Il s'agit de dispositifs

6

permettant de réaliser des fonctionnalités particulières à ce type de mise en œuvre. Parmi ces périphériques, les plus intéressants pour la commande d'un robot sont :

• quatre TIMER/COUNTERS qui permettent la gestion du temps ; • 7 ports d’entrée sortie parallèle multi usage ; • 2 UART (Universal, Asynchronous, Receiver, Transmitter) qui permettent de gérer les

communications : un pour la communication PC/CM-5 pour le téléchargement du code et un autre pour la communication inter-module.

1.5 – Communication inter-module La communication inter-module utilise une norme propriétaire. Il s'agit d'un bus trois fils : deux fils d'alimentation (9,6V et GND) et un fil de données. Sur la ligne de données circulent en série deux types de messages :

• Des messages de type « instructions » qui permettent de donner des ordres aux actionneurs et aux capteurs ;

• Des messages de type « état » qui permettent des d'avoir un retour sur l'état du dispositif concerné.

Les messages de type « instruction » sont structurés selon la trame suivante :

Les deux premiers champs sont des champs délimiteurs. Le champ « ID » est l'identificateur du dispositif concerné par l'instruction. Il est compris entre 0x00 et 0xfd soit 254 ID possibles. Le champ « L » donne la longueur du message en nombre d'octets calculée sur les champs qui suivent. Le champ « Instruction » contient l'instruction, c'est-à-dire la fonction que le dispositif esclave : actionneur ou capteur, doit réaliser. Ce champ est suivi des paramètres nécessaires à l'exécution de la fonction. Ces fonctions sont décrites en annexe 3. Enfin la trame est terminée par un champ de type somme de contrôle permettant de vérifier l'intégrité du message. Ce champ est calculé comme le complément de la somme des champs ID, L, Instruction et paramètres. Si cette somme dépasse 255, seul l'octet de poids faible est utilisé. Lorsqu'un dispositif reçoit un message de type « instruction » de la partie commande, il répond avec un message de type « Etat » structuré selon la trame suivante :

Le champ ID contient l'identificateur du dispositif qui émet ce message. Le champ « L » donne la longueur de la trame en octet calculée sur les champs qui suivent. Le champ « Erreur » pour un module actionneur contient un octet dont la signification est donnée dans le tableau suivant :

7

II – Programmation du robot – Outils de développement

2.1 – Sous Windows La carte peut être programmée de deux manières différentes. La première méthode consiste à utiliser l'outil propriétaire fourni avec le robot. Il s'agit d'un atelier logiciel graphique qui permet de générer du code téléchargeable sur la carte. La seconde méthode est de programmer l'application directement en assembleur/C. Pour cela, il faut disposer d’un compilateur croisé qui permet de générer à partir d'un PC un code exécutable pour le processeur ATMEGA 128. Il en existe plusieurs, le plus intéressant est le compilateur gnu avr-gcc. Sous Windows, il est possible de le télécharger à l’adresse :

http://winavr.sourceforge.net/

L’outil AVR Studio permet de saisir et de compiler et de simuler le code. Il est fourni par ATMEL, le constructeur des processeurs de la famille AVR. Il est possible de le télécharger à l’adresse :

http://www.atmel.com/dyn/Products/tools_card.asp?tool_id=2725 Lorsque le programme source est compilé, un code exécutable pour un processeur AVR est généré. Ce code exécutable doit être téléchargé sur la carte CM-5. Sous Windows, il est possible d’utiliser l’outil fourni dans le CD de la boîte Bioloid. Pour cela, lancer l’application « Behavior Control programmer ». Dans le menu : « Management », choisir l’item : « Recovery » et suivre les instructions. Le fichier à télécharger est un fichier au format HEX (extentsion .hex) résultant de la compilation du programme source.

8

2.2 – Sous Linux Sous linux, les outils sont installés sur les postes de l'ENSTA ParisTech dans le répertoire : /usr/local/pack/OpenBioloid-0.1.0. Pour compiler votre application codée en assembleur/C, il suffit de copier dans votre répertoire de travail le Makefile placé dans le répertoire : /usr/local/pack/OpenBioloid-0.1.0/devCM5/examples/hello. Il faudra ensuite l’adapter à votre application en modifiant le nom du fichier source (par défaut Main.c) et de l'exécutable. Ce makefile est le suivant : TARGET=hello # nom de l'exécutable OBJECTS =\ ./Main.o export BIOLOID_DIR = /usr/local/pack/OpenBioloid-0. 1.0 export GNU_AVR_PATH = $(BIOLOID_DIR)/tools/build export LIB_CM5_PATH= $(BIOLOID_DIR)/devCM5/libCM5 CC = $(GNU_AVR_PATH)/bin/avr-gcc OBJCOPY = $(GNU_AVR_PATH)/bin/avr-objcopy OPTIM_LEVEL = s CFLAGS = -g CFLAGS += -O$(OPTIM_LEVEL) CFLAGS += -funsigned-char -funsigned-bitfields -fpa ck-struct -fshort-enums CFLAGS += -Wall -Wstrict-prototypes CFLAGS += -std=gnu99 CFLAGS += -I$(LIB_CM5_PATH)/include all: $(TARGET).hex $(TARGET).bin $(TARGET).elf: $(OBJECTS) $(CC) -mmcu=atmega128 -o $@ $(OBJECTS) $(LIB_CM5_P ATH)/libCM5.a %.hex:%.elf $(OBJCOPY) -O ihex -R .eeprom $< $@ %.bin:%.elf $(OBJCOPY) -O binary -R .eeprom $< $@ %.o:%.c $(CC) -mmcu=atmega128 $(CFLAGS) -o $@ -c $< clean: rm -f $(OBJECTS) cleaner: clean rm -f $(TARGET).elf \ $(TARGET).hex \ $(TARGET).bin

Pour générer le code exécutable, il suffit d'utiliser la commande : make.

La compilation fournit plusieurs fichiers dont l'extension est respectivement : hex, bin et elf. Le fichier dont l'extension est hex est un fichier dont le format est de type HEX, à savoir un format transfert de code pour les processeur INTEL. Il est possible de télécharger ce fichier sur la carte à l'aide de l'outil « Behavior Control programmer » sous Windows ou à l'aide de l'outil IUSP sous Linux. Sur les machines de l'ENSTA ParisTech, l'outil qui permet de programmer les cartes CM5

9

est l'outil BioUpload. Cet outil utilise le fichier dont l'extension est : bin. La commande type est :

BioUpload -i <nom du fichier>.bin

Cet outil utilise la liaison série mise à disposition sur le port COM (EIA 232). Elle doit être configurée par la commande suivante :

stty 57600 cs8 -parenb -F /dev/ttyS0

2.3 – Exemple de programmation : gestion des leds Le programme suivant permet d’allumer une led sur deux sur le module CM-5 : int main(void) { // init du port C en sortie, D en entrée asm( "ldi r16,0xff" "\n\t" // Port C En sortie "sts 0x34,r16" "\n\t" "ldi r16,0x00" "\n\t" // Port D en entrée "sts 0x31,r16"); // init pull up asm( "lds r16,0x40" "\n\t" // r16 <- SFIOR "andi r16,0xfb" "\n\t" // PUD <- 0 "sts 0x40,r16"); // eteindre les leds asm( "ldi r16,0xaa" "\n\t" "sts 0x35,r16"); while(1) {} }

L’instruction asm permet d’insérer du code assembleur dans un programme C. Ce code permet d’avoir directement accès aux registres de programmation du processeur. Ces registres sont accessibles en lecture et en écriture à une adresse qui leur est propre (cf. annexe 4). Ainsi les instructions suivantes :

lds r16,0x40 andi r16,0xfb sts 0x40,r16

réalisent les opérations, un chargement d’un registre (r16) à la valeur contenu à l’adresse 0x40, puis réalisent un masque sur le registre de façon à placer le bit 2 à 0 puis réécrivent le contenu du registre r16 à l’adresse 0x40. La boucle sans fin qui termine ce programme est due au fait qu’il n’y a pas de système d’exploitation sur ce type de carte et que le processeur n’a donc rien d’autre à faire.

2.4 – Exemple de programmation : gestion du bus de la carte CM-5 Le programme suivant permet d’émettre une trame permettant de faire tourner un actionneur AX-12 à la vitesse 80 :

10

/* init bus serie 0 robot */ void init() { /* initialisation des ports du processeur : tous l es ports en entrées */ asm( "clr r16" "\n\t" // r16<-0 "out 0x3a,r16" "\n\t" // ddra <-0 "out 0x17,r16" "\n\t" // ddrb <-0 "out 0x14,r16" "\n\t" // ddrc <-0 "out 0x11,r16" "\n\t" // ddrd <-0 "sts 0x61,r16" "\n\t" // ddrf <-0 "sts 0x64,r16" "\n\t" // ddrg <-0 "ldi r16, 0x0e" "\n\t" // Pe0(Rxd) en entre // Pe1(Txd) en sortie // Pe2, Pe3 en sortie pilotage du bus // Pe4 à Pe7 en entre interrupteur "out 0x22,r16" "\n\t" // initialisation ddre "lds r16,0x20" "\n\t" // SFIOR(PUD) <-1 pull up are one "andi r16,0xfb" "\n\t" "sts 0x20,r16"); /* initialisation du port D pour liaison série */ asm( "sbi 0x11,3"); // DDRD(3) <- 1 (TXD1 en sorti e) // Initialisation de la vitesse de la liaison séri e et du format

// 8 bits // et 1 stop bit

asm( "ldi r16, 0x02" "\n\t" // format 8 bit et n stop bit "ldi r17, 0x00" "\n\t" // vitesse de la liaison s érie "ldi r18, 0x22" "\n\t" "ldi r19, 0x18" "\n\t" "sts 0x2a, r19" "\n\t" //USART0 Control and Statu s Register B "sts 0x90, r17" "\n\t" // USART0 Baud Rate Regist er High "sts 0x29, r18" "\n\t" // USART0 Baud Rate Regist er Low "sts 0x2b, r16"); // USART0 Control and Status Register A } /************************* envoie d'un caractère */ /* entrée car : caractère à émettre */ /* retour : néant */ void emission(unsigned char car) { unsigned char status; // état de la liaison /* bit de direction à 1 : pe2 = 0 et pe3 = 1 */ asm( "lds r16,0x23" "\n\t" // lecture état du por t E "andi r16,0xfb" "\n\t" // masque pour Pe2 à la bo nne valeur "ori r16,0x08" "\n\t" // masque pour Pe3 à la bon ne valeur "sts 0x23,r16"); // écriture état du port /* lecture du registre d'état de la liaison */ asm( "lds %0,0x2b ": "=r" (status)); /* attente que le registre soit vide */ while((status&0x20)==0x00) { // lecture du registre d'état asm( "lds %0,0x2b ": "=r" (status)); } /* ecriture du caractère dans le registre d'émissi on */ asm( "ld r16,%a0" "\n\t" "sts 0x2c, r16" : : "e" (&car)); } // fin émission /************************* réception d'un caractère */ /* entrée néant */ /* retour : caractère reçu */ unsigned char reception() {

11

unsigned char status; // etat de la liaison unsigned char car; // caractère recu */ /* bit de direction à 0 : pe2 = 1 et pe3 = 0*/ asm( "lds r16,0x23" "\n\t" // lecture état du por t E "andi r16,0xf7" "\n\t" // masque pour Pe2 à la bo nne valeur "ori r16,0x04" "\n\t" // masque pour Pe3 à la bon ne valeur "sts 0x23,r16"); // écriture état du port /* lecture du registre d'état de la liaison */ asm( "lds %0,0x2b ": "=r" (status)); /* attente registre soit vide */ while((status&0x80)==0x00) { asm( "lds %0,0x2b ": "=r" (status)); } /* ecriture du caractère dans le registre d'émissi on */ asm( "lds %0,0x2c" : "=r" (car)); return(car); } // fin reception int main(void) { init(); // initialisation du bus du robot emission(255); emission(255); emission(2); emission(7); emission(3); emission(30); emission(0); emission(0); emission(80); emission(0); emission(133); while(1) {} } La fonction init() permet d’initialiser les périphériques qui gèrent le bus de terrain de la carte CM-5. La fonction emission() permet d’émettre sur le bus un champ (cf partie 31.4). La fonction reception() permet de recevoir un champ quand un des modules répond. L’émission d’une trame revient à l’émission d’une suite de caractères selon le protocole donné dans la partie 31.4.

2.5 – Notion de machine d’état Une machine d’état est un système qui évolue en fonction de combinaison d’informations issues de capteurs. La machine reste dans un état donné tant que les conditions de son évolution ne sont pas remplies. L’évolution d’une machine d’état peut être décrite soit avec un GRAFCET soit avec un « diagramme à bulle ». La description de type GRAFCET s’applique particulièrement aux automatismes. Dans le cas qui nous intéresse, le diagramme à bulle est plus intéressant car plus souple. Chaque état est décrit par une bulle identifiée par un numéro, les conditions de sortie de l’état sont portées sur le diagramme au moyen d’une combinaison logique d’information :

12

Sur la figure précédente, les états sont exclusifs. En conséquence, si la « condition 1 » est vraie, la « condition 2 » est fausse. Il est possible d’implanter ce type de machine en C en utilisant un code du type : while(1) { switch (etat) { case etat_1 : // etat 1 while (condition de sortie de l’état 1 == FALSE) { Action état } break; case etat_2 : // état 2 while (condition de sortie de l’état 2 == FALSE) { Action état } break; … // description de tous les états default : // dans tous les autres cas while (condition de sortie == FALSE) { Action état } } }

Ce type de programmation est particulièrement adapté à ce type de commande de dispositifs robotiques.

13

Annexe 1 : Actionneur AX-12 ��

Du point de vue du bus de terrain, l’actionneur AX-12 se comporte comme une mémoire dans laquelle il est possible de lire et d’écrire. A chaque adresse de cette mémoire correspond une fonctionnalité précise décrite dans le tableau suivant :

14

La description d’une action (lecture ou écriture) d’une donnée aux adresses de la table est la suivante :

20

Annexe 2 : Actionneur AX-S1 ��

Du point de vue du bus de terrain, le module capteur AX-S112 se comporte comme une mémoire dans laquelle il est possible de lire et d’écrire. A chaque adresse de cette mémoire correspond une fonctionnalité précise décrite dans le tableau suivant :

21

La description d’une action (lecture ou écriture) d’une donnée aux adresses de la table est la suivante :

31

Annexe 3 : Instructions de gestion des actionneurs et des capteurs ��

Le tableau suivant résume les instructions d’une trame de type « instructions » :

34

Annexe 4 : Registres du processeur ATMEG128 ��

36

Sources ��

Ingénierie système Site de l’AFIS : http://old.afis.fr/praout/accueil/accueil.html Bioloid Documentations techniques disponibles sur : http://www.robotis.com/zbxe/software_en ATMEGA 128 Documentations techniques disponibles sur : http://www.atmel.com/dyn/products/product_card.asp?part_id=2018 Outils de développement disponibles sur : http://www.atmel.com/dyn/products/tools_v2.asp?family_id=607 http://www.avrfreaks.net/

mise en oeuvre du robot - ensta paris

Documents