Vous êtes sur la page 1sur 24

TP N°7 : Programmation en C

A. Introduction :
Nous allons utiliser l’environnement de développement MPLAB de chez Microchip©

B. MPLAB :
Lancer le programme MPLAB :

Faire Project -> Project Wizard :

JFA 2015 Page 1 /24 TP7


Vous obtenez alors la fenêtre suivante :

Sélectionner la référence exacte du PIC qui est sur votre Carte (ici Pic18F45K20)

JFA 2015 Page 2 /24 TP7


Choisissez ou gardez le programme CCS C Compiler.

Créez et sélectionnez un répertoire de sauvegarde de votre projet.

JFA 2015 Page 3 /24 TP7


Faire suivant

Si vous avez déjà un fichier source en langage C, vous pouvez l’insérer.

JFA 2015 Page 4 /24 TP7


Terminez la création du projet

Voilà votre espace de travail :

JFA 2015 Page 5 /24 TP7


On va maintenant créer le fichier code source en C

Choisissez le même répertoire que le projet et donnez le même nom au fichier que le projet.

JFA 2015 Page 6 /24 TP7


Vous pouvez maintenant entrer votre programme dans cette fenêtre.

Tapez alors le programme ci-dessous :

JFA 2015 Page 7 /24 TP7


Compiler votre programme an cliquant sur l’icône « Build All »

JFA 2015 Page 8 /24 TP7


Et vérifiez qu’il n’y a pas d’erreurs dans la fenêtre « Output »

Mode « Programmer »
Si vous voulez seulement programmer votre carte Pic, effectuez les opérations ci-dessous, sinon passer à la
connexion en mode « Debugger ».

Sélectionnez PicKit 3 comme programmer.

Une fenêtre pop-up vous demande de vérifier la connexion et les valeurs d’alimentions de votre carte.

JFA 2015 Page 9 /24 TP7


Faire ok. Et sélectionnez le menu Programmer -> Settings, et dans l’onglet « Power »

Sélectionnez 3,25 V comme tension d’alimentation en glissant le curseur ou en tapant la valeur dans la case. Et
cochez la case « Power target circuit from PicKit3 », ce qui permet d’alimenter la carte avec le PicKit 3 si le courant
consommé n’est pas trop important !

Et vérifiez l’onglet « Status » et le cadre « Voltage » pour vérifier que vous avez la bonne tension !

JFA 2015 Page 10 /24 TP7


Mode « Debbuger »
Si vous voulez programmer et débuguer votre carte Pic, effectuez les opérations ci-dessous.

Sélectionnez PicKit 3 comme debugger.

Si vous étiez en mode « Programmer » une fenêtre vous indique que vous devez choisir le mode « Programmer »,
soit le mode « Debugger ». On choisit alors le mode « Debugger » !

JFA 2015 Page 11 /24 TP7


Une fenêtre popup vous demande de vérifier la connexion et les valeurs d’alimentions de votre carte.

Faire ok. Et sélectionnez le menu Debugger -> Settings,

JFA 2015 Page 12 /24 TP7


et dans l’onglet « Power »

JFA 2015 Page 13 /24 TP7


Sélectionnez 3,25 V comme tension d’alimentation en glissant le curseur ou en tapant la valeur dans la case. Et
cochez la case « Power target circuit from PicKit3 », ce qui permet d’alimenter la carte avec le pickit 3 si le courant
consommé n’est pas trop important !

Et vérifiez l’onglet « Status » et le cadre « Voltage » pour vérifier que vous avez la bonne tension !

Et il demande confirmation que vous êtes bien sûr !

et dans l’onglet « Program Memory », vous pouvez cocher les cases « Program after successful Build » et « Run after
successful program », ce qui va effectuer automatiquement la programmation, et l’exécution du programme si tout
est correct !

Sinon vous pouvez cliquer sur l’icône Program pour programmer votre carte avec le programme compilé,

JFA 2015 Page 14 /24 TP7


Et vous pouvez lancer l’execution de votre programme :

et vérifier sur la carte que cela fonctionne !

JFA 2015 Page 15 /24 TP7


C. CCS :
Le langage CCS est un langage C adapté aux microcontrôleurs et Pics. C’est donc en langage qui
contient tous les mots clés du C plus des mots clés particuliers pour les microcontrôleurs.
I. Port du microcontrôleur :
Tout microcontrôleur contient des broches qui peuvent envoyer ou recueillir des informations. Ces
broches sont organisées en blocs de 8 pour former un PORT et ceux-ci sont repérés par une lettre
A, B, C, D, E, …. On peut trouver plusieurs types d’entrées sorties sur le microcontrôleur. Elles
peuvent être logiques, analogiques, de type timers, de type bus, … et ils peuvent avoir des
spécificités de connections.

II. Pour les entrées-sorties logiques (I/O) :


Ces ports logiques sont appelées entrées-sorties. Car on peut les programmer indépendamment soit
en entrée, soit en sortie. Pour lire ou écrire des niveaux logiques, il va falloir effectuer deux
opérations :
1°) Configuration de la direction du port :
Avant de pouvoir utiliser un bit (ou tout) du port, il va falloir configurer la direction voulue
pour le bit (ou port). Donc programmer la broche en entrée ou en sortie !
C’est l’opération SET_TRIS_x () qui va se charger de cette configuration.
Cherchez dans la documentation CCS la fonction de la commande SET_TRIS_x () et
déterminez que fait la commande suivante :

JFA 2015 Page 16 /24 TP7


SET_TRIS_B (0xAA);

// B ,B ,B ,B sont des sorties,


// B ,B ,B ,B sont des entrées.
2°) Lecture ou écriture du port :
Maintenant que la direction du port est configurée, il nous reste maintenant à lire ou à
écrire dans ce port :
a. Ecriture du port :
Il existe plusieurs commandes CCS pour écrire des données sur le port :
La commande : output_x( )
Cherchez dans la documentation CCS la fonction de la commande output_x( ) et
déterminez ce que fait la commande suivante, avec la configuration de port
précédente :
OUTPUT_B (0x15) ;

// B ,B ,B ,B sont à 1,
// B ,B ,B ,B sont à 0.
// B ,B ,B ,B sont à X,

La commande : output_bit( )
Cherchez dans la documentation CCS la fonction de la commande output_bit( ) et
déterminez ce que fait la commande suivante, avec la configuration de port
précédente :
OUTPUT_BIT (PIN_B0, 0) ;
OUTPUT_BIT (PIN_B2, 1) ;
OUTPUT_BIT (PIN_B4, 1) ;
OUTPUT_BIT (PIN_B6, 0) ;

// B ,B ,B ,B sont à 1,
// B ,B ,B ,B sont à 0.
// B ,B ,B ,B sont à X,

La commande : output_high( )
Cherchez dans la documentation CCS la fonction de la commande output_high( ) et
déterminez l’équivalent de la commande suivante :
OUTPUT_B (0x15) ; et avec la configuration de port précédente, avec les
commandes :
JFA 2015 Page 17 /24 TP7
OUTPUT_HIGH ( , );
OUTPUT_HIGH ( , );
OUTPUT_HIGH ( , );
OUTPUT_HIGH ( , );

// B ,B ,B ,B sont à 1,
// B ,B ,B ,B sont à 0.
// B ,B ,B ,B sont à X,

La commande : output_low( )
Cherchez dans la documentation CCS la fonction de la commande output_low( ) et
déterminez l’équivalent de la commande suivante :
OUTPUT_B (0x15) ; et avec la configuration de port précédente, avec les
commandes :
OUTPUT_LOW ( , );
OUTPUT_LOW ( , );
OUTPUT_LOW ( , );
OUTPUT_LOW ( , );

// B ,B ,B ,B sont à 1,
// B ,B ,B ,B sont à 0.
// B ,B ,B ,B sont à X,

La commande : output_toggle( )
Cherchez dans la documentation CCS la fonction de la commande output_toggle( ) et
déterminez l’équivalent de l’inverse de la commande suivante :
OUTPUT_B (0x15) ; et avec la configuration de port précédente, avec les
commandes :
OUTPUT_TOGGLE ( , );
OUTPUT_TOGGLE ( , );
OUTPUT_TOGGLE ( , );
OUTPUT_TOGGLE ( , );

// B ,B ,B ,B sont à 1,
// B ,B ,B ,B sont à 0.

JFA 2015 Page 18 /24 TP7


// B ,B ,B ,B sont à X,

b. Lecture du port :
Il existe plusieurs commandes CCS pour lire les données du port :
La commande : input( )
Cherchez dans la documentation CCS la fonction de la commande input( ) et
déterminez ce que font les commandes suivantes si le port A vaut 0x55 :
Valeur0 = INPUT(PIN_A0) ;
Valeur1 = INPUT(PIN_A1) ;
Valeur2 = INPUT(PIN_A2) ;
Valeur3 = INPUT(PIN_A3) ;
Valeur4 = INPUT(PIN_A4) ;
Valeur5 = INPUT(PIN_A5) ;
Valeur6 = INPUT(PIN_A6) ;
Valeur7 = INPUT(PIN_A7) ;

La commande : input_change ( )
Cherchez dans la documentation CCS la fonction de la commande input_change( ) et
déterminez ce que font les commandes suivantes si le port A valait 0x50 et vaut
maintenant 0x55 :
Valeur0 = INPUT_CHANGE (PIN_A0) ;
Valeur1 = INPUT_CHANGE (PIN_A1) ;
Valeur2 = INPUT_CHANGE (PIN_A2) ;
Valeur3 = INPUT_CHANGE (PIN_A3) ;
Valeur4 = INPUT_CHANGE (PIN_A4) ;
Valeur5 = INPUT_CHANGE (PIN_A5) ;
Valeur6 = INPUT_CHANGE (PIN_A6) ;
Valeur7 = INPUT_CHANGE (PIN_A7) ;

La commande : input_x ( )
Cherchez dans la documentation CCS la fonction de la commande input_x( ) et
déterminez ce que fait la commande suivante si le port A vaut 0x55 :
Valeur = INPUT_A ( ) ;

JFA 2015 Page 19 /24 TP7


III. Pour les délais :
Les délais d’attente les plus simples peuvent être obtenus avec les commandes suivantes. Pour cela
il faut utiliser la commande #USE DELAY pour spécifier au compilateur la vitesse d’horloge du
microcontrôleur (valeur du quartz) utilisée pour qu’il adapte correctement les commandes delay :
La commande : delay_us ( )
Cherchez dans la documentation CCS la fonction de la commande delay_us( ) et
déterminez ce que fait la commande suivante :
DELAY_US (5000) ;

La commande : delay_ms ( )
Cherchez dans la documentation CCS la fonction de la commande delay_ms( ) et
déterminez ce que fait la commande suivante :
DELAY_MS (2000) ;
IV. Synthèse :
Pour vérifier que vous avez bien compris les commandes précédentes, analyser le programme ci-
dessous et déterminer sa fonction :
//------------ Programme prog1.c ---------------------------
//
// Auteur : JFA
// Version: 1.0
//-----------------------------------------------------------
#include <16F876A.H> // fichier Header
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
// Déclaration des adresses des ports E/S
#byte PORTB = 6 // adresse du PORT B
// Fréquence du quartz
#use delay (clock=20000000) // Fréquence du quartz 20MHz
// Affectation des entrées et sorties de type bit
#define Led1 PIN_B1
#define Led2 PIN_B2
#define Led3 PIN_B3
#define Led4 PIN_B4
//----------Programme principal ---------------------------------
void main (void)
{

JFA 2015 Page 20 /24 TP7


PORTA=0x00;
set_tris_a(0b11111111);
PORTB=0x00;
set_tris_b(0b00000000);
do {
output_high(Led1) ;
delay_ms(1000);
output_low(Led1) ;
delay_ms(1000);
output_bit(Led2,1) ;
delay_ms(1000);
output_bit(Led2,0) ;
delay_ms(1000);
output_b(0x04) ;
delay_ms(1000);
output_b(0x00) ;
delay_ms(1000);
output_toggle(Led4) ;
delay_ms(1000);
output_toggle(Led4) ;
delay_ms(1000);
} while ( ! input(PIN_A1) ) ;
}

JFA 2015 Page 21 /24 TP7


V. Pour les entrées-sorties analogiques (ADC) :
Ces ports analogiques sont appelés AN.

Ils peuvent être répartis sur plusieurs ports. Pour lire ou écrire des niveaux analogiques, il va falloir
effectuer plusieurs opérations dans le bon ordre :
1°) Configuration de l’ADC :
La commande : setup_adc_port(valeur)
Cherchez dans la documentation CCS la fonction de la commande
setup_adc_port(valeur) et déterminez les options « valeurs » disponibles, et déterminer
que fait la commande suivante :
setup_adc_port (ALL_ANALOG );
2°) Configuration du mode de l’ADC :
La commande : setup_adc(mode)
Cherchez dans la documentation CCS la fonction de la commande setup_adc(mode) et
déterminez les options « mode » disponibles, et déterminer que fait la commande
suivante :
setup_adc(ADC_CLOCK_INTERNAL);
3°) Choix du convertisseur :
La commande : set_adc_channel(valeur)
Cherchez dans la documentation CCS la fonction de la commande
set_adc_channel(valeur) et déterminez les options « valeur » disponibles, et
déterminer que fait la commande suivante :
set_adc_channel(0) ;
Quelle commande faut-il mettre absolument après ?

JFA 2015 Page 22 /24 TP7


4°) Lecture de la valeur :
La commande : read_adc (mode)
Cherchez dans la documentation CCS la fonction de la commande read_adc (mode), et
déterminez les options « mode » disponibles, et déterminer que fait la commande
suivante :
read_adc(ADC_START_ONLY);
delay_us(10) ;
value=read_adc(ADC_READ_ONLY);
Quelle est la contrainte à respecter sur la variable valeur ?
5°) Durée de conversion :
La conversion d’une tension analogique en numérique n’est pas instantanée et peut
prendre un peu de temps à l’échelle de l’horloge du microcontrôleur ! De plus sur
certains convertisseurs, le temps de conversion dépend de la valeur de la tension à
convertir. Plus la tension est élevée, plus la conversion est longue. Donc il faut soit
attendre un temps maximum, soit attendre la fin de la conversion avant d’aller chercher
la valeur convertie.
La commande : adc_done( )
Cherchez dans la documentation CCS la fonction de la commande adc_done( ), et
déterminer que fait la commande suivante :
int1 done = adc_done();
while(!done) {
done = adc_done();
}

VI. Synthèse :
Pour vérifier que vous avez bien compris les commandes précédentes, analyser le programme ci-
dessous et déterminer sa fonction :
/*
* File: main.c
*
* Created on January 25, 2013, 18:09 PM */
#include <18F45K20.h> //Déclaration des registre et de la configuration
#fuses FOSC,NOWDT,NOPROTECT,NOLVP,NOPUT
#use delay(clock=20000000) //quartz à 20MHZ
void main(void)
{
int value;

JFA 2015 Page 23 /24 TP7


setup_adc(ADC_CLOCK_DIV_32);
setup_adc_ports( ALL_ANALOG );
set_adc_channel(0);
delay_ms(100);
while ( true )
{
value = read_adc();
output_d(value);
delay_ms( 100 );
}
}

JFA 2015 Page 24 /24 TP7

Vous aimerez peut-être aussi