Instructions et commandes C

De Enseignement secondaire.
Aller à : Navigation, rechercher

Retourner à la page principale

Le but de ce document n’est pas d’expliquer les instructions, qui ont été vues dans les exercices, et dont on trouve le détail dans de nombreuses pages sous Google. Le but est d’avoir un résumé sur 1-2 pages, que le débutant consulte quand il n’est plus sûr de lui (orthographe, syntaxe).

Sommaire

Généralités

Règles

Types de données

u8 u16: unsigned     0..255  0..64535
                     0..0xff 0..0xffff

s8 s16: int signed   -128..+127  -32268 
                     0x80..0x7F  0x7FF

Il y en a beaucoup d’autres.

Une multiplication étend un type 8 bits en 16 bits

Numérotation des éléments et poids

Pour un ordinateur, le premier élément est toujours l’élément 0 et pas 1.

Dans un mot binaire, on distingue le rang 7 6 .. 2 1 0 et le poids 128 (=27) 64 ... 4 2 1

Déclarer une constante

Le #define permet de donner un nom à une valeur, comme un bit dans un port du processeur.

Par convention, un nom de constante se note de préférence en majuscule, ce que nous ne faisons pas toujours.

#define LedBleue    LATAbits.LATA4
#define LedBleueOn  LATAbits.LATA4 = 0

Include

Include permet au préprocesseur d’insérer un fichier. On utilise des " " pour les fichiers locaux, et des < > pour les librairies standard.

#include "KiAscDef.h"   même dossier
#include "../KiDeSoft/KiDeJoue.h"  dossier différent
#include <std_io>  en librairie standard

Mise en page

Les espaces, tabulateurs et retours à la ligne sont libres, mais il est très important de respecter les règles d’encolonnement avec les tabulateurs.

// devant un commentaire qui se termine à la fin de la lignes 
/* devant des lignes de commentaire qui se terminent par un */

Instructions

Les instructions ont un point-virgule terminateur, et on peut mettre plusieurs instructions par ligne (pas recommandé pour la lisibilité et le dépannage). Un ; seul est vu comme une instruction vide.

Variables

Une variable et son type doivent être déclarés avant utilisation. On peut assigner une valeur initiale par la même occasion.

u8 var=12 ;   //Déclare la variable var 8 bits et l’initialise à la valeur 12

On remarque le ; terminateur des instructions (mais pas des commandes), qu’il ne faut pas oublier. Les espace et lignes supplémentaires sont libres.

// ignore la fin de la ligne (commentaire).

Assignation (égalité)

On assigne ou change la valeur d’une variable avec une instruction d’égalité.

var8 = PORTB ;  
var16 = 3*toto ;  //(les multiplications se font en 16 bits au moins)

Comparaison

Si on veut comparer, on utilise un signe = dédoublé. (xx==LOW). C’est une question que l’on doit mettre entre parenthèse : est-ce que xx est égal à LOW ? La réponse est vrai ou faux, "1" ou "0".

Les opérateurs de comparaison sont == (égalité), != (différent), < (inférieur), > (supérieur), <= (inférieur ou égal), >= (supérieur ou égal). Ces comparaisons s’appliquent sur des nombres positifs ou négatifs, selon le type de donnée déclaré. Dans la figure 1 plus haut, si A et B sont de type u8, on a A < B , mais si c’est le type s8, A>B.

Voir Resumé du langage C pour d’autres comparaisons.

Attention, ne pas utiliser = à la place de ==, le compilateur accépte, mais la condition sera toujours vraie.

Commandes

Une commande est suivie d’un bloc d’instructions entre { }. S’il y a une seule instruction dans le bloc, les accolades sont superflues.

if (condition) { }

Si la condition est vraie, on exécute le groupe d’instructions qui suit entre accolades. S’il n’y a qu’une seule instruction, les accolades ne sont pas nécessaires.

La condition est en général une comparaison, qui donne comme résultat faux (=0) ou vrai (différent de 0, en général 1).

i++;           // compteur circulaire pour un Dé  0 1 2 3 4 5 0 1 2 …
if(i==6) i=0;  // pas de { } car une seule instruction

if (condition) { } else { }

Si la condition est fausse, on exécute le groupe d’instructions qui suit le else.

if (Sens ==0)  PortD = 0b00000010 ;
else  PortD = 0b00000001 ;

if ... else if ... else ... if ... else

Le if ( ) else { } ne teste qu’une condition. Avec cette autre structure, on peut tester plusieurs conditions différentes successivement.

La commande switch-case en général mieux adapté et plus lisible.

while ( condition ) { }

Le groupe d’instruction entre { } est exécuté jusqu'à ce que la condition devienne fausse. Donc while (1) boucle indéfiniment !

loop () {
   ... instructions d’initialisation
   while (1) {
      ... instructions du programme
   }
}

do { } while ( condition )

La boucle while ("tant que") boucle jusqu'à ce que la condition ou l'expression entre les parenthèses ( ) devienne fausse. donc while (1) boucle indéfiniment !

do  
{  //on a déclaré avant u8 a=0 ;
   a++ ; 
   PORTB = a ;
}
while (a<10);

for

Il y a 3 parties dans l'entête d'une boucle for :

for (initialization; condition; increment)
{ 
  //instruction(s); 
}

L'initialisation a lieu en premier et une seule fois. A chaque exécution des instructions de la boucle, la condition est testée; si elle est VRAIE, le bloc d'instructions et l'incrémentation sont exécutés. puis la condition est testée de nouveau. Lorsque la condition devient FAUSSE, la boucle stoppe.

u8 i ;
for (i=1; i<=10; i++) instr-bloc 1;

break

L’instruction break ; permet de sortir d’une bouble while ou for, ce qui peut être pratique.

Par exemple, pour sortir de la boucle si on presse sur une touche :

if (Poussoir == PousOn)  break ;

Commandes avancées

Tableaux

Un tableau est une suite de cases mémoires de même taille, accessibles à l'aide d'un numéro d'index. à partir du nom donné. Le tableau a un type , une longueur que l’on mets entre crochet et une suite de valeurs entre accolade.

Par exemple, pour un dé:

u8 faces[6]={0b01000000,0b00001001,0b0100… )

Pour le dé électronique:

u8 faces[6]={0b01000000,0b00... ;

PORTB = faces[3] ; // Pour lire la combinaison en position 3 (4e élément !)

Structure

Une structure regroupe des valeurs de types éventuellement différents et on peut partir dans des bases de données. Ce n’est pas notre objectif.

Enumération

Associe des noms à une valeur mémorisée dans une variable. enum est un nom réservé suivi entre accolade d’une suite de symboles qui se voient attribuer les valeurs 0, 1, 2.. qui sont rangées dans la variable dont le type est unique, donc pas spécifié.

Ceci est donc une aide à la documentation.

enum { Do1, Do2, Do3 } var ; // On peut définir ensuite un switch (var)

La commande switch mentionne une variable et est associée aux commandes case qui sélectionnent des valeurs de cette variable.

switch (variable) {
    case val1:
        instruction ;  break ;
    case val1:
        instruction ;  break ;
    ...
    default:
    ...
}

Il faut parenthéser le groupe switch, mais les case et default sont terminés par un : , sans accolade pour le groupe d’instructions.

break; sort du groupe switch, pour ne pas exécuter les instructions des autres case.

Switch.png

Outils personnels
Espaces de noms
Variantes
Actions
Navigation
Boîte à outils