{"id":1563,"date":"2020-03-31T08:51:16","date_gmt":"2020-03-31T06:51:16","guid":{"rendered":"http:\/\/www.ardpylab.fr\/?page_id=1563"},"modified":"2020-05-09T17:49:23","modified_gmt":"2020-05-09T15:49:23","slug":"structure-du-programme","status":"publish","type":"page","link":"https:\/\/www.ardpylab.fr\/?page_id=1563","title":{"rendered":"Structure du programme"},"content":{"rendered":"\n

 <\/p>\n

Dans les fonctions de bases \u201d<\/strong>setup()\u201d <\/strong>et \u201dloop()\u201d <\/strong>obligatoires pour tous les programmes ou dans toute autre fonction, on utilisera les structures de langage suivantes :<\/p>\n\n\n\n

<\/a>

1. Syntaxe de base

<\/u><\/strong><\/h4>\n

. Le point-virgule ;<\/strong><\/span><\/h4>\n

Il est obligatoire \u00e0 la fin de chaque instruction. Pour le compilateur, les sauts de lignes n’ont pas de signification : c’est le point-virgule qui marque la fin de ligne.<\/p>\n

Oublier le point-virgule en fin de ligne donnera une erreur de compilation.<\/p>\n

Exemple<\/u> :<\/p>\n\n\n\n

\n\n\n\n
int a = 13;<\/span>      \/\/ le point-virgule indique la fin de l’instruction<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. Les accolades {}<\/span><\/strong><\/h4>\n

Les accolades sont un \u00e9l\u00e9ment majeur de la programmation en langage C.<\/p>\n

Toute ouverture d’une accolade d’ouverture \u00ab\u00a0{\u00a0\u00bb doit obligatoirement \u00eatre accompagn\u00e9e dans le code d’une accolade de fermeture \u00ab\u00a0}\u00a0\u00bb correspondante. On dit souvent qu’il faut que les accolades soient \u00e9quilibr\u00e9es (c\u00e0d autant de\u00a0\u00bb{\u00a0\u00bb que de \u00ab\u00a0}\u00a0\u00bb).<\/p>\n

L\u2019Arduino IDE inclut une fonctionnalit\u00e9 pratique pour v\u00e9rifier la correspondance des accolades entre elles. Il suffit de s\u00e9lectionner une accolade, ou m\u00eame de cliquer juste apr\u00e8s une accolade, et l\u2019accolade d\u2019ouverture ou de fermeture associ\u00e9e sera mise en surbrillance.<\/p>\n

Les accolades sont utilis\u00e9es dans les fonctions, les boucles et les conditions<\/p>\n

Exemples<\/u> :<\/p>\n

 – Avec des fonctions :<\/p>\n\n\n\n

\n\n\n\n
\n

void myfunction(datatype argument){<\/span>      \/\/ ouverture de la fonction<\/span>
         \/\/ instructions<\/span>
}<\/span>                                                                          \/\/ fermeture de la fonction<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

– Dans des boucles :<\/p>\n\n\n\n

\n\n\n\n
\n

while (boolean expression)<\/span>
{ \/\/ accolade d’ouverture du code de la boucle while<\/span> <\/span>
      \/\/ instructions<\/span>
} \/\/ fermeture de la boucle<\/span><\/span><\/p>\n

do<\/span>
{ \/\/ accolade d’ouverture du code de la boucle do<\/span><\/span>
      \/\/ instructions<\/span>
} while (boolean expression); \/\/ fermeture de la boucle<\/span><\/span><\/p>\n

for (initialisation; termination condition; incrementing expr)<\/span>
{ \/\/ ouverture du code de la boucle for<\/span><\/span>
     \/\/ instructions<\/span>
} \/\/ fermeture de la boucle<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

– Dans des conditions :<\/p>\n\n\n\n

\n\n\n\n
\n

if (boolean expression)<\/span>
{ \/\/ ouverture du code de la condition if<\/span><\/span>
     \/\/ instructions<\/span>
} \/\/ fermeture du code de la condition if<\/span><\/span><\/p>\n

else if (boolean expression)<\/span>
{ \/\/ ouverture du code de l’instruction else if<\/span><\/span>
     \/\/ instructions<\/span>
} \/\/ fermeture du code de l’instruction else if<\/span><\/span><\/p>\n

else<\/span>
{ \/\/ ouverture du code de l’instruction else<\/span><\/span>
     \/\/ instructions<\/span>
} \/\/ fermeture du code de l’instruction else<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. \/\/ Les commentaires<\/span><\/strong><\/h4>\n

Lorsqu’on \u00e9crit dans le programme derri\u00e8re un double slash \/\/<\/strong>, c’est pour donner des informations sur le programme. Les commentaires n’ont aucune action sur le programme.<\/p>\n

On peut \u00e9crire un commentaire sur plusieurs lignes entre \/* et *\/ .<\/strong><\/p>\n

Exemple : \/*commentaire sur plusieurs lignes, commentaire sur plusieurs lignes, commentaire sur plusieurs lignes *\/<\/p>\n\n\n\n

<\/a>

2. <\/span>Les op\u00e9rateurs arithm\u00e9tiques<\/span>

<\/u><\/strong><\/h4>\n

. op\u00e9rateur d’assignement (signe \u00e9gal unique) =<\/strong><\/span><\/h4>\n

Cet op\u00e9rateur stocke la valeur \u00e0 droite du signe \u00e9gal dans la variable \u00e0 gauche du signe \u00e9gal.<\/p>\n

Le signe \u00e9gal dans le langage de programmation C est appel\u00e9 op\u00e9rateur d’assignement. Il a un sens diff\u00e9rent de celui qu’il a en alg\u00e8bre o\u00f9 il indique une \u00e9quivalence ou une \u00e9galit\u00e9. L’op\u00e9rateur d’assignement indique au microcontr\u00f4leur d’\u00e9valuer la valeur ou l’expression qui se trouve \u00e0 droite du signe \u00e9gal et de la stocker dans la variable \u00e0 gauche du signe \u00e9gal :<\/p>\n

variable = valeur ;<\/strong><\/p>\n

Exemple<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

int sensVal;<\/span>   \/\/ d\u00e9clare une variable enti\u00e8re de 16 bits nomm\u00e9e senVal<\/span><\/p>\n

senVal = analogRead(0)<\/span>;       \/\/ m\u00e9morise la valeur de la conversion analogique num\u00e9rique dans la variable  <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. Addition + , Soustraction – , Multiplication * , et Division \/<\/span><\/strong><\/h4>\n

Ces op\u00e9rateurs renvoient respectivement la somme, la diff\u00e9rence, le produit ou le quotient entre deux op\u00e9randes (= entre deux termes).<\/p>\n

Cette op\u00e9ration est r\u00e9alis\u00e9e en utilisant le type des donn\u00e9es des op\u00e9randes. Ainsi par exemple, 9 \/ 4 donne 2 d\u00e8s lors que 9 et 4 sont de type int.<\/p>\n

Si les op\u00e9randes sont de deux types de donn\u00e9es diff\u00e9rents, le plus \u00ab\u00a0grand\u00a0\u00bb est utilis\u00e9 pour le calcul.<\/p>\n

Si un des nombres (op\u00e9randes) est du type float ou double, le calcul dit \u00ab\u00a0en virgule flottante\u00a0\u00bb est utilis\u00e9 pour le calcul (c\u00e0d que 9\/4 donne 2.25).<\/p>\n

– Syntaxe :<\/p>\n\n\n\n

\n\n\n\n
\n

result = value1 + value2;<\/span>
result = value1 – value2;<\/span>
result = value1 * value2;<\/span>
result = value1 \/ value2;<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

– Exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

y = y + 3;<\/span>
x = x – 7;<\/span>
i = j * 6;<\/span>
r = r \/ 5;<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>

1.3. <\/span>Les op\u00e9rateurs de comparaison<\/span>

<\/span><\/strong><\/h4>\n

==, !=, <, ><\/span> <\/strong><\/h4>\n

sont des op\u00e9rateurs logiques de comparaison :<\/span><\/p>\n\n\n\n

\n\n\n\n
\n

\u2022 x == y (x est \u00e9gal \u00e0 y)<\/span>
\u2022 x != y (x est diff\u00e9rent de y)<\/span>
\u2022 x < y (x est inf\u00e9rieur \u00e0 y)<\/span>
\u2022 x > y (x est sup\u00e9rieur \u00e0 y)<\/span>
\u2022 x <= y (x est inf\u00e9rieur ou \u00e9gal \u00e0 y)<\/span>
\u2022 x >= y (x est sup\u00e9rieur ou \u00e9gal \u00e0 y)<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>

1.4. Les op\u00e9rateurs bool\u00e9ens

<\/span><\/strong><\/h4>\n

Ces op\u00e9rateurs peuvent \u00eatre utilis\u00e9s \u00e0 l’int\u00e9rieur de la condition d’une instruction if pour associer plusieurs conditions (ou op\u00e9randes) \u00e0 tester.

<\/p>\n

. && (ET LOGIQUE)<\/strong><\/span><\/h4>\n

VRAI seulement si les deux op\u00e9randes sont VRAI, par exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { \/\/ lit l’\u00e9tat de 2 entr\u00e9es<\/span><\/span>
       \/\/ Instructions<\/span>
}<\/span>
\/\/ est VRAI seulement si les deux entr\u00e9es sont \u00e0 l’\u00e9tat HAUT simultan\u00e9ment.<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. || ( OU LOGIQUE)<\/strong><\/span><\/h4>\n

VRAI si l’un des deux op\u00e9randes est VRAI, par exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

if (x > 0 || y > 0) { \/\/ si x sup\u00e9rieur \u00e0 0 ou si y sup\u00e9rieur \u00e0 0<\/span><\/span>
      \/\/ Instructions<\/span>
}<\/span>
\/\/ est VRAI si soit x, soit y est sup\u00e9rieur \u00e0 0.<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. ! (NON LOGIQUE)<\/span><\/strong><\/h4>\n

VRAI si l’op\u00e9rande est FAUX, par exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

if (!x) {<\/span>
     \/\/ Instructions<\/span>
}<\/span>
\/\/ VRAI si la variable x est FAUSSE (c\u00e0d si x = 0)<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/h4>\n

1.5. Les op\u00e9rateurs compos\u00e9s
<\/a>
<\/u><\/strong><\/h4>\n

. ++ (incr\u00e9ment) \/ — (d\u00e9cr\u00e9ment)<\/strong><\/span><\/h4>\n

Ces op\u00e9rateurs incr\u00e9mentent ou d\u00e9cr\u00e9mentent une variable enti\u00e8re de type int ou long (pouvant \u00eatre unsigned).<\/p>\n

– Syntaxe<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

x++; \/\/ incr\u00e9mente x de un, sans modifier x<\/span><\/span>
++x; \/\/ incr\u00e9mente x de un et modifie x<\/span><\/span><\/p>\n

x– ; \/\/ d\u00e9cr\u00e9ment x de un, sans modifier x<\/span><\/span>
–x ; \/\/ d\u00e9cr\u00e9mente x de un, et modifie x<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

– Exemples<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

x = 2; \/\/ variable x = 2<\/span><\/span>
y = ++x; \/\/ x contient 3 et y contient 3<\/span><\/span>
y = x++; \/\/ x contient toujours 2, y contient 3<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. += , -= , *= , \/=<\/span><\/strong><\/h4>\n

Ces op\u00e9rateurs r\u00e9alisent une op\u00e9ration math\u00e9matique entre une variable x<\/strong> et une autre variable ou une constante y<\/strong>. Les op\u00e9rateurs +<\/strong>,–<\/strong> ,*<\/strong> et \/<\/strong> sont juste utiles pour raccourcir la forme compl\u00e8te des op\u00e9rations math\u00e9matiques list\u00e9es ci-dessous :<\/p>\n\n\n\n

\n\n\n\n
\n

x += y; \/\/ \u00e9quivaut \u00e0 l’expression x = x+y<\/span><\/span>
x -= y; \/\/ \u00e9quivaut \u00e0 l’expression x = x- y<\/span><\/span>
x *= y; \/\/ \u00e9quivaut \u00e0 l’expression x = x * y<\/span><\/span>
x \/= y; \/\/ \u00e9quivaut \u00e0 l’expression x= x \/ y<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

– Exemples<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

x = 2;<\/span>
x += 4; \/\/ x contient 6<\/span><\/span>
x -= 3; \/\/ x contient 3<\/span><\/span>
x *= 10; \/\/ x contient 30<\/span><\/span>
x \/= 2; \/\/ x contient 15<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/h4>\n

1.6. <\/span>Structures de contr\u00f4le<\/span>
<\/a>
<\/span><\/strong><\/h4>\n

. if (condition)<\/strong><\/span><\/h4>\n

L’instruction if (\u00ab\u00a0si\u00a0\u00bb en fran\u00e7ais), utilis\u00e9e avec un op\u00e9rateur logique de comparaison, permet de tester si une condition est vraie, par exemple si la mesure d’une entr\u00e9e analogique est bien sup\u00e9rieure \u00e0 une certaine valeur.

Le format d’un test if est le suivant :<\/p>\n\n\n\n

\n\n\n\n
\n

if (uneVariable > 50) <\/span>
{<\/span>
\/\/ Action<\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

Dans cet exemple, le programme va tester si la variable uneVariable<\/strong> est sup\u00e9rieure \u00e0 50. Si c’est le cas, le programme va r\u00e9aliser une action particuli\u00e8re.<\/p>\n

Autrement dit, si l’\u00e9tat du test entre les parenth\u00e8ses est vrai, les instructions comprises entre les accolades sont ex\u00e9cut\u00e9es. Sinon, le programme se poursuit sans ex\u00e9cuter ces instructions.<\/p>\n\n\n\n

Les accolades peuvent \u00eatre omises apr\u00e8s une instruction if. Dans ce cas, la suite de la ligne (qui se termine par un point-virgule) devient la seule instruction de la condition.<\/p>\n

Tous les exemples suivants sont corrects :<\/p>\n\n\n\n

\n\n\n\n
\n

if (x > 120) digitalWrite(LEDpin, HIGH);<\/span><\/p>\n

if (x > 120)<\/span>
digitalWrite(LEDpin, HIGH);<\/span><\/p>\n

if (x > 120){ digitalWrite(LEDpin, HIGH); }<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. if \/ else<\/span><\/strong><\/h4>\n

L’instruction if\/else (si\/sinon en fran\u00e7ais) permet un meilleur contr\u00f4le du d\u00e9roulement du programme que la simple instruction if, en permettant de grouper plusieurs tests ensemble.<\/p>\n

Par exemple, une entr\u00e9e analogique peut-\u00eatre test\u00e9e et une action r\u00e9alis\u00e9e si l’entr\u00e9e est inf\u00e9rieure \u00e0 500, et une autre action r\u00e9alis\u00e9e si l’entr\u00e9e est sup\u00e9rieure ou \u00e9gale \u00e0 500. Le code ressemblera \u00e0 cela :<\/p>\n\n\n\n

\n\n\n\n
\n

if (valsensor < 500)<\/span>
{<\/span>
\/\/ action A<\/span>
}<\/span>
else<\/span>
{<\/span>
\/\/ action B<\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

L\u2019instruction else<\/strong> peut contenir un autre test if<\/strong>, et donc des tests multiples et exclusifs peuvent \u00eatre r\u00e9alis\u00e9s en m\u00eame temps.<\/p>\n

Chaque test sera r\u00e9alis\u00e9 apr\u00e8s le suivant jusqu’\u00e0 ce qu’un test VRAI soit rencontr\u00e9.
Quand une condition vraie est rencontr\u00e9e, les instructions associ\u00e9es sont r\u00e9alis\u00e9es, puis le programme continue son ex\u00e9cution \u00e0 la ligne suivant l’ensemble de la construction if\/else<\/strong>.
Si aucun test n’est VRAI, le bloc d’instructions par d\u00e9faut else<\/strong> est ex\u00e9cut\u00e9, s\u2019il est pr\u00e9sent, d\u00e9terminant ainsi le comportement par d\u00e9faut.<\/p>\n

Un bloc else if<\/strong> peut \u00eatre utilis\u00e9 avec ou sans bloc de conclusion else.<\/strong><\/p>\n

Un nombre illimit\u00e9 de branches else if<\/strong> est autoris\u00e9.<\/p>\n\n\n\n

\n\n\n\n
\n

if (valsensor < 500) <\/span>
{<\/span>
\/\/ action A<\/span>
}<\/span>
else if (valsensor >= 1000)<\/span>
{<\/span>
\/\/ action B<\/span>
}<\/span>
else<\/span>
{<\/span>
\/\/ action C<\/span>
}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. Boucle for<\/span><\/strong><\/h4>\n

L’instruction for<\/strong> est utilis\u00e9e pour r\u00e9p\u00e9ter l’ex\u00e9cution d’un bloc d’instructions regroup\u00e9es entre des accolades.
Un compteur incr\u00e9mental est habituellement utilis\u00e9 pour incr\u00e9menter et finir la boucle.
L’instruction for<\/strong> est tr\u00e8s utile pour toutes les op\u00e9rations r\u00e9p\u00e9titives et est souvent utilis\u00e9es en association avec des tableaux de variables pour agir sur un ensemble de donn\u00e9es ou broches.<\/p>\n

Il y a 3 parties dans l’ent\u00eate d’une boucle for :<\/p>\n\n\n\n

\n\n\n\n
\n

for (initialisation; condition; incrementation) {
<\/span>      \/\/instructions
<\/span>}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

L’initialisation a lieu en premier et une seule fois. A chaque ex\u00e9cution de la boucle, la condition est test\u00e9e.
Si elle est VRAIE, le bloc d’instructions et l’incr\u00e9mentation sont ex\u00e9cut\u00e9s, puis la condition est test\u00e9e de nouveau. Lorsque la condition devient FAUSSE, la boucle stoppe.<\/p>\n

Exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

for (int i=0; i <= 255; i++){  \/\/ boucle incr\u00e9mentant la variable i de 0 \u00e0 255, de 1 en 1<\/span><\/span><\/p>\n

     \/\/instructions<\/span><\/p>\n

} \/\/ fin de la boucle for<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

<\/a>
. Boucle while<\/span><\/strong><\/h4>\n

Les boucles while<\/strong> (\u00ab\u00a0tant que\u00a0\u00bb en anglais) bouclent sans fin, et ind\u00e9finiment, jusqu’\u00e0 ce que la condition ou l’expression entre les parenth\u00e8ses ( ) devienne fausse.
Quelque chose doit modifier la variable test\u00e9e, sinon la boucle while<\/strong> ne se terminera jamais. Cela peut \u00eatre dans votre code, soit une variable incr\u00e9ment\u00e9e, ou \u00e9galement une condition externe comme le test d’un capteur.<\/p>\n\n\n\n

\n\n\n\n
\n

while(expression){ \/\/ tant que l’expression est vraie
<\/span><\/span>     \/\/ instructions
<\/span>}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

Avec expression, <\/strong>une instruction (bool\u00e9enne) qui renvoie un r\u00e9sultat VRAI ou FAUX<\/p>\n

Exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

var = 0;<\/span>
while(var < 200){ \/\/ tant que la variable est inf\u00e9rieur \u00e0 200<\/span><\/span><\/p>\n

\/\/ fait quelque chose 200 fois de suite…<\/span><\/p>\n

var++; \/\/ incr\u00e9mente la variable<\/span><\/span><\/p>\n

}<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

 <\/h4>\n

<\/a>. boucle do \u2013 while<\/strong><\/span><\/h4>\n

La boucle do \/ while<\/strong> (\u00ab\u00a0faire tant que\u00a0\u00bb en anglais) fonctionne de la m\u00eame fa\u00e7on que la boucle while<\/strong>, \u00e0 la diff\u00e9rence pr\u00e8s que la condition est test\u00e9e \u00e0 la fin de la boucle, et par cons\u00e9quent la boucle do sera toujours ex\u00e9cut\u00e9e au moins une fois.<\/p>\n

– Syntaxe<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

do \/\/ faire…<\/span><\/span>
{<\/span>
   \/\/ instructions
<\/span><\/span>} while (condition); \/\/ tant que la condition est vraie<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

– Exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

do \/\/ faire…<\/span><\/span>
{<\/span>
x = analogRead(A0); \/\/ lit la valeur de la tension d\u2019un capteur<\/span><\/span><\/p>\n

} while (x < 100); \/\/ …tant que x est inf\u00e9rieur \u00e0 100<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n


Remarque<\/u> :<\/p>\n

L’instruction break<\/strong> est utilis\u00e9e pour sortir d’une boucle do, for ou while, en passant outre le d\u00e9roulement normal de la boucle.<\/p>\n

Exemple :<\/p>\n\n\n\n

\n\n\n\n
\n

for (int i=0; i <= 100; i++){ \/\/ boucle incr\u00e9mentant la variable i de 0 \u00e0 100, de 1 en 1
<\/span><\/span>x = analogRead(A0); \/\/ lit la valeur de la tension d\u2019un capteur<\/span><\/span>
if (x < 100) <\/span>
{<\/span>
break ; \/\/ si la mesure est inf\u00e9rieure \u00e0 un seuil, on sort de la boucle<\/span><\/span>
}<\/span>
} \/\/ fin de la boucle for<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

\u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0<\/p>\n\n\n

\n
\n\n
\"\"<\/a><\/figure><\/div>\n\n<\/div>\n\n
\n\n
\"\"<\/a><\/figure><\/div>\n\n<\/div>\n<\/div><\/div>\n\n\n\n","protected":false},"excerpt":{"rendered":"

  Dans les fonctions de bases \u201dsetup()\u201d et \u201dloop()\u201d obligatoires pour tous les programmes ou dans toute autre fonction, on utilisera les structures de langage suivantes : 1. Syntaxe de base . Le point-virgule ; Il est obligatoire \u00e0 la fin de chaque instruction. Pour le compilateur, les sauts de lignes n’ont pas de signification : […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1563","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages\/1563","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1563"}],"version-history":[{"count":0,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages\/1563\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1563"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}