Amélioration du confort et de l'efficacité énergétique dans l'habitat. Réalisation d'une "box" domotique

Les opérateurs de calcul à connaître sont le : ' + ' ,' - ', ' * ',' / ' ,' % '

Le ' + ' , ' - ' et ' * ' sont connus.

Le '/ ' (divisé)représentante la division entière. Exemple : 9/2 revoie 4 (la partie décimale est supprimée)

Le ' % ' (modulo) renvoie le reste de la division entière. Exemple : 9%2 (se lit 9 modulo 2) et renvoie le reste de 9/2 soit 1.

l'opérateur d'assignation à connaître est le : ' = '

Exemple : varx = 4 ; (affecte la valeur à droite du égal (4 ) à la variable (varx) à gauche du égal

vary= varx ; (affecte la valeur de la variable à droite du égal (varx ) à la variable (vary) à gauche du égal

les opérateurs d'incrémentation à connaître sont le : le ++ et --

• Exemples :

  mavar++ ; ajoute 1 à la variable mavar, le résultat est identique avec : mavar = mavar+1 ou ++mavar (ou mavar+=1)

  mavar-- ; enlève 1 à mavar (idem mavar=mvar-1 ou --mavar ...)

• Lorsque ces opérateurs sont combinés avec l’opérateur d'affectation il apparaît une différence entre le x++ et le ++x (idem x-- et --x )

  varx = vary++ ; ici on utilise la post-incrémentation on réalise d’abord l'affectation puis après l'incrémentation.

  • Exemple :

    mavar = 4 ; //-->la variable mavar vaut donc 4

    var = mavar ++ ; //--> d'abord l'affectation donc var vaut 4 puis l'incrémentation donc mavar vaut 5

  varx = ++vary ; ici on utilise la pre-incrémentation on réalise d’abord l'incrémentation puis après l'affectation

  • Exemple :

    mavar = 4 ; //-->la variable mavar vaut donc 4

    var =++ mavar ; //--> d'abord l'incrémentation donc mavar vaut 5 puis l'affectation donc var vaut 5.

Les opérateurs de comparaison à connaître sont les  : '== (égal)' , ' != (différent)' , '> (supérieur)' , '<(inférieur)' , ' >= (supérieur ou égal)' , ' <= (inférieur ou égal)'

Ces opérateurs sont utilisés dans des tests ( par exemple dans un "if" ), ils renvoient un 'booléen' (variable binaire ) qui ne peut être que vrai ou faux

La valeur 'faux' ou 'False' est codée par un '0' et la valeur 'vrai' ou 'True' par un '1'. (en C toutes valeurs différentes de '0' est considérée comme 'vrai')

• Exemples : soit les variables --> a= 2 , b=5 , c = 10 ;

  le code : a == 4 va tester l'égalité entre a et 4 et va renvoyer 'faux' car a vaut 2 et est donc différent de 4

  a < b va tester si a est inférieur à b et comme a est inférieur à b il renvoie 'vrai'

  c != a*b va tester si c et a*b sont différents et comme a*b = 10 et c =10 il renverra 'faux' car ils ne sont pas différents.

• les opérateurs logiques utilisables dans les comparaisons

Il peut aussi être utile de faire plusieurs tests à la fois . Par exemple, vous voudriez tester si une variable est comprise entre 2 valeurs (var >5 et var< 20 ), il faudra alors utilisé des symboles logiques.

Ils sont aux nombre de trois :

• le et logique --> symbole " && " il renvoie 'vrai" si tous les membres sont 'vrai'

  • Exemple : soit les variables --> a= 2 , b=5 , c = 10 ;

    (a==2) && (c=!4) renverra vrai car a égal 2 et c est différent de 4

    (b==4) && (c>3) && ( a=!0) renverra faux car b est différent de 4 ( un des termes étant faux le résultat est faux)

• le ou logique --> symbole " || " il renvoie 'vrai" si au moins un des membres est 'vrai'

  • Exemple : soit les variables --> a= 2 , b=5 , c = 10 ;

    (a==5) || (b>6) renverra faux car aucun des termes est vrai.

    (b==4) || (c>3) || ( a !0) renverra vrai car au moins un des termes est vrai (c est supérieur à 3 , a est différent de 0)

• la négation logique --> symbole " ! "il renvoie l'inverse de l'état logique reçu (vrai si faux ou faux si vrai)

  • Exemple :

    ! True renverra faux

    !(4==5) renverra vrai

Les opérateurs de manipulation de bits.

Ces opérateurs permettent de faire des opérations directement sur les bits qui constituent les variables.

• Pour comprendre leur fonctionnement il faut être capable de convertir les variables en binaire.

• Par défaut en 'C' les valeurs numériques sont exprimées en décimal.

• Pour exprimer une valeur en binaire il faut la faire précéder de '0b' --> 0b11001000 équivaut à 200 en décimal (réviser si nécessaire les conversions binaire / hexadécimal / décimal ).

• Pour exprimer une valeur en hexadécimal il faut la faire précéder de '0x' --> 0x4C équivaut à 0b01001100 en binaire et 76 en décimal.

• Par exemple le test 0x4C==0b01001100renverrai 'vrai'

• Pour convertir les variables en binaire il faut connaître leur taille qui est défini par leur 'type' : (voir cours)

  • Sur l'arduino le 'byte' fait un octet (8 bits) si on à une variable de type byte qui vaut 21 on l'écrira en binaire 0b00010101

  • Sur l'arduino le 'int' fait deux octets (16 bits) si on à une variable de type int qui vaut 21 on l'écrira en binaire 0b0000000000010101

Il existe 2 types d'opérateurs :

• Les opérateurs de décalage de bit

  • >>n provoque le décalage de n bits vers la droite

    Exemple : soit la variable 'truc' de type byte (1 octet) byte truc=54 ; //(54 en décimal <-->0b00110110

    • le code : chose = truc >>2 va prendre la valeur binaire de 'truc' la décaler de 2 bits vers la droite (les bits de droite sont perdus et on rajoute des '0' pour les bits de gauche) et l'affecter à 'chose' donc 'chose' vaut 0b00001101 (soit 13)

    • Le code var= 0b01001110 >>1 va affecter la valeur 0b00100111 à 'var'

    • Remarque : un décalage de 1 bit à droite correspond à une division entière par 2

  • <<n provoque le décalage de n bits vers la gauche

    Exemple : soit la variable 'ga' de type byte (1 octet) byte ga =54 ; //(54 en décimal <-->0b00110110

    • le code : cov = ga<<1 va prendre la valeur binaire de 'ga' la décaler de 1 bits vers la gauche (les bits de gauche sont perdus et on rajoute des '0' pour les bits de droite) et l'affecter à 'cov' donc 'cov' vaut 0b01101100 (soit 108)

    • Le code vid= 0b00101110 <<2 va affecter la valeur 0b10111000 à 'vid'

    • Remarque : un décalage de 1 bit à gauche correspond à une multiplication par 2

• Les opérateurs logiques : ou , et , ou exclusif, et complémentation

  • L'opérateur de complémentation " ~ " inverse tous les bits d'une variable ( les '0' deviennent des '1' et les '1' deviennent des '0')

    • Exemple : soit les variables de type byte 'ona', 'onb' et 'ovni' avec ovni=0x55(85)

      Le code : ona = ~0b10011100 va affecter la valeur 0b01100011 à la variable 'ona'.

      Le code : onb = ~25 va affecter ( on convertit 25 en binaire-> 0b00011001 ) puis on inverse 0b11100110 (230) à la variable 'onb'

      Le code : oxi= ~ovniva affecter ( on convertit 0x55 en binaire-> 0b01010101 ) puis on inverse 0b10101010 (170) à la variable 'oxi'

  • Les opérateurs logiques bit à bit : ou, ou exclusif, et

    Ces opérateurs vont effectuer une opération logique bit à bit entre 2 opérandes et l'affecter au bit correspondant du résultat, soit pour des opérandes de un octet:

    • on prend le bit 0 de l'opérande 1, on effectue la fonction logique avec le bit 0 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 0 du résultat

    • on prend le bit 1 de l'opérande 1, on effectue la fonction logique avec le bit 1 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 1 du résultat

    • on prend le bit 2 de l'opérande 1, on effectue la fonction logique avec le bit 2 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 2 du résultat

    • on prend le bit 3 de l'opérande 1, on effectue la fonction logique avec le bit 3 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 3 du résultat

    • on prend le bit 4 de l'opérande 1, on effectue la fonction logique avec le bit 4 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 4 du résultat

    • on prend le bit 5 de l'opérande 1, on effectue la fonction logique avec le bit 5 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 5 du résultat

    • on prend le bit 6 de l'opérande 1, on effectue la fonction logique avec le bit 6 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 6 du résultat

    • on prend le bit 7 de l'opérande 1, on effectue la fonction logique avec le bit 7 de l'opérande 2 et on affecte le résultat de cette fonction logique au bit 7 du résultat

    Rappel :

    • Le " et " logique ( symbolisé par " & " ) renvoie '1' lorsque les 2 opérandes sont à '1' (sinon il renvoie un '0')

    • Le " ou " logique ( symbolisé par " | " )renvoie '0' lorsque les 2 opérandes sont à '0' (sinon il renvoie un '1')

    • Le " ou exclusif " ( symbolisé par " ^ " ) renvoie '0' lorsque les 2 opérandes sont identiques (un '1' si elles sont différentes)

    Quelques exemples : (pour simplifier les variables sont écrites en binaire)

    • vet = 0b101010111 & 0b00001111 --> vet vaudra 0b00000111

    • vou = 0b10100011 | 0b11110000 --> vou vaudra 0b11110011

    • vor= 0b00111100 ^ 0b11110000 --> vor vaudra 0b11001100