Fiche 2 : Maîtriser les bases de la programmation

Samedis bénévoles spécial Arduino
Workshop n°1
FICHE F2 – MAITRISER LES BASES DE LA
PROGRAMMATION
SOMMAIRE
1. Introduction à la programmation ........................................................................................................ 3
2. Un peu d’algorithmique ...................................................................................................................... 3
2.1. Les structures de contrôle ........................................................................................................ 4
2.2. Les structures de données........................................................................................................ 4
3. Programmer l’Arduino......................................................................................................................... 5
3.1. Qu’est ce que l’Arduino ? ......................................................................................................... 5
3.2. La structure d’un programme pour l’Arduino .......................................................................... 5
3.3. Le langage utilisé par l’Arduino ................................................................................................ 6
3.4. Les types de données les plus courants ................................................................................... 7
Les nombres : .................................................................................................................................. 7
Les booléens : .................................................................................................................................. 7
Les tableaux ..................................................................................................................................... 7
Contact : Paula Bruzzone Rouget
Secrétariat général :
6, rue Emmanuel Pastré 91000 Evry - Tél. : 01 64 97 82 34 – [email protected]
Les chaînes de caractères ................................................................................................................ 8
Les fonctions : void .......................................................................................................................... 8
Les constantes ................................................................................................................................. 8
3.5. Les structures de contrôles les plus utilisées ........................................................................... 9
La structure conditionnelle ............................................................................................................. 9
La structure répétitive ................................................................................................................... 10
Les opérateurs de comparaison .................................................................................................... 11
Les opérateurs booléens ............................................................................................................... 11
Les opérateurs composés .............................................................................................................. 11
3.6. Les fonctions courantes.......................................................................................................... 11
Entrée-sorties digitales.................................................................................................................. 11
Entrée-sorties analogiques ............................................................................................................ 11
Autres fonctions et librairies ......................................................................................................... 12
3.7. Représenter simplement un programme Arduino ................................................................. 12
4. L’Arduino dans son environnement .................................................................................................. 14
4.1. Le boitier de paramétrage ...................................................................................................... 14
4.2. Un exemple de programme ................................................................................................... 15
2/16
1. Introduction à la programmation
Cette fiche a pour but de donner les seuls éléments de programmation nécessaires au pilotage d’un
robot filoguidé pour les Trophées. Pour approfondir, nous vous renvoyons vers les ouvrages de
références sur la programmation en langage C et plus particulièrement ceux dédiés à l’Arduino.
La programmation est connue et pratiquée depuis longtemps maintenant et les programmeurs ont
quitté les salles informatiques de la taille d’un immeuble et leurs blouses blanches (cliché des années
60) pour la table du salon ou le canapé, armés d’un portable ou d’une tablette et d’un
microcontrôleur pas plus grand qu’une carte de crédit, voir plus petit encore.
Mais les principes ont peu changé, à peine une fois tous les 10 ans. Nous sommes actuellement dans
l’ère du REST (representational state transfer) qui succède ) celle du SOA (Service Oriented
Architecture), qui a suivi la révolution objet, qui faisait elle-même suite à la programmation
procédurale…
Plus simplement, pour l’Arduino, nous nous contenterons des bases de l’algorithmique et d’éléments
du langage C – une vingtaine de mots tout au plus – qui sont bien approprié à ce que nous
souhaitons faire. Pour la suite, la programmation visuelle est un outil bien plus puissant que la
programmation manuelle, encor faut-il comprendre ce que l’on programme.
2. Un peu d’algorithmique
En 1976 (bientôt 40 ans), un des pères fondateurs de la programmation moderne, appelée la
programmation structurée à l’époque, avait posé une équation aussi fondamentale que simple, qui
était d’ailleurs le titre de son ouvrage :
Algorithms + Data Structures = Programs
Algorithmes + structures de données = Programmes
Dès lors, et malgré le rapprochement des données et des programmes apportés par l’approche objet,
programmer n’est pas autre chose que l’application d’algorithmes à des structures de données. Pour
simplifier et parce que la plupart des algorithmes sont disponibles sur étagères, nous allons nous
concentrer sur les structures de contrôles et les structures de données
3/16
2.1. Les structures de contrôle
Basiquement, elles sont au nombre de 3 :
A
B
A
A
Condition
VRAI
B
C
B
FAUXI Condition
C
C
La combinaison de ces 3 structures de contrôle permet de créer n’importe quel algorithme. Ce sont
des primitives. Chaque langage propose des implémentations avec des variantes mais dans le cas de
cet atelier, nous nous bornerons à ce sous-ensemble.
2.2. Les structures de données
Les données sont la matière première de l’informatique. Au-delà de ce lieu commun, elles répondent
à la vocation première de l’informatique : représenter et stocker l’information de manière à pouvoir
l’acquérir, la traiter et la restituer de façon compréhensible pour un être humain.
Hormis les ordinateurs quantiques, tous les « calculateurs numériques » du globe fonctionnent à
l’aide de deux états électriques que sont 0 et 1. Qu’ils soient unitaire (1 bit) ou regroupés en octets (8
bits) ou 32 ou 64 bits selon l’architecture du processeur, ces morceaux d’informations ne sont
matérialisés que par des états électrique ou une rémanence magnétique. Si les premiers ordinateurs
étaient programmés bit par bit, il y a très longtemps qu’il n’en est plus ainsi et par une abstraction,
nous pouvons représenter une donnée par sa structure sans se soucier de son implémentation
physique.
Il existe des structures de données élémentaires : un nombre entier, un nombre réel (donc qui peut
avoir des décimales), un caractère ou un octet. Ils sont très courants.
Les autres types de données sont dits complexes : un tableau de nombres ou de caractères, une
chaîne de caractère, un objet composé de différents types de données et qui englobe également les
procédures (méthodes) ou programmes qui permettent de les traiter.
4/16
Avant de pouvoir stocker, traiter ou restituer une donnée, il faut la déclarer, c'est-à-dire lui donner
un nom et indiquer son type. Ainsi la donnée contenant le mot « Arduino » sera une chaîne de 7
caractères.
3. Programmer l’Arduino
3.1. Qu’est ce que l’Arduino ?
L’Arduino est un circuit électronique particulier qui comprend un mécanisme lui permettant de
traiter des données en exécutant des instructions qui sont stockées dans sa mémoire :
-
Les données peuvent correspondre à des signaux qu’il détecte sur les PIN en entrée ;
Elles peuvent également devenir des signaux qui seront envoyés vers les PIN en sortie ;
Elles peuvent être traitées en mémoire lors de calculs ou stockées sur un support externe ou
transmises .
Les instructions sont données par un programme et exécutées une par une par le
microcontrôleur.
Programmer un microcontrôleur comme l’Arduino dans son langage propre (on parle de langage
machine) serait fastidieux car la plus simple commande, faire afficher « Hello World ! » sur un
terminal nécessiterait de décrire plusieurs dizaines de micro-instructions.
On a donc recours à un compilateur, programme informatique qui saura traduire des instructions
dites « de haut niveau », car écrites sous une forme proche du langage courant, en instruction
élémentaires directement exécutables par le microcontrôleur. Une fois que le programme sera
compilé, il pourra être chargé dans sa mémoire et sera prêt à être exécuté.
C’est un peu simpliste mais largement suffisant pour comprendre ce qui suit.
3.2. La structure d’un programme pour l’Arduino
5/16
Un programme Arduino est composé de 3 parties, même si l’environnement de développement de
l’Arduino (IDE pour Integrated Development Environment) n’en fait apparaître que deux lors de la
création d’un nouveau croquis (programme) :
La déclaration des variables utilisées par le programme
Setup()
L’initialisation des variables et la description d’actions qui ne seront exécutées
qu’une seule fois au lancement du programme
Loop()
La fonction loop() est une boucle infinie et les instructions qu’elle contient
seront exécutés à chaque cycle du processeur.
3.3. Le langage utilisé par l’Arduino
Les créateurs de l’Arduino, dans leur grande sagesse, ont choisi un langage très répandu, simple
d’accès mais suffisamment puissant pour permettre d’utiliser des fonctions dites « de bas niveau »,
c'est-à-dire au plus près du processeur, pour rédiger du code dont les performances sont critiques
par exemple ou parce que les fonctions de haut niveau ne sont pas suffisantes.
Le compilateur a également pour fonction de vérifier la syntaxe du langage avant de compiler le
programme. Pour ce faire, il compare ce qu’il lit ligne par ligne avec la référence du langage et
déclenche une erreur de compilation le cas échéant.
Pour analyser les instructions ligne par ligne, il s’attend à ce qu’une ligne soit terminée par un pointvirgule et aussi que toutes les données utilisées aient été déclarées avant et si possible, qu’elles aient
le bon type au regard de l’opération qu’on demande de leur appliquer. Par exemple, élevé une
chaîne de caractère au carré n’a pas de sens et déclenchera une erreur indiquant que l’opération
demandée est invalide pour le type de donnée.
Le compilateur fera une distinction entre « maDonnee » et « maDOnnee » qui seront stockées à deux
endroits différents de la mémoire car leur étiquette – le nom qui leur a été attribué – est différente.
Il est fréquent que l’on oublie ou écorche le nom de la donnée que l’on a déclaré lorsqu’on
programme le traitement qu’on veut lui appliquer. Une erreur qui est signalée à la compilation.
Le compilateur va donc lire toutes les instructions et en traduire la plupart dans un format conforme
au processeur utilisé. La plupart seulement car des instructions uniquement documentaires, les
6/16
commentaires, resteront visibles dans le code et ne seront pas traduites. On les signale par une
double barre oblique sur une ligne
// commentaire écrit le 16 juin 2015
ou par un couple de /*et de */ encadrant une ou plusieurs lignes
/* encore un autre commentaire
Ecrit le 16 juin 2015
*/
Traditionnellement, le code est écrit avec une police courrier, qui était la police la plus facile à éditer
sur une imprimante à aiguille (« je vous parle d’un temps… ») et dans l’environnement de
développement de l’Arduino (IDE pour Integrated Development Environment), il est colorié (on parle
de « color-coding » ) :
Les mots-clés du langage sont en orange ou en marron : myservo.attach(7);
Les variables déclarées par le programmeur et les paramètres sont en noir ::
myservo.attach(7);
- Les commentaires sont en bleu : // ceci est un commentaire
- Les textes sont en bleu foncé : Serial.println(« Hello World ! »)
Bien que gratuit et un fruste, l’environnement de l’Arduino embarque une aide en ligne assez riche
puisqu’elle contient la référence du langage C utilisé. Elle est accessible par le menu Aide/Référence.
A noter des applications sur smartphone et tablettes qui ont le même contenu (Arduino Companion,
par exemple)
-
3.4. Les types de données les plus courants
Les nombres :
-
int : entier, est le type le plus couramment utilisé et permet de stocker des données dont la
valeur est comprise entre -2^15 et 2^15 (2^15 = 32768
word ou unsigned int : idem pour les entiers positifs compris entre 0 et 65535
Long : pour des nombres compris entre -2,147,483,648 et 2,147,483,647.
unsigned long : idem pour des nombres compris entre 0 et 4,294,967,295
Float ou double : nombre à virgule flottante compris entre -3.4028235E+38
et.3.4028235E+38
Byte : pour un nombre positif entre 0 et 255 (codé sur un byte soit un octet soit 8 bits)
Les booléens :
-
Boolean : possède 2 valeurs possibles, true et false
Les tableaux
- Array : une suite de variables accessibles par un index numérique
int monTableau[5] ; //tableau qui peut contenir jusqu’à 5 nombres entiers ;
7/16
monTableau = {7, 8, 9, 4, 5}
// initialisation du tableau
monTableau [3] contient la valeur 9, 3 est l’indice du tableau
monTableau [3] = 6 ; // change la valeur 9 en 6
Les chaînes de caractères
-
-
Char : correspond à un caractère ASCII, un caractère est encadré par des simples guillements
(‘A’ par exemple)
unsigned char et byte : sont équivalents et permettent de coder un caractère dont la valeur
varie entre et 255, le type byte est à privilégier
chaîne de caractère (char array) : une chaîne de caractères est un tableau (array) de
caractères dont on définit la longueur lors la définition du type, par exemple char
maChaine[10] ; Pour affecter une valeur constante à une chaîne de caractère, on peut
l’encadrer par des doubles guillemets, par exemple, char maChaine2[15] = "Arduino ".
String : un objet utilizable à partir de la version 0019 de l’IDE et qui permet de manipuler des
chaînes de caractères
Les fonctions : void
Ce mot-clé n’est utilisé que pour la déclaration d’une fonction qui ne renverra pas de valeur. En
programmation structurée, cette fonction est en fait une procédure. Les fonctions setup() et loop()
sont des exemples de fonctions de type void.
Les constantes
-
-
HIGH et LOW : ces constantes définissent le niveau logique des PINs de l’arduino. Ce niveau
dépend du mode d’utilisation du PIN : en entrée (INPUT) ou en sortie (OUTPU). En entrée, le
niveau est haut (HIGH) si une tension de plus de 3V est mesurée sur le PIN. Il est à HIGH en
sortie si tension est de +5V. Pour les modules en 3,3V (cas du Due), les niveaux sont
différents mais le principe reste le même. Le niveau LOW correspond à la masse.
Habituellement, les niveau d’entrée sont mis à HIGH lors de l’initialisation par un pull-up :
digitalWrite(monPIN, HIGH) qui met l’entrée à l’état haut de façon explicite pour éviter une
pollution par des interférences (moteurs, électricité statique…). En général, on fait un pull-up
sur le PIN d’entrée d’un bouton poussoir dont l’autre borne est connectée à la masse. L’appui
sur le bouton fait passer l’état à LOW et ce changement d’état est détecté dans le code par la
fonction analogRead(monPIN). Les PIN en sortie peuvent alimenter une LED ou un
servomoteur ou un petit moteur mais ne peuvent délivrer qu’un courant limité. Ils doivent
être amplifiés par un dispositif de puissance pour piloter des courants plus forts et ne doivent
jamais être reliés à la masse
INPUT, OUTPUT et INPUT_PULLUP : tous les PINs de l’Arduino peuvent être déclarés en
entrée (INPUT) ou en sortie (OUTPUT) avec la fonction pinMode(). Pour les PIN en entrée,
l’initialisation est facilitée en combinant le choix du mode et le pull-up par la constante
INPUT_PULLUP
8/16
-
true et false : utilisés dans les tests des conditions ou les boucles de type while(),toute valeur
d’un entier différente de zéro est à la valeur « vrai », fausse si égale à zéro.
3.5. Les structures de contrôles les plus utilisées
La structure conditionnelle
-
if… : cette structure est la plus courante en robotique où l’on détermine le comportement
d’un robot à partir des signaux transmis par ses capteurs. La valeur des variables
correspondant aux ports d’entrée est donc couramment testée pour décider de l’action à
réaliser selon une ou plusieurs valeurs prévues. On utilise des opérateurs de comparaison
pour combiner les évaluations de variables.
La syntaxe est la suivante :
if (maVariable > 50)
{
// action
}
Si une seule instruction correspond à l’action, digitalWrite(13, HIGH) pour allumer une LED,
par exemple, l’expression peut être contractée en
if (maVariable > 50) digitalWrite(13, HIGH);
-
Notez que l’expression logique est toujours entre parenthèses
if…else…: cette variante permet des tests multiples en spécifiant l’action à réaliser dans le
cas où la condition n’est pas remplie
if (maVariable < 500)
{
// alors on fait l’action A
}
else
{
// sinon on fait l’action B
}
Notez que la branche else peut également inclure une structure conditionnelle
if (maVariable < 500)
{
// faire A
}
else if (maVariable >= 1000)
{
// faire B
}
else
{
// faire C
}
A noter : la structures witch case permet de tester simplement l’ensemble des valeurs
possible d’une variable.
9/16
La structure répétitive
Très courante également, la structure répétitive est du type
Pour
maVariable = une valeur de départ
jusqu’à ce que maVariable = une valeur ou une condition de fin
en faisant varier maVariable
faire ….
En langage C (celui de l’Arduino), la syntaxe est la suivante, par exemple :
for (int i=0; i <= 255; i++){
action
}
On définit un entier i comme index de la boucle et on l’initialise à 0 : int i=0 ;
On fixe la condition d’arrêt de la boucle : dès que i dépassera 255, on sortira de la boucle
On fixe un incrément, ici i++ signifie simplement qu’on ajouter une unité à i (i = i + 1).
Un exemple de boucle for : la variation de puissance d’une LED (croquis exemple « fade »)
qui est également un bon exemple de variation de puissance PWM avec la fonction
analogWrite()
int ledPin = 9; // l’anode de la LED est connectée sur le pin 9
void setup() {
// Pas d’action dans le setup
}
void loop() {
// la LED s’éclaire progressivement de la vaeur min au max par increments de 5 points:
for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {
// sets the value (range from 0 to 255):
analogWrite(ledPin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
// puis diminue de la meme façon:
for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
// sets the value (range from 0 to 255):
analogWrite(ledPin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
}
A noter : la structure while permet de créer des boucles avec une expression conditionnelle.
10/16
Les opérateurs de comparaison
Comme on l’a vu, leur usage est précieux dans les structures conditionnelles et ils interviennent aussi
dans boucles
-
==
!=
<
>
<=
>=
égal à
différent de
plus petit que
plus grand que
plus petit ou égal à
plus grand ou égal à
Les opérateurs booléens
-
&&
||
!
et
ou
non
Les opérateurs composés
-
++
-+=
-=
*=
/=
incrément
décrément
addition composée : A += 5 équivaut à A = A + 5
idem
idem
idem
3.6. Les fonctions courantes
Entrée-sorties digitales
-
pinMode(pin, INPUT ou OUTPUT) : configure le mode du PIN (sortie, entrée, entrée avec
pull-up)
digitalWrite(pin, HIGH ou LOW) : écrit une valeur HIGH ou LOW sur un PIN digital
digitalRead(pin) : lit la valeur d’un PIN digital, utilisé pour détecter l’appui sur un bouton
poussoir ou le changement d’état d’un capteur digital (suivi de ligne, par exemple)
Entrée-sorties analogiques
-
-
analogReference() : configure la valeur de référence de la tension maxi mesurée
analogRead(pin) : fonction du convertisseur analogique-numérique qui transforme par
mapping une tension lue entre 0 et la tension de référence en une valeur comprise entre 0 et
1023. La durée de lecture étant de 100 micro secondes, cette fonction peut réaliser 10000
lectures dans un intervalle d’une seconde
analogWrite(pin, valeur) : génère un signal carré dont la fréquence est de 500hz
approximativement et donc la durée de signal haut au cours d’un cycle est réglée par la
11/16
valeur qui est comprise entre 0 (pas de signal haut) et 255 (signal haut sur toute la période).
Cette fonction est utilisée pour le PWM sur les PINs 3, 5, 6, 9, 10 et 11 étant précisé que pour
certains modules Arduino, les PINs 5 et 6 ne peuvent être complètement à une durée nulle.
Autres fonctions et librairies
-
-
-
Serial() : permet de communiquer avec un autre appareil selon un protocole série.
Pratiquement, il permet d’envoyer des messages sur le moniteur série de l’IDE pour suivre le
déroulement du programme. La connexion est initialisée avec l’instruction
Serial.begin(vitesse), où vitesse prend en général la valeur 9600. Pour afficher du texte ou
des valeurs en mode ligne de commande on utilise Serial.print() ou Serial.prinln() si on
souhaite faire un saut de ligne. Pour lire des commandes tapées au clavier, on utlisera
Serial.read()
Delay(durée en millisecondes) : fait faire une pause au programme pendant le temps
indiqué. Une variante de cette fonction delayMicroseconds() permet de spécifier le temps de
pause en microsecondes. A noter : pendant la pause, l’exécution de tout programme ou
fonction est suspendue. Pour continuer à exécuter des tâches de fond, la gestion des
interruptions est plus appropriée.
Servo : une bibliothèque (library) qui permet de gérer simplement jusqu’à 12 servomoteurs
sur la plupart des modules Arduino. A noter que son utilisation désactive le PWM sur les PIN
et 9 et 10. Pour l’utiliser :
o Déclarer une variable de type servo : servo monServo ;
o Activer le PIN correspondant :
monServo.attach(pin) ;
o Donner une valeur d’angle entre 0 et 180 : monServo.write(angle) ;
o Lire la valeur d’angle courante:
monServo.read(angleCourant) ;
o Libérer le PIN du servo :
monServo.detach(pin)
Cette dernière action permet de récupérer l’usage des PIN 9 et 10 pour le PWM
Et bien sûr d’autres fonctions dont les fonctions mathématiques courantes.
Il est également possible de créer ses propres fonctions. (voir l’atelier avancé).
3.7. Représenter simplement un programme Arduino
Pour faciliter la programmation, il est pratique d’utiliser une représentation sous forme d’arbre
programmatique qui reprend la structure d’un programme (déclaration, initialisation, boucle) et fait
apparaître des blocs d’instruction qui correspondent à une fonction.
Par exemple, pour un programme qui permettrait :
-
De diriger le robot : avant/arrière/droite.gauche
-
De dérouler un tapis rouge sur des marches d’escalier
-
De ramasser des balles de ping-pong dans un distributeur
-
Puis de les déposer dans un bac
12/16
On commenterait par décrire la structure de base, que l’on lit de gauche à droite :
Mon programme
-
Déclarations
PIN
Constantes
Variables
Objets
Initialisation
Setup()
- PIN
- Variables, objets
- Port série
Boucle
loop()
Puis on détaille ce que fait la boucle loop()
Mon programme
-
Déclarations
PIN
Constantes
Variables
Objets
Initialisation
Setup()
- PIN
- Variables, objets
- Port série
Boucle
loop()
Gérer la
direction
Déposer le
tapis
Ramasser
les balles
Déposer les
balles
Notez le petit losange au dessus de chaque fonction : il indique que ce bloc d’instruction est
déclenché seulement si une ou plusieurs conditions sont remplies. Au lieu d’une structure
conditionnelle, on aurait pu avoir une structure répétitive de type « pour i = 1 jusqu’à N » mais dans
l’exemple, on ne fait que tester la valeur de boutons ou de potentiomètres.
Les plus cartésiens remarqueront une décomposition analytique : du global au particulier et jusqu’à
la ligne de code. C’est la méthode la plus ancienne en programmation et elle est parfaite pour
débuter mais notez que pour une robotique un peu plus étoffée, avec des composants actifs dotés
d’un comportement qui leur est propre comme un bras robot ou une centrale inertielle, une
communication par messages échangés entre des objets sera plus appropriée.
Pour l’instant, une approche fonctionnelle est appropriée. L’idée est de regrouper dans un même
ensemble les instructions qui concourent à une même action. Ces fonctions peuvent retourner une
valeur si on les sollicite , dans le cas d’une mesure de distance, par exemple, ou se contenter
d’exécuter une par une des instructions élémentaires.
Ce dernier cas convient bien à l’exemple et on utilisera le descripteur void pour indiquer qu’on
utilise une fonction qui ne renvoie rien, comme c’est le cas pour les fonctions setup() et loop().
13/16
Pour utiliser une fonction qui renvoie une valeur, l’aire d’un cercle à partir de son rayon, par
exemple, on la déclare en indiquant le type de données de la valeur qu’elle retourne.
Procédure
void DeposerBalles (){
Fonction
double AireCercle(int rayon) {
mySVERSE.write(90);
delay(3000);
mySVERSE.write(0)
double Resultat ;
Resultat = 3.14.16 * pow(rayon, 2) ;
Return Resultat ;
}
Dans le code de la boucle loop(), on appellera la fonction de dépose des balles de la façon suivante :
DeposerBalles() ;
Et le résultat de la fonction AireCercle(x) sera affecté à une variable de type compatible :
Int RayonDisque = 0 ;
Double Surface = 0 ;
…
void loop()
Surface = AirCercle(RayonDisque) ;
Cette approche dite « d’analyse structurée descendante » est très pratique pour écrire rapidement
un programme : on « pose » les structures de contrôle (if then else, for…) et on invoque une fonction
dont on choisit bien le nom plutôt que de coder dans le détail les instructions qui la composent. Au
passage, on nomme des variables, toujours en choisissant bien leur nom, que l’on utilise dans le
code.
Ensuite, on déclare et on initialise ces variables en début de programme puis on écrit le code des
fonctions. De cette façon, on privilégie l’architecture générale du programme, le squelette, qui est
cohérente avec le comportement attendu du robot puis on ajoute la chair et les muscles qui vont
permettre de l’exécuter.
Notez qu’une simulation via le port série en écrivant par exemple :
Serial.print("Distance mesuree = ");
Serial.println(maDistance);
Permet de simuler l’exécution d’une fonction et de savoir que le code correspondant sera exécuté à
ce moment là.
4. L’Arduino dans son environnement
4.1. Le boitier de paramétrage
14/16
A la différence d’un ordinateur, le programme d’un robot ne s’exécute pas dans un environnement
habituel mais va collecter des données (des signaux) à partir de capteurs, les traiter et envoyer des
signaux ou des commandes vers des actionneurs.
Ces interactions passent par les ports ou PIN de l’Arduino qui en assure le routage vers le processeur.
La mise en correspondance des capteurs et actionneurs avec les PIN de l’Arduino est assurée lors de
la déclaration des variables.
Le terme de boîtier de paramétrage permet de visualiser un endroit du code où les PIN physiques de
l’Arduino sont reliés aux variables qui seront traitées dans le code. Pour rendre un code portable sur
un autre Arduino ou un autre robot, il suffira de le « personnaliser » en modifiant que l’attribution
des PIN.
Les erreurs d’attribution des PIN sont assez courantes du fait des mises au point et un petit tableau
permet de s’y retrouver lorsque l’on câble de façon définitive ou que l’on cherche une panne…
PIN
Affectation
PIN
Affectation
PIN
Affectation
A0
Potentiomètre
D1
LED
D8
Servomoteur A
A1
Photorésistance
D2
Moteur droit
D9
Servomoteur A
…
…
…
4.2. Un exemple de programme
Exemple à peu près universel, le croquis « blink » qui a pour but de faire clignoter une LED !
15/16
Il est utilisé plus souvent qu’on ne le pense : lorsqu’un programme est en cours de mise au point, il
arrive que son comportement ne soit pas approprié une fois téléversé dans l’Arduino. Une façon
rapide et efficace de retrouver une situation normale est de téléversé ce petit croquis qui restaurera
un peu de sérénité sur votre de plan de travail, en particulier lorsque vous devrez stopper à tout prix
deux moteurs un peu trop emballés pour la bonne santé de votre robot…
*
*
*
16/16