Structure d'un programme

Bien que basé sur le langage C/C++ l’Arduino IDE possède sa propre structure qui diffère quelque peu du langage C/C++.

Pour les puristes et les programmeurs invétérés, il faut préciser que bien que l’on parle couramment du langage Arduino, celui-ci n’est pas à proprement parler un langage informatique.

D’ailleurs de nombreux débats enflamment la toile à ce sujet : https://forum.arduino.cc/t/arduino-nest-pas-un-langage-cest-le-c/883161/17.

Je reprendrais donc ce que j’y ai lu :

Arduino n’est pas un langage, c’est du C/C++ utilisé dans l’Arduino IDE avec des outils (bibliothèques de fonctions et de classes) qui simplifient son accès et évite de nombreux écueils aux débutants.

La syntaxe du langage C/C++ est en arrière-plan, on ne la voit pas, et c’est d’ailleurs ce qui rend l’Arduino aussi simple. Mais vous pouvez programmer ou utiliser du langage C/C++ depuis l’interface Arduino IDE sans que cela ne pose de problème.

Mais alors comment est-ce possible ?

Alors de ce que j’en ai compris (et j’espère, ne pas vous dire trop de bêtises), certains mots-clés et fonctions d’Arduino appellent des lignes codes en C/C++ intégrées dans les bibliothèques du logiciel qui ne sont donc pas visible de prime abord.

Ainsi donc lorsque vous tapez par exemple analogRead dans l’IDE, cette fonction est reconnue par l’une des bibliothèques de l’IDE, c’est d’ailleurs pour cela que le texte prend la couleur orange (c’est qu’il est bien identifié). Le code prendra alors en compte les instructions correspondantes dans la bibliothèque, sans que l’on aura besoin de les taper dans le programme.

C’est un peu une espèce de raccourci…

Lorsque vous faites un programme dans l’Arduino IDE, il est question de Sketch (Croquis en français). Il semblerait que ses inventeurs ont choisi cette notion, plutôt que code ou programme, pour renforcer la notion de simplicité. Car rappelons-le, à la base la carte Arduino et son IDE ont été conçu pour simplifier l’utilisation des cartes à microcontrôleur et de leur programmation, afin de le rendre accessible aux étudiants et au néophyte.

Chaque Sketch doit impérativement être enregistré dans un dossier portant le même nom que lui.

Par défaut un Sketch (Croquis) s’enregistre dans le dossier Arduino, situé dans le dossier Documents.

Voici un exemple de code, très simple, utilisé comme « Hello World » c’est-à-dire comme routine, c’est le premier code à faire lorsqu’on débute l’apprentissage de l’Arduino : le Blink.

Il s’agit de faire clignoter une LED.

En règle générale le code fait sur l’Arduino IDE se décompose en 3 parties minimum :

L’En-tête est une zone qui se situe au-dessus du Setup, représente la zone de déclaration des Constantes et des Variables. C’est également ici que l’on déclare les Bibliothèques.

Les constantes et les variables qui y sont déclarées, sont prises en compte pour l’intégralité du code. Ce sont des constantes et des variables globales.

Parfois vide ou inexistante, lorsqu’il n’y a pas lieu d’être car le code ne comprend pas de constantes et de variables globale ou qu’il n’y a pas de bibliothèque à déclarer.

Le Setup est une zone qui se situe entre l’En-tête et le Loop. Elle représente la partie du code qui ne s’exécute qu’une fois, et sert principalement à initialiser et configurer.

Elle sert pour :

- La Configuration des Broches

- L’Initialisation des Variables

- L’Initialisation des Constantes

En effet pinMode est une instruction, et LED et OUTPUT sont ses arguments.

- pinMode fait appel à une bibliothèque intégrée à l’Arduino IDE, qui permet de définir et de configurer les Broches de la carte Arduino.

- On ouvre la parenthèse, car entre les parenthèses se trouve les arguments de l’instruction, c’est-à-dire ses paramètres.

« LED » est le nom de la variable que l’on a créée (dans l’En-tête), et souvenez-vous, elle est associée à la broche 13. En utilisant le nom de la variable, on fait appel à la broche qui lui est allouée. En effet, c’est beaucoup plus compréhensif de recourir à des noms qu’à des chiffres, surtout si dans votre code vous avez beaucoup de broches utilisées. Allez, vous souvenir ce que tel chiffre correspond à tel capteur, ou tel composant…

- Une virgule « , » vient ensuite séparer ce premier argument du second.

- Puis vient le second argument : « OUTPUT » qui indique que cette broche est une sortie. En effet les broches de la carte Arduino peuvent être à la fois des entrées et des sorties, il est donc indispensable de faire la distinction dans le code.

- On ferme la parenthèse.

- Et on finit la ligne de code par un « ; » pour indiquer au programme que l’on passe à une autre instruction.

Notez que l’intégralité du Setup doit se trouver :

- Après la mention void setup ( )

- Mais également entre les accolades { et }

La dernière partie du code est le Loop, cette zone se situe en dessous du Setup. Elle représente la partie du code qui s’exécute à l’infinie en boucle.

Le code s’exécute toujours dans le même sens : du haut vers le bas. Puis arrivé en bas, il repart à partir du Loop pour exécuter celui-ci en boucle à l’infinie.

Note n°1 : Il arrive parfois que l’on crée des Fonctions « Void » afin d’alléger le code. Dans ce cas, celle-ci s’intercale entre le Setup et le Loop. C’est le cas par exemple d’un bout de code qui se répèterai plusieurs fois dans le programme. Au lieu de le recopier plusieurs fois, on le transforme en Fonction « Void » et à chaque fois que c’est nécessaire on y fait appel.

Note n°2 : la seule façon de faire recommencer le programme depuis le début, c’est d’appuyer sur le bouton Reset de la carte ou de la débrancher électriquement et de la rebrancher. En effet celui-ci n’efface pas le code qui se trouve dans la carte, mais relance le programme en partant du début.

Quel que soit la taille et le contenu de votre code, celui-ci doit impérativement être formé de certaine parties, c’est le minimum vital.

Voici ce que doit comporter votre code, même s’il ne possède pas d’instruction :

Par exemple un code peut, ne rien avoir en setup, aucune broche à configurer et rien à initialiser. Mais il doit tout de même comporter le setup.

Tout langage, qu’il soit informatique ou pas, se doit de respecter les règles de syntaxe dudit langage. L’Arduino IDE ne déroge pas à la règle.

Chaque ligne de code (à quelques exceptions près) doit se terminer par un point-virgule « ; ».

Notez qu’une ligne de code ne signifie pas forcément une ligne physique de l’éditeur de textes. En effet, le texte présenter de haut en bas tel qu’on le trouve dans l’IDE, est lu par le programme comme une succession d’instruction en continu. C’est ce point-virgule qui sert à faire comprendre au programme que l’on passe à une autre instruction.

Exemples de codes tirés du croquis Fading : 

Ici l’on peut voir que le code s’étend sur 2 lignes (physiquement), mais en réalité pour le programme cette commande sera lu comme si elle n’était que sur une ligne, c’est bien le point-virgule qui indique au programme que la commande s’achève et que l’on passe à la suivante.

Dans l’exemple suivant, les 2 lignes de code s’étendent sur la même ligne physique. C’est fortement déconseillé, car elle contribue à rendre le programme plus difficilement lisible.

Les accolades représentent une part importante de la syntaxe de programmation en C/C++. Car ceux-ci représentent des containers.

Elles s’utilisent toujours par paires, l’une en ouverture et l’autre en fermeture, car elles servent à délimiter des blocs d’instructions dans un certain nombre d’occasions.

Par exemple les fonctions setup et loop possèdent tous deux des accolades pour définir leurs limites.

Ou dans les boucles « if » : 

Ou encore dans les boucles « while » ou « do while » : 

Bien que cela peut représenter une source d’erreur fréquente, l’Arduino vérifie automatiquement lors de sa phase de débogage, si les accolades sont bien appairées.

D’ailleurs, lorsqu’on place le curseur sur une accolade, le logiciel nous indique automatiquement sa jumelle, en la désignant sous la forme d’un petit cadre autour de celle-ci.

Pratique pour déceler d’éventuels problèmes et quelle accolade est couplée avec quelle autre.

Pour éviter les erreurs, il est conseillé d’ajouter l’accolade de fermeture immédiatement après une accolade d’ouverture. Puis d’insérez ensuite quelques sauts de lignes entre les deux, avant d’écrire les instructions.

Les commentaires sont des lignes de code qui ne sont pas pris en compte par le compilateur et permettent donc de pouvoir y placer bon nombre de choses.

Mettre des commentaires dans son code est plus que conseillé car ces commentaires permettent :

- Comprendre ce que l’on fait. Et je ne dis pas cela sur le moment même où l’on écrit son programme, mais lorsqu’on y revient plus tard, voire beaucoup plus tard.

- Se faire comprendre des autres. Eh oui ! faire un programme c’est super, le partager c’est encore mieux ! Que ce soit pour se faire relire par quelqu’un qui souhaite vous aidez en cas de difficulté ou parce que vous avez partagé votre création en vue d’aider d’autres personnes. Mettre des commentaires aide souvent à éclairer la lanterne de vos lecteurs.

- Prendre des notes. Si vous êtes comme moi à toujours griffonner sur un petit bout de papier, les commentaires sont faits pour vous.

- Désactiver des lignes de code sans les supprimer. Il arrive parfois que l’on reprend et retravaille un programme trouvé sur Internet par exemple. Dans ce cas de figure il est parfois intéressant de désactiver des lignes ou des instructions pour que le programme n’en tienne pas compte lors de sa compilation, et que l’on pourra à tout moment réactivé les faisant redevenir du code et non des commentaires. Il m’est déjà arrivé de créer mon propre code en fusionnant des parties de code puisées dans plusieurs sketchs, pour cela j’avançais parfois à tâtons en désactivant certaines parties de code, pour voir ce que cela faisait, puis je les réactivais au besoin.

Dans l’Arduino IDE, il y a deux façon de faire des commentaires.

- Lorsque les commentaires sont sur 1 seule ligne. Dans ce cas-là, on utilise le double slash « // » comme balise avant le texte. Par exemple : 

- Lorsque les commentaires sont sur plusieurs lignes. Dans ce cas-là, on utilise une balise au début du texte « /* » et une balise en fermeture « */ ».

Notez également que lorsque le texte est sous cette forme, donc entre ces balises /*    */ la couleur du texte devient grise. Très pratique pour le différencier encore plus du code.

Comme tous les langages de programmation les accents sont à bannir ! Sauf bien sûr dans les commentaires !

L’Arduino IDE possède une mise en page particulière, en effet, il utilise une coloration syntaxique. Certains termes reconnus par le programme prennent automatiquement une couleur afin de les différencier et d’améliorer la lisibilité du code.

Se colore en orange, les termes reconnus par le langage Arduino comme des fonctions et des instructions existantes.

Lorsqu'on sélectionne un mot coloré en orange et qu'on effectue un clic avec le bouton droit de la souris, parmi les options se trouve « Trouver dans la référence » : cette commande ouvre directement la documentation de la fonction sélectionnée sur le site Arduino.cc.

En bleu apparaissent les mots-clés reconnus par le langage Arduino comme des constantes.

En gris les commentaires qui ne seront pas pris en compte et exécuté par le programme.

La casse est importante dans la programmation, entendez par là qu’il faut respecter la forme de chaque mot, majuscule et minuscule.

Par exemple dans la ligne de code suivante, la fonction serial begin n’est pas reconnue par le programme, si on ne l’écrit pas avec une majuscule : 

Nous voyons dans ce cas de figure, que sans la majuscule, le texte apparait en noir et non en orange.

C’est que le programme ne le reconnait pas.

L’indentation est la mise en forme du programme servant à améliorer sa lecture, en montrant les relations d’emboîtement logique des différentes parties du code. Techniquement il n’y a aucune obligation de le faire, mais cela peut vraiment aider à la compréhension du code.

Cette mise en forme, se fait principalement par des retraits vers la droite par rapport à la ligne précédente à chaque nouveau bloc d’instructions.

Dans l’exemple qui suit nous pouvons voir le même code indenté et non indenté : 

Le code ainsi indenté est décalé et permet en un regard de voir les lignes de code qui appartiennent à la boucle While. Cela ne paraît peut-être rien sur ce morceau de code, mais sur un programme de plusieurs dizaines de lignes, cette mise en forme peut, être d’une grande aide.  

L’indentation peut se faire automatiquement, grâce à l’option « Formatage automatique » dans le menu Outils. Mais cette mise en forme ne se fait que sur les retraits et non sur les lignes du code. Ce sera à vous de créer des espaces entre vos différents blocs d’instructions en y sautant des lignes.

Toutes ces règles de mise en forme tel que l’indentation, sont importantes pour bien coder. Bien sûr cela ne fera pas de vous de super codeurs, mais lorsqu’on débute, autant bien le faire !

Par exemple, les constantes à la différence des variables s’écrivent en majuscule, tout attaché.

Les 2 fonctions indispensables au programme pour fonctionner, ont une mise en forme qu’il est important de respecter. Voici pour le Setup : 

Il est constitué du mot « void » associé au mot « setup » tous deux en minuscule. Suivi par des parenthèses vide, permettant d’y écrire d’éventuels paramètres.

Et finalement deux accolades servant de container et qui au final contiendront le code du setup. 

La mise en forme de la fonction Loop est très proche de celle du Setup : 

Tout comme le setup, le loop est constitué du mot « void » associé au mot « loop » tous deux en minuscule. Suivi par des parenthèses vide, permettant d’y écrire d’éventuels paramètres.

Et finalement deux accolades servant de container et qui au final contiendront le code du loop. 

Les instructions dans le code possèdent également leur mise en forme, comme par exemple dans l’exemple suivant : 

• https://plaisirarduino.fr/les-fonctions-loop-et-setup-arduino/
• https://www.locoduino.org/spip.php?article102
• http://bts2m.free.fr/TP_Arduino/00_b_Debut.html
• https://arduino.developpez.com/tutoriels/cours-complet-arduino/?page=bien-coder