JFA 2015 Page 1 /24 TP7

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 2 /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 3 /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 4 /24 TP7

Faire suivant

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

JFA 2015 Page 5 /24 TP7

Terminez la création du projet

Voilà votre espace de travail :

JFA 2015 Page 6 /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 7 /24 TP7

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

Tapez alors le programme ci-dessous :

JFA 2015 Page 8 /24 TP7

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

JFA 2015 Page 9 /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 10 /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 11 /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 12 /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 13 /24 TP7

et dans l’onglet « Power »

JFA 2015 Page 14 /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 15 /24 TP7

Et vous pouvez lancer l’execution de votre programme :

et vérifier sur la carte que cela fonctionne !

JFA 2015 Page 16 /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 17 /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 18 /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 19 /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 20 /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 21 /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 22 /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 23 /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 24 /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 );

}

}