Dans les programmes, il est souvent n´ecessaire d’appliquer le mˆeme traitement sur des donn´ees diff´erentes, ou de n’effectuer certains traitements que dans certaines situations. Dans le langage de programmation de l’environnement ARDUINO, ces probl`emes sont r´esolus en utilisant les mˆemes structures algorithmiques que celles du langage C :
• La structure conditionnelle (ou alternative) s’´ecrit
if (condition)
{instructions executees si condition est vraie}
else
{instructions executees si condition est fausse}
Cette structure ´evalue condition, qui doit renvoyer une variable bool´eenne. Si celle-ci est vraie, les instructions pr´esentes apr`es la condition seront ex´ecut´ees. Si conditionest fausse, ce sont les instruc-tions situ´ees apr`es leelsequi seront ex´ecut´ees. La partie alternative (else ...) est facultative. Il est
´egalement possible d’imbriquer plusieurs structures conditionnelles en utilisant unelse if, comme dans l’exemple ci-dessous :
if (condition1)
{instructions executees si condition1 est vraie}
else if (condition2)
{instructions executees si condition1 est fausse et si condition2 est vraie}
else
{instructions executees si condition1 et condition2 sont fausses}
Les conditions utilis´ees dans les structures conditionnelles peuvent ˆetre ´elabor´ees `a l’aide des op´erateurs de comparaison de la figure11, et modifi´ees ou associ´ees `a l’aide des op´erateurs logiques de la figure12. Par exemple, le morceau de programme suivant,
fonctions et op´erateurs applicables aux nombres de tout type - n´egation (compl´ement `a deux)
abs valeur absolue (d’un nombre sign´e16bits)
+ addition
- soustraction
* multiplication
/ division exacte ou euclidienne (ou euclidienne), suivant le types des variables max calcule le maximum de2nombres :y=max(x,100)sera ´egal `axsi celui-ci est
sup´erieur `a100, et ´egal `a100sinon.
min calcule le minimum de2nombres :y=min(x,100)sera ´egal `axsi celui-ci est inf´erieur `a100, et ´egal `a100sinon.
constrain constrain(x, a, b)contraintx`a rester entreaetb.
fonctions applicables seulement aux nombres entiers
% reste de la division euclidienne de deux nombres entiers :17 % 5renvoie 2 map map(x, x1, x2, y1, y2)calcule une transformation lin´eairey=a x+b,
o`uaetbsont tels quey1 =a x1+bety2 =a x2+b.
bitRead bitRead(x, n)renvoie le niveau logique du bitnde la variablex.
bitWrite bitWrite(x, n, level) met le bit n de la variable x au niveau logique level.
fonctions qui renvoient un r´esultat de typedouble sqrt racine carr´ee
square carr´e
log fonction logarithme n´ep´erien log10 fonction logarithme d´ecimal
exp fonction exponentielle
pow pow(x,n)´el`evex`a la puissancen.
sin sinus
cos cosinus
tan tangente
atan arctangente
atan2 atan2(y,x)arctangente dey/xentre0et2π.
Figure 10: op´erateurs arithm´etiques et fonctions disponibles.
if (temperature>=80) {alarme_chaud=1;}
else {
alarme_chaud=0;
if (temperature<=6) {alarme_froid=1;}
else
{alarme_froid=0;}
}
examine si la variable temperature est sup´erieure ou ´egale `a 80. La variable alarme_chaud est mise `a 1 si c’est le cas, et mise `a 0 dans le cas contraire. Si, en plus d’ˆetre inf´erieure `a 80, la variable temperatureest inf´erieure `a6, la variablealarme_froidest mise `a1. Elle est mise `a0dans le cas contraire.
op´erateurs de comparaison
== ´egal
!= diff´erent
< inf´erieur
<= inf´erieur ou ´egal
> sup´erieur
>= sup´erieur ou ´egal
Figure 11: op´erateurs de comparaison.
association de comparaisons
! n´egation
&& et logique
|| ou logique
Figure 12: op´erateurs d’association de comparaisons.
Rappelons ´egalement qu’une condition ne peut ˆetre que la comparaison entre2nombres, ou une association de comparaisons entre 2 nombres : pour tester par exemple si un nombre x est compris entre0 et2, on
´ecrira surtout pasif (0<x<2)mais
if ((0<x)&&(x<2)) {y=log(x*(2-x));}
• Il existe plusieurs structures de r´ep´etition (ou boucles). La premi`ere est la structure de r´ep´etition avec pr´e-condition, qui est utilis´ee pour r´ep´eter un ensemble d’instructions tant qu’une condition (appel´eecondition de poursuite) est vraie. La syntaxe est :
while (condition)
{instructions repetees}
• La deuxi`eme est la structure de r´ep´etition avec post-condition, utilis´ee lorsque la condition de poursuite doit ˆetre plac´ee apr`es le groupe d’instructions r´ep´et´ees. La syntaxe est :
do
{instructions repetees}
while (condition);
On notera qu’avec une telle structure, le groupe d’instructions est ex´ecut´e au moins une fois, puisque la condition de poursuite est ´evalu´ee apr`es ce groupe d’instructions.
compteurou tout simplementboucle for, utilis´ee principalement lorsque l’on sait d’avance combien de fois on doit r´ep´eter un ensemble d’instructions. La syntaxe est :
for (Initialisation;ConditionPoursuite;Progression) {instructions repetees}
Cette structure est ´equivalente `a
Initialisation;
while (ConditionPoursuite) {
instructions repetees;
Progression;
}
Par exemple, l’instruction
for (i=0;i<5;i=i+1) {Serial.println(i,DEC);}
est ´equivalente `a
i=0;
while (i<5) {
Serial.println(i,DEC);
i=i+1;
}
et affiche les cinq valeurs deicomprises entre0et4.
Pour illustrer ces structures, on peut prendre comme exemple le programme ci-dessous, qui extrait (d’une mani`ere assez peu efficace) les chiffres d´ecimaux d’un nombre entier naturel :
// Extraction des chiffres de la representation decimale d’un nombre
// F. Auger, IUT de Saint-Nazaire (Universite de Nantes, France), aout 2010 int i;
unsigned int Nombre, CopieNombre, Seuil, Chiffre[4];
// setup ***************************************************
void setup()
{ // initialisation de la liaison serie avec le pc
Serial.begin(9600); Serial.println("Demarrage du programme");
Nombre=63451; // initialisation du nombre }
// loop ****************************************************
void loop() {
CopieNombre=Nombre; Seuil=10000; // initialisation de l’algorithme
for (i=4;i>=0;i=i-1) // on commence par les dizaines de milliers {
Chiffre[i]=0; // initialisation de chiffre a zero
while (CopieNombre>=Seuil) // on augmente le chiffre et diminue la copie {Chiffre[i]=Chiffre[i]+1; CopieNombre=CopieNombre-Seuil;}
Serial.print( Chiffre[i], DEC);
Seuil=Seuil/10; // on passa a la puissance de 10 en dessous }
Serial.println(); delay(2000); // attend 2 s avant la reprise }