nîmes exercices - pages perso - iut de...

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



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



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.



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.



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.



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.



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.



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.



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); } }



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



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); } }



TESTER VOTRE PROGRAMME

Vous devez observer l’allumage de la Del rouge lorsque le bouton de gauche est

appuyé.


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.



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.


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); } } }




Vous devez observer que le robot avance pendant une seconde sur appui du bouton

droit et recule sur appui du bouton gauche.


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.



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



fichier moteurs.h.


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; } } } }



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


Vous pouvez utiliser le Terminal intégré au Bootloader AN1310 pour envoyer des

commandes du PC au robot et afficher le texte reçu.


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.



L’AFFICHEUR LCD

OBJECTIFS

Apprendre à utiliser un afficheur LCD


DOCUMENTS

Instructions en C.

EXERCICE 5



fichier LCD_4bit.h.


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); } }



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


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.


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.



UTILISATION DES ENTRÉES ANALOGIQUES

OBJECTIFS

Apprendre à utiliser les entrées analogiques.


DOCUMENTS

Instructions en C.

EXERCICE 6



fichier moteurs.h.


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);} } } }



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


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.


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.



UTILISATION DES TIMERS

OBJECTIFS

Apprendre à utiliser les Timers

DOCUMENTS

Data sheet PIC18F452

EXERCICE 7


Exo_07 dans votre répertoire avec les fichiers exo_07.c, Picky_8, fonctions.h,

moteurs.h et le fichier stdlib.h.


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()); } }



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


Vous pouvez utiliser Hyperterminal pour lire envoyer les distances de

déplacements au robot et pour afficher les indications.


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.



UTILISATION DES SERVOMOTEURS

OBJECTIFS

Apprendre à utiliser les servomoteurs

DOCUMENTS

Data sheet PIC18F452

EXERCICE 8



fichier moteurs.h.


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); } }



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


Utiliser le PC pour faire bouger le bras et la pince du robot. Les valeurs des servos

sont affichées.


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).



SCHÉMA DE LA CARTE PICKY 8



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

http://www.easyrobotics.fr/

nîmes exercices - pages perso - iut de...

Documents