Les variables sont des expressions que l’on utilise dans les programmes pour stocker des valeurs, telles que la tension de sortie d’un capteur présente sur une broche analogique.

 

1. Les constantes Arduino prédéfinies

Dans le langage Arduino, les constantes sont des variables prédéfinies. Elles sont utilisées pour rendre les programmes plus faciles à lire.

. INPUT ET OUTPUT

Ces constantes sont utilisées pour définir des broches numériques en entrée ou en sortie :

Les broches numériques peuvent être utilisées soit en mode INPUT (= en entrée), soit en mode OUTPUT (= en sortie).

Modifier le mode de fonctionnement d’une broche du mode INPUT (=ENTREE) en mode OUTPUT(=SORTIE) avec l’instruction pinMode() change complètement le comportement électrique de la broche.

– Broches configurées en entrée (INPUT)

Les broches d’une carte Arduino configurées en mode INPUT (=en entrée) à l’aide de l’instruction pinMode() sont dites en état de « haute-impédance ».

Ces broches ne consomment alors qu’une toute petite intensité (de l’ordre du microampère) du circuit sur lequel elles sont connectées. Leur mode de fonctionnement est équivalent à celui d’un voltmètre.

– Broches configurées en sortie (OUTPUT)

Les broches configurées en mode OUTPUT (= en sortie) avec l’instruction pinMode() sont en état dit de « basse-impédance » .

Cela veut dire qu’elles peuvent fournir une quantité significative de courant aux autres circuits. Chaque broche de la carte Arduino peut fournir jusqu’à 40 mA d’intensité au circuit sur lequel elle est connectée. Son mode de fonctionnement est équivalent à celui d’un générateur.

Cependant, l’intensité cumulée fournie par les broches de la carte ne doit pas dépasser les 200mA !

 

. HIGH ET LOW

Lorsqu’on lit ou on écrit sur une broche numérique, seuls deux états distincts sont possibles, la broche ne peut être qu’à deux valeurs : HIGH (HAUT) ou LOW (BAS).

– HIGH

La signification de la constante HIGH (en référence à une broche) est quelque chose de différent selon que la broche est définie comme une ENTREE ou comme une SORTIE.

Si la broche est configurée en ENTREE avec l’instruction pinMode, et lue avec l’instruction digitalRead, le microcontrôleur renverra HIGH (=HAUT) si une tension de 3V ou + est présente sur la broche.

Quand une broche est configurée en SORTIE avec l’instruction pinMode, et mise au niveau HAUT avec l’instruction digitalWrite, la broche est mise à 5V. Dans cet état, la broche peut fournir une certaine intensité (jusqu’à 40 mA par broche, sans dépasser 200 mA pour l’ensemble des broches).

– LOW

La constante LOW a également une signification différente selon que la broche est configurée en ENTREE ou en SORTIE.

Quand une broche est configurée en ENTREE avec l’instruction pinMode, et lue avec l’instruction digitalRead, le microcontrôleur renverra un niveau BAS si une tension de 2V ou moins est présente sur la broche.

Quand la broche est configurée en SORTIE avec l’instruction pinMode, et est mise au niveau LOW avec l’instruction digitalWrite, la broche est à 0 volts.

 

. true ET false

Il existe deux constantes utilisées pour représenter le VRAI et le FAUX dans le langage Arduino : true et false.

– false (= FAUX)

La constante false est définie comme le 0 (zéro).

– true (=VRAI)

La constante true est définie comme tout entier qui n’est pas 0 (zéro).

Noter que les constantes true et false sont écrites en minuscule à la différence des constantes HIGH, LOW, INPUT et OUTPUT.

 

2. Les variables – Types de données

Les variables peuvent être de type variés. Les différents types de variables sont décrits ci-dessous :

. Int

Déclare une variable de type int (pour integer, entier en anglais). Les variables de type int sont lee type de base pour le stockage de nombres, et ces variables stockent une valeur sur 2 octets. Elles peuvent donc stocker des valeurs allant de – 32 768 à 32 767 (valeur minimale de -2 ¹⁵ et une valeur maximale de 2 ¹⁵ -1).

– Syntaxe :

int var = val;

• var: le nom de votre variable de type int
• val: la valeur d’initialisation de la variable

– Exemple:

int ledPin = 13; // déclare une variable de type int appelée LedPin et valant 13

– Remarque :

Quand les variables dépassent la valeur maximale de leur capacité, elles « débordent » et reviennent à leur valeur minimale, et ceci fonctionne dans les 2 sens :

int x // déclaration de la variable de type int appelée x x = -32,768; // x prend la valeur -32 768 x = x – 1; // x vaut maintenant 32 767, car déborde dans le sens négatif x = 32,767; // x prend la valeur 32 767 x = x + 1; // x vaut maintenant la valeur – 32 768, car déborde dans le sens positif

 

. unsigned int

Déclare une variable de type int non-signée. Les variables de type unsigned int (entiers non signée) sont les mêmes que les variables de type int en ce sens qu’elle stocke une valeur sur 2 octets. Cependant, au lieu de stocker des valeurs négatives, les variables de type unsigned int stocke uniquement des valeurs positives, dans une fourchette allant de 0 à 65535 (2¹⁶-1).

– Syntaxe :

unsigned int var = val;

• var: le nom de votre variable int
• val: la valeur donnée à votre variable
  
  

– Exemple :

unsigned int ledPin = 13; // déclaration d’une variable entière non signée nommée ledPin et valant 13

– Remarque :

Quand la valeur des variables excède leur capacité maximale, elles « débordent » et reprennent leur valeur minimale, et ceci se produit dans les 2 sens.

unsigned int x // déclaration d’une variable int non signée nommée x x = 0; // x vaut 0 x = x – 1; // x contient maintenant 65535 x = x + 1; // x contient maintenant 0

 

. long

Déclare des variables de type long. Les variables de type long sont des variables de taille élargie pour le stockage de nombre entiers, sur 4 octets (32 bits), de -2 147 483 648 à + 2 147 483 647.

– Syntaxe :

long var = valeur;

•  var : le nom de la variable long
•  valeur : la valeur donnée à la variable

– Exemple :

long speedOfLight = 186000L; //déclare une variable de type long // le ‘L’ pour forcer à traiter la variable dans le format de donnée de type long

 

. unsigned long

Déclare une variable de type long non signé. Les variables de type long non signé sont des variables de taille élargie pour le stockage de nombre entier qui stocke les valeurs sur 4 octets (32 bits).

A la différence des variables de type long standard, les variables de type long unsigned ne peuvent pas stocker des nombres négatifs, la fourchette des valeurs qu’elles peuvent stocker s’étendant de 0 à 4 294 967 295 (2³²-1)

– Syntaxe :

unsigned long var = valeur;

• var : le nom de votre variable de type long
• valeur : la valeur donnée à la variable

– Exemple :

unsigned long time; // déclare une variable de type long non signé appelée time void setup() { Serial.begin(9600); // initialise la connexion série à 9600 bauds } void loop() { Serial.print(« Time: « ); // Met dans la variable time le temps écoulé depuis le démarrage time = millis(); //affiche le temps écoulé depuis que le programme a démarré Serial.println(time); // attend une seconde avant d’envoyer un nouveau message au PC delay(1000); }

 

. float

Déclare des variables de type « virgule-flottante », c’est à dire des nombres à virgules. Les nombres à virgule sont souvent utilisés pour l’expression des valeurs analogiques.

Les nombres à virgule ainsi stockés peuvent prendre des valeurs entre – 3.4028235E+38 et 3.4028235E+38. Ils sont stockés sur 4 octets (32 bits) de mémoire.

Les variables float ont seulement 6 à 7 chiffres de précision. Ceci concerne le nombre total de chiffres, pas seulement le nombre à droite de la virgule.  

– Syntaxe :

float var = valeur;

• var : le nom de la variable
• valeur : la valeur donnée à la variable

– Exemple :

float myfloat; // déclare une variable à virgule appelée myfloat float sensorCalibrate = 1.117; // déclare une variable à virgule appelée sensorCalibrate int x; // déclare une variable entière de type int appelée x int y; // déclare une variable entière de type int appelée y float z; // déclare une variable nombre à virgule de type float appelée z x = 1; // x vaut 1 y = x / 2; // y vaut 0 car les entiers ne supporte pas les décimales z = float (x)/ 2.0; // z vaut 0.5 (float (x) : conversion de x en float, alors x=1.0)

 

. char

Déclare une variable d’un octet de mémoire (8 bits) qui contient une valeur correspondant à un caractère. Les caractères unitaires sont écrits entre guillemets uniques: ‘A’.

Les caractères sont stockés de la même façon que les nombres. A chaque caractère correspond une valeur numérique comprise entre 0 et 127 (code ASCII) :

La variable de type char est de type signée, ce qui veut dire qu’elle peut contenir des valeur allant de -128 à +127.

– Syntaxe :

char monChar=’B’; // déclare une variable char

– Exemple :

char myChar = ‘A’; // déclare une variable char initialisée avec la valeur A char myChar = 65; // expression équivalente car la valeur ASCII de A est 65