Idée générale sur Le langage C du compilateur CCS

By: Unknown on 1/21/2016 06:25:00 AM

Share it Please

Tweet

 

Idée générale sur Le langage  C du compilateur CCS

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 d’instructions commence par { et se termine par } .

2. Les variables et les constantes :

2.1. Les constantes :

            Les constantes n’existent pas, c'est-à-dire qu’il n’y a pas d’allocation mémoire, mais on peut affecter à un identificateur(Nom : Il ne doit pas dépasser 32 caractères, sans accent)
Une valeur constante par l’instruction  #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 d’un bit)
  • X : Nom du variable ou d’une 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>
·         .l’identificateur : C’est  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 ;
• L’octale :                  A=012 ;
• L’hexadé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, d’affectation, etc.…

3.1. L’opérateur d’affectation :

Type	Symbole	Exemple
Opérateur d’affectation	=	X=10  ;  Y = a + b

L’opérande de gauche prend pour valeur l’opé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 d’instruction le nombre de répétitions n’est pas défini et dépend du résultat du test effectué sur la condition. Si cette dernière n’est jamais vérifiée, la séquence n’est pas exécutée.

while (int x!=0)

     {

     ...

     }

La structure précédente répète la suite d’instruction 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 n’est 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 d’instruction 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 d’exé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 d’agir sur les ports d’entré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 A…E
•  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 d’entrée et de sortie peuvent être redirigées sur le port série du microcontrôleur, il suffit d’ajouter 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 d’un 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 d’E/S de type bit : commande d’un 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 d’une fonction ou procédure ou encore appelé sous-programme s’effectue ainsi :

2.1. Syntaxe :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entré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 d’entrée et de sortie :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Rien
//Paramètre de sortie : Rien
Void   nom de fonction (Void)
{
       Instruction 1 ;
       .
       .
       .
       Instruction n ;}

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

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entré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 d’entrée et un paramètre de sortie :

//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entré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 d’interruption :

    L’exécution d’une fonction d’interruption 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. L’appel d’une fonction d’interruption ne dépend pas de programme principal, mais elle l’interrompe  pendant son exécution.
Une fonction d’interruption n’a pas de paramètre d’entrée et de sortie. Le compilateur CCS utilise une directive spéciale INIT_XXXX (XXXX nom de l’interruption) 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 l’interruption
Void   nom de fonction (Void)
{
       Instruction 1 ;
       .
       Instruction n ;
}