Leçons de niveau 15

Utiliser les PIC 16F et 18F/Introduction au langage C

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Introduction au langage C
Icône de la faculté
Chapitre no 6
Leçon : Utiliser les PIC 16F et 18F
Chap. préc. :Les sous-programmes en assembleur
Chap. suiv. :Les ports et le langage C

Exercices :

Introduction au langage C
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Utiliser les PIC 16F et 18F : Introduction au langage C
Utiliser les PIC 16F et 18F/Introduction au langage C
 », n'a pu être restituée correctement ci-dessus.

Il existe un livre complet sur le langage C dans la Wikiversité. Il est pas question donc de réintroduire ici les structures de contrôles et autres fondamentaux du langage C, mais seulement de s'intéresser particulièrement aux opérateurs, aux masques et autres choses peu utilisées en programmation C standard. Le fait que l’on cible une petite architecture aura en effet quelques conséquences que l’on se propose d'examiner.

Les opérateurs du langage C[modifier | modifier le wikicode]

Les opérateurs du language C sont classés par priorités. L'intérêt d'un tel classement est d’éviter de mettre trop de parenthèses dans les expressions qui utilisent ces opérateurs.

Le problème des parenthèses[modifier | modifier le wikicode]

Il y a tellement d'opérateurs que l'apprentissage des priorités de ceux-ci est long. Pour éviter de se reporter à d'autres documents, on rappelle le tableau de priorité des opérateurs du C :

Catégorie d'opérateurs
Opérateurs
Associativité
fonction, tableau, membre de structure, pointeur sur un membre de structure ( ) [ ] . -> Gauche -> Droite
opérateurs unaires - ++ -- ! ~

* & sizeof (type)

Droite ->Gauche
multiplication, division, modulo * / % Gauche -> Droite
addition, soustraction + - Gauche -> Droite
décalage << >> Gauche -> Droite
opérateurs relationnels < <= > >= Gauche -> Droite
opérateurs de comparaison == != Gauche -> Droite
et binaire & Gauche -> Droite
ou exclusif binaire ^ Gauche -> Droite
ou binaire ǀ Gauche -> Droite
et logique && Gauche -> Droite
ou logique ǁ Gauche -> Droite
opérateur conditionnel ? : Droite -> Gauche
opérateurs d'affectation = += -= *= /= %=

&= ^= |= <<= >>=

Droite -> Gauche
opérateur virgule , Gauche -> Droite

La priorité des opérateurs va décroissante lorsqu'on se déplace du haut du tableau vers le bas du tableau. Quand les opérateurs ont même priorité, c’est la colonne de droite sur l’associativité qui est utilisée.

Eliminer les parenthèses[modifier | modifier le wikicode]

Eliminer les parenthèses consiste à isoler une partie de l’expression entre parenthèses et à regarder si l'autre partie de l’expression est moins prioritaire. Si c’est le cas, les parenthèses peuvent être retirées. Si ce n’est pas le cas on ne les retire pas. Lorsque les opérateurs ont même priorité on utilise l’associativité.


Interprétation d'une expression[modifier | modifier le wikicode]

Vous ne serez pas l'auteur de tous les programmes C que vous lirez. Ainsi, parfois, votre problème ne sera pas de savoir si on peut retirer les parenthèses, mais de savoir simplement que fait l’expression. Ce problème est intimement lié à celui d'éliminer les parenthèses.

Travail sur les bits individuels en C[modifier | modifier le wikicode]

Lorsqu'on programme en C sur une petite architecture comme le PIC 16F/18F, on est très souvent amené à faire des tests sur les bits individuels de certains registres. On peut aussi être amené à être plus actif en positionnant certains bits individuels à 1 ou à 0.

Positionner un bit particulier en C[modifier | modifier le wikicode]

Le principe de base est d’utiliser des masques.

Les opérations logiques effectuées sont des opérations bit à bit :

  • & et logique bit à bit en C pour positionner un ou plusieurs 0 ;
  • | ou logique bit à bit en C pour positionner un ou plusieurs 1.

Les masques seront exprimés en hexadécimal. Ce n’est pas obligatoire car certains compilateurs offrent la possibilité d'écrire en binaire, mais si l’on veut être portable, il vaut mieux utiliser l'hexadécimal.

Utisation de masques[modifier | modifier le wikicode]

Début d’un principe
Fin du principe

Un schéma de principe sera peut-être plus parlant :

Utiliser des masques pour positionner des bits

Les masques sont donnés en rouge en binaire et en hexadécimal. Les X dans le registre représentent des valeurs que l’on ne connait pas. Remarquez que les X sont restés des X (ce qui signifie qu’ils n'ont pas changé) sauf pour un seul bit.

Début d’un principe
Fin du principe


Utilisation de macros[modifier | modifier le wikicode]

Il existe plusieurs autres méthodes pour positionner les bits (http://www.microchipc.com/HiTechCFAQ/index.php)

1° méthode pour positionner bit à bit :

	#define bit_set(var,bitno) ((var) |= 1 << (bitno))
	#define bit_clr(var,bitno) ((var) &= ~(1 << (bitno)))
	unsigned char x=0b0001;
	bit_set(x,3); //now x=0b1001;
	bit_clr(x,0); //now x=0b1000;*/

2° méthode pour positionner plusieurs bits

	#define bits_on(var,mask) var |= mask
	#define bits_off(var,mask) var &= ~0 ^ mask
	unsigned char x=0b1010;
	bits_on(x,0b0001); 	//now x=0b1011
	bits_off(x,0b0011);	//now x=0b1000 */

Tests de bits en C[modifier | modifier le wikicode]

Utilisation des masques[modifier | modifier le wikicode]

On utilise encore des masques mais en général toujours avec l'opérateur ET.

Test de bit à l'aide d'un masque
Début d’un principe
Fin du principe

Cette valeur prédéfinie est égale au masque lorsqu'on cherche à savoir si c’est un 1 ou à 0 partout dans le cas contraire. Le test de gauche dans la figure ci-dessus peut donc s'écrire :

   // unsigned char Reg;
   if ((Reg & 0x40) == 0x40) { //E.B. vraie si bit B6 à 1
     ...
   }

tandis que le test de droite s'écrit quant à lui :

   // unsigned char Reg;
   if ((Reg & 0x08) == 0x00) { //E.B. vraie si bit B6 à 0
     ...
   }

Il n’est pas possible de supprimer les parenthèses dans les deux programmes ci-dessus.

Utilisation d'une macro[modifier | modifier le wikicode]

Les tests d'un bit particulier en C peuvent aussi être réalisés de la manière suivante (http://www.microchipc.com/HiTechCFAQ/index.php)

	x=0b1000; //decimal 8 or hexadecimal 0x8
	if (testbit_on(x,3)) a(); else b(); //function a() gets executed
	if (testbit_on(x,0)) a(); else b(); //function b() gets executed
	if (!testbit_on(x,0)) b(); //function b() gets executed
	#define testbit_on(data,bitno) ((data>>bitno)&0x01)

Les types C du PIC[modifier | modifier le wikicode]

Malheureusement ces définitions sont dépendantes des compilateurs C utilisés. Les compilateurs C pour PIC sont classés dans la catégorie 16 bits, c'est-à-dire que le type "integer" est sur 16 bits.

Les types du C PIC sont :

  • unsigned char a;//8 bits, 0 to 255
  • signed char b; //8 bits, -128 to 127
  • unsigned int c; //16 bits, 0 to 65535
  • signed int d; //16 bits, -32768 to 32767
  • long e; //32 bits, -2147483648 to 2147483647
  • float f; //32 bits

Expression booléenne (PIC 16FXXX et autres)[modifier | modifier le wikicode]

Nous expliquons souvent à nos étudiants que la syntaxe du si est :

if ( E.B. )

par exemple, où E.B. est le diminutif d'Expression Booléenne. Le problème est qu'en C, il est possible de remplacer l’expression booléenne par n’importe quelle expression.


Nous allons examiner le passage d'une catégorie d'expression à une autre. Le language C est capable d'interpréter une expression comme expression booléenne ou inversement.

  • expression vers expression booléenne : si vous remplacez une expression booléenne par une expression, le principe est qu'une évaluation de l’expression est exécutée et que si le résultat est nul on considère l’expression comme fausse et pour toute autre valeur, on considère l’expression comme vraie.
  • expression booléenne vers expression : la première est évaluée, si elle est vraie elle est remplacée par un un, si elle est fausse elle est remplacée par un 0.

C'est très pratique, mais la confusion des deux peut conduire à des erreurs.

Voici comment on transforme une expression en expression booléenne à travers un exemple :

Fausse expression booléenne
Vraie expression booléenne
   char n=10;
   while(n) {
   .....;
   n--; }
  char n=10;
   while(n!=0) {
   ..... ;
   n--; }

Ces deux constructions marchent en C. Si on se rappelle que dans une parenthèse d'un while on a une Expression Bolléenne (E.B.), on a ici d'un côté n (qui est une expression) et de l'autre n!=0 (qui est une E.B.). La différence entre les deux est que pour n elle peut prendre toutes les valeurs entre -128 et +127 (si n est de type char) alors que n!=0 ne prendra que deux valeurs 0 ou 1.

Le problème du langage C est que l'oubli d'un & ou d'un | conduit en général à une fausse expression booléenne (c'est-à-dire à une expression tout court) ce qui est tout à fait autorisé. Par exemple écrire a & b au lieu de a && b.

Principe de construction d'une expression booléenne[modifier | modifier le wikicode]

Toutes les expressions du langage C sont construites à partir de briques de bases. La brique de base de l’expression booléenne est la comparaison.

Début de l'exemple
Fin de l'exemple

Si vous associez les briques de bases avec les opérateurs logiques : && et || et ! vous obtenez encore une expression booléenne.

Début de l'exemple
Fin de l'exemple


Voir aussi[modifier | modifier le wikicode]

Langage C sur PIC 16F876


Image logo représentative de la faculté Voir les exercices sur : Introduction au langage C.