Accueil Forum Emploi

De v el op p e z. c om ! Rubriques "
Arduino

Cours complet pour

apprendre à
programmer un
Arduino

Table des matières

XI. Programmer Arduino

XI-A. Le langage de programmation

XI-B. La structure d'un programme
XI-C. Coloration syntaxique
XI-D. La syntaxe du langage

XI-D-1. ponctuation
XI-D-2. Les variables
XI-D-3. Les fonctions
XI-D-4. Les structures de contrôle
XI-D-5. Exemple
XI-D-6. Pour aller plus loin

XI. Programmer Arduino ▲

Ce chapitre présente le langage Arduino, son

vocabulaire ainsi que la structuration d'un programme
écrit en Arduino.

XI-A. Le langage de programmation ▲

Un langage de programmation ( 1 5 ) est un langage

permettant à un être humain d'écrire un ensemble
d'instructions (code source) qui seront directement
converties en langage machine grâce à un
compilateur (c'est la compilation). L'exécution d'un
programme Arduino s'effectue de manière
séquentielle, c'est-à-dire que les instructions sont
exécutées les unes à la suite des autres. Voyons plus
en détail la structure d'un programme écrit en
Arduino.

XI-B. La structure d'un programme ▲

Un programme Arduino comporte trois parties :

1. La partie déclaration des variables

(optionnelle) ;
2. La partie initialisation et configuration des
entrées/sorties : la fonction setup ()  ;
3. La partie principale qui s'exécute en boucle : la
fonction loop () .

Dans chaque partie d'un programme sont utilisées

différentes instructions issues de la syntaxe du
langage Arduino.

XI-C. Coloration syntaxique ▲

Lorsque du code est écrit dans l'interface de

programmation, certains mots apparaissent en
différentes couleurs qui clarifient le statut des
différents éléments.

En orange, apparaissent les mots-clés reconnus par

le  langage  Arduino comme des fonctions existantes.
Lorsqu'on sélectionne un mot coloré en orange et
qu'on effectue un clic avec le bouton droit de la
souris, l'on a la possibilité de choisir «  Find in
reference  »  : cette commande ouvre directement la
documentation de la fonction sélectionnée.

En bleu, apparaissent les mots-clés reconnus par

le langage Arduino comme des constantes.

En gris, apparaissent les commentaires qui ne

seront pas exécutés dans le programme. Il est utile
de bien commenter son code pour s'y retrouver
facilement ou pour le transmettre à d'autres
personnes. L'on peut déclarer un commentaire de
deux manières différentes :

dans une ligne de code, tout ce qui se trouve

après « // » sera un commentaire ;
l'on peut encadrer des commentaires sur
plusieurs lignes entre « /* » et « */ ».

XI-D. La syntaxe du langage ▲

XI-D-1. ponctuation ▲

Le code est structuré par une ponctuation stricte :

toute ligne de code se termine par un

point-virgule « ; » ;
le contenu d'une fonction est délimité par
des accolades « { » et « } » ;
les paramètres  d'une fonction sont
contenus pas des parenthèses « ( » et « ) ».

Une erreur fréquente consiste à oublier un de ces

éléments.

XI-D-2. Les variables ▲

Une variable est un espace réservé dans la

mémoire de l'ordinateur. C'est comme un
compartiment dont la taille n'est adéquate que
pour un seul type d'information. Elle est
caractérisée par un nom qui permet d'y accéder
facilement.

Il existe différents types de variables identifiés par

un mot-clé dont les principaux sont :

nombres entiers (int) ;

nombres à virgule flottante (float) ;
texte (String) ;
valeurs vrai/faux (boolean).

Un nombre à décimales, par exemple 3.14159,

peut se stocker dans une variable de type float.
Notez que l'on utilise un point et non une virgule
pour les nombres à décimales. Dans Arduino, il est
nécessaire de déclarer les variables pour leur
réserver un espace mémoire adéquat. On déclare
une variable en spécifiant son type, son nom, puis
en lui assignant une valeur initiale (optionnel).
Exemple :

Sélectionnez
int ma_variable = 45;
// int est le type,
ma_variable le nom et = 45
assigne une valeur.

XI-D-3. Les fonctions ▲

Une fonction (également désignée sous le nom de

procédure ou de sous-routine) est un bloc
d'instructions que l'on peut appeler à tout endroit
du programme.

Le langage Arduino est constitué d'un certain

nombre de fonctions, par exemple
analogRead() , digitalWrite() ou
delay() .

Il est possible de déclarer ses propres fonctions,

par exemple :

Sélectionnez
1. void clignote(){
2. digitalWrite (brocheLED,
3. HIGH);
4. delay (1000);
5. digitalWrite (brocheLED,
6. LOW);
delay (1000);
}

Pour exécuter cette fonction, il suffit de taper la

commande :

Sélectionnez
clignote();

On peut faire intervenir un ou des paramètres

dans une fonction :

Sélectionnez
1. void clignote(int broche,int
2. vitesse){
3. digitalWrite (broche,
4. HIGH);
5. delay (1000/vitesse);
6. digitalWrite (broche,
LOW);
delay (1000/vitesse);
}

Dans ce cas, l'on peut moduler leurs valeurs

depuis la commande qui l'appelle :

Sélectionnez
clignote(5,1000); //la sortie 5
clignotera vite
clignote(3,250); //la sortie 3
clignotera lentement

XI-D-4. Les structures de contrôle ▲

Les structures de contrôle sont des blocs

d'instructions qui s'exécutent en fonction du
respect d'un certain nombre de conditions.

Il existe quatre types de structure.

if...else   : exécute un code si certaines

conditions sont remplies et éventuellement
exécutera un autre code avec sinon.

exemple :

Sélectionnez
1. //si la valeur du capteur
2. dépasse le seuil
3. if(valeurCapteur>seuil){
4. //appel de la fonction
5. clignote
clignote();
}

while   : exécute un code tant que certaines

conditions sont remplies.

exemple :

Sélectionnez
1. //tant que la valeur du
2. capteur est supérieure à 250
3. while(valeurCapteur>250){
4. //allume la sortie 5
5. digitalWrite(5,HIGH);
6. //envoi le message "0"
7. au port série
8. Serial.println(1);
9. //en boucle tant que
10. valeurCapteur est supérieure
11. à 250
12. }

Serial.println(0);

digitalWrite(5,LOW);

for   : exécute un code pour un certain nombre

de fois.

exemple :

Sélectionnez
1. //pour i de 0 à 255, par pas
2. de 1
3. for (int i=0; i <= 255; i++){
4. analogWrite(PWMpin, i);
5. delay(10);
}

switch/case   : fait un choix entre plusieurs

codes parmi une liste de possibilités

exemple :

Sélectionnez
1. // fait un choix parmi
2. plusieurs messages reçus
3. switch (message) {
4. case 0: //si le message
5. est "0"
6. //allume que la
7. sortie 3
8. digitalWrite(3,HIGH);
9. digitalWrite(4,LOW);
10. digitalWrite(5,LOW);
11. break;
12. case 1: //si le message
13. est "1"
14. //allume que la
15. sortie 4
16. digitalWrite(3,HIGH);
17. digitalWrite(4,LOW);
18. digitalWrite(5,LOW);
19. break;
20. case 2: //si le message
21. est "2"
//allume que la
sortie 5
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,HIGH);
break;
}

XI-D-5. Exemple ▲

L'exemple qui suit montre l'utilisation de quelques

éléments de la syntaxe du langage Arduino.

Sélectionnez
1. /*
2. Dans ce programme, un signal
3. analogique provenant d'un
4. capteur (potentiomètre)
5. fait varier la vitesse de
6. clignotement d'une LED, à
7. partir d'un certain seuil
8. */
9. ////déclaration des variables
10. // sélection de la broche
11. sur laquelle est connectée
12. le capteur
13. int brocheCapteur = 0;
14. // sélection de la broche
15. sur laquelle est connectée
16. la LED
17. int brocheLED = 13;
18. // variable stockant la
19. valeur du signal reçu du
20. capteur
21. int valeurCapteur = 0;
22. //seuil de déclenchement
23. int seuil= 200;
24. ///////////initialisation
25. void setup () {
26. // broche du capteur
27. configurée en entrée
28. pinMode (brocheCapteur,
29. INPUT);
30. // broche de la LED
31. configurée en sortie
32. pinMode (brocheLED,
33. OUTPUT);
34. }
35. ////////////boucle principale
36. void loop () {
37. // lecture du signal du
38. capteur
39. valeurCapteur =
40. analogRead (brocheCapteur);
41. //condition de
déclenchement
if(valeurCapteur>seuil){
//appel de la
fonction clignote
clignote();
}
}
/////fonction personnalisée
de clignotement
void clignote(){
// allume la LED
digitalWrite (brocheLED,
HIGH);
// délai de
"valeurCapteur" millisecondes
delay (valeurCapteur);
// éteint la LED
digitalWrite (brocheLED,
LOW);
// delai de
"valeurCapteur" millisecondes
delay (valeurCapteur);
}

Le principe de fonctionnement est le suivant :

1. Le signal lu est avec la fonction

analogRead ()  :
2. La valeur du signal varie en 0 et 1023 ;
3. Si la valeur dépasse le seuil, la LED est
allumée et éteinte pendant un délai
correspondant à la valeur du signal reçu du
capteur.

XI-D-6. Pour aller plus loin ▲

La liste exhaustive des éléments de la syntaxe du

langage Arduino est consultable sur le site  :
https://www.arduino.cc/reference/fr/.

(15) http://fr.wikipedia.org/wiki/Langage_de_programmation .

C e c o u r s es t p u b l i é s o u s l i c en c e G P Lv 2, p eu t êt r e l u et
copié librement.

© 2000-2022 - www.developpez.com

Partenaire : Hébergement Web

Connexion Inscription Contacts