Instruction de cas de commutation dans Arduino
Déclaration de cas de commutation
Dans l'instruction de cas Switch Si l'affaire est vraie, l'instruction sera exécutée et la sortie sera affichée et si le cas est faux, le code passera au cas suivant. Le code vérifiera tous les cas donnés par l'utilisateur. Si tous les cas sont faux, il y a un cas par défaut qui est déclaré à la fin du programme Arduino sera exécuté. Pour utiliser l'instruction de cas de commutateur, la syntaxe suivante doit être gardée à l'esprit:
commutateur (variable)
Valeur variable de cas:
// instruction
casser;
Valeur variable de cas:
// instruction
casser;
défaut:
// instruction
casser;
Pour utiliser l'instruction de cas Switch First, la variable doit être déclarée sur la valeur de laquelle les cas doivent être faits, les cas sont écrits en les numérotant avec les valeurs de la variable requise par l'utilisateur dans la sortie. En donnant le numéro de cas, la valeur requise vérifiera si l'opération appliquée au début du programme Arduino donne la valeur souhaitée ou non. Pour isoler les cas les uns des autres un mot-clé casser est utilisé à la fin de chaque cas. Le fonctionnement de l'instruction Switch Case peut être encore compréhensible par le graphique de flux.
Exemples de codes pour l'instruction Switch-Case
L'instruction de cas Switch peut être utilisée à plusieurs fins, comme vérifier les valeurs obtenues en effectuant une opération mathématique, en générant une liste de nombres ayant des intervalles spécifiques ou en attribuant une instruction en fonction des valeurs obtenues à partir de tout type d'opération. Ce contexte donne les deux différents types d'exemples de codes de programmation Arduino dans lesquels les instructions de cas de commutation sont utilisées. Cela aidera le lecteur à saisir facilement le concept de déclaration de cas de commutateur et son implémentation dans la programmation Arduino.
Exemple 1 pour l'instruction de cas de commutateur dans Arduino
Le premier exemple de code consiste à tracer une série de nombres sous forme incrémentielle de 1 à 4 à l'aide d'une instruction de cas pour une boucle et commutation. La série peut également être tracée sous forme décroissante simplement en modifiant l'opérateur d'incrément en opérateur décrément.
void setup()
En série.commencer (9600);
En série.println ("====== série de nombres de 0 à 4 ======");
pour (int a = 0; a <= 4; a++)
commutateur (a)
Cas 0:
En série.print ("cas 0: a =");
En série.println (a);
casser;
cas 1:
En série.print ("cas 1: a =");
En série.println (a);
casser;
Cas 2:
En série.print ("cas 2: a =");
En série.println (a);
casser;
Cas 3:
En série.print ("cas 3: a =");
En série.println (a);
casser;
Cas 4:
En série.print ("cas 4: a =");
En série.println (a);
casser;
défaut:
En série.print ("cas par défaut: a =");
En série.println (a);
casser;
VOID LOOP ()
Sortir
Exemple 2 pour l'instruction de commutation
Dans le deuxième exemple du code Arduino, une opération mathématique est effectuée, puis la sortie de l'opération est testée en utilisant différents cas sur chaque itération de la boucle où deux valeurs sont considérées. L'un est la valeur variable et l'autre est la valeur constante. La valeur de la variable A C sera modifiée après chaque itération et la valeur de l'entier D est maintenue constante tout au long du programme Arduino.
void setup()
En série.commencer (9600);
En série.println ("====== Multiplication ======");
const int d = 2;
int a;
pour (int c = 0; c <= 4; c++)
a = c * d;
commutateur (a)
Cas 0:
En série.print ("cas 0: a =");
En série.println (a);
casser;
cas 1:
En série.print ("cas 1: a =");
En série.println (a);
casser;
Cas 2:
En série.print ("cas 2: a =");
En série.println (a);
casser;
Cas 3:
En série.print ("cas 3: a =");
En série.println (a);
casser;
Cas 4:
En série.print ("cas 4: a =");
En série.println (a);
casser;
Cas 5:
En série.print ("cas 5: a =");
En série.println (a);
casser;
Cas 6:
En série.print ("cas 6: a =");
En série.println (a);
casser;
défaut:
En série.print ("cas par défaut: a =");
En série.println (a);
casser;
VOID LOOP ()
Sortir
La sortie affiche uniquement les cas sur lesquels la valeur de la variable a pour l'opération de multiplication est vraie. De même, il y a un cas par défaut qui montre la valeur obtenue après l'exécution du cas 6.
Conclusion
Les instructions de cas de commutateur utilisent plusieurs conditions sous forme de cas. Chaque condition a ses propres instructions et chaque cas est séparé en utilisant le mot-clé Break. Dans cette instruction de commutation d'écriture, est expliquée à l'aide d'un graphique de flux et de codes d'exemples.