Leçon inaugurale à la programmation Arduino

Table des matières

1 Introduction à Arduino........................................................................................................................ 3
1.1 Présentation de la carte Arduino ................................................................................................ 3
1.2 Comment télécharger et installer le logiciel Arduino ................................................................. 3
1.3 Les différentes versions d'Arduino .............................................................................................. 3
2 Les bases de la programmation en Arduino ....................................................................................... 4
2.1 Syntaxe de base : structure d'un programme Arduino ............................................................... 4
2.2 Variables : déclaration, types de données, portée ..................................................................... 5
2.3 Opérateurs : arithmétiques, logiques, binaires .......................................................................... 6
2.3.1 Les opérateurs arithmétiques : ........................................................................................... 6
2.3.2 Les opérateurs logiques : .................................................................................................... 6
2.3.3 Les opérateurs binaires : ..................................................................................................... 6
2.3.4 Il existe également des opérateurs d'incrémentation et de décrémentation :................... 6
2.3.5 Les opérateurs de comparaison .......................................................................................... 7
2.4 Fonctions : déclaration,............................................................................................................... 7
2.5 appel, .......................................................................................................................................... 8
2.6 Les paramètres, ........................................................................................................................... 9
2.7 Valeur de retour ........................................................................................................................ 10
3 Les bibliothèques Arduino : comment les utiliser............................................................................. 10
4 Les entrées/sorties numériques ....................................................................................................... 11
4.1 Les broches d'E/S numériques : définition, types (entrée ou sortie), fonctionnement ........... 11
4.2 Exemples de projets avec des broches d'E/S numériques : LED clignotante ............................ 12
5 Les Entrées analogiques .................................................................................................................... 14
6 Le moniteur série .............................................................................................................................. 15
6.1 initialisation............................................................................................................................... 15
6.2 L’affichage.................................................................................................................................. 16
7 Les boucles ........................................................................................................................................ 17
7.1 Les structures de contrôle de base : if/else, while, for ............................................................. 17
7.2 Les boucles conditionnelles : do/while ..................................................................................... 18
7.3 Les instructions de saut : break, continue ................................................................................ 18
8 Exemples de projets avec des boucles : compteur,........................................................................... 20
1 Introduction à Arduino
1.1 Présentation de la carte Arduino
Arduino est une plateforme open-source de prototypage électronique basée sur des
microcontrôleurs. Elle permet de réaliser des projets électroniques interactifs en utilisant des
capteurs, des actionneurs et des circuits électroniques.
La carte Arduino est la principale composante de cette plateforme. Elle est équipée d'un
microcontrôleur programmable, d'entrées/sorties numériques et analogiques, ainsi que
d'autres composants électroniques nécessaires pour le fonctionnement de la carte.
Il existe plusieurs types de cartes Arduino, chacune ayant ses propres caractéristiques et
spécifications.

1.2 Comment télécharger et installer le logiciel Arduino

Le logiciel Arduino est disponible en téléchargement gratuit sur le site officiel d'Arduino
([Link] Il est compatible avec les systèmes d'exploitation
Windows, Mac OS X et Linux.
Une fois le logiciel téléchargé, il doit être installé sur l'ordinateur. L'installation est
généralement simple et guidée par des instructions affichées à l'écran.

1.3 Les différentes versions d'Arduino

Il existe plusieurs versions d'Arduino, chacune ayant des spécifications et des fonctionnalités
différentes. Voici quelques-unes des versions les plus courantes :
- Arduino Uno : la carte la plus courante et la plus populaire. Elle est équipée d'un
microcontrôleur ATmega328P, de 14 broches d'E/S numériques, de 6 broches d'E/S
analogiques et d'un connecteur USB.
- Arduino Mega : une version plus avancée avec plus de broches d'E/S et une plus
grande capacité de stockage de programmes. Elle est équipée d'un microcontrôleur
ATmega2560 et de 54 broches d'E/S numériques et 16 broches d'E/S analogiques.
- Arduino Leonardo : une version avec des fonctionnalités plus avancées, y compris un
port USB natif pour faciliter la communication avec l'ordinateur. Elle est équipée d'un
microcontrôleur ATmega32u4.
 - Arduino Nano : une version plus compacte de la carte Arduino Uno avec une taille plus
petite. Elle est équipée d'un microcontrôleur ATmega328P et de 14 broches d'E/S
numériques et 8 broches d'E/S analogiques.
Il existe également d'autres versions plus spécifiques pour certains projets, comme l'Arduino
Mini, l'Arduino Micro, l'Arduino Due, etc.

2 Les bases de la programmation en Arduino

2.1 Syntaxe de base : structure d'un programme Arduino
La programmation en Arduino utilise une syntaxe similaire à celle du langage C/C++. Voici la
structure de base d'un programme Arduino :

Le programme commence généralement par un commentaire facultatif qui décrit le

fonctionnement global du programme. La fonction setup() est ensuite définie. Elle est
exécutée une seule fois au démarrage de la carte Arduino, et est utilisée pour effectuer les
opérations d'initialisation, telles que la configuration des broches d'E/S.
Ensuite, la fonction loop() est définie. Cette fonction est exécutée en boucle tant que la carte
Arduino est alimentée. Elle est utilisée pour exécuter les instructions principales du
programme, telles que la lecture des entrées et l'écriture sur les sorties.

Les instructions à exécuter dans la fonction setup() et loop() sont écrites à l'intérieur de blocs
de code délimités par des accolades {}.
Voici un exemple de programme Arduino qui utilise cette structure de base :
Ce programme allume et éteint une LED connectée à la broche 13 en utilisant les fonctions
digitalWrite() et delay().
La fonction pinMode() est utilisée dans la fonction setup() pour définir la broche 13 comme
une sortie.

2.2 Variables : déclaration, types de données, portée

Les variables sont des éléments clés de la programmation en Arduino (et en général). Une
variable est un espace de stockage qui permet de stocker des données telles que des nombres,
des caractères, des booléens, etc.
Voici les différentes étapes pour utiliser une variable en Arduino :
- Déclaration de la variable : il faut déclarer la variable en indiquant son nom et son type
de données. Par exemple :

- Initialisation de la variable : il est possible d'initialiser la variable en lui attribuant une

valeur. Par exemple :

- Utilisation de la variable : la variable peut être utilisée pour stocker des valeurs ou
effectuer des opérations.
Il existe plusieurs types de données pour les variables en Arduino, voici les plus courants :
- int : entier signé sur 2 octets (de -32768 à 32767)
- unsigned int : entier non signé sur 2 octets (de 0 à 65535)
- long : entier signé sur 4 octets (de -2147483648 à 2147483647)
- unsigned long : entier non signé sur 4 octets (de 0 à 4294967295)
- float : nombre à virgule flottante sur 4 octets (de -3.4028235E+38 à 3.4028235E+38)
La portée d'une variable détermine où elle peut être utilisée dans le programme. En Arduino, il
y a deux types de portée de variables :
- Les variables globales : définies en dehors des fonctions, elles sont accessibles depuis
toutes les fonctions du programme.
- Les variables locales : définies à l'intérieur d'une fonction, elles ne sont accessibles que
dans cette fonction.

2.3 Opérateurs : arithmétiques, logiques, binaires

En programmation, les opérateurs sont des symboles qui permettent d'effectuer des
opérations sur des variables ou des valeurs. En Arduino, il existe plusieurs types d'opérateurs :

2.3.1 Les opérateurs arithmétiques :

+ : addition
- : soustraction
* : multiplication
/ : division
% : modulo (reste de la division)

2.3.2 Les opérateurs logiques :

&& : ET logique (retourne vrai si les deux conditions sont vraies)
|| : OU logique (retourne vrai si au moins une des conditions est vraie)
! : NON logique (inverse la valeur de la condition)

2.3.3 Les opérateurs binaires :

& : ET binaire (retourne un bit à 1 si les deux bits correspondants sont à 1)
| : OU binaire (retourne un bit à 1 si au moins un des bits correspondants est à 1)
^ : OU exclusif binaire (retourne un bit à 1 si un seul des bits correspondants est à 1)
~ : NOT binaire (inverse les bits)

2.3.4 Il existe également des opérateurs d'incrémentation et de décrémentation :

++ : incrémente la valeur de 1
++ : incrémente la valeur de 1
-- : décrémente la valeur de 1
Les opérateurs arithmétiques, logiques et binaires sont utilisés pour effectuer des opérations
mathématiques, de comparaison ou de logique sur les variables. Les opérateurs
d'incrémentation et de décrémentation sont utilisés pour augmenter ou diminuer la valeur
d'une variable.
Voici quelques exemples d'utilisation des opérateurs en Arduino :

2.3.5 Les opérateurs de comparaison

== : Egal
< : Inférieur
<= Inférieur ou égal
> : Supérieur
>= : Supérieur ou égal
Ils sont utilisés pour comparer les variables entre elles souvent dans le but de mettre en place
des conditions

2.4 Fonctions : déclaration,

En programmation, une fonction est un bloc de code qui peut être appelé à partir d'un autre
endroit dans le programme. Les fonctions sont utilisées pour organiser le code en morceaux
réutilisables et pour faciliter la maintenance du code.
En Arduino, la syntaxe pour déclarer une fonction est la suivante :

type_de_retour : c'est le type de valeur que la fonction renvoie. Si la fonction ne renvoie rien,
on utilise le type void.
nom_de_la_fonction : c'est le nom que l'on donne à la fonction.
type_arg_1, type_arg_2, ... : ce sont les types des arguments que la fonction peut prendre en
entrée.
Voici un exemple de déclaration de fonction :

Dans cet exemple, la fonction s'appelle somme et prend deux arguments de type entier a et b.
Elle renvoie la somme de a et b. Le type de retour de la fonction est int, car la fonction renvoie
un entier.
Pour appeler une fonction, on utilise son nom suivi des arguments entre parenthèses. Par
exemple :

Dans cet exemple, on appelle la fonction somme avec les arguments x et y. La valeur de retour
de la fonction (5) est stockée dans la variable z.
Il est également possible de définir des fonctions sans argument. Dans ce cas, on omet les
parenthèses vides dans la déclaration de la fonction et lors de l'appel de celle-ci.

2.5 appel,
Pour appeler une fonction en Arduino, il suffit d'utiliser son nom suivi des arguments entre
parenthèses. Par exemple, si on a une fonction somme qui prend deux arguments de type
entier a et b et qui renvoie la somme de ces deux nombres, on peut l'appeler de la manière
suivante :

Dans cet exemple, la fonction somme est appelée avec les arguments x et y. La valeur de
retour de la fonction (5) est stockée dans la variable z.
Si la fonction ne prend pas d'arguments, il suffit d'omettre les parenthèses dans l'appel de la
fonction. Par exemple, si on a une fonction bonjour qui affiche un message de salutation à
l'utilisateur, on peut l'appeler de la manière suivante :
bonjour();
Dans cet exemple, la fonction bonjour est appelée sans argument.
Il est important de noter que la fonction doit être déclarée avant son appel dans le
programme. Cela signifie que la déclaration de la fonction doit être placée avant l'appel de la
fonction.

2.6 Les paramètres,

En programmation, les paramètres sont les valeurs que l'on passe à une fonction lors de son
appel. Les paramètres permettent à une fonction d'effectuer des actions spécifiques en
fonction des valeurs fournies en entrée.
Dans Arduino, les paramètres sont déclarés dans la déclaration de la fonction, à la suite du
nom de la fonction. Par exemple, si on veut déclarer une fonction qui calcule la somme de
deux nombres, on peut écrire :

Dans cet exemple, la fonction somme prend deux paramètres de type int : a et b. Ces
paramètres sont utilisés dans le corps de la fonction pour calculer la somme des deux nombres
et renvoyer le résultat.
Lorsque l'on appelle une fonction qui prend des paramètres, on doit fournir les valeurs de ces
paramètres entre parenthèses lors de l'appel. Par exemple :

Dans cet exemple, la fonction somme est appelée avec les valeurs 3 et 4 comme paramètres.
Le résultat de l'appel est stocké dans la variable résultat.
Il est important de noter que le nombre et le type des paramètres doivent correspondre à la
déclaration de la fonction. Si l'on fournit un nombre ou un type de paramètre incorrect, le
programme peut produire une erreur ou un comportement indésirable.
2.7 Valeur de retour
La valeur de retour d'une fonction est la valeur qu'elle renvoie lorsqu'elle est appelée. Cette
valeur peut être utilisée dans d'autres parties du programme.
En Arduino, pour spécifier la valeur de retour d'une fonction, on utilise le mot-clé return suivi
de la valeur à retourner.
Par exemple, si on veut déclarer une fonction qui calcule la somme de deux nombres et
renvoie le résultat, on peut écrire :

Dans cet exemple, la fonction somme prend deux paramètres de type int et calcule leur
somme. Elle stocke ensuite le résultat dans une variable résultat et utilise le mot-clé return
pour renvoyer cette valeur.
Lorsque l'on appelle une fonction qui renvoie une valeur, on peut stocker cette valeur dans une
variable ou l'utiliser directement. Par exemple :

Dans le premier exemple, la valeur renvoyée par la fonction est stockée dans la variable res1.
Dans le deuxième exemple, la valeur renvoyée par la fonction est affichée directement sur la
console série.
Il est important de noter que toutes les fonctions ne renvoient pas de valeur. Dans ce cas, on
utilise le mot-clé void pour spécifier que la fonction ne renvoie rien.

3 Les bibliothèques Arduino : comment les utiliser

Les bibliothèques Arduino sont des collections de fonctions et de code qui peuvent être
utilisées pour étendre les fonctionnalités de la carte Arduino. Ces bibliothèques peuvent être
téléchargées depuis Internet ou créées par l'utilisateur.
Pour utiliser une bibliothèque dans un programme Arduino, il faut d'abord l'inclure dans le
code. Pour cela, on utilise la directive #include suivie du nom de la bibliothèque. Par exemple,
pour inclure la bibliothèque Wire qui permet de communiquer avec des périphériques I2C, on
peut écrire :

Une fois la bibliothèque incluse, on peut utiliser ses fonctions dans le code. Par exemple, pour
envoyer des données à un périphérique I2C à l'adresse 0x42, on peut écrire :

Dans cet exemple, on utilise la fonction beginTransmission de la bibliothèque Wire pour

démarrer une transmission I2C à l'adresse 0x42. On utilise ensuite la fonction write pour
envoyer une valeur de 0x01, puis la fonction endTransmission pour terminer la transmission.
Il est important de noter que toutes les bibliothèques ne sont pas incluses par défaut dans
l'environnement de développement Arduino. Si vous voulez utiliser une bibliothèque
spécifique, vous devrez peut-être la télécharger et l'installer manuellement.
En résumé, pour utiliser une bibliothèque Arduino :
- Inclure la bibliothèque dans le code avec la directive #include.
- Utiliser les fonctions de la bibliothèque dans le code.

4 Les entrées/sorties numériques

4.1 Les broches d'E/S numériques : définition, types (entrée ou sortie),
fonctionnement
Les broches d'entrée/sortie numériques (ou E/S numériques) sont des ports sur la carte
Arduino qui peuvent être utilisés pour lire ou écrire des signaux électriques. La plupart des
cartes Arduino ont entre 14 et 20 broches d'E/S numériques, qui sont numérotées de 0 à n-1
(où n est le nombre total de broches).
Chaque broche d'E/S numérique peut être configurée comme une entrée ou une sortie en
utilisant la fonction pinMode(). Lorsqu'une broche est configurée en entrée, elle peut lire des
signaux électriques provenant de capteurs ou d'autres sources externes. Lorsqu'une broche est
configurée en sortie, elle peut envoyer des signaux électriques à des actionneurs ou à d'autres
périphériques.
Le fonctionnement des broches d'E/S numériques dépend du microcontrôleur utilisé dans la
carte Arduino. En général, chaque broche peut accepter une tension d'entrée de 0 à 5 volts,
bien que certains modèles puissent accepter des tensions plus élevées. Lorsqu'une broche est
configurée en entrée, elle peut détecter si la tension d'entrée est de 0 volts (ou proche de 0
volts) ou de 5 volts (ou proche de 5 volts). Si la broche est configurée en sortie, elle peut
envoyer une tension de 0 volts ou de 5 volts.
- La fonction digitalWrite() permet d'écrire une valeur numérique sur une broche d'E/S
numérique configurée en sortie. La valeur doit être soit HIGH (équivalent à 5 volts), soit
LOW (équivalent à 0 volts). Par exemple, pour écrire une valeur de 5 volts sur la broche
13, on peut écrire : digitalWrite(13, HIGH);
- La fonction digitalRead() permet de lire la valeur d'une broche d'E/S numérique
configurée en entrée. La fonction renvoie soit HIGH si la tension d'entrée est proche de
5 volts, soit LOW si la tension d'entrée est proche de 0 volts. Par exemple, pour lire la
valeur de la broche 7, on peut écrire : bool valeur = digitalRead(7);
Dans cet exemple, la valeur de la broche 7 est lue et stockée dans la variable valeur. La variable
valeur contiendra soit la valeur HIGH si la tension d'entrée est proche de 5 volts, soit la valeur
LOW si la tension d'entrée est proche de 0 volts.

Fonctions pour contrôler les broches d'E/S numériques :

- pinMode(),
- digitalWrite(),
- digitalRead()

Les fonctions pinMode(), digitalWrite() et digitalRead() sont les fonctions de base pour
contrôler les broches d'E/S numériques en Arduino.

4.2 Exemples de projets avec des broches d'E/S numériques : LED clignotante
Un exemple simple de projet avec des broches d'E/S numériques est de faire clignoter une LED
connectée à une broche de sortie. Voici un exemple de code pour réaliser ce projet :
Dans ce code, nous avons défini la broche de sortie pour la LED en tant que int ledPin = 7;.
Dans la fonction setup() nous avons configuré la broche ledPin en tant que sortie numérique
avec la fonction pinMode(ledPin, OUTPUT);.
Dans la fonction loop(), nous avons allumé la LED en écrivant une valeur de tension de 5 volts
sur la broche avec la fonction digitalWrite(ledPin, HIGH);. Nous avons ensuite attendu pendant
1 seconde avec la fonction delay(1000);. Nous avons ensuite éteint la LED en écrivant une
valeur de tension de 0 volt sur la broche avec la fonction digitalWrite(ledPin, LOW);. Nous
avons ensuite attendu pendant 1 seconde avant de recommencer le cycle.

Le bouton poussoir

Un autre exemple de projet avec des broches d'E/S numériques est de lire l'état d'un bouton
poussoir connecté à une broche d'entrée et d'allumer ou d'éteindre une LED connectée à une
broche de sortie en fonction de l'état du bouton. Voici un exemple de code pour réaliser ce
projet :
Dans ce code, nous avons défini la broche d'entrée pour le bouton poussoir en tant que int
buttonPin = 2; et la broche de sortie pour la LED en tant que int ledPin = 7;.
Dans la fonction setup(), nous avons configuré la broche d'entrée en tant qu'entrée numérique
avec résistance de pull-up activée avec la fonction pinMode(buttonPin, INPUT_PULLUP);. Nous
avons également configuré la broche de sortie en tant que sortie numérique avec la fonction
pinMode(ledPin, OUTPUT);.
Dans la fonction loop(), nous avons lu l'état du bouton avec la fonction digitalRead(buttonPin);.
Si le bouton est enfoncé, la valeur retournée par la fonction digitalRead() sera LOW, et nous
allumons la LED en écrivant une valeur de tension de 5 volts sur la broche de sortie avec la
fonction digitalWrite(ledPin, HIGH);. Si le bouton n'est pas enfoncé, la valeur retournée par la
fonction digitalRead() sera HIGH, et nous éteignons la LED en écrivant une valeur de tension de
0 volt sur la broche de sortie avec la fonction digitalWrite(ledPin, LOW);. Ce code permet donc
de contrôler l'état d'une LED en fonction de l'état d'un bouton poussoir.

5 Les Entrées analogiques

Les broches analogiques sur une carte Arduino sont des entrées/sorties qui peuvent être
utilisées pour lire des valeurs analogiques, telles que celles provenant de capteurs de
température, de lumière, de distance, etc. Voici un exemple de code pour lire la valeur
analogique d'un capteur de lumière connecté à la broche A0 de la carte Arduino :
Dans cet exemple, nous utilisons la fonction analogRead() pour lire la valeur analogique sur la
broche A0 et stocker la valeur lue dans la variable sensorValue. Nous envoyons ensuite cette
valeur sur le moniteur série à l'aide de la fonction [Link](). Nous utilisons également la
fonction delay() pour attendre 1 seconde avant de lire à nouveau la valeur analogique.

6 Le moniteur série
Le moniteur série (ou Serial Monitor en anglais) est un outil intégré à l'environnement de
développement intégré (IDE) d'Arduino qui permet aux utilisateurs de communiquer avec leur
carte Arduino via un port série. Il permet de surveiller les données envoyées et reçues par la
carte Arduino en temps réel et d'envoyer des commandes ou des données à la carte pour
contrôler son fonctionnement.

Le moniteur série affiche les données en texte brut qui sont échangées entre l'Arduino et
l'ordinateur via le port série. Il peut être utilisé pour déboguer les programmes Arduino en
affichant les messages d'erreur, les valeurs de variables et les résultats de calculs.

6.1 initialisation

Pour utiliser le moniteur série, l'utilisateur doit connecter la carte Arduino à l'ordinateur via un
câble USB et sélectionner le port série approprié dans l'IDE Arduino. Ensuite, il peut ouvrir le
moniteur série et commencer à envoyer et recevoir des données.
Pour utiliser le moniteur série sur Arduino, vous devez suivre les étapes suivantes :

1. Connectez votre carte Arduino à votre ordinateur via un câble USB.

2. Ouvrez l'IDE Arduino sur votre ordinateur.
3. Ouvrez le programme que vous souhaitez téléverser sur la carte Arduino.
4. Sélectionnez le port série approprié dans l'IDE Arduino. Vous pouvez trouver le port
série dans le menu "Outils" sous "Port".
5. Dans votre programme, ajoutez la ligne suivante au début de votre code pour initialiser
le port série :
 6. Utilisez la fonction [Link]() ou [Link]() dans votre programme pour envoyer
des données à l'ordinateur via le port série. Par exemple :

7. Pour afficher les données envoyées par l'Arduino, ouvrez le moniteur série en cliquant
sur l'icône "Moniteur série" en haut de l'IDE Arduino.
8. Choisissez la bonne vitesse de transmission (bauds) dans la liste déroulante en bas de
l'écran. Cette vitesse doit être la même que celle que vous avez spécifiée dans le code
avec la fonction [Link]().
9. Vous pouvez maintenant voir les données envoyées par l'Arduino s'afficher dans le
moniteur série. Vous pouvez également envoyer des commandes ou des données à la
carte Arduino en tapant directement dans la zone de texte en bas de l'écran et en
appuyant sur Entrée.
10. Lorsque vous avez terminé, fermez le moniteur série en cliquant sur le bouton
"Fermer" en haut à droite de l'écran.
Le moniteur série est un outil très utile pour déboguer les programmes Arduino et pour
surveiller les données échangées entre la carte Arduino et l'ordinateur. Il est important de
noter que la fonction [Link]() doit être utilisée au début de votre programme pour
initialiser le port série, sinon le moniteur série ne fonctionnera pas correctement.

6.2 L’affichage
Il existe deux syntaxes pour l’affiche ges données dans le moniteur série qui sont :

- [Link]() : Permet l’affichage des données sur une même ligne

- [Link]() : Permet l’affichage des données puis un reour à la ligne à la fin de cet affichage.

Exemple :

Cette ligne de code envoie la valeur lue par un capteur connecté à la broche A0 de la carte
Arduino. L'affichage en texte brut dans le moniteur série ressemblera à ceci :
Sensor value: 478
Sensor value: 650
7 Les boucles
7.1 Les structures de contrôle de base : if/else, while, for
Les structures de contrôle de base permettent de contrôler l'exécution de votre programme en
fonction des valeurs des variables ou des conditions spécifiées. Voici quelques exemples de
structures de contrôle de base en Arduino :
- if/else : Cette structure de contrôle permet d'exécuter un bloc de code si une condition
est vraie, et un autre bloc de code si la condition est fausse. Voici un exemple de code :

- while : Cette structure de contrôle permet d'exécuter un bloc de code tant qu'une
condition est vraie. Voici un exemple de code :

Ce code affiche les nombres de 0 à 9 sur le moniteur série.

- for : Cette structure de contrôle permet d'exécuter un bloc de code un certain nombre
de fois. Voici un exemple de code :

Ce code affiche les nombres de 0 à 9 sur le moniteur série.

Dans ces exemples, [Link]() est une fonction qui permet d'afficher une valeur sur le
moniteur série. Vous pouvez remplacer cette fonction par toute autre fonction que vous
souhaitez exécuter dans votre programme.

7.2 Les boucles conditionnelles : do/while

En plus des boucles while et for, Arduino prend également en charge la boucle do/while. La
boucle do/while est similaire à la boucle while, mais elle exécute le bloc de code au moins une
fois avant de vérifier la condition. Voici un exemple de code :

Ce code affiche les nombres de 0 à 9 sur le moniteur série, tout comme l'exemple de la boucle
while. La différence est que le bloc de code est exécuté au moins une fois, même si la
condition n'est pas vraie au départ.
Il est important de noter que les boucles while, for et do/while doivent être utilisées avec
prudence, car elles peuvent entraîner des boucles infinies si la condition n'est jamais satisfaite
ou si la variable de contrôle n'est pas correctement mise à jour. Il est donc recommandé
d'utiliser ces boucles avec des conditions de sortie claires et des variables de contrôle
correctement initialisées.

7.3 Les instructions de saut : break, continue

Les instructions de saut sont des instructions qui permettent de modifier le comportement
d'une boucle en interrompant ou en sautant une itération. Les deux instructions de saut les
plus courantes en Arduino sont break et continue.
- break : Cette instruction permet de sortir immédiatement d'une boucle, quelle que soit
la condition. Elle est souvent utilisée pour sortir d'une boucle lorsque certaines
conditions sont remplies. Voici un exemple de code :
Ce code affiche les nombres de 0 à 4 sur le moniteur série, puis sort de la boucle.
- continue : Cette instruction permet de passer immédiatement à l'itération suivante
d'une boucle, sans exécuter le reste du code de l'itération en cours. Elle est souvent
utilisée pour sauter des itérations en fonction de certaines conditions. Voici un exemple
de code :

Ce code affiche les nombres impairs de 1 à 9 sur le moniteur série, en sautant les nombres
pairs.
Il est important de noter que les instructions de saut doivent être utilisées avec prudence, car
elles peuvent rendre le code plus difficile à comprendre et à déboguer. Il est recommandé
d'utiliser ces instructions uniquement lorsque cela est nécessaire pour améliorer l'efficacité du
code.
Il est important de noter que les instructions de saut doivent être utilisées avec prudence, car
elles peuvent rendre le code plus difficile à comprendre et à déboguer. Il est recommandé
d'utiliser ces instructions uniquement lorsque cela est nécessaire pour améliorer l'efficacité du
code.
8 Exemples de projets avec des boucles : compteur,
Un exemple de projet avec une boucle est un compteur qui utilise une boucle for pour afficher
les nombres de 0 à 9 sur un écran LCD. Voici un exemple de code :

Ce code utilise la bibliothèque LiquidCrystal pour contrôler un écran LCD 16x2. La boucle for
est utilisée pour afficher les nombres de 0 à 9 sur l'écran, avec une pause d'une seconde entre
chaque nombre.