Projet QUAD - Lise Nicolas | Engineer

 Lise
NICOLAS
Stéphane LESSIEU-DUFOUR
_______ ____ _ _
Projet QUA D
_______ __ _ __
1/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Sommaire
Introduction ......................................................................................................... 3
Présentation des outils......................................................................................... 4
Le MBED NPX LCP1768 ..................................................................................... 4
Le Signal RS232 .................................................................................................... 5
Démarches et contraintes .................................................................................... 6
PROGRAMMATION DE LA CARTE MBED .................................................... 6
INTEGRATION DE LA TELECOMMANDE ................................................... 11
Répartition du travail ....................................................................................... 14
Conclusion .......................................................................................................... 15
2/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Introduction
Le projet Quad étant un nouveau projet lancé cette année par monsieur Bouaziz est le
projet qui nous a semblé le plus attractif. Nous l’avons donc choisi, les outils du projet étant
la programmation C sur ARM7, Visual C++ pour la partie PC, CAO pour les cartes à
réaliser. Comme nous n’avons eu que peu de cours d’informatique lors de ce semestre, nous
avions envie de consolider nos bases dans ce langage.
Le projet consistait à rendre autonome un Quad électrique. La première étape est de
déporter certaines commandes de ce Quad pour le contrôler à partir d’une radiocommande.
C’est dans cette partie que nous sommes intervenus.
L’émetteur radiocommande transmet plusieurs voies qui commandent plusieurs
grandeurs physiques (direction,…). Le récepteur est embarqué sur le Quad.
Cette année, les groupes travaillant sur le quad se sont occupés de créer une partie
de l’électronique qui contrôle ses voies et les convertit en des grandeurs permettant de piloter
les actionneurs.
D’autre part, dans les années futures des élèves permettront aux données capteurs
embarqués sur le Quad d’être remontés vers le pilote grâce à la transmission sans fil et
affichées sur PC.
Nous étions 4 binômes sur ce projet et nous nous sommes répartis les tâches en 4
étapes.
Le premier binôme, le nôtre, à simulé un récepteur radio 2.4GHz. (Nous y reviendrons plus
tard.)
Le second a codé l’émission : le passage du RS232 à Pwm.
Le troisième a codé la réception : le passage de Pwm à RS232
Le quatrième, a tiré les canaux du récepteur et les a convertis en différents signaux.
3/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Présentation des outils
Pour réaliser ce projet nous avons dû utiliser des outils que nous ne connaissions pas.
Tout d’abord le microcontrôleur utilisé : nous avons programmé sur un microcontrôleur
Arm7 MBED et plus particulièrement sur le MBED NPX LCP1768. Nous avons donc dû
nous renseigner (principalement sur www.mbed.org ) pour apprendre les différentes
bibliothèques et fonctions dont nous disposions.
Le MBED NPX LCP1768
Le microcontrôleur MBED de NXP LPC 1768 est conçu pour le prototypage de toutes
sortes de dispositifs, particulièrement ceux comprenant l’Ethernet, USB et la flexibilité d’un
nombre d’interfaces périphériques et de mémoire instantanée.
L’avantage de ces composant est qu’ils peuvent utiliser une multitude d’interfaces et de
périphériques (par exemple des bus USB, des ports séries et Ethernet,…).
Nous disposions d’un « CookBook » et d’un « HandBook » qui nous ont permis de comprendre
4/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Le Signal RS232
Nous allons simuler l’émission d’une trame de la radio commande. Pour cela, voici un petit
rappel sur cette trame. Cette trame est un signal RS232. Elle est composée de 21 octets dont
2 bits de start et un bit de fin. Elle est transmise avec le format :
2 bits de start
2x9
FF FF 00 00 _ _ _ _ _ _ _ _ _ _ _ _ _ _
1 bit de fin
EE
T= 115 200 bts/µs
Cette trame est émise durant une période T de 115 200 bits/µsecondes. Elle est répétée sur
un temps t.
T
t= 20000 µs
Le RS232 est une norme standardisant un bus de communication de type série sur trois
fils minimum. Les ports RS-232 sont désignés par les noms COM1, COM2, etc. Cela leur a
valu le surnom de « ports COM », encore utilisé de nos jours. Cependant, il est de plus en plus
souvent remplacé par le port USB.
.
5/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Démarches et contraintes
PROGRAMMATION DE LA CARTE MBED
Notre objectif était donc de simuler un récepteur radio 2,4GHz. Pour cela nous avons
donc codé un programme qui se lancera sur la carte MBED. Nous avons donc utilisé le
compiler intégré à la page internet sur www.mded.org . En commençant par ajouter la
bibliothèque « mbed.h », afin d’utiliser toutes les fonctionnalités de la carte pré installée.
Nous avons utilisé les constantes suivantes :
/**********************************************/
/***
BIBLIOTHEQUE
***/
/**********************************************/
#include "mbed.h"
/***********************************************/
/***
CONSTANTES
***/
/***********************************************/
#define PERIODE = 20000
#define VITESSE_TRANS = 115200
#define PAS = 100
// microsecondes
// bits/secondes
La période correspond au ‘t’ et la vitesse de transition au T vu sur le schéma page 5(Le
RS232). Le pas est l’indice que l’on peut modifier afin de faire varier plus ou moins la voie
sélectionnée.
Nous avons dû utiliser comme terminal TeraTerm, pour visualiser les données que l’on
affiche dans notre programme. Pour pouvoir utiliser un terminal sur le PC, il faut intégrer le
PC dans notre programme sur la MBED. Nous l’avons donc déclaré sous la forme :
Serial pc (USBTX, USBRX); //tx,rx
6/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz On déclare ensuite un port série sur les pattes p9 et p10 simulant le récepteur :
Serial sercom (p9, p10);
Pour finir on a également besoin d’un ticker, c’est une interface utilisée pour initialiser
une interruption périodique qui appelle à plusieurs reprises une fonction à une période t
choisie.
(Nous reviendrons sur son utilité ultérieurement).
Ticker periode_emission ;
La génération de trame série simulant un récepteur radio 2.4GHZ s’effectue par
l’intermédiaire d’une trame RS 232. Pour ce faire, nous avons travaillé avec le binôme
Michaël/Anas pour obtenir la trame RS 232 qui est envoyée par la télécommande sur le
récepteur. Grâce à leur algorithme qui permet d’afficher la trame en format RS 232 qui est
émise par la télécommande, lorsque que l’on place tous les boutons à zéro, on obtient une
trame que l’on supposera par défaut ; on prend désormais en compte la trame suivante :
unsigned char trame[21] = {0xFF, 0xFF, 0xFF, 0xFF, 0x2B, 0x19, 0x2B, 0x86,
0x2B, 0x0B, 0x2B, 0x09, 0x2B, 0x4D, 0x2B, 0x0F, 0x2B, 0x4D, 0x2B, 0x33, 0xEE};
Pour nous permettre une visualisation de cette trame lors de la réalisation de notre
programme, et de mieux voir où nous réalisions des erreurs, nous avons créé une fonction
basique qui affiche la trame :
/***************************************************************/
/***
Fonction qui affiche la trame
***/
/***************************************************************/
void affiche_trame( unsigned char *trame)
{
for(int i=0; i<21;i++)
{
pc.printf("0x%02X ",trame[i]);
}
pc.printf( "\r\n" );
}
7/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Suite à cette acquisition, on a exploré quel bouton/variateur agissait sur telle ou telle
voie de la trame. Nous avons alors mis en évidence que les joysticks, les paramètres qui nous
intéressent le plus pour le quad, occupent deux voies chacun. Comme nous avons configuré la
télécommande de telle sorte que nous utilisons uniquement 5 voies, nous avons déterminé que
la dernière voie correspond au bouton/variateur situé sur le côté latéral gauche de la
télécommande. Nous avons ensuite testé les valeurs obtenues sur les voies en se positionnant
sur les maximums et les minimums pour le variateur gauche, et les positions : haut, bas,
droite, gauche.
Nous nous sommes alors attaqué au cœur du programme. Le plus important est la
liaison entre la carte et l’ordinateur avec les bons paramètres, notamment la vitesse de
transmission qui doit correspondre à celle du format RS 232, celle par défaut étant pour
l’ordinateur 9600 b/s. Nous avons donc utilisé la fonction baud qui nous permet d’initialiser
cette vitesse à 115200b/s. Nous l’avons codé par définition de la manière suivante :
sercom.baud (VITESSE_TRANS);
Nous avons ensuite créé une fonction qui permet d’intégrer notre trame courante dans la
MBED, c’est notre fonction émission, on utilise donc « sercom.putc (trame[i]); :
/************************************************************************/
/***
Fonctions utilisées pour gérer le module de sortie
***/
/************************************************************************/
void emission()
{
unsigned short i;
for(i=0;i<21;i++)
{
sercom.putc(trame[i]);
}
}
Ensuite, nous avons utilisé la fonction attach qui est une fonction appelée par le ticker (vu cidessus qui rappelons-le répète une fonction avec une période donnée). Celle-ci prend donc en
paramètre l’adresse de la fonction à répéter et l’intervalle de temps souhaité.
periode_emission.attach_us (&emission, PERIODE);
8/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz On demande ensuite à l’utilisateur de sélectionner la voie à modifier et la valeur souhaitée,
étant donné que chaque voie s’échelonne sur 2 octets et que notre trame contient un seul octet
dans chaque case du tableau trame. Ainsi, on a fait en sorte que la valeur entrée par
l’utilisateur s’implémente correctement dans le tableau.
/*******************************************************/
/***
MAIN
***/
/*******************************************************/
int main()
{
unsigned int val, voie;
sercom.baud(VITESSE_TRANS);
periode_emission.attach_us(&emission, PERIODE);
affiche_trame(trame);
while(1)
{
pc.scanf(" %u %u",&voie,&val);
pc.printf("voie : %u, valeur : %u\r\n",voie, val);
voie=voie*2; //
trame[voie]= (val>>8)&0xFF;
// on récupère le bit de poids fort et le modifie
trame[voie+1]= val&0xFF;
// on récupère le bit de poids faible et le modifie
}
return 0;
}
9/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Quand le programme sur la MBED a été réalisé, nous avons visualisé sur l’oscilloscope le
signal série. Nous avons pu alors observer le signal série suivant : Figure 1 – Signal Série RS232 de la MBED Figure 2-­‐ Signal Série Zoomé RS232 de la MBED Il nous fallait, une fois la MBED programmée, intégrer un substitut de télécommande. 10/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz INTEGRATION DE LA TELECOMMANDE
Une fois que l’utilisateur peut saisir la voie et la valeur, nous pouvons alors intégrer le
pavé numérique du clavier afin de simuler la télécommande, à l'aide des touches de direction
du clavier. Cela nous permet une approche plus intuitive de la saisie d'une valeur pour une
voie donnée. Il est donc indispensable de communiquer entre la carte et le clavier. La carte
étant sur notre machine branchée au COM4. On ouvre à partir d'un nouveau programme,
cette fois-ci codé avec Visual C 2008 et non plus l'interface de compilation du site mbed.org.
Cette opération d'ouverture et d'écriture nécessite l'intégration de la librairie « Windows.h »,
qui intègre les paramètres principaux des fonctions importantes.
Nous avons donc commencé par écrire la fonction init_port(char* pcComPort) qui
retourne un port (type HANDLE). Cette fonction ouvre le port de nom pcComPort et écrit
un message par défaut avec les vérifications nécessaire pour n'importe quel port.
/********************************************************************/
/***
Fonctions qui ouvre le port serie de la mbed
***/
/********************************************************************/
HANDLE init_port(char* pcComPort)
{
DWORD rw;
DCB dcb;
BOOL b;
HANDLE hCom;
hCom = CreateFile(pcComPort, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0); //On ouvre le port serie COM4
if( hCom == INVALID_HANDLE_VALUE)
{ // HANDLE invalide ?
printf("Erreur lors de la création du HANDLE hCom. " );
printf("Le port ne peut pas être ouvert ?\n" );
return NULL;
}
BuildCommDCB("9600,n,8,1", &dcb);
b=SetCommState(hCom, &dcb);
if(!b)
{
printf( "Erreur lors du SetCommState" );
return NULL;
}
b = WriteFile(hCom, trame, strlen(trame), &rw, NULL);
if(!b)
{
printf( "Erreur lors de l ecriture de la trame par defaut" );
return NULL;
}
return hCom;
}
11/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Ensuite nous avons gérés la gestion des changements de valeurs à partir des touches
directionnelles du pavé numérique dans la fonction reception( ). Nous avons assigné un pas
déclaré constant. Ce pas nous permet pour chaque appuie sur une touche d'augmenter la
valeur par défaut de la voie, gérée par cette touche. Puis nous récupérons les appuies grâce à
la fonction getche( ) qui permet d'obtenir la saisie clavier (sans avoir a appuyer sur le retour
chariot). Pour pouvoir utiliser cette fonction il nous a fallut inclure la bibliothéque
« conio.h ». Puis pour finir nous avons dû ajuster notre code pour qu'il corresponde à celui
programmer sur la mbed, notamment au niveau de la saisie par l'utilisateur de la voie et de la
valeur que l'on automatise ici. On utilise la fonction WriteFile pour écrire la nouvelle trame
modifiée par le switch suivant la valeur de getche.
/************************************************************************/
/***
Fonction qui traite la voix sélectionnée au clavier
***/
/************************************************************************/
char reception()
{
BOOL success;
DWORD BytesWriten;
char c;
c=getche();
switch(c)
{
case '8' : // corespond au joystick gauche en haut
valtab[2]+= PAS;
sprintf(trame,"3 %u\n\r",valtab[2]); //voie 3
break;
case '2' : // corespond au joystick gauche en bas
valtab[2]-= PAS;
sprintf(trame,"3 %u\n\r",valtab[2]); //voie 3
break;
case '4' : // corespond au joystick droit a gauche
valtab[0]+= PAS;
sprintf(trame,"1 %u\n\r",valtab[0]); //voie 1
break;
case '6' : // corespond au joystick droit a droite
valtab[0]-= PAS;
sprintf(trame,"1 %u\n\r",valtab[0]); //voie 1
break;
case '+' : // corespond au bouton lateral gauche au max (+)
valtab[6]+= PAS;
sprintf(trame,"7 %u\n\r",valtab[6]); //voie 7
break;
case '-' : // corespond au bouton lateral gauche au min (-)
valtab[6]-= PAS;
sprintf(trame,"7 %u\n\r",valtab[6]); //voie 7
break;
case 'q' : //quitter
12/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz return 1;
break;
default :
return 0;
break;
}
/* Ecrit la voie modifiee dans le port COM */
success = WriteFile(mycom, trame, strlen(trame), &BytesWriten, NULL);
if (!success) /* Verifie si il y a une erreur */
{
printf("ERREUR EMISSION\n");
return 1;
}
return 0;
}
Nous avons aussi par la suite commencés à intégrer une manette de XBOX 360 de la même
manière que nous avions codés l’ouverture du port du clavier. Cependant par manque de temps nous
n’avons pas pu terminer cette démarche mais somme parven, après maintes recherches sur internet, à
afficher les coordonnées des joysticks de la manette sur le pc.
13/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Répartition du travail
Le but de ce projet était de réaliser un travail d’équipe. Nous avons unanimement
décidé de travailler ensemble. Le projet a donc été réalisé à deux du début à la fin. Le travail
en groupe nous paraît essentiel et bien plus instructif pour ce genre de projet De cette
manière nous avons pu nous aider mutuellement sur nos lacunes et progresser. Chacun
d’entre nous a donc participé à l’élaboration chaque fonction : en cherchant l'idée générale,
en la traduisant en langage C ou bien encore en trouvant l'idée qui nous débloque après
l'écriture d'une mauvaise fonction ou d’une fonction incomplète.
14/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz Conclusion
Notre programme C pour ce projet a été mené à son terme. Nous avons
rencontré quelques difficultés que nous avons réussi à contourner ou à régler et nous avons
également eu la volonté et le temps nécessaire pour commencer l’ajout d’une manette
XBOX 360 comme substitut de télécommande pour contrôler notre MBED. Cette dernière
étape nous permet de finaliser le projet en le rendant plus concret et plus attrayant.
L’enseignement Projet C nous a permis d’une part de nous améliorer en
programmation C et de pousser plus loin nos connaissances dans ce langage. D’autre part,
on a pu voir en quoi consiste la réalisation d’un projet du début jusqu’à la fin en respectant
un cahier des charges, c’est-à-dire les critères, volontés et contraintes imposées par le
« client » tout en respectant également le temps imparti pour sa réalisation.
15/15 ET3 Tuteur de Projet: Mr. Samir Bouaziz