Arduino : Le cahier de programmation
De Wikidebrouillard.
Traduction par Antony Auffret du "Arduino Programming Notebook", écrit et compilé par Brian W. Evans
Ce cahier est une référence de programmation pratique, facile a utiliser pour la structure des programmes et les bases de la syntaxe du microcontroleur Arduino.
Pour le garder simple, certaines exclusions ont été faites pour faire de ce cahier une référence, pour les débutants. Il est très utile comme source complémentaire de d'autres sites web, livres, ateliers ou classes.
Cette décision a conduit à une sélection d'utilisations autonomes d'Arduino ce qui, par exemple, exclue les usages les plus complexes des tableaux ou des formes avancées de communication série.
Ce livre débute avec les structure de base du langage de programme Arduino dérivé du C. Il se poursuit en décrivant la syntaxe des éléments les plus commun, et illustre leurs utilisations avec des exemples et morceaux de programmes. Cela inclue plusieurs fonctions de la bibliothèque principale, suivie par un appendice avec des schémas et des débuts de programmes.
Sommaire |
Structure
La structure de base du langage de programmation Arduino est assez simple et comprend au moins deux parties. Ces deux parties, ou fonctions, contiennent des blocs d'instructions.
void setup()
{
blocs d'instructions;
}
void loop()
{
blocs d'instructions;
}
Setup() est la préparation, l'initialisation du programme et loop est l'exécution du programme. Ces deux fonctions sont impérativement requises pour que le programme fonctionne.
La fonction setup() doit suivre la déclaration des variable au tout début du programme. Il s'agit de la première fonction à exécuter dans le programme. Elle est exécutée une seule fois et sert à établir le mode d'une broche (pinMode) ou à initialiser la communication série.
La fonction loop() suit immédiatement et comprend le code à exécuter en continue - lisant les capteurs en entrée et déclenchant les actionneurs en sortie, etc. Cette fonction est le noyau de tout programme Arduino et réalise l'essentiel du travail.
initialisation du programme : setup()
La fonction setup() n'est appelée qu'une fois au démarrage du programme. Utilisez-là pour initialiser le mode des broches ou fixer le débit de communication série. Il doit être dans tout les programmes même si il n'y a aucune instruction à jouer.
void setup()
{
pinMode(broche, OUTPUT); //met la "broche" comme sortie
}
Boucle du programme : loop()
Après avoir appelé la fonction void setup(), la fonction void loop() fait une boucle (loop en anglais) infinie permettant de contrôler la carte arduino, tant que le programme ne change pas.
void loop()
{
digitalWrite(broche, HIGH); //met la broche en "ON"
delay(1000); //pause pendant une seconde
digitalWrite(broche, LOW); //met la broche en "OFF"
delay(1000); //pause pendant une seconde
}
Les fonctions : blocs de code particuliers
Une fonction est un bloc de code possédant un nom et exécutant ses instructions à chaque appel. Les fonctions void setup() et void loop() sont les 2 fonctions obligatoires en arduino, mais d'autres peuvent être créées.
Il est possible de créer des fonctions afin d'améliorer des programmes répétitifs et pour rendre plus compréhensif un programme. On commence par donner un type aux fonctions. Il s'agit du type de valeur qui sera renvoyée par la fonction, par exemple un "int" donnera une fonction de type entier (integer). Si aucune valeur n'est renvoyée, le type est void (void setup()/void loop() ). Après le type, on attribue un nom à la fonction puis, dans les parenthèses, on donne les paramètres passées à la fonction.
type nomFonction(paramètres)
{
instructions;
}
La fonction entière (int) suivante, delayVal(), va permettre de changer l'intervalle de la valeur lue sur le potentiomètre. On commence par déclarer une variable locale v, elle contient la valeur du potentiomètre, c'est à dire entre 0 et 1023. On divise cette valeur par 4 afin de passer à une valeur comprise entre 0 et 255 puis on renvoie cette valeur au programme.
int delayVal()
{
int v; //création de la variable locale "v"
v = analogRead(pot); //lecture de la valeur du potentiomètre
v /= 4; //conversion de 0-1023 à 0-255
return v; //renvoie de la valeur finale
}
Les accolades : {}
Les accolades (ouvrantes ou fermantes) définissent le début et la fin d'une fonction ou d'un bloc d'instructions, comme pour la fonction void loop() ou les instructions if et for.
type fonction()
{
instructions;
}
Une accolade ouvrante { est toujours suivie par une accolade fermante }. Une accolade non fermée donne des erreurs ou des programmes lors de la compilation mais peut être dure à corriger en cas de programmes très longs.
L'environnement arduino inclue un système de vérification des accolades. Il suffit de cliquer sur une accolade pour voir sa "paire" se sur-ligner.
Le point-virgule : ;
Le point-virgule est utilisé pour finir une instruction et séparer les éléments d'un programme. On l'utilise, par exemple, pour séparer les éléments de la boucle for.
int x = 13; //on déclare la variable x comme un entier valant 13
Note : Oublier le point-virgule à la fin d'une ligne donne une erreur de compilation. Le message d'erreur peut parfois faire référence au point-virgule oublié, mais pas toujours. Si le message d'erreur est illogique et incompréhensible, une des premières choses à faire est de vérifier s'il n'y a pas un point-virgule manquant.
Les paragraphes de commentaire/*...*/
Un commentaire (sur une ligne ou sur plusieurs) est une zone de texte qui est ignoré par le programme lors de la compilation et qui est utilisé afin de décrire le code ou pour le commenter pour faciliter sa compréhension auprès de personnes tiers. Un commentaire commence par /* et fini avec */ et peut faire plusieurs ligne.
/* ceci est un paragraphe de commentaire commencé
ne pas oublier de le refermer
*/
De par le fait que les commentaires soient ignorés et qu'ils ne prennent pas d'espace mémoire, ils peuvent être utilisés généreusement, par exemple pour débuger une partie du code.
Note : Il est possible de faire un paragraphe d'une seule ligne avec /* */ mais on ne peut pas inclure un second bloc dans le premier.
Les lignes de commentaires : //
Une seule ligne de commentaire commence par // et fini à la fin de la ligne de code. Tout comme le paragraphe de commentaires, la ligne est ignorée lors de la compilation et ne prend pas de mémoire.
//ceci est une ligne de commentaires
La ligne de commentaire est souvent utilisée pour donner des informations ou pour rappeler quelque chose à propos d'une ligne.
Variables
Les variables
Une variable est une façon de nommer et de stocker une information/valer afin de l'utiliser plus tard dans le programme. Comme leur nom l'indique, une variable est une valeur qui peut être continuellement modifiée à l'opposé d'une constante qui ne change jamais de valeur. Une variable a besoin d'être déclarée et on peut lui assigner une valeur que l'on veut stocker, mais cela est optionnel. Le code suivant déclare une variable nommé inputVariable et lui assigne une valeur lue via analogRead sur la broche 2.
int inputVariable = 0; //déclare la variable et lui assigne la valeur 0 inputVariable = analogRead(2); //assigne la valeur de la broche analogique 2 à la variable
"inputVariable" est une variable. La première ligne donne le type de la valeur contenue : int (diminutif de integer, entier). La seconde ligne assigne la valeur de la broche analogique 2 à cette variable. Cela permet de rendre accessible dans le code la valeur de la broche analogique 2.
Une fois que la variable a été assignée ou ré-assignée, il est possible de la tester pour voir si elle remplie certaines conditions ou de l'utiliser directement. Afin d'illustrer 3 opérations habituelles sur les variables, le code suivant vérifie si inputVariable est plus petit que 100, si oui elle lui assigne la valeur 100 et le programme marque une pause de inputVariable millisecondes, au minimum 100 donc.
if (inputVariable < 100) //on vérifie si la variable est plus petite que 100
{
inputVariable = 100; //si oui, on lui attribue la valeur 100
}
delay(inputVariable); //on utilise la variable comme temps de pause (fonction delay() )
Note : Pour rendre le code plus lisible, on peut donner aux variable un nom explicatif. Les noms de variables tels que boutonAppuie (pushButton) ou mouvementCapteur (tiltSensor) aident le programmateur ainsi que les personnes lisant le code afin de savoir ce que représentent les variables. Les noms de variables tels que var (pour variable) ou valeur (value) ne rendent pas vraiment le code plus lisible et ne sont utilisés que dans les exemples. Une variable peut avoir n'importe quel mot comme nom tant que celui-ci n'est pas un mot clé du langage arduino.
La déclaration des variables
Toutes les variables doivent être déclarées avant d'être utilisées. La déclaration d'une variable définie son type, tel que int, long, float, ... lui attribue un nom spécifique et peut lui assigner une valeur initiale. Cela ne doit être fait qu'une seule dans le programme, mais on peut modifier la valeur tout au long du programme par des assignations ou des opérations arithmétiques.
L'exemple suivant déclare inputVariable comme un int, ou type entier (integer) et lui assigne 0 comme valeur initiale. C'est ce qu'on appelle une simple assignation.
int inputVariable = 0;
Une variable peut être déclarée à de nombreux endroits dans le programme, l'emplacement de sa déclaration détermine quelles parties du programme auront accès à cette variable.
Visibilité des variables pour le programme
Une variable peut être déclarée au début du programme avant l'initialisation (Void setup() ), à l'intérieur de fonctions et parfois au sein d'un bloc d'instruction comme les boucles. La zone où la variable est déclarée détermine la "visibilité" de celle-ci, autrement dit la possibilité pour certaines parties d'un programme à utiliser cette variable.
Une variable globale est une variable qui peut être vue et utilisée par l'ensemble du programme. Cette variable doit être déclarée au début du programme, avant la fonction void setup().
Une variable locale est une variable définie à l'intérieur d'une fonction ou dans une partie d'une boucle for. Elle est uniquement visible et utilisable à l'intérieur de la fonction où elle a été déclarée. Il est de ce fait possible d'avoir 2 variables ou plus ayant le même nom dans différentes parties du programme avec des valeurs différentes. Permettre à une seule fonction d'avoir accès à ses variables permet de réduire les erreurs potentielles de programmation.
L'exemple suivant montre comment déclarer les différents types de variables et expliquent leur visibilité :
int value; //"value" est visible par toutes les fonctions
void setup()
{
//no setup needed
}
void loop()
{
for (int i=0 ; i<20 ;) //"i" est uniquement visible à l'intérieur de la boucle for
{
i++;
}
float f; //"f" est uniquement visible dans la fonction void loop()
}
type de données
byte
int
long
float
arrays
arithmétique
L'arithmétique
compound assignments
Opérateur de comparaison
Opérateurs logiques
Constantes
Les constantes
Vrai/faux (true/false)
Haut/bas (high/low)
Entrée/sortie (input/output)
Structures de contrôle
if
if... else
for
while
do... while
Entrées et Sorties numériques (digital i/o)
pinMode(pin, mode)
digitalRead(pin)
digitalWrite(pin, value)
Entrées et Sorties analogiques (analog i/o)
analogRead(pin)
analogWrite(pin, value)
Gestion de la durée
delay(ms)
millis()
math
min(x,y)
max(x,y)
hasard
randomSeed(seed)
random(min, max)
Communication avec le port série
serial.begin(débit)
serial.println(donnée)
appendice
sortie numérique
Entrée numérique
Courant de sortie haut
Sortie pwm(Pulse Width Modulation - modulation de largeur d'impulsions)
Arduino permet de synthétiser un signal analogique grâce à la modulation de largeur d'impulsions(Pulse Width Modulation ou PWM)
Entrée potentiomètre
Entrée résistance variable
Sortie Servo-moteur
Crédits
Ce livre a été écrit à partir d'inspirations et d'informations tirées des sites web suivants :
- http://www.arduino.cc
- http://www.wiring.org.co
- http://www.arduino.cc/en/Booklet/homePage
- http://cslibrary.stanford.edu/101/
Incluant des éléments écrits par :
- Massimo Banzi
- Hernando Barragan
- David Cuartielles
- Tom Igoe
- Daniel Jolliffe
- Todd Kurt
- David Mellis
- and others...
Première édition publiée en août 2007 sous licence CC-By-Nc-Sa
S'inscrire
Login
Aide
