Technologies numériques/Arduino/Arduino- Débutant/Introduction aux variables et aux instructions conditionnelles
Les variables permettent de stocker ou de modifier des informations dans le code du programme. Pour créer une variable dans votre programme, il faut la déclarer. Pour déclarer une variable, le codeur doit d'abord écrire le type de variable à déclarer. Différents types existent, les plus couramment utilisés sont :
| Type | Syntaxe |
|---|---|
| Entiers | int |
| non-entiers (rationnels et non-rationnels) | double or float |
| caractères | char |
Après avoir déclaré le type de variable, le codeur doit ensuite nommer la variable. Le nom de la variable doit clairement refléter le but de la valeur, afin que le codeur et le lecteur puissent facilement identifier quelle valeur est associée à quelle variable. En outre, les variables ne peuvent pas comporter d'espaces dans leur nom. Par exemple, "Mon dépôt" n'est pas un nom de variable valide, mais "MonDépôt" l'est. Notez que les majuscules peuvent être utiles pour la lisibilité. En outre, les variables ne doivent pas commencer par des chiffres ou par un trait de soulignement "_".
Après avoir nommé la variable, le codeur peut choisir d'initialiser la variable, c'est-à-dire de choisir une valeur initiale à associer à la variable (qui peut changer tout au long du programme). Veillez à rester cohérent avec le type de la variable. Par exemple, vous ne pouvez pas initialiser la variable int Age avec la valeur "k", car "k" n'est pas un nombre entier. Les segments de code ci-dessous illustrent le processus d'initialisation :
int a;// non initialisé, ce qui est correct !
double b=1.23;/* Notez que la valeur 1,23 correspond au type "double" qui est un nombre rationnel*/.
char MyVariable = “h”; //notez les points-virgules!
Ce qui suit produira une erreur, qui empêchera le compilateur de compiler votre code :
char YourVariable= 1.23; //1.23 n'est pas un caractère!
Les variables peuvent être classées en variables globales ou locales. La principale différence est la portée à laquelle elles sont accessibles. Une variable globale peut être accédée par toutes les fonctions qui existent dans un programme, alors qu'une variable locale ne peut être accédée que par la fonction dans laquelle elle est déclarée. L'exemple ci-dessous illustre bien cette différence [https://www.arduino.cc/reference/en/language/variables/variable-scope-qualifiers/scope/] :
/* Il y a deux fonctions dans ce programme : setup() et loop(), et trois variables : "k", "i", "f".*/
int k; // toute fonction verra cette variable, ainsi appelée variable globale.
void setup() {
// ... }
void loop() {
int i; // "i" est seulement "visible" à l'intérieur de "loop".
float f; } // "f" est seulement "visible" à l'intérieur de "loop".
.....// quelques lignes de code}
Conditionnels
Les instructions conditionnelles sont des opérations de programmation qui indiquent à l'ordinateur d'effectuer une action pour un certain ensemble de conditions. L'instruction "if" est la plus courante. Elle indique à l'ordinateur d'effectuer un ensemble d'actions uniquement si la condition est remplie. La syntaxe est la suivante :
if (condition) {
///un ensemble d'instructions }
Les altérations courantes des instructions if sont les "if...else" et "if... else if". Les conditionnels "if...else" vérifient d'abord la condition "if", dans le cas où elle est vraie, le compilateur ignorera le jeu d'instructions "else". Dans le cas où la ou les conditions déclarées dans l'instruction "if" ne sont pas remplies, les instructions "else" s'exécutent automatiquement. La syntaxe d'une instruction "if...else" est la suivante :
if (condition){
///instructions;}
else {
///Instructions qui seront exécutées UNIQUEMENT dans le cas où les conditions "si" ne sont pas remplies. }
Dans le cas de la série d'instructions "if...else if", le programme ne s'exécutera que si les conditions spécifiées dans le "if" ou le "else if" sont vraies. La syntaxe est la suivante :
if (condition){
///instructions }
else if (condition) {
///instructions }