Initiation à la programmation Arduino

Court historique du projet Arduino

Traduction d’un extrait de la page https://www.arduino.cc/en/Main/AboutUs (cette traduction est sous licence CC-BY-SA)

Initialement commencé comme un projet de recherche par Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, et David Mellis au « Interaction Design Institute » d’Ivrea (Italie) au début des années 2000, Arduino c’est construit à partir du projet Processing, un langage destiné à l’apprentissage de la programmation dans les arts visuels et lui-même développé par Casey Reas et Ben Fry, ainsi que sur le projet de thèse de Hernando Barragan concernant la carte Wiring.

La première carte Arduino a été produite en 2005 afin d’aider des étudiants, sans expérience ni en électronique, ni dans la programmation des microcontrôleurs, à créer des prototypes fonctionnels, interconnectant le monde physique au monde numérique. Depuis, c’est devenu l’outil de prototypage électronique le plus populaire, utilisé aussi bien par des ingénieurs que par de grands groupes.

Conclusion rapide, c’est un ensemble de logiciels et de matériels permettant un accès facile à l’électronique et à la programmation.

Il en existe évidemment d’autres, comme Scratch notamment et la Raspberry PI, par exemples.

Forme d’un croquis

Chaque croquis contient au minimum deux méthodes (functions) obligatoires qui sont présentes dans un nouveau croquis :

void setup() {
 // put your setup code here, to run once:

}

void loop() {
 // put your main code here, to run repeatedly:

}

Comme indiqué en anglais, la première méthode setup est lancée une fois (au démarrage) pour assurer tous les réglages initiaux du programme, alors que la méthode loop est lancée infiniment.

Rappel du principe de fonctionnement de l’IDE

Le poste de travail est connecté à l’Arduino via le port USB qui émule un port de communication Série qui permet d’envoyer et de recevoir des caractères entre la carte et le PC.

D’autre part l’IDE permet de compiler localement un programme puis de le transmettre dans la carte pour qu’il s’y exécute. Dans cet environnement, le programme ne peut pas fonctionner directement sur le PC et la carte ne peut pas interpréter le programme sans cette phase de traduction (compilation).

Quelques principes de programmation

Le langage utilisé est tiré du langage C qui est couramment utilisé dans l’industrie et principalement dans les objets connectés (ou non d’ailleurs) du fait de sa grande efficacité ; le code est compilé assez rapidement et rien n’est ajouté (ou retranché) entre le programme et son exécution sur la carte Arduino.

C’est un langage procédural, dans lequel on définit des procédures (méthodes) qui sont exécutées séquentiellement (successivement).

Les variables

Les variables sont en faite des références à des zone de mémoire vive où sont stockées les données. Toutes les variables doivent être déclarées et typées avant d’être utilisées.  On écrit :

<type> <variable> = <constante d’initialisation> ;

Les types de base

Les principaux types sont :

  • les entiers (int) ;
  • les booléens (bool) qui vrai (TRUE) ou faux (FALSE) ;
  • les nombres à virgule flotante (float) ;
  • les caractères (un seul signe) (char) ;
  • les chaines de caractères qui forme du texte (String) ;

D’autres types existent aussi (https://en.wikipedia.org/wiki/C_data_types).

Attention : tous les types ont des limites qui correspondent à leur taille en mémoire qui ne doivent pas être dépassées sous réserve de graves ennuis puisque le compilateur ne vérifie pas ces dépassement (pour des raisons d’efficacité du programme).

Par exemple, les entiers (int) ne peuvent contenir que des valeurs comprises entre -32767 et 32767, les caractères (char) ne peuvent contenir des signes de la table ASCII-US (256 caractères différents) et les nombres à virgules flottante (float) peuvent avoir des pertes de précision dans les calculs (ne jamais tester l’égalité de deux float).

Les tableaux

Il est possible d’utiliser ces types de base sous la forme de tableaux qui sont simplement des répétitions du même type : int a[12]; est un tableau de 12 entiers adressables un par un.

Les constantes

Si une variable ne doit pas changer, on peut la faire précéder du mot const pour la « protéger » et éviter toute modification imprévue ultérieure. Cela permet aussi au compilateur d’optimiser le programme (et de le rendre plus rapide).

Les références

La langage est aussi capable de gérer les références sur des variables (leur adresse en mémoire), car il est souvent plus rapide d’utiliser une référence plus courte que la valeur elle-même. Une référence est indiquée en faisant précéder la variable par un &. On peut aussi définir ainsi des types, comme « une référence sur un entier »  : &int.

Opérateurs & opérandes

(cf. : https://fr.wikibooks.org/wiki/Programmation_C/Opérateurs)

Des opérateurs sont disponibles pour réaliser des… opérations sur les variables, des constantes et/ou des fonctions. On trouve plusieurs familles d’opérateurs suivant les types sur lesquels ils s’appliquent.

Opérateurs mathématiques

Ils s’appliquent aux nombres (int et float) :

  • Addition : +
  • Soustraction : -
  • Multiplication : *
  • Division entière, ou pas, suivant les opérandes (entiers, réels) : /
  • Le reste de la division entière, le modulo : %

Opérateur arithmétiques (binaires)

Ils s’appliquent sur les entiers, bit à bit :

  • Et binaire : &
  • Ou binaire : |
  • Ou exclusif (l’un ou l’autre mais pas les deux) : ^
  • Non binaire (inversion bit à bit) : ~

Opérateurs logiques

Ils s’appliquent aux booléens, en particulier pour les conditions :

  • Ou : || (si xx ou yy)
  • Et : && (si xx et yy)
  • Non (inverse) : !
  • Plus grand, plus petit, avec ou sans égalité, égalité, différence sont des opérateurs qui retournent des résultats booléens : <, >, <=, >=, ==, !=

Les structures de contrôle

Ces éléments de langage permettent de contrôler le déroulement d’un programme ou d’une méthode. Ils se décomposent en 3 groupes :

Les tests

Sont de la forme : si condition alors exécution sinon exécution :

  • if (expression) instruction
  • if (expression) instruction else instruction
  • switch (expression) instruction, avec case et default dans l’instruction.

Les boucles

Sont de la forme d’une répétition sous condition :

  • while (expression) instruction
  • for (expression_optionnelle ; expression_optionnelle ; expression_optionnelle) instruction
  • do instruction while (expression)

Les sauts

Sous la forme d’une commande, mais sont relativement peu utilisés car ils rendent le code difficile à lire.

  • break
  • continue
  • return expression_optionnelle
  • goto étiquette

Les fonctions

Les fonctions sont des méthodes ou des procédures qui retournent une valeur. Elles peuvent être prédéfinies soient par le langage, soit dans des bibliothèques fournies qui viennent étendre les capacités natives du langage.

Il est possible de définir de nouvelles fonctions. Une fonction peut ne rien retourner (void).

Assez de théorie ! Les autres éléments du langage seront vu pendant la suite de l’atelier.

 

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *