Post on 13-Sep-2018
Nîmes
Exercices
Cours de systèmes embarqués
Semestre 3 (2012/2013)
Module ER II
Frédéric GIAMARCHI
Département G.E.I.I.
I.U.T. de Nîmes – Université Montpellier II
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 1
Sommaire
Présentation ..........................................................................................................................2
Le Robot Easy Rob..................................................................................................................2
La carte Picky 8 ......................................................................................................................3
L’environnement de développement ....................................................................................5
Programmer un PIC ................................................................................................................5
Premier programme ..............................................................................................................9
Capturer une entrée ............................................................................................................11
Déplacements élémentaires ................................................................................................13
Utilisation de la liaison série ................................................................................................15
L’afficheur LCD .....................................................................................................................17
Utilisation des entrées analogiques .....................................................................................19
Utilisation des Timers ..........................................................................................................21
Utilisation des Servomoteurs ...............................................................................................23
Schéma de la carte Picky 8 ...................................................................................................25
Références ...........................................................................................................................26
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 2
PRÉSENTATION
Cette série de travaux pratiques doit vous permettre de découvrir les notions de systèmes
embarqués, de programmation en C de systèmes temps réels et les premières subtilités de la
robotique mobile.
La programmation d’un robot mobile diffère de celle d’un programme pour PC sur divers
points.
Le matériel est un ensemble d’éléments mécaniques et électriques dont il est important de
connaître les caractéristiques pour bien les utiliser en relation avec la carte électronique.
La carte électronique regroupe toutes les interfaces, les plus adaptées aux contraintes du
matériel. Mais aussi le cœur du système, à savoir un microcontrôleur capable de piloter toutes
les ressources du matériel proposé.
Le langage de programmation le plus adaptée est le C. Mais il peut être nécessaire d’écrire
quelques routines en assembleur, pour réduire la taille d’une fonction critique.
Un environnement de développement est aussi nécessaire. Celui-ci devant être adapté à la
programmation des microcontrôleurs utilisés.
Le mode de programmation et le matériel pour programmer le composant sont des
éléments qu’il est nécessaire de connaître et de comprendre aussi pour pouvoir se concentrer
sur la partie apprentissage.
LE ROBOT EASY ROB
La partie mécanique du robot est un kit disponible auprès de la société Easy Robotics [1].
Cette jeune société s’est spécialisée dans la conception de base mécanique en aluminium pour
la robotique ludique et pédagogique. Le modèle que nous avons choisi est disponible nu ou
associé à une pince ou à un support de caméra ( photo 1).
Photo 1 : La mécanique est une base roulante de chez Easy Robotics
La base roulante est équipée de deux servomoteurs à rotation continue sans électronique.
Il s’agit, à la base, de servomoteurs standards dans lesquels on a supprimé toute l’électronique
pour les transformer en moto-réducteur. Les roues usinées utilisent un joint torique comme
pneu. Elles se fixent directement sur l’arbre de sortie des servomoteurs de propulsion. La
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 3
vitesse de déplacement du robot n’est pas très élevée du fait de la grande démultiplication
propre aux servomoteurs. Mais ce n’est pas ce que l’on attend d’un robot pédagogique.
Le modèle que nous avons choisi est équipé de deux servomoteurs en moto-réducteur avec
une pince. La pince est mue par deux servomoteurs standards qui permettent d’ouvrir et de
fermer la pince et de lever et baisser la pince. Celle-ci nous permettra de saisir des petits
objets, comme des petites balles ou encore des canettes de sodas ( photo 2).
Photo 2 : La pince, très pratique pour attraper des petits objets
CARACTÉRISTIQUES :
Les moteurs de rotation des roues et les servomoteurs fonctionnent sous 6 Volts.
LA CARTE PICKY 8
Cette carte a été réalisée spécialement pour la base robotique Easy Robotics, vu dans le
paragraphe précédent [2].
Le schéma détaillé est fourni en fin de document. Il vous permettra de repérer les liaisons
entre les diverses interfaces et le microcontrôleur.
LE MICROCONTRÔLEUR
Le microcontrôleur choisi, un PIC18F452, est un modèle très performant dont les
caractéristiques sont indiquées dans le tableau suivant, avec le PIC16F877, son prédécesseur
pour comparaison.
Composant Mémoire Programme RAM EEPROM E/S CAN MLI MSSP UART Timer
8/16bit
Oscillateur
Octets Instructions SPI I2C
PIC16F877 14,3k 8192 368 256 33 8 2 Oui Maitre Oui 2/1 20MHz
PIC18F452 32k 16384 1536 256 33 8 2 Oui Maitre Oui 1/3 40MHz
LES CONNECTEURS DE PROGRAMMATION
Le microcontrôleur peut être programmé par une interface spécialisée appelé ICSP (In
Circuit Serial Programming). Ce qui évite de l’enlever pour le programmer.
Mais il peut aussi être programmé par l’interface série RS232 ou encore l’interface I2C.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 4
L’INTERFACE ÉLÉMENTAIRE
On nomme, ainsi, les trois boutons poussoirs, les trois Dels et le bruiteur de type piezo.
L’INTERFACE DE COMMANDE DES MOTEURS
On va utiliser un circuit spécialisé pour la commande de moteurs à courant continu. Les
deux transistors T3 et T4 et leurs résistances associées permettent de réaliser deux inverseurs.
Ils servent à simplifier la commande des moteurs en réalisant l’inversion de deux signaux
pour le circuit L293D.
LES INTERFACES SÉRIE
La liaison RS232 entre la carte et un PC un moyen simple pour dialoguer ou pour mettre
au point les programmes. Elle peut être filaire ou HF, à l’aide de module de type XBee par
exemple. C’est un outil de développement très utilisé qui permet de visualiser des résultats de
mesure et de modifie des paramètres internes.
La liaison I2C est un autre moyen simple de dialoguer avec des cartes spécialisées
(caméra, ultra-sons, odomètre, capteurs de ligne).
L’AFFICHEUR
L’afficheur est un indispensable outil de mise au point des programmes et apporte un
confort de lecture de l’état du robot. On s’en servira pour visualiser les différents modes pour
les tests, les entrées analogiques, les déplacements et les états internes, état de la batterie et
autres.
LA TÉLÉCOMMANDE IR
Le photo-module infrarouge permet de piloter le robot par une télécommande de type TV,
c’est très pratique pour modifier les paramètres du robot pendant qu’il se déplace, lorsque la
liaison RS232 n’est plus utilisable.
LES CONNECTEURS D’ENTRÉES SORTIES
On dispose de deux sorties, connecteurs JP5 et JP6, pour piloter deux servomoteurs sur les
lignes RB1 et RB2 du microcontrôleur, de deux entrées, connecteurs JP7 et JP8, pour lire des
capteurs analogiques sur les lignes RA1 et RA3 et de deux entrées sorties, au choix,
connecteurs JP9 et JP10, sur les lignes RA4 et RC0 pour lire des entrées de type compteurs de
vitesse ou pour piloter d’autres servomoteurs.
L’ALIMENTATION
La source de tension est réalisée à partir de 5 accumulateurs de 1,2Volt en série.
Cette tension de 6Volts est régulée à 5Volts. Le régulateur est un module à faible chute de
tension LDO (Low Drop Output voltage) de type LM2940-5. La tension non régulée en entrée
du régulateur ne doit pas descendre sous 5,25 Volts.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 5
DIVERS
Il a été prévu de pouvoir suivre la tension à l’entrée de la carte. Un pont diviseur de
tension réalisé avec deux résistances de précision de même valeur permet de diviser par deux
la tension d’entrée. Les entrées du composant n’appréciant pas les tensions supérieures à
5Volts.
L’ENVIRONNEMENT DE D ÉVELOPPEMENT
L’environnement de développement MPLAB de Microchip est un formidable outil
d’édition de programmes, de simulation, de débogage et de programmation de composants
[3]. Il est gratuit et peut être associé à des compilateurs C d’autres sources que Microchip,
comme celui que nous utilisons CCS [4].
Il est compatible avec des programmateurs classiques ou de type ICSP, comme l’ICD2 de
Microchip.
MPLAB
L’environnement de développement MPLAB de Microchip est un logiciel d’édition de
fichiers texte au format *.asm ou *.c, mais paramétré pour des fichiers de programmation
pour les composant PIC de Microchip. En plus de l’édition de fichiers, il réalise l’assemblage
de fichiers assembleur *.asm, ou de fichiers *.c si un compilateur C est installé.
Il crée divers fichiers utiles dont le fichier *.hex permettant de programmer un composant
PIC.
COMPILATEUR C
Microchip propose son propre compilateur C pour PIC18F, gratuit : C18.
Nous utiliserons le compilateur C de CCS qui est compatible pour tous les composants de
Microchip.
Le compilateur CCS doit être installé sur le PC, puis un plug-in doit être lancé pour qu’il
soit reconnu par MPLAB.
Le gros avantage de ce compilateur est d’être efficace à la compilation, de disposer de
beaucoup d’exemples de programmes et d’être suffisamment ancien pour avoir un des forums
les plus actifs.
PROGRAMMER UN PIC
Il y a deux moyens de programmer un composant PIC. Soit avec un programmateur
classique comme l'ICD2 de Microchip ou le PicKit2 qui est reconnu dans l’environnement
MPLAB, soit en utilisant une des interfaces de dialogue comme le port série RS232.
C’est cette dernière méthode qui a été choisie ici en raison de sa simplicité d’utilisation
qui ne nécessite pas de programmateur.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 6
Pour cela, il est nécessaire d’installer un programme permettant le dialogue avec un PC.
Celui-ci devra être programmé une seule fois avec un programmateur classique comme
l’ICD2 ou un autre programmateur artisanal.
Ce fichier est un programme d’amorce appelé bootloader.
Dans le cas présent, c’est une liaison série qui sera utilisé entre le robot et un PC. Il est
nécessaire de disposer d’une carte additionnelle de conversion TTL/RS232 et d’un câble non
croisé.
La disparition des interfaces séries RS232 sur les PC actuelles va entrainer une évolution
vers l’utilisation de PIC intégrant une interface USB. Mais le principe ne changera pas.
LE BOOTLOADER
Le bootloader est un programme qui démarre à la mise sous tension du composant et
scrute la liaison de dialogue sélectionnée : RS232, I2C ou encore USB.
Si un PC essaie de dialoguer avec le composant, alors le bootloader transfert le nouveau
programme dans le PIC sans écraser son propre programme.
Puis à la fin du transfert, le bootloader lance le nouveau programme.
Si au démarrage, il n’y a pas de dialogue avec un PC, alors le bootloader saute
directement au programme précédemment installé.
Cette méthode est plus souple et plus rapide, mais ne permet pas un débogage en
profondeur du PIC.
Mais elle nécessite un programme préalablement installé sur le PC pour dialoguer avec le
booloader dans le composant.
UTILISATION DU BOOTLOADER : AN1310
Ce programme gratuit pour PC permet de dialoguer avec le bootloader dans un composant
de type PIC [5].
Connecter et configurer l'application avec votre cible.
1. Lancer l'application AN1310ui.exe.
2. Connecter votre application sur un port série ou USB.
3. Sélectionner le port de communication et les vitesses de programmation pour le
bootloader et de dialogue avec l'application.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 7
4. Passer en mode bootloader en cliquant sur le bouton rouge "Bootloader Mode".
UTILISATION DE L'APPLICATION AN1310UI.EXE
Lancer l'application pour charger le fichier .hex dans votre PIC.
1. Sélectionner le fichier .hex avec Open.
2. Programme le fichier sélectionné en cliquant sur le bouton "Write Device" avec la
flèche rouge vers le bas.
3. Lancer le programme placé dans votre PIC en cliquant sur le bouton vert "Run
Application Firmware".
4. L'application passe automatiquement en mode Terminal série pour dialoguer avec
votre PIC.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 8
STOPPER VOTRE PIC OU CHARGER UN NOUVEAU FICHIER
1. Cliquer sur le bouton bleu "Break/Reset".
2. Réaliser un reset du PIC ou couper l'alimentation et reconnecter celle-ci.
3. Cliquer sur le bouton rouge "Bootloader Mode".
4. Relancer votre programme avec le bouton vert "Run".
5. Ou charger le nouveau fichier avec le bouton "Write Device"
Voila, amusez vous bien avec ce nouveau bootloader.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 9
PREMIER PROGRAMME
OBJECTIFS
Apprendre à utiliser l’environnement Mplab de Microchip.
Apprendre à programmer un composant par bootloader
DOCUMENTS
Didacticiel Mplab
Annexe des fonctions C
EXERCICE 1
Créer un répertoire de travail pour vos exercices sur le stage de robotique, puis
nommer ce répertoire par exemple Syst_Emb.
Copier les fichiers exo_00.c, Picky_8.h et fonctions.h dans votre répertoire puis
réaliser une copie de exo_00.c que vous renommerez exo_01.c.
Lancer Mplab et créer un projet Exo_01 dans votre répertoire avec les fichiers
exo_01.c, Picky_8 et fonctions.h.
Compléter votre programme avec le listing suivant.
REMARQUES :
Init_Picky_8 () initialise les divers registres internes du microcontrôleur en fonction de
la carte Picky 8. Consulter le contenu du fichier Picky_8.h.
While (1) permet de réaliser une boucle sans fin.
output_high (Del_Ve) met à 1 la Del verte qui est reliée à la broche 2 du port E.
delay_ms (500) marque une temporisation de 500ms.
output_low (Del_Ve) met à 0 la Del verte.
void main(void) { Init_Picky_8 (); while (1) { output_high (Del_Ve); delay_ms(500); output_low (Del_Ve); delay_ms(500); } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 10
TESTER LE PROGRAMME SUR LE ROBOT
Compiler votre programme sous MPLAB. Un fichier exo_01.hex a été créé.
Transférer le fichier exo_01.hex dans le PIC avec l'application Bootloader
AN1310.
Suivez les indications sur l'interface AN1310 afin de vérifier le bon déroulement
du téléchargement. Le programme se lance automatiquement.
Vous devez observer le clignotement de la Del verte connectée à la broche E2 du
microcontrôleur.
Le programme est arrêté en utilisant le bouton bleu ou rouge de l'application.
EXERCICES COMPLÉMENTAIRES
Modifier le programme pour allumer la Del verte en premier pendant 300ms, puis la
Del orange, puis la Del rouge ensuite la Del orange et on recommence.
Créer une séquence d’allumage rouge, jaune, verte. Déplacer cette séquence dans la
routine Init_Picky_8().
Dans le fichier " fonctions.h", compléter la fonction Del(couleur) afin d'allumer la
couleur de la Del indiqué et éteindre les 3 Dels pour la valeur 0.
Compléter la fonction Beep(Etat) afin de générer une fréquence de 1kHz sur le piezo.
NOTES
Consulter le contenu du fichier Picky_8.h, vous pourrez visualiser les paramètres de
configuration du microcontrôleur et les diverses broches du composant en entrée ou en
sortie.
De même pour le fichier fonctions.h ou sont indiquées les associations de noms,
comme Del_Ve pour Del verte associée à la broche E2
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 11
CAPTURER UNE ENTRÉE
OBJECTIFS
Apprendre à utiliser les entrées logiques.
DOCUMENTS
Instructions en C.
EXERCICE 2
Enregistrer l’exercice suivant sous le nom exo_02.c
Lancer Mplab et créer un projet Exo_02 dans votre répertoire avec les fichiers
exo_02.c, Picky_8 et fonctions.h.
Modifier votre programme avec le listing suivant.
REMARQUES :
if (input(Btn_Ga) == 0) permet de tester l’état du bouton.
Si la condition est vrai, la Del verte est allumé,
else sinon, la Del est éteinte
void main(void) { Init_Picky_8 (); while (1) { if (input(Btn_Ga) == 0)
output_high (Del_Ro); else output_low (Del_Ro); } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 12
TESTER VOTRE PROGRAMME
Vous devez observer l’allumage de la Del rouge lorsque le bouton de gauche est
appuyé.
EXERCICES COMPLÉMENTAIRES
Modifier le programme afin que chaque bouton allume une Del différente seule.
Compléter la fonction Test_Bouton() pour retourner le numéro du bouton appuyé et 0
s’il n’y a pas de bouton appuyé.
Créer une fonction Beep(short Etat) qui accepte une variable d’entrée binaire On ou
Off. Ajouter cette fonction au fichier fonctions.h.
o Beep (Off) coupe le son
o Beep (On) fréquence 1kHz
Mettre au point les deux fonctions suivantes qui tourneront en boucle dans le while (1)
while (1)
{
Del (Test_Bouton());
Beep (Test_Bouton());
}
Modifier à nouveau le programme pour obtenir un allumage de la Del rouge pendant
2s et de la Del verte pendant 4s. Mais si on appui sur le bouton du centre, les deux
Dels doivent s'éteindre.
Modifier à nouveau le programme afin de générer un code d'erreurs en fonction d'un
chiffre, entre 1 et 5, envoyé par le PC.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 13
DÉPLACEMENTS ÉLÉMENTAIRES
OBJECTIFS
Apprendre à utiliser les compteurs MLI.
DOCUMENTS
Instructions en C.
EXERCICE 3
Enregistrer l’exercice suivant sous le nom exo_03.c. Lancer Mplab et créer un projet
Exo_03 dans votre répertoire avec les fichiers exo_03.c, Picky_8, fonctions.h et le
fichier moteurs.h.
Modifier votre programme avec le listing suivant.
REMARQUES :
Cmd_Moteurs (50,50) envoie un ordre de vitesse aux moteurs
void main(void) { Init_Picky_8(); Init_Moteurs(); while (1) { if (Test_Bouton() == 3) { Del (Test_Bouton()); Cmd_Moteurs (50,50); delay_ms (1000); } else if (Test_Bouton() == 1) { Del (Test_Bouton()); Cmd_Moteurs (-50,-50); delay_ms (1000); } else { Del (Test_Bouton()); Cmd_Moteurs (0,0); } } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 14
TESTER VOTRE PROGRAMME
Vous devez observer que le robot avance pendant une seconde sur appui du bouton
droit et recule sur appui du bouton gauche.
EXERCICES COMPLÉMENTAIRES
Modifier le programme pour que le robot dessine un carré de 20cm de coté environ sur
appui sur le bouton de gauche et un triangle sur un autre bouton. Programmer et tester
les dessins un par un.
Compléter le programme en faisant effectuer un déplacement de 40cm vers l’avant, en
contournant un obstacle placé à 20cm devant, utiliser le dernier bouton.
Quelle remarque pouvez-vous faire sur l’efficacité de vos nouveaux programmes de
dessin ? Comment améliorer cela ?
NOTES :
Ouvrer le fichier moteurs.h et observer les paramétrages du Timer2 associé à la génération
des signaux MLI pour les moteurs.
Le timer 2 est un registre de type compteur utilisé ici pour générer deux signaux de type
MLI. Il est possible de paramétrer la période commune aux deux signaux et le temps haut
pour chacun séparément.
Mesurer la distance parcourue par le robot en ligne droite en une seconde à différentes
vitesses.
Mesurer le temps que met le robot pour faire un tour sur lui-même.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 15
UTILISATION DE LA LIAISON SÉRIE
OBJECTIFS
Apprendre à dialoguer avec un PC par la liaison série RS232.
Apprendre à mettre en forme les variables.
DOCUMENTS
Instructions en C.
EXERCICE 4
Enregistrer l’exercice suivant sous le nom exo_04.c. Lancer Mplab et créer un projet
Exo_04 dans votre répertoire avec les fichiers exo_04.c, Picky_8, fonctions.h et le
fichier moteurs.h.
Compléter votre programme avec le listing suivant.
int nb_r, nb_j, nb_v; void main(void) { Init_Picky_8(); Init_Moteurs(); printf ("\n\r Test Liaison : PC <-> Picky\n\r"); while (1) { if (RS232_Data_In) { RS232_Data_In = 0; switch (toupper(Buffer_PC)) { case 'R' : nb_r++; Del (Off); Del (Rouge); printf ("\r\n Rouge = %u",nb_r); break; case 'V' :nb_v++; Del (Off); Del (Verte); printf ("\r\n Verte = %u",nb_v); break; case 'J' : nb_j++; Del (Off); Del (Jaune); printf ("\r\n Jaune = %u",nb_j) ; break; } } } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 16
REMARQUES :
printf ("\n\r Test RS232\n\r") envoie un texte vers le PC
getc() attend un caractère (ex : touche du clavier)
printf("\r Rouge = %u",nb_r) envoie un texte et le contenu d’une variable
TESTER VOTRE PROGRAMME
Vous pouvez utiliser le Terminal intégré au Bootloader AN1310 pour envoyer des
commandes du PC au robot et afficher le texte reçu.
EXERCICES COMPLÉMENTAIRES
Modifier le programme pour piloter les déplacements du robot par le PC, avance
pendant une seconde, recule, tourne à droite, à gauche avec les touches (A)vance,
(R)ecule, (D)roite, (G)auche et (S)top.
Améliorer votre programme en modifiant la vitesse par les touches P(lus) et M(oins).
Afficher le mouvement et la vitesse sur le PC.
NOTES :
Vérifier que la ligne de validation de la liaison RS232 est activée dans le fichier Picky_8.
#use rs232(baud=19200,xmit=PIN_C6,rcv=PIN_C7)
Cette ligne est indispensable pour valider la liaison série et pour préciser la vitesse, baud,
et les broches du microcontrôleur utilisée en émission, xmit, et en réception, rcv.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 17
L’AFFICHEUR LCD
OBJECTIFS
Apprendre à utiliser un afficheur LCD
Apprendre à mettre en forme les variables.
DOCUMENTS
Instructions en C.
EXERCICE 5
Enregistrer l’exercice suivant sous le nom exo_05.c. Lancer Mplab et créer un projet
Exo_05 dans votre répertoire avec les fichiers exo_05.c, Picky_8, fonctions.h et le
fichier LCD_4bit.h.
Modifier votre programme avec le listing suivant.
REMARQUES :
void main(void) { Init_Picky_8(); delay_ms(1000); Init_Lcd(); lcd_putc("*** Test LCD ***"); while (1) { signed int nb; char text[4]; if (Test_Bouton() == 1) { Del (Off); Del (Test_Bouton()); nb--; } else if (Test_Bouton() == 2) { Del (Off); Del (Test_Bouton()); nb=0; } else if (Test_Bouton() == 3) { Del (Off); Del (Test_Bouton()); nb++; } sprintf (text,"%d ",nb); lcd_gotoxy(8,2); printf (lcd_putc,text); delay_ms(150); } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 18
Init_Lcd() Initialise l’afficheur avec le composant PIC.
lcd_putc("*** Test LCD ***") affiche un texte sur l’afficheur.
sprintf (text,"%d ",nb) convertit la variable nb en un texte en mode décimal
printf (lcd_putc,text) envoie le texte créé vers l’afficheur
TESTER VOTRE PROGRAMME
Vérifier sur l’afficheur du robot les divers messages.
Tester le programme en appuyant sur les poussoirs.
Trouver les valeurs maximales affichées, expliquer ces valeurs.
EXERCICES COMPLÉMENTAIRES
Modifier le programme pour afficher sur le LCD, tout texte envoyé par le PC.
Modifier le programme pour faire exécuter les 2 figures géométriques de l’exercice 3
sur commande du PC et avec affichage des paramètres intéressants sur l’afficheur.
NOTES :
Les paramètres de liaison entre l’afficheur et le composant PIC sont déclarés dans le
fichier LCD_4bit.h. Il est conseillé de lire le début du fichier qui donne des explications sur
les fonctions disponibles.
L’afficheur LCD est piloté par deux lignes de contrôle et quatre lignes de données.
La première chose à faire est d’initialiser l’afficheur dans le programme et ensuite on peut
afficher du texte.
S’il est simple d’afficher un texte, il n’en est pas de même pour une variable.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 19
UTILISATION DES ENTRÉES ANALOGIQUES
OBJECTIFS
Apprendre à utiliser les entrées analogiques.
Apprendre à mettre en forme les variables.
DOCUMENTS
Instructions en C.
EXERCICE 6
Enregistrer l’exercice suivant sous le nom exo_06.c. Lancer Mplab et créer un projet
Exo_06 dans votre répertoire avec les fichiers exo_06.c, Picky_8, fonctions.h et le
fichier moteurs.h.
Compléter votre programme avec le listing suivant.
REMARQUES :
void main(void) { Init_Picky_8(); Init_Moteurs(); printf ("\n\r Test Telemetre Infrarouge\n\r"); while (1) { int Dist_Gau,Dist_Dro; set_adc_channel(Capteur_Gauche); delay_us (10); // Attente pour stabilisation Dist_Gau = read_adc(); set_adc_channel(Capteur_Droit); delay_us (10); Dist_Dro = read_adc(); printf ("\r Dist Gau : %u Dro : %u ",Dist_Gau,Dist_Dro); if (Dist_Gau > 100 || Dist_Dro > 100) { Cmd_Moteurs (0,0); Del (Off); Del (Rouge); printf (" ** Robot Arrete "); } else if (Dist_Gau < 80 && Dist_Dro < 80) { Del (Off); Del (Verte); printf (" >> Robot Avance "); Cmd_Moteurs (60,60);} } } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 20
set_adc_channel (Capteur_Gauche) sélectionne l’entrée qui est reliée au
convertisseur, car il n’y a qu’un seul convertisseur dans le composant.
Dist_Gau = read_adc() lit la valeur numérique convertie
TESTER VOTRE PROGRAMME
Visualiser les résultats des mesures sur votre PC.
Placer un obstacle devant le robot et lancer le avancer. Il doit s’arrêter devant
l’obstacle.
EXERCICES COMPLÉMENTAIRES
Modifier le programme afin que le robot se dirige vers un obstacle placé devant lui à
moins de 30cm ; cet obstacle pouvant se déplacer.
Modifier le programme afin de parcourir une distance de 50cm vers l’avant en
contournant tout obstacle placé devant, quelque soit la distance entre l’obstacle et le
robot.
Modifier le programme pour lire la tension d’alimentation du robot.
Créer une fonction qui lit les 3 entrées analogiques et envoie le résultat vers un PC.
Modifier le programme pour convertir les valeurs affichées par des distances en cm.
NOTES :
Pour utiliser le convertisseur analogique numérique interne, il faut d’abord l’initialiser.
Ouvrer le fichier Picky_8_V3, vous trouverez les deux lignes suivantes.
setup_adc(ADC_CLOCK_INTERNAL)
setup_adc_ports(AN0_AN1_AN3)
La première ligne valide le convertisseur avec l’horloge interne comme paramètre.
La deuxième ligne sélectionne les broches du microcontrôleur qui seront reliées au
convertisseur.
Noter les diverses valeurs des télémètres pour les distances de 10cm en 10cm.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 21
UTILISATION DES TIMERS
OBJECTIFS
Apprendre à utiliser les Timers
DOCUMENTS
Data sheet PIC18F452
EXERCICE 7
Enregistrer l’exercice suivant sous le nom exo_07.c. Lancer Mplab et créer un projet
Exo_07 dans votre répertoire avec les fichiers exo_07.c, Picky_8, fonctions.h,
moteurs.h et le fichier stdlib.h.
Compléter votre programme avec le listing suivant.
REMARQUES :
long depla; // declarations : variable 16 bits int X_demand; // declarations : variable 8 bits char Key[4]; // declarations : variable chaine de 4 caractères ASCII void main(void) { Init_Picky_8(); Init_Moteurs(); delay_ms(2000); printf ("\n\n\r Test Timer 1\n\r"); setup_timer_1(T1_EXTERNAL); set_timer1(0); while (1) { printf ("\n Entrez Distance : "); gets(Key); X_demand = atoi(Key); printf ("%u mm",X_demand*8); set_timer1(0); do { Cmd_Moteurs (70,70); } while (get_timer1() < X_demand); Cmd_Moteurs (0,0); printf ("\n\r T1 : %lu",get_timer1()); } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 22
Setup_Timer_1(T1_external) Le timer 1 est configuré en compteur
Set_Timer1(0) On met à zéro le timer 1
get_timer1() donne le contenu du timer 1
atoi (Key) convertit un chiffre écrit en ASCII en entier
TESTER VOTRE PROGRAMME
Vous pouvez utiliser Hyperterminal pour lire envoyer les distances de
déplacements au robot et pour afficher les indications.
EXERCICES COMPLÉMENTAIRES
Faites dessiner un carré au robot dont la valeur de chaque coté sera envoyée par le
PC.
NOTES :
Les timers sont des registres internes qui s’incrémentent tout seul, et redémarre à 0 lorsque
la valeur maximale est atteinte. On peut les assimiler à des compteurs.
Le timer 1 est un registre 16 bits qui va de 0 à 65535. Avec un oscillateur à 4MHz, le
maximum est atteint au bout de 65535 µs.
L’horloge qui incrémente le timer est reliée à l’oscillateur interne (T1_Internal), mais peut
être relié avec l’extérieur par la broche RC0 (T1_External).
L’horloge peut passer par un prédiviseur avant d’incrémenter le timer 1.
T1_Div_By_2 divise par 2 l’horloge et donc multiplie par 2 le temps final.
Il y a 3 autres timers dans le PIC18F452. Le timer 0, le timer 2 et le timer 3.
Le timer 0, registre 8 ou 16 bits, est souvent utilisé pour générer l’horloge temps réel. Les
timer 1 et 3 sont des compteurs 16 bits à usage général. Le timer 2, registre 8 bits, est utilisé
pour générer les signaux périodiques comme les MLI de commande des moteurs.
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 23
UTILISATION DES SERVOMOTEURS
OBJECTIFS
Apprendre à utiliser les servomoteurs
DOCUMENTS
Data sheet PIC18F452
EXERCICE 8
Enregistrer l’exercice suivant sous le nom exo_08.c. Lancer Mplab et créer un projet
Exo_08 dans votre répertoire avec les fichiers exo_08.c, Picky_8, fonctions.h et le
fichier moteurs.h.
Compléter votre programme avec le listing suivant.
REMARQUES :
void main(void) { Init_Picky_8(); Init_Moteurs(); Init_Servos(); delay_ms(2000); printf ("\n\n\r Test Servos\n\r"); while (1) { switch (getc()) { case '+' : Del (Off); Del (Verte); Tempo_Servo_1 ++; break; case '-' : Del (Off); Del (Jaune); Tempo_Servo_1 --; break; case 'q' : Del (Off); Del (Rouge); Tempo_Servo_2 ++; break; case 'a' : Del (Off); Tempo_Servo_2 --; break; } printf ("\r Bras : %lu Pince : %lu",Tempo_Servo_1,Tempo_Servo_2); } }
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 24
Setup_Timer_1(T1_internal|T1_div_by_1) Le timer 1 est configuré
Set_Timer1(0) On met à zéro le timer 1
Temps = get_timer1(); On lit le contenu du timer 1
TESTER VOTRE PROGRAMME
Utiliser le PC pour faire bouger le bras et la pince du robot. Les valeurs des servos
sont affichées.
EXERCICES COMPLÉMENTAIRES
Chercher les valeurs maximales et minimales correspondant aux limites
d’utilisation des servos.
NOTES :
Les paramètres de configuration et d’utilisation des servos sont déclarés dans le fichier
moteurs.h. Il est conseillé de lire le fichier qui donne des explications sur les fonctions
disponibles.
L’horloge qui incrémente le timer 1 est reliée à l’oscillateur interne (T1_Internal).
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 25
SCHÉMA DE LA CARTE PICKY 8
Études & Réalisations Exercices de systèmes embarqués Semestre 3
I.U.T. de Nîmes Département : G.E.I.I. page 26
RÉFÉRENCES
[1] Base mécanique : www.easyrobotics.fr
[2] Picky 8 : www.geii.iut-nimes.fr
[3] Composant Microchip (data sheet) et logiciel MPLAB : www.microchip.com
[4] Compilateur C de CCS : www.ccsinfo.com
[5] AN1310 : High-Speed Serial Bootloader for PIC16 and PIC18 Devices