Le compilateur de l’IDE Arduino compile par défaut du code écrit en C et en C++ simplifié pour microcontrôleur. Le code est par ailleurs enrichit des bibliothèques natives au monde Arduino pour communiquer directement avec l’électronique. Au travers des programmes Arduino, on retrouve des types de données différents selon les variables déclarées. Dans cet article, nous allons faire un tour d’horizon de tous ces types de données.

Le tableau ci-dessous montre l’ensemble des données que l’on peut rencontrer et utiliser en programmation Arduino :

Void

Le mot-clé « void » est uniquement utilisé pour déclarer des fonctions. La spécificité du « void » c’est que la fonction ne retourne aucun résultat lorsque celle-ci est appelée.

void loop ( ) {
   // le code à exécuter ici
}

Boolean ou bool

Un « boolean » est un booléen. Il s’agit d’une donnée ne pouvant prendre que 2 valeurs : true (vrai) ou false (faux). Il est également possible de remplacer true par 1 et false par 0 pour un booléen. Chaque variable booléenne occupe un byte de mémoire.

boolean val = false; // déclaration d'une variable booléenne et initialisation à false.
boolean state = true; // déclaration d'une variable booléenne et initialisation à true.

Char

Les données Char sont des données pouvant contenir un caractère. C’est un type de donnée qui occupe un octet de mémoire. caractère s’écrit dans une variable char entre guillemets simples comme ceci : ‘A’. Pour écrire plusieurs caractères, ce qu’on appelle aussi une chaîne de caractères (string), on utilisera les guillemets doubles comme ceci : « ABC ».

Mais derrière chaque caractère se cache un nombre.Vous pouvez voir l’encodage spécifique dans le tableau ASCII. Cela signifie qu’il est possible d’effectuer des opérations arithmétiques sur des caractères, dans lesquels la valeur ASCII du caractère est utilisée. Par exemple, ‘A’ + 1 a la valeur 66, car la valeur ASCII du caractère ‘A’ est 65.

char chr_a = ‘a’; // Déclaration d'une variable Char et initialisation de cette variable avec le caractère 'a'
char chr_a_bis = 97;  // Déclaration d'une variable Char et initialisation de cette variable avec le caractère numéro 97, soit le caractère 'a'

char str[ ] = "arduino";	// Déclaration d'une suite de caractère. La suite est stockée sous forme de tableau. La longueur du tableau est initialisée à la longueur du mot.
char str2[8] = "arduino";	// Idem ici, sauf que le tableau a déjà été initialisé à la bonne longueur du mot avant initialisation.
char str3[15] = "arduino";	// On peut également insérer une suite de caractères dans un tableau plus grand.

Unsigned Char

La donnée unsigned char se comporte exactement comme une variable char, sauf que celle ci prends en compte la table ASCII étendue qui va de 0 à 255. Voici la liste des codes restants (128-255) :

Unsigned Char chr_c = 99; // Déclaration d'une variable de type Unsigned Char est initialisation avec le caractère c

Byte

Une donnée byte peut stocker un nombre non signé sur 8 bits, de 0 à 255.

byte m = 42; // Déclaration d'une variable de type byte et initialisation de cette variable à la valeur 42

Int

Les données int représentent les données de stockage des nombres entiers. Il s’agit du type de donnée principal pour le stockage des nombres. Int stocke une valeur sur 16 bits, soit 2 octets. Cela donne une fourchette de -32 768 à 32 767 (soit une valeur minimale de -2¹⁵ et une valeur maximale de 2¹⁵-1).

Attention : la taille de la donnée Int varie d’une carte à l’autre. Sur Arduino Due, MKR100 et Zero par exemple, un int sotcke une valeur sur 32 bits, soit 4 octets. La plage de valeur est donc bien plus grande : de -2 147 483 648 à 2 147 483 647 (soit une valeur minimale de -2³¹ et une valeur maximale de 2³¹-1).

int cpt = -12500; // Déclaration d'une variable int et initialisation à la valeur -12500

Unsigned Int

Les Unsigned Int fonctionnent de la même manière que les Int. La différence ici, c’est que les nombres négatifs ne sont plus pris en compte. Le nombre est toujours encodé sur 2 bytes, soit 16 bits, soit 2 octets. La plage positive est donc plus grande : de 0 à 65 535 (2¹⁶-1). Les Arduino Due, MKR1000, Zero étant sur des nombres en 32 bits, la plage de ce type de données se situe entre 0 et 4 294 967 295 (2³²-1).

Unsigned int cpt = 42500; // Déclaration d'une variable de type Unsigned Int à la valeur 42500.

Word

Sur l’Arduino UNO et les autres cartes ATMEGA, un Word peut stocker un nombre non signé sur 16 bits. Sur l’Arduino Due, MKR1000 et Zero, le Word peut stocker une nombre sur 32 bits non signé. Le fonctionnement d’une variable Word est exactement le même qu’un Unsigned Int.

word cpt = 42500; // Déclaration d'une variable de type word à la valeur 42500.

Long

Les variables Long peuvent stocker des nombres entiers sur 4 bytes, soit 32 bits : de -2 147 483 648 (-2³¹) à 2 147 483 647 (2³¹+1).

long vitLumiere = 299792458; // Déclaration d'une variable de type long à la valeur 299 792 458.

Unsigned long

Les variables Unsigned long peuvent stocker des nombres non signés entiers sur 32 bits : de 0 à 4 294 967 295 (2³²-1).

Unsigned long max = 4294967295; // Déclaration d'une variable de type unsigned long à la valeur 4 294 967 295.

Short

Une donnée de type short peut stocker un nombre entier sur 16 bits quel que soit la carte Arduino utilisée : de -32 768 à 32 767 (soit une valeur minimale de -2¹⁵ et une valeur maximale de 2¹⁵-1).

short max = 32767; // Déclaration d'une variable de type short à la valeur 32 767.

Float

Le type de données float permet de stocker un nombre à virgule flottante. Les variables float sont souvent utilisées pour approcher les valeurs analogiques et continues car la donnée float possède une plus grande résolution que les nombres entiers.

La plage d’un nombre float est la plus grande : de -3,4028235 E+38 à 3,4028235 E+38. Ce nombre est stocké sur 32 bits, soit 4 octets.

float pi = 3.14159265359; // Déclaration d'une variable de type float à la valeur 3.14159265359.

Double

Sur Arduino UNO et autres cartes munies de processeur ATMEGA, une donnée double fonctionne exactement de la même manière qu’une donnée float. Elle occupe également 32 bits, sans gain de précision supplémentaire. Par contre sur Arduino Due, MKR1000 ou Zero, la donnée double occupe 64 bits, ce qui offre plus de précision.

double pi = 3.14159265359; // Déclaration d'une variable de type double à la valeur 3.14159265359.