Contrôle d`impulsions : le sonar

DUT informatique, TP temps-réel n° 6 2015
P. Kauffmann
MODULE TEMPS-REEL EMBARQUE
Contrôle d’impulsions
:
le sonar
1. Présentation
De nombreux capteurs fournissent en guise d’information des impulsions répétitives dont la
longueur est proportionnelle à la grandeur mesurée, car le temps (durée d’une impulsion) et
moins sujet aux bruits électroniques qu'un signal analogique sous forme de tension.
Par ailleurs, si certains actionneurs sont commandés directement par un signal analogique en
provenance d’un convertisseur N/A, d’autres sont contrôlés en leur appliquant des impulsions
répétitives dont la largeur est proportionnelle à la grandeur contrôlée. C’est un signal
périodique de fréquence fixe mais de rapport cyclique variable appelé PWM en anglais (Pulse
Width Modulation) et MLI (Modulation de Largeur d’Impulsion) en français.
Dans ce TP de 4 h nous allons réaliser un système à sonar ultrasonique capable d’indiquer la
distance des obstacles sur un arc de cercle autour de lui. Le dispositif est composé de deux
parties :
• le sonar proprement dit qui retourne des impulsions électroniques dont la longueur
correspond au temps mis par les impulsions ultrasoniques pour aller et revenir au
capteur, indiquant ainsi la distance entre le sonar et l’obstacle le plus proche,
• un servomoteur, dispositif d’automatisme commandant la position angulaire d’un
palonnier sur environ 80° en fonction du signal PWM qu’on lui applique. Le sonar est
fixé sur le palonnier, ce qui lui permet ainsi de balayer un arc de cercle de 80° devant
lui.
2. Objectif(s) opérationnel(s)
• Devenir capable d’écrire un code d’initialisation et d’exploitation de temporisateurs en
mode « générateur d’impulsion » (one shot, soit monostable) et mode « mesure de
longueur d’impulsion ».
• Devenir capable d’utiliser une longueur d’impulsion comme grandeur analogique de
mesure et de commande.
• Améliorer la maîtrise d’un noyau temps-réel embarqué.
3. Organisation matérielle

Le TP sera réalisé par un groupe de deux étudiants. Le TP fera l'objet d’un rapport écrit
contenant les réponses aux questions et le code des fonctions demandées, rendu en fin de
séance sur papier.
4. Documentation et matériel nécessaire
Les documentations nécessaires pour la réalisation de ce TP sont :
• polycopié de cours sur les microcontrôleurs,
• notes de cours personnelles,
• documentation électronique de la famille RX62,
• les schémas de la plateforme cible.
• La documentation du sonar SRF04 de mesure de distance.
Le matériel nécessaire pour la réalisation de ce TP est :
• un ordinateur compatible PC avec l’AGL RX62, un système d’exploitation Itron4 et
Tcl/Tk sous Windows,
• un système RX62N avec carte prototypage rapide,
• un sonar de mesure de distance SRF 04 monté sur un servomoteur.
5. Sonar et mesure de distance
5.1 Fonctionnement du sonar
Le sonar SRF04 est un dispositif ultrasonique simple. On lui transmet une impulsion de 10 µs
minimum sur sa broche TI (trigger input) pour le déclencher, ce qui lui fait émettre un
« ping » ultrasonique. Il retourne sur une autre broche PO (Pulse Output) après un délai
d'environ 300 µs une impulsion positive (1 logique) de 115 µs à 18,5 ms de longueur
correspondant au temps mis par le « ping » ultrasonique généré pour effectuer le parcours
allez/retour entre le capteur et l’obstacle. Pour une distance de 2 m la durée de l’impulsion est
de 12 ms pour une vitesse du son de 333 m/s.
N. B. : la vitesse du son étant fonction de la température de l’air, il faut calibrer les sonars en
fonction de la température pour que leur mesure soit correcte.
5.2 Temporisateurs universels MTU
Le RX62N comporte un ensemble de 12 compteurs dits universels et nommés MTU (MTU0 à
MTU11) qui peuvent fonctionner dans de nombreux modes pour générer, soit des impulsions,
soit des signaux périodiques, et qui peuvent aussi mesurer des durées d’impulsion ou compter
des évènements. Chacun des douze compteurs est relié à quatre broches (MTIOCxA à
MTIOCxD, x représentant le numéro du compteur) qui peuvent être configurées en entrée ou
en sortie. Néanmoins, sur notre système les possibilités sont beaucoup plus limitées car en

tout et pour tout, seuls trois compteurs sont connectés vers l’extérieur (MTU3, MTU9 et
MTU10) avec cinq broches en entrées (MTUIOC9B, MTUIOC9C, MTUIOC10B,
MTUIOC10C et MTUIOC10D) et trois broches en sortie (MTUIOC3C, MTUIOC9A et
MTUIOC10A).
Nous allons utiliser MTU3 pour générer les impulsions de démarrage du sonar, MTU9 pour
générer les impulsions de contrôle du servomoteur et MTU10 pour mesurer la largeur
d’impulsion générée par le sonar et représentant la distance mesurée.
D’une façon générale, pour configurer les temporisateurs il faut :
• mettre le ou les temporisateurs sous tension avec MSTP(MTUx) = 0;
• configurer les broches utilisées en entrée ou en sortie dans le mode correspondant,
• choisir la période et le reset du signal de comptage avec TCR, code :
MTUx.TCR.BYTE = 0x03 ; // on compte de1,33 µs jusqu'à 87 ms
• choisir le mode de fonctionnement avec TMDR,
• configurer les liaisons entre les registres généraux TGRx et les broches
d’E/S (registres TIORL et TIORH),
• éventuellement activer certaines sorties (registres MTUA.TOER et MTUB.TOER),
• éventuellement mettre des valeurs de temps dans les registres TGR utilisés et TCNT,
• le moment venu démarrer le comptage (registres MTUA.TSTR et MTUB.TSTR).
5.3 Temporisateur MTU3 en génération d’impulsions
Nous allons utiliser la broche MTIOC3C-B (P5.6) comme sortie d’impulsions. Il faudra donc
relier MTIOC3C à la broche TI du sonar. Nous utilisons MTU3 en mode normal, libre
(jusqu’à 87 ms).
// initialisation
MSTP(MTU3) = 0; // power up MTU timer 0 to 5
IOPORT.PFCMTU.BIT.MTUS2 = 1; // select MTIOC3C-B pin
MTU3.TCR.BYTE = 0x03; // PCLK/64
MTU3.TGRC = 22; // 30 µs count
// génération d’une impulsion
MTUA.TSTR.BIT.CST3 = 0; // stop counting
MTU3.TIORL.BYTE = 0x05; // positive pulse on MTIOC3C
MTU3.TCNT = 0; // reset MTU3 counter
MTUA.TSTR.BIT.CST3 = 1; // start counting
5.4 Temporisateur MTU10 en mesure de durée d’impulsion
Nous allons utiliser les broches MTIOC10D (PB.7) et MTIOC10B (PB.6) pour mesurer la
durée des impulsions. MTIOC10D sera configuré pour mesurer l’instant du front montant de
l’impulsion et MTIOC10B l’instant de son front descendant. Il faudra donc relier MTIOC10B
et MTIOC10D à la broche PO du sonar. Nous utilisons ce compteur en mode normal sans
remise à zéro.
// initialisation

R_IO_PORT_Set(PDL_IO_PORT_B_6|PDL_IO_PORT_B_7, \
PDL_IO_PORT_INPUT| PDL_IO_PORT_INPUT_BUFFER_ON); // activate input
MSTP(MTU10) = 0; // power up MTU timer 6 to 10
MTU10.TCR.BYTE = 0x03; // PCLK/64
MTU10.TIORL.BYTE = 0x80 ; // input capture on MTIOC10D on rising
edge
MTU10.TIORH.BYTE = 0x90 ; // input capture on MTIOC10B on falling
edge
MTUB.TSTR.BIT.CST4 = 1; // start counting
// mesure de la durée de l’impulsion
sonarTime = MTU10.TGRB - MTU10.TGRD; // pulse time count
MTU10.TCNT = 0; // reset MTU10 counter
6. Servomoteur d’automatisme
6.1 Contrôle d’un servomoteur d’automatisme
Un servomoteur se pilote par un signal PWM d’une période d’environ 20 ms (fréquence
d’environ 50 Hz) comportant une impulsion (niveau logique 1) d’une durée variable entre 1
ms et 2 ms. La position médiane du palonnier du servomoteur est obtenue pour une largeur
d’impulsion de 1,5 ms, elle est appelée position neutre. Lorsque l’impulsion est de 1 ms, le
palonnier est en position de rotation maximum gauche (environ – 40°) ; lorsque l’impulsion
est de 2 ms, le palonnier est en position rotation maximale droite (environ +40°). La position
angulaire du palonnier peut ainsi être réglée progressivement de -40° à +40°.
N. B. : la période du signal PWM doit être d’environ 20 ms bien que cette valeur n’influe pas
sur la position du palonnier.
6.2 Génération d’impulsions avec MTU9
Nous allons utiliser la broche MTIOC9A (PB.0) comme sortie d’impulsions pour le
servomoteur. Il faudra donc relier MTIOC9A à la broche de signal du servomoteur. Nous
utilisons MTU9 en mode normal avec une configuration analogue avec celle de MTU3.
// initialisation
MSTP(MTU9) = 0; // power up MTU timer 6 to 10
MTU9.TCR.BYTE = 0x03; // PCLK/64
MTU9.TGRA = 1125; // 1.5 ms count
// génération d’une impulsion
MTUB.TSTR.BIT.CST3 = 0; // stop counting
MTU9.TIORH.BYTE = 0x05; // positive pulse on MTIOC3C
MTU9.TCNT = 0; // reset MTU9 counter
MTUB.TSTR.BIT.CST3 = 1; // start counting

N. B. : une fois le code écrit il faut vérifier à l’oscilloscope que la largeur des impulsions
émises reste bien comprise entre 1 et 2 ms et la périodicité de l’ordre de 50 Hz avant de
connecter le servomoteur.
7. Manipulations
7.1 Exploitation du sonar en mode direction fixe
La structure générale de l’application sera déduite de celle du TP précédant utilisant le
système d’exploitation temps réel ITRON4. Cette fois-ci l’application va utiliser deux
handlers cycliques, quatre tâches et une fonction d’interruption :
• La tâche start() initialise l’ensemble du système.
• La tâche périodique affiche() activée quarante fois par seconde pour gérer
l’affichage.
• La tâche chargeCPU() de priorité minimale comme avant indique la charge du
processeur en faisant clignoter les leds rouge et verte.
• Le handler cyclique calcTemps() activé cent fois par seconde incrémente le temps
(heures, minutes, secondes) et envoie la valeur courante sous forme d’un message
ID_temps à la tâche affiche() .
• La tâche périodique clavier() activée aussi cent fois par seconde scrute le clavier et
transmet sous forme de « data queue » ID_conver1 et ID_conver2, la valeur de la
variable conver à la tâche affiche() et au handler sonar(). La variable conver
est un booléen, qui contient « true » lorsque le système est activé et « false » lorsqu’il
est au repos (pas de mesure ni de transmission).
• Le handler cyclique sonar() invoqué cinquante fois par seconde mesure la distance
libre devant le sonar et transmet le résultat via un message ID_ mesSonar à la tâche
affiche() . Ce handler transmet aussi la distance mesurée au port série .
• La fonction sciTrans() transmet automatiquement sur le port série la valeur de
comptage de MTU10 représentant la distance courante.
Pour faire fonctionner le sonar on va générer un « ping » périodique avec une périodicité de
50 ms en activant l’impulsion à chaque passage dans le handler sonar() qui utilise la
méthode mtuTimer.control(). Le code d’affichage recevra la mesure brute de MTU10
entre 0 et 13500 (pour 3 m) et la traduira en mètres avec deux chiffres après la virgule sur
l’afficheur à cristaux liquides embarqué.
Réalisez le travail suivant :
• Créez une classe de base nommée mtuTimer qui contiendra tout le code correspondant aux
temporisateurs universels MTU et incluez y les codes d’initialisation des temporisateurs
MTU3 et MTU10.
• Ecrivez l’application temps réel avec ses tâches et ses handlers, mais sans la gestion du port
série et la gestion du clavier. La distance sera affichée sur la cinquième ligne de l’afficheur.
• Ajoutez la gestion du clavier. Lorsqu’on pressera sur 1, le calcul et l’affichage de la distance
seront activés. Le calcul et l’affichage de la distance seront inhibés par la pression de