Programmation en C - CCS PCWH

Apprendre la programmation des microcontroleur PIC avec PIC C Compiler PCWH c'est simple. Ce cours vous propose une démarche progressive pour réussir un programme en C pour PIC
1. Les Règles de bases :

Toutes instructions ou actions se terminent par un point virgule ;

Une ligne de commentaires doit commencer par /* et se terminer par */ ou commence par // norme C++.

Un bloc dinstructions commence par { et se termine par } .

2. Les variables et les constantes :

2.1. Les constantes :

            Les constantes nexistent pas, c'est-à-dire quil ny a pas dallocation mémoire, mais on peut affecter à un identificateur (Nom : Il ne doit pas dépasser 32 caractères, sans accent)

Une valeur constante par linstruction #define.

        Syntaxe : < #define> <identificateur> <valeur> ;

Exemple :
#define PI 3,14;
2.1.1. Déclarations spécifiques au compilateur CCS :

#bit id =x,y

Id : identifiant (Nom dun bit)

X : Nom du variable ou dune constante

Y : position du bit

Exemple :
#bit RW              =PORTA,2
#bit BUZZER       =PORTD,7
#byte id = X

Id: identifiant

X: valeur 8 bits

Exemple :
#byte  PORTA  = 5                 // adresse  du port A
#byte  PORTB  = 6                 // adresse  du port B
#byte  PORTC  = 7                 // adresse  du port C
#byte  PORTD  = 8                 // adresse  du port D
#byte  PORTE  = 9                 // adresse  du port E    
2.2. Les variables :

         Les variables sont définies par signé ou non signé,

Syntaxe :   <Signed><type><identificateur1>,.., <identificateurn>

·         .lidentificateur : Cest le nom (il ne doit pas dépasser 32 caractères sans accent) affecté à la variable.

·         . le type : il détermine la taille de la variable et les opérations pouvant être effectuées. On peut rajouter le mot signed devant le type de la variable, alors les variables deviennent signées.

2.2.1Les types du compilateur CCS :

Type	Taille	valeurs
Int1	1 bit	0 OU 1
Int8	8 bits	De 0x00 à 0xFF ou 0 à 255
Int16	16 bits	De 0x0000 à 0xFFFF ou 0 à 655535
Int32	32 bits	De 0x0000000 à 0xFFFFFFFF
char	8 bits	De 0 à 255 ou une lettre A. Z
float	32 bits	Format flottant
short		Même type que int1
int		Même type que int8
long		Même type que int16

Exemples :
Int A,B,C,D ;
Char MESSAGE[10] ;
Les types signés

Par défaut, tous ces types de données sont signés, ils peuvent être signés en rajoutant le mot clé signed devant le type.

Exemple :
Signed int A ;        //  Entier de type signé, de -128 à +127
Signed long NB;       //  Entier de type signé, de -32768 à +32767
2.2.2 Les base du compilateur CCS :

Le décimal :             A=10 ;

Loctale :                  A=012 ;

Lhexadécimal         A=0x0A ;

Le binaire                 A=0b00001010 ;

Le caractère : Exemple la lettre A code ASCII 65(Décimal) ou $41(Hexadécimal), peut sécrire :

LETTRE = 65    Ou    LETTRE = 0x41   Ou    LETTRE = A

3. Les opérateurs du langage C :

     Lors de son exécution, un programme est amené à effectuer des opérations qui peuvent être purement arithmétiques, de comparaison, daffectation, etc.

3.1. Lopérateur daffectation :

Type	Symbole	Exemple
Opérateur daffectation	=	X=10 ; Y = a + b

Lopérande de gauche prend pour valeur lopérande de droite.

3.2. Les opérateurs arithmétiques :

Type	Symbole	Exemple
Addition	+	a = a + b ; x = 5+ a
Soustraction	-	a = a b ; y = c - 5
Moins unaire	-	a = - b
Multiplication	*	a = a * a ; b = y * 8
Division	/	c = 9 / b ; d = a / b
Reste de la division entière	%	r = a % b

3.3. Les opérateurs de comparaison ou relationnels :

Type	Symbole	Exemple
Egalité	==	a == b ; c == 9
Différent	!=	c!= a
Supérieur	>	a > b ; 8 > a
Supérieur ou égal	>=	a >= b ; 8 >= a
Inférieur	<	a < b ; 8 < a
Inférieur ou égal	<=	a <= b ; 8 <= a

3.4. Les opérateurs logiques :

Type	Symbole
Et logique	&&
Ou logique	\|\|
Non logique	!

3.5. Les opérateurs binaires bit à bit :

Type	Symbole	Exemple
Et binaire	&	x = y & z
Ou binaire	\|	x = y \| z
Ou exclusif	^	x = y ^ z
Complément à 1	~	x = b ~ z
Décalage de n bits à droite	>>	x = b >> n
Décalage de n bits à gauche	<<	x = b << n

4. Les structures répétitives.

Le langage C possède des instructions permettant de répéter plusieurs fois une même séquence en fonction de certaines conditions.

4.1 Structure while : tant que ... faire ...

Avec ce type dinstruction le nombre de répétitions nest pas défini et dépend du résultat du test effectué sur la condition. Si cette dernière nest jamais vérifiée, la séquence nest pas exécutée.
while (int x!=0) 
          { 
             ... 
          }
La structure précédente répète la suite dinstruction comprises entre crochets tant que la variable entière x est différente de 0.

4.2 Structure do ... while : faire ... tant que...

Cette structure ressemble fortement à la précédente à la seule différence que la séquence à répéter est au moins exécuter une fois même si la condition nest jamais vérifiée.
     
	do  { 
                ...
               }  
    while (int x!=0);
	
4.3 Structure for : Pour <variable> allant de <valeur initiale> à <valeur finale> faire...

Cette instruction permet de répéter, un nombre de fois déterminé, une même séquence.
for (i=0;i<5;i++) 
              { 
                  ... 
              }
La structure précédente répète 5 fois la suite dinstruction comprise entre crochets. La variable i prendra les valeurs successives de : 0, 1, 2, 3 et 4.

4.4 Les structures alternatives.

Ces structures permettent dexécuter des séquences différentes en fonction de certaines conditions.

4.5 Structure if ... Else : Si <condition> faire ... sinon faire ...

Avec cette structure on peut réaliser deux séquences différentes en fonction du résultat du test sur une condition.
if (a<b) c=b-a;
             else c=a-b;
La structure précédente affecte la valeur b-a à c si a est inférieur à b sinon c est affecté par la valeur a-b.

4.6 Structure switch ... case.

Cette structure remplace une suite de if ... else if ...else et permet une de réaliser différentes séquences appropriées à la valeur de la variable testée.
switch (a)
     {
   case 1 : b=16;
   case 2 : b=8;
   case 3 : b=4;
   case 4 : b=2;
     } 
Dans la structure précédente b=16 si a=1, b=8 si a=4 etc.

5. Les fonctions adaptées aux microcontrôleurs PIC :

5.1. La gestion des entrées et des sorties :

Les fonctions suivantes permettent dagir sur les ports dentrées et de sorties :

Output_low ( ) ;

Output_high ( ) ;

Output_bit (pin_xx, 0 ou 1) ;

Input (pin_xx) ;

Output _x (valeur) ;      // X : nom de port AE

Input_x ( ) ;

Set_tris_x (valeur) ;       // Valeur : définie la configuration de port (1 entrée et 0 sotie)

Exemples :

Lecture de la broche Rb4 :
X = input (pin_B4) ;
Mise à 1 de RA5 :
  output (pin_A4 ,1) ; 
ou
 output_high (pin_A4) ;  
Configuration de port c, 4 broches en entrées et 4 broches en sorties :
Set_tris_c (0b11110000) ;
5.2. La gestion des temporisations :

Le compilateur intègre des fonctions très pratique pour gérer les délais :

delay_cycles (valeur) ; // temporisation en NB de cycles

delay_us (valeur) ; // temporisation en µs

delay_ms (valeur) ; // temporisation en ms

Pour pouvoir utiliser ces fonctions, il faut indiquer la fréquence du Quartz de votre application, cette ligne doit être définie au début du programme.

#use delay (clock = fréquence_de_quartz) ;

Exemples :
#use delay (clock=4000000);       // quartz de 4 MHz
#use delay (clock = 20000000);   //quartz en 20 MHz
5.3. La gestion de la liaison série :

Toutes les fonctions dentrée et de sortie peuvent être redirigées sur le port série du microcontrôleur, il suffit dajouter la ligne ci-dessous pour configurer le port série :
 #use rs232 (BAUD=9600, xmit=PIN_C6, rcv=PIN_C7)   //Cette ligne configure la liaison série de PIC avec une vitesse de 9600 bauds.
Les fonctions suivantes utiliseront le port série comme moyenne de communication :

Printf() ;

Putc() ;

getc() ;

Kbhit() ;

Traduction dun algorithme en langage C :

1. Constantes et variables :

1.1. Déclaration de Constantes :

                     Algorithmique : Constante Nomconstante : [Type] = valeur

                     Syntaxe C :    #define    ID_de_la_constante      valeur

Exemple :

Affectation dE/S de type bit : commande dun moteur
#bit LIMIT  =PORTC,1;
#bit CLOCK  =PORTD,3;
#bit F_H    =PORTC,5;
#bit ENABLE =PORTC,0;
1.2. Déclaration de variables:

Algorithmique : variable Nomvariable : [Type]

Syntaxe C : #define ID_de_la_variable ;

Exemples :
float VALEUR_CAN ;         // variable de type réel   
int ETAT_RE[4] ;           // tableau de 4 éléments entier          
char  MESSAGE_N1[10] ;     // chaîne de 9 caractères  
2. Procédures et fonctions :

La traduction dune fonction ou procédure ou encore appelé sous-programme seffectue ainsi :

2.1. Syntaxe :

//Nom de la fonction :

//Description du rôle de la fonction :

//Paramètres dentrée : Noms et types des paramètres dentrée

//Paramètre de sortie : Nom et type du paramètre de sortie

Type de la variable de retour    nom de fonction (types nom des paramètres)

{

       Instruction 1 ;

       .

       .

       Instruction n ;

       Return (valeur) ;     // Valeur à renvoyer

}

·       A partir de ce syntaxe, on peut avoir plusieurs cas possibles comme :

2.2. Une fonction sans paramètres dentrée et de sortie :

//Nom de la fonction :

//Description du rôle de la fonction :

//Paramètres dentrée : Rien

//Paramètre de sortie : Rien

Void   nom de fonction (Void)

{

       Instruction 1 ;

       .

       .

       .

       Instruction n ;}

2.3. Une fonction avec des paramètres dentrée et sans paramètre de sortie :

//Nom de la fonction :

//Description du rôle de la fonction :

//Paramètres dentrée : Noms et types des paramètres dentrée

//Paramètre de sortie : Rien

Void nom de fonction (types nom des paramètres)

{

       Instruction 1 ;

       .

       .

       .

       Instruction n ;}

2.4. Une fonction avec des paramètres dentrée et un paramètre de sortie :

//Nom de la fonction :

//Description du rôle de la fonction :

//Paramètres dentrée : Noms et types des paramètres dentrée

//Paramètre de sortie : Nom et type du paramètre de sortie

Type de la variable de retour    nom de fonction (types nom des paramètres)

{

       Instruction 1 ;

       .

       Instruction n ;

       Return (valeur) ;     // Valeur à renvoyer   }

2.5Une fonction dinterruption :

    Lexécution dune fonction dinterruption répond a un évènement qui peut être interne (périphérique : CAN, TIMER, EEPROM, USART, I2C) ou externe (RB0,PORTB) du microcontrôleur. Lappel dune fonction dinterruption ne dépend pas de programme principal, mais elle linterrompe pendant son exécution.

Une fonction dinterruption na pas de paramètre dentrée et de sortie. Le compilateur CCS utilise une directive spéciale INIT_XXXX (XXXX nom de linterruption) pour les différencier avec les autres fonctions logicielles.

Syntaxe :

//Nom de la fonction :

//Description du rôle de la fonction :

#INIT_XXXX                     //Nom de linterruption

Void   nom de fonction (Void)

{

       Instruction 1 ;

       .

     Instruction n ;

}

Organisation dun programme en langage C :
///////////////////////////////////////////////////////////////////////////////////////////////
//rôle du programme :                                                                        //
// Auteur :                                                                                  //
//Lieu :                                                                                     //
//Version :                                                                                  //
///////////////////////////////////////////////////////////////////////////////////////////////

//fichier de déclaration des registres internes du microcontrôleur 16F84A.H
#include  <16F84A.H> 
            
//Déclaration des adresses des ports E/S
#byte PORTA  = 5                   //adresse  du port A
#byte  PORTB  = 6                 // adresse  du port B   
//Déclaration des constantes
#define NB_MAX 100 
//Affectation des entrées et sorties de type bit
#bit  BUZZER = PORTD7         //par exemple : Command dun buzzer 
//Fréquence du quartz
#use delay (clock=20000000)
//Configuration de la liaison série de PIC avec une vitesse de9600 bauds
#use rs232 (BAUD=9600, xmit=PIN_C6, rcv=PIN_C7)                   
//Déclaration du prototype de toutes les fonctions logicielles 
//Nom de la fonction suivi dun point virgule par exemple :
Void INIT_UC(Void) ;
//Déclaration des variables globales Par exemple :
Long DEBIT ;
Long VOULUME ;
//Programme principale
Main()
{  
       Instruction 1 ;
       .
       Instruction n ;
}
//Déclaration des fonctions logicielles Par exemple :
//Nom de la fonction : DECALAGE_DROITE
//Description du rôle de la fonction : décalage à droite de NB bits
//Paramètres dentrée : entier VAL, entier NB
//Paramètre de sortie : entier RESULTAT
int  DECALAGE_DROITE (int VAL ,int NB)
{
      Int RESULTAT;
      RESULTAT = VAL >> NB;
     Return (RESULTAT);}
//Appel de la fonction: Nom de la fonction (nom des paramètres) ;
//Exemple :
A = 16 ;
B = DECALAGE_DROITE (A, 2) ;    //la valeur de A sera affectée à VAL
                                //la valeur 2  sera affectée à NB
                                //le résultat de la fonction sera affectée à B         
Quelques directives et fonctions du pic C compiler

1- Directives

#use delay
	Syntaxe	:	#use delay(*clock=fréquence*)
	Rôle	:	Renseigne le compilateur sur la fréquence du quartz utilisé.
	Exemple	:	#use delay(clock=4000000)

#fuses
	Syntaxe	:	#fuses *options*
	Rôle	:	Permet de définir le mot de configuration. Les options sont : · LP, XT, HS, RC · WDT, NOWDT · PUT, NOPUT · PROTECT, NOPROTECT.
	Exemple	:	#fuses XT,NOWDT,NOPUT,NOPROTECT

#int_xxxx

Syntaxe

#int_ext

#int_ RB

#int_TIMER0

#int_EEPROM

: interruption externe.

: changement détat de RB4 à RB7.

: débordement du timer0.

: fin décriture dans lEEPROM.

Rôle

Spécifie la source de linterruption.

2- Fonctions

BIT_CLEAR()
	Syntaxe	:	BIT_CLEAR(*var, bit*)
	Rôle	:	Mettre à 0 le bit « bit » de la variable « var ».
	Exemple	:	a=0x1F BIT_CLEAR(a, 3) a devient 17 hexa.

BIT_SET()
	Syntaxe	:	BIT_SET(*var, bit*)
	Rôle	:	Mettre à 0 le bit « bit » de la variable « var ».
	Exemple	:	a=0x1F BIT_SET(a, 6) a devient 3F hexa.

BIT_TEST()
	Syntaxe	:	BIT_TEST(*var, bit*)
	Rôle	:	Teste létat du bit « bit » de la variable « var ».
	Exemple	:	a=0x1F BIT_TEST(a, 2) Le résultat est 1 car le bit 2 de la variable « a » est à 1.

DELAY_MS()
	Syntaxe	:	DELAY_MS(x)
	Rôle	:	Temporisation se « x » ms.
	Exemple	:	DELAY_MS(2000) Temporisation de 2 secondes.

INPUT()
	Syntaxe	:	etat=INPUT(*pin*)
	Rôle	:	Permet de lire létat dune broche dun port préalablement configurée en entrée.
	Exemple	:	a=input(PIN_B0) la variable « a » reçoit létat de la broche 0 du port B.

INPUT_x()
	Syntaxe	:	etat=INPUT_x()
	Rôle	:	Permet de lire létat dun port (x sur 8 bits) préalablement configuré en entrée.
	Exemple	:	c=input_A() la variable « c » reçoit létat du port A (1 octet).

OUTPUT_x()
	Syntaxe	:	OUTPUT_x(*valeur*)
	Rôle	:	Permet de sortir loctet «valeur» sur le port x , préalablement configuré en sortie.
	Exemple	:	OUTut_B(0x1F) La valeur 1FH est envoyée sur le port B.

OUTPUT_BIT()
	Syntaxe	:	OUTPUT_BIT(*pin, etat*)
	Rôle	:	Permet de mettre la pin (*pin) à létat logique (etat*).
	Exemple	:	OUTut_BIT(PIN_A3,1) Mettre à 1 la broche 3 du port A.

OUTPUT_HIGH()
	Syntaxe	:	OUTPUT_HIGH(*pin*)
	Rôle	:	Permet de mettre à 1 la pin (*pin*).
	Exemple	:	OUTut_HIGH(PIN_A3) Mettre à 1 la broche 3 du port A.

OUTPUT_LOW()
	Syntaxe	:	OUTPUT_LOW(*pin*)
	Rôle	:	Permet de mettre à 0 la pin (*pin*).
	Exemple	:	OUTut_LOW(PIN_A3) Mettre à 0 la broche 3 du port A.

ROTATE_LEFT()
	Syntaxe	:	ROTATE_LEFT(*adresse*, n)
	Rôle	:	Rotation à gauche de « n » positions de loctet ayant pour adresse « adresse ».
	Exemple	:	a=0x86 ROTATE_LEFT(&a, 1) a devient 0d hexa.

ROTATE_RIGHT()
	Syntaxe	:	ROTATE_RIGHT(*adresse*, n)
	Rôle	:	Rotation à droite de « n » positions de loctet ayant pour adresse « adresse ».
	Exemple	:	a=0x86 ROTATE_ RIGHT (&a, 1) a devient 43 hexa.

SET_TRIS_x()
	Syntaxe	:	SET_TRIS_x(*valeur*)
	Rôle	:	Configure la direction du port « x ».
	Exemple	:	SET_TRIS_B(0x0F) Les pins B7, B6, B5, B4 sont configurées en sortie (0). Les pins B3, B2, B1, B0 sont configurées en entrée (1).

SHIFT_LEFT()
	Syntaxe	:	SHIFT_LEFT(*adresse, n, bit*)
	Rôle	:	Décalage à gauche de « n » positions de loctet dadresse « adresse » ; bit est le bit introduit 0 ou 1.
	Exemple	:	SHIFT_LEFT(&b, 2, 0) Décalage à gauche de 2 positions de la variable « b ».

SHIFT_RIGHT()
	Syntaxe	:	SHIFT_RIGHT(*adresse, n, bit*)
	Rôle	:	Décalage à droite de « n » positions de loctet dadresse « adresse » ; bit est le bit introduit 0 ou 1.
	Exemple	:	SHIFT_ RIGHT (&b, 2, 0) Décalage à droite de 2 positions de la variable « b ».

Programmation en C - CCS PCWH

1. Les Règles de bases :

2. Les variables et les constantes :

2.1. Les constantes :

2.2. Les variables :

2.2.1Les types du compilateur CCS :

Type

Taille

valeurs

2.2.2 Les base du compilateur CCS :

3. Les opérateurs du langage C :

3.1. Lopérateur daffectation :

Type

Symbole

Exemple

3.2. Les opérateurs arithmétiques :

Type

Symbole

Exemple

3.3. Les opérateurs de comparaison ou relationnels :

Type

Symbole

Exemple

3.4. Les opérateurs logiques :

Type

Symbole

3.5. Les opérateurs binaires bit à bit :

Type

Symbole

Exemple

4. Les structures répétitives.

4.1 Structure while : tant que ... faire ...

4.2 Structure do ... while : faire ... tant que...

4.3 Structure for : Pour <variable> allant de <valeur initiale> à <valeur finale> faire...

4.4 Les structures alternatives.

4.5 Structure if ... Else : Si <condition> faire ... sinon faire ...

4.6 Structure switch ... case.

5. Les fonctions adaptées aux microcontrôleurs PIC :

5.1. La gestion des entrées et des sorties :

5.2. La gestion des temporisations :

5.3. La gestion de la liaison série :

Traduction dun algorithme en langage C :

1. Constantes et variables :

1.1. Déclaration de Constantes :

1.2. Déclaration de variables:

2. Procédures et fonctions :

2.1. Syntaxe :

2.2. Une fonction sans paramètres dentrée et de sortie :

2.3. Une fonction avec des paramètres dentrée et sans paramètre de sortie :

2.4. Une fonction avec des paramètres dentrée et un paramètre de sortie :

2.5Une fonction dinterruption :

Organisation dun programme en langage C :

Quelques directives et fonctions du pic C compiler

3.1. Lopérateur daffectation :

4.1 Structure while : tant que ... faire ...

4.2 Structure do ... while : faire ... tant que...

4.3 Structure for : Pour <variable> allant de <valeur initiale> à <valeur finale> faire...

4.5 Structure if ... Else : Si <condition> faire ... sinon faire ...

4.6 Structure switch ... case.

Traduction dun algorithme en langage C :

2.2. Une fonction sans paramètres dentrée et de sortie :

2.3. Une fonction avec des paramètres dentrée et sans paramètre de sortie :

2.4. Une fonction avec des paramètres dentrée et un paramètre de sortie :

2.5Une fonction dinterruption :

Organisation dun programme en langage C :