Arduino

Ni olas LARDENOIS
28 mars 2017
 Table des matières

Chapitre 1 Introdu tion à Arduino 3

I. L'interfa e prin ipale d'Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
II. La barre d'outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Chapitre 2 Syntaxe et fon tions parti ulières 5

I. Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
II. Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
III. Fon tions parti ulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Chapitre 3 Les variables 7

I. Les noms des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
II. Les types de variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
III. Dénitions et ae tations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
IV. Cal uls élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
V. Complément sur les opérations : simpli ations . . . . . . . . . . . . . . . . . . . . 8

Chapitre 4 Le ontrle du programme 9

I. Les onditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
II. Les bou les . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1 La fon tion while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Les bou les ave la fon tion for . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
III. Les onditions ave if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Chapitre 5 Les fon tions 11

I. Un peu de sémantique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
II. La syntaxe des fon tions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
III. Fon tions ré ursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Chapitre 6 Mathématiques avan ées 13

I. Opérations sur les bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
II. Cal uls avan és . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1 Les fon tions lassiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Des fon tions plus spé iques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Chapitre 7 Les tableaux 14

I. Dé laration et réation d'un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1 Dé larer un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2 Les haînes de aratères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3 La taille d'un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
II. Remplir un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
III. A éder aux éléments d'un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1 Numérotation des éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Le ture et é riture des éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Tableaux et bou les . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Chapitre 8 Gestion des entrées-sorties 17

I. Entrées numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
II. Entrées analogiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
III. Sorties numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
IV. Sorties analogiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

TABLE DES MATIÈRES - N. Lardenois - Ly ée Colbert - Page 1 / 20.

Chapitre 9 Gestion du temps ave un Arduino 19
I. Le temps é oulé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
II. Les fon tions d'attente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
III. Attendre autrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Chapitre 10 Les ommuni ations sérielles 20

I. Les bases de la ommuni ation sérielle . . . . . . . . . . . . . . . . . . . . . . . . . 20
II. Envoi de données sur la liaison série . . . . . . . . . . . . . . . . . . . . . . . . . . 20

TABLE DES MATIÈRES - N. Lardenois - Ly ée Colbert - Page 2 / 20.

 Chapitre 1: Introdu tion à Arduino

Le hoix d'Arduino est lié à plusieurs problématiques :

• L'interfaçage simple ave le matériel, notament en e qui on erne les a tionneurs (Led, mo-
teurs, é rans LCD, ...), les le tures de valeurs ontinues ( onversion analogique-numérique) ou
dis rètes (boutons),

• Et bien sûr la gratuité du système tant au niveau développement qu'au niveau logi iel et
matériel : toutes les sour es matérielles et logi ielles sont disponibles de manière Open-Sour e.

I. L'interfa e prin ipale d'Arduino

Au démarrage, nous nous retrouvons fa e à l'interfa e suivante :

Juste sous la barre de titre de la fenêtre ( lassique ave le nom du s ript et le nom du logi iel),
nous retrouvons la barre des menus et la barre d'outils détaillée i-après.

La partie a tive de ette interfa e est la zone de saisie (en blan i i) qui permet de rentrer le ode
qui va être ompilé et exe uté ensuite.

La partie inférieure, en noir i i, est la onsole qui a he les erreurs et avertissements.

Chapitre 1: Introdu tion à Arduino - N. Lardenois - Ly ée Colbert - Page 3 / 20.

II. La barre d'outils

Le détail des boutons est le suivant :

1. Verify/Compile : Compile le sket h (programme) en ours d'édition et, de e fait, vérie sa

syntaxe.

2. Upload (Télé harge) : Compile le programme en ours d'édition et le télé harge en mémoire
de l'Arduino.

3. New (Nouveau) : Crée un nouveau sket h vide pour é rire un nouveau programme.
4. Open (Ouvrir) : Re harge un sket h préalablement sauvé.
5. Save (Sauver) : Enregistre le sket h ourant pour travail ou réutilisation ultérieure.
6. Serial Monitor : Ouvre l'é ran du moniteur du port série intégré à l'environnement.

Chapitre 1: Introdu tion à Arduino - N. Lardenois - Ly ée Colbert - Page 4 / 20.

 Chapitre 2: Syntaxe et fon tions parti ulières

I. Syntaxe
• Arduino est une interfa e qui se programme en language C, et don possède une grammaire
et une syntaxe qu'il faut impérativement respe ter pour avoir un programme fon tionnel.

• Une instru tion est une opération élémentaire, terminée par un point virgule.

• Un blo d'instru tions est un ensemble logique d'opérations élémentaires (instru tions) re-
groupées entre deux a olades. Les blo s d'instru tions suivent la dénition d'une fon tion,
les instru tions de bou le ou de ondition.

Remarque: Même si pour les bou les et onditions, il n'est pas né essaire de mettre un blo dans
le as d'une instru tion unique, il est re ommandé de toujours utiliser la notation de blo (entre
a olades).

II. Commentaires
• Il est possible de mettre des instru tions et textes non interprétés ni ompilés. Ce sont les
ommentaires. Il est impératif d'en user, voire d'en abuser. En eet, un sket h é rit un jour
peut être di ile à relire quelques jours (mois, année ?) plus tard.

• La syntaxe onsiste à utiliser deux anti-slash pour un ommentaire jusqu'à la n de la ligne.

instru tion; // Commentaire sur une ligne

// Autre ommentaire ( l ' instru tion n ' est pas obligatoire !)

• La syntaxe pour un blo de ommentaire est de débuter par /* et le blo se termine par */.

/*
Commentaire sur plusieurs
lignes
*/

III. Fon tions parti ulières

Arduino se base sur deux fon tions parti ulières :

• void setup() est une fon tion appelée une seule fois au début du programme (sket h ) pour
réaliser par exemple les initialisations, dénir les pattes en entrée et elles en sortie, ...

void setup ()
{
pinMode(13 , OUTPUT );
pinMode(5 , INPUT );
}

Chapitre 2: Syntaxe et fon tions parti ulières - N. Lardenois - Ly ée Colbert - Page 5 / 20.
 • void loop() est une fon tion qui est appelée indéniment, et qui, omme son nom l'indique,
bou le sur elle-même.

void loop ()
{
digitalWrite( led , HIGH ); // Allume la LED ( tension haute )
delay (1000); // Attend 1000 ms =1 s
digitalWrite( led , LOW ); // Eteint la LED ( tension basse )
delay (1000); // Attend une se onde
}

Chapitre 2: Syntaxe et fon tions parti ulières - N. Lardenois - Ly ée Colbert - Page 6 / 20.
 Chapitre 3: Les variables

I. Les noms des variables

Il est possible d'utiliser de nombreux noms pour les variables, et il est même re ommandé d'utiliser
des noms expli ites.

Les règles sont ependant les suivantes :

• Le nom doit ommen er par une lettre,

• Il ne doit pas y avoir d'espa e ou de ara tères a entués,

• Sont autorisés les lettres, hires et le ara tère souligné bas (unders ore )

Exemples : tauxTVA, temperature, volumePie e, largeur

Remarque 1 : Une habitude assez  lassique onsiste à toujours ommen er par une minus ule, et
de mettre une majus ule pour tout nouveau mot, omme dans uneVariablePeuUtile.
Remarque 2 : Les noms en C sont sensibles à la asse, e qui signie que les majus ules et minus ules
se signient par le même nom de variable, don temperature, Temperature, TEMPERATURE sont trois
variables diérentes.

II. Les types de variable

• Les entiers sont dénis par le type int. ils peuvent alors voir des valeurs omprises entre
−32768 et 32767. La dénition d'une variable n de type entier se fait par la ligne suivante :

int n;

• Il est également possible de dénir des entiers non signés, entre 0 et 65536. La dénition d'une
variable n de type entier non signé se fait par la ligne suivante :

unsigned int n;

• Les entiers ourts non signés peuvent omprendre des valeurs entre 0 et 255, et sont dénis
par le type byte. La dénition d'une variable n de type entier se fait par la ligne suivante :

byte n;

• Les booléens ne peuvent avoir que deux états : true et false. Leur dénition se fait de la
manière suivante :

boolean bEtat;

• Les réels sont dénis par le type float. La dénition d'une variable f de type réel se fait par
la ligne suivante :

float f;

Chapitre 3: Les variables - N. Lardenois - Ly ée Colbert - Page 7 / 20.

III. Dénitions et ae tations
• L'ae tation se fait ave le signe égal :

temperature =20.6; n =5;

• Il est également possible de réaliser l'ae tation lors de la dénition de la variable, omme :

int i =5;
float largeur =12.3;

IV. Cal uls élémentaires

• Tous les al uls élémentaires sont présents en C. Les al uls peuvent servir, soit pour une
ae tation, soit pour un test.

• Les règles de priorité sont les règles des Mathématiques, et les parenthèses peuvent être utilisées
pour for er l'ordre des opérations.

Opérateur Opération Exemple

+ Addition i=3+5;
− Soustra tion i=i-4;
∗ Multipli ation i=2*j;
/ Division j=i/2;
% Modulo (division entière) j=g%4;

V. Complément sur les opérations : simpli ations

• Il est possible de simplier les in rémentations d'une seule unité. La syntaxe est simplement
l'utilisation de ++. Nous avons don :

i++; pour i=i+1;

• Il est de même possible de simplier les dé rémentations d'une unité ave l'opérateur --. Nous
avons don :

i--; pour i=i-1;

• Il est également possible de ompa ter une opération ave une ae tation à la même variable :

Opérateur simplié Opération omplète

i+=5; i=i+5;
j-=7; j=j-7;
f*=5.2; f=f*5.2;
g/=2.0; g=g/2.0; ∗
∗
La division par 2.0 permet de onserver des valeurs réelle, sans arrondir ! !

Remarque: Il ne faut tout de même pas trop réduire l'é riture, ar elle devient illisible, don di ile
à reprendre plus tard.

Chapitre 3: Les variables - N. Lardenois - Ly ée Colbert - Page 8 / 20.

 Chapitre 4: Le ontrle du programme

I. Les onditions
• Les onditions sont très utiles pour les tests (fon tions if) et pour les bou les (fon tions
while).
Opérateur Opération Exemple
> Supérieur (i>3) : i plus grand que 3
Supérieur ou
>= (j>=5) : j >= 5
égal
< Inférieur g<8 : g plus petit que 8
<= Inférieur ou égal g<=7 : g inférieur ou égal à 7
== Égal i==4 : i égal à 4
!= Diérent j!=2 : j diérent de 2

• Les onditions peuvent être asso iées ave des parenthèses, le ET logique qui se traduit au
niveau Arduino par &&, ou le OU logique qui se traduit par ||.
((i==6) && (j!=3)) signie i égal à 6 ET j diérent de 3.

II. Les bou les

1) La fon tion while
• La fon tion TantQue s'é rit en C ave le mot lé while, et la ondition entre parenthèses, suivi
par le blo des instru tions entre a olades.

• Si nous voulons faire une petite bou le pour a her les nombres de 0 à 5, nous pouvons é rire :

int i =0;
while (i <=5)
{
println(" i="+ i );
i=i +1;
}

Remarque: Il faut faire attention aux onditions initiales et nales, et il serait bon de faire des tests
pour bien assimiler es on epts.

Chapitre 4: Le ontrle du programme - N. Lardenois - Ly ée Colbert - Page 9 / 20.

2) Les bou les ave la fon tion for
• La fon tion algorithmique Pour se réalise en C ave le mot lé for. Nous avons trois parties
entre parenthèses, séparées par des points-virgule :

 La ondition initiale du ou des ompteurs, ave éventuellement leur dénition,

 La ondition d'arrêt de la bou le,
 Un modi ateur du ou des ompteurs, permettant une sortie de la bou le.

• La bou le pré édente pour a her les nombres de 0 à 5 s'é rit maintenant :

for ( int i =0; i <=5; i= i +1)

{
println(" i="+ i );
}

Remarque: Il est possible d'utiliser une variable déjà dénie. Nous avons alors :
for (i=1; i<=5; i=i+1).

III. Les onditions ave if

• Il est également possible de réaliser des tests et des déroulements onditionnels, orrespondant
à SI ondition ALORS a tion. Ce i se ode en C ave le mot- lé if suivi de la ondition
entre parenthèses, et du blo d'instru tion à ee tuer, entre a olades. Nous avons don :

if ( ondition)
{
// a tions multiples et variees
}

• Il est également possible de faire les as SI ondition ALORS a tion SINON a tion_sinon.
La partie SINON se ode en Arduino ave else. Nous avons don :
le mot- lé

if ( ondition)
{
// A tion si ondition remplie
}
else
{
// A tion dans le as ontraire
}

Remarque: Il est possible d'imbriquer les onditions (un if dans une a tion d'un premier if), et e
sans limite de nombre. La rele ture peut s'avérer alors très lourde.

Chapitre 4: Le ontrle du programme - N. Lardenois - Ly ée Colbert - Page 10 / 20.

 Chapitre 5: Les fon tions

I. Un peu de sémantique
Il y a quelques années, les notions de fon tions et de pro édures étaient très disjointes et il était
de bon ton d'utiliser le terme adéquat.

Le terme pro édure était relatif à un ensemble d'instru tions nommées et qui ne renvoyait pas de
résultat. Une pro édure réalise une a tion, mais ne renvoie pas d'état ni de résultat.

Le terme pro édure était utilisé par opposition pour tout ensemble d'instru tions renvoyant une
valeur ou un état. C'est la même signi ation que la notion de fon tion en Mathématiques.

De nos jours, le terme de pro édure est quasiment désuet, et nous ne parlerons dans e do ument
que de fon tion, qu'elle renvoie ou non un résultat.

Remarque: La  disparition  est en partie liée aux nouveaux styles de programmation, où les an-
iennes pro édures ont fait pla e à des  pro édures  renvoyant l'état de bonne exé ution des ins-
tru tions, se transformant en fon tions !

II. La syntaxe des fon tions

La syntaxe générale de la dénition des fon tions omporte deux parties :

• La dénition du prototype, omportant le nom et les arguments de la fon tion,

• Le orps de la fon tion, ave la possibilité pour les fon tions de renvoyer une valeur de retour.

La dénition de la signature d'une fon tion omporte trois parties :

 Le type de valeur renvoyé par la fon tion (int, float) ou rien, pour les pro édures, qui se
note void,
 Le nom de la fon tion, ave les mêmes ontraintes de syntaxe que pour les variables ( ara tères
alphanumériques non a entués),
 La liste des arguments (ou rien si la fon tion n'admet pas d'argument), séparés par des virgules
(dans le as de plusieurs), ave pour haque le type, un espa e et le nom utilisé dans la fon tion.

Le orps de la fon tion :

 Le orps de la fon tion doit être entre a olades.

 Dans le as d'une fon tion, la valeur renvoyée est introduite par le mot- lé return, qui met
également n à la fon tion.
 Il est également possible de sortir d'une pro édure en utilisant le mot- lé return, en ignorant
le reste des instru tions. Cela peut être utile ave une ondition (instru tion if).

Exemples :

 void LedOn(void) : Pro édure qui allume une Led,

 void Clignote(int n) : Pro édure qui lignote n fois,

 int Fa torielle(int n) : Fon tion prenant un argument entier n et renvoyant un résultat

entier,
 int Pas al(int n, int k) : Fon tion prenant deux arguments, et renvoyant un résultat
entier.

Chapitre 5: Les fon tions - N. Lardenois - Ly ée Colbert - Page 11 / 20.

III. Fon tions ré ursives
Une fon tion est dite ré ursive dans le as où elle s'appelle elle-même.

Le seul danger de e type de fon tion est e qui est appelé une re ursion innie (pas de ondition
d'arrêt), et a généralement pour eet un plantage du programme.

L'exemple le plus simple est la fon tion fa torielle, qui est dénie de manière ré ursive :
(
n × (n − 1)! si n >= 1
n! =
1 si n = 1 ou n = 0

Nous avons alors la dénition suivante :

int Fa torielle( int n)

{
if (n <2) return 1;
return n * Fa torielle(n -1);
}

Remarque: Cela est un style de programmation qui peut être très élégant, et est pro he de la notion
mathématique de suite qui se réfère à l'élément pré édent.

Chapitre 5: Les fon tions - N. Lardenois - Ly ée Colbert - Page 12 / 20.

 Chapitre 6: Mathématiques avan ées

I. Opérations sur les bits

L'unité élémentaire d'information est le bit, qui vaut 0 ou 1, soit Faux ou Vrai.
Les diérentes opérations possibles sont alors :

Opérateur Opération Eet

Nous avons le bit à 1 si les deux bits valent 1.
& ET logique
3&5 donne 1, ar 3d = 011b et 5d = 101b , d'où 011&101 = 001b .
Tous les bits sont dé alés de n bits à gau he, et les bits à gau he
Dé alage à
<< deviennent des 0.
gau he
3 << 2 = 12 ar 3d = 011b et 011b << 2 = 01100b = 12d
Dé alage à Tous les bits sont dé alés de n bits à droite.
>>
droite 17 >> 3 = 2 ar 17d = 010001b et 010001b >> 3 = 010b = 2d
Nous avons le bit à 1 si un des deux bits valent 1.
| OU logique 17|5 = 21d , ar 17d = 010001b et 5 = 00101b ,
d'où 010001|101 = 010101b = 21d .

Remarque: Nous utilisons la notation nd pour le nombre n en base dé imale, et mb pour le nombre
m en binaire (base 2).

II. Cal uls avan és

1) Les fon tions lassiques

Arduino est livré ave un grand nombre de fon tions mathématiques intégrées, dont les plus utiles
pour nous sont :

Nom Prototype Détail

min min(x, y) Renvoie la valeur minimale entre x et y .
max max(x, y) Renvoie la valeur maximale entre x et y .
abs abs(valeur) Renvoie la valeur absolue.
pow pow(x,n) Renvoie la valeur de x
n
√
sqrt sqrt(x) Renvoie la ra ine arrée de x : x

Remarque: Attention, la mémoire est limitée, et les bibliothèques mathématiques sont parfois lourdes ! !

2) Des fon tions plus spé iques

• La fon tion onstrain(x,

 a, b) permet de ontraindre la variable x entre a et b.
a si
 x<a
Elle renvoie don : x si a<x<b

b si b<x


• La fon tion map(value, fromLow, fromHigh, toLow, toHigh) permet de translater la va-
leur value de la plage de valeurs [f romLow, f romHigh] vers la nouvelle plage [toLow, toHigh].

value − f romLow
Cela orrespond à la fon tion : sortie = ×(toHigh − toLow)+toHigh
f romHigh − f romLow

Chapitre 6: Mathématiques avan ées - N. Lardenois - Ly ée Colbert - Page 13 / 20.

 Chapitre 7: Les tableaux

Un tableau est une suite ordonnée d'éléments de même type, qui peuvent être a édés dire tement
par un indi e.

I. Dé laration et réation d'un tableau

1) Dé larer un tableau

• La réation d'un tableau suit la syntaxe du C, ave la dé laration de son type, son nom et la
dé laration entre ro hets de la taille du tableau :
int mesEntiers[4℄; rée un tableau de 4 entiers.

• Il est également possible de dé larer et remplir le tableau en même temps :

int mesEntiers[6℄={-3, 2, -7, 0}; rée un tableau pour 6 entiers, et initialise les 4 pre-
miers.

• Si nous remplissons dire tement le tableau, il est alors possible d'omettre la taille du tableau,
omme suit :
int mesEntiers[℄={-3, 2, -7}; rée un tableau pour 3 entiers.

Remarque: Lors de la dé laration d'un tableau sans initialisation, il n'est pas possible de prédire la
valeur que vont prendre les éléments dé larés, et il ne faut en au un as présumer que les éléments
seront nuls ! !

2) Les haînes de aratères

Les haînes de ara tères sont un type parti ulier de tableau, en réalité un tableau de ara tères.
Il faut ependant ne pas oublier la pla e pour le ara tère nul nal, sous peine de problème de
débordement ! !

haine[8℄="Bonjour"; ar Bonjour fait 7 ara tères, don 8 ave le zéro nal.

3) La taille d'un tableau

La fon tion sizeof(variable) renvoie le nombre d'o tets utilisés par la variable variable.
• Un tableau pouvant ontenir des éléments de plus d'un o tet, le nombre d'éléments dans un
tableau peut être retrouvé par :

int tableau [4℄;

int taille = sizeof ( tableau)/ sizeof ( int );

• Dans le as d'une haîne de ara tères, par ontre, ela est plus simple ar un aratère n'o upe
qu'un o tet :
int taille=sizeof( haine);

Chapitre 7: Les tableaux - N. Lardenois - Ly ée Colbert - Page 14 / 20.

II. Remplir un tableau
• Chaque élément d'un tableau est asso ié à un index. La numérotation des index ommen e
toujours à 0 et se termine à la taille du tableau - 1. Par exemple, la numérotation des index
d'un tableau de 100 éléments ommen e à 0 et se termine à 99.

• Remplir un tableau manuellement :

int [℄ monTableau = new int [100℄;

monTableau [0℄ = random (100);

monTableau [1℄ = random (100);
monTableau [2℄ = random (100);
... // et
monTableau [99℄ = random (100);

• Remplir un tableau ave une bou le :

int [℄ monTableau = new int [100℄;

for ( int i = 0; i < monTableau. length ; i=i +1 ) {

monTableau[i℄ = random (100);
}

III. A éder aux éléments d'un tableau

1) Numérotation des éléments

• Les indi es des tableaux ommen ent à zéro, don le premier élément d'un tableau à l'indi e
0 et le dernier est à l'indi e taille − 1.
• Cela nous donne don :

int tableau [6℄={2 ,4 ,6 ,8 ,10 ,12};

// tableau [3℄ ontient 8
// tableau [6℄ ontient des donnees in onnues

Remarque: Il faut don être très prudent lors de l'a ès aux éléments d'un tableau, ar leur le ture
hors limite donne un résultat aléatoire, et l'é riture hors limite peut é raserdes données d'autres
variables ! !

Remarque: En eet, Arduino étant asé sur le langage C, il n'y a pas de véri ation de l'a ès hors
des limites du tableau, ontrairement au Basi , à Java,...

2) Le ture et é riture des éléments

• L'assignation d'une valeur à un élément de tableau se fait ave la syntaxe :

int tableau [6℄; // De laration

tableau [3℄=10; // Assigne la valeur dix au quatrieme element du tableau

• De même, la le ture d'un élément se fait ave la syntaxe :

int tableau [6℄={2 ,4 ,6 ,8 ,10 ,12};

int x ;
x = tableau [2℄; // x =6 apres la le ture du troisieme element du tableau

Chapitre 7: Les tableaux - N. Lardenois - Ly ée Colbert - Page 15 / 20.

3) Tableaux et bou les

Les bou les, en parti ulier la bou le for sont bien adaptées aux par ours de tableaux, omme
dans l'exemple i-dessous qui envoie sur le port série un tableau ontenant l'état d'un ertain nombre
de pattes :

// De larations globales initiales

onst int NB_PINS =5;
int tabPins[ NB_PINS ℄;

// Fon tion d ' envoi ( tableau et port initialises)

void EnvoiPins( void )
{
for ( int i =0; i < NB_PINS; i ++)
{
Serial . print ( tabPins[i ℄);
if (i != NB_PINS -1) Serial . print (";" );
}
Serial . println ();
}

Chapitre 7: Les tableaux - N. Lardenois - Ly ée Colbert - Page 16 / 20.

 Chapitre 8: Gestion des entrées-sorties

I. Entrées numériques
• L'Arduino Uno possède 14 entrées/sorties numériques, dont ertaines sont utilisées pour des
fon tions spé iales (0 et 1 pour la ommuni ation série, 13 pour la Led intégrée).
• Il est bon de dénir les bro hes utilisée ave des noms "parlant" dans le préambule, 'est-à-dire
hors de toute fon tion, ave :

onst int entree=3; permet de xer le numéro de la bro he utilisée en entrée.

• Il est également possible d'utiliser une onstante, introduite par le mot lé #define, omme
suit :

#define entree 3

• Pour pouvoir utiliser es bro hes en entrée, il faut le pré iser avant l'utilisation ave la om-
mande :

pinMode(entree, INPUT); qui xe la patte patte en entrée. Cette dénition est réalisée par
défaut au démarrage du module, mais par sou is de larté, il est bon de le repré iser. Cette
dénition doit être faite dans l'initialisation, 'est-à-dire dans la fon tion setup().

• Il est possible de lire l'état (haut ou bas) de la bro he en entrée ave :

int valeur=digitalRead(entree);

Remarque: Il est bon d'éviter d'utiliser les deux pattes 0 et 1, sauf en as d'absolue né éssité. La
patte 13 quant à elle est utilisée souvent en sortie pour sa Led intégrée.

II. Entrées analogiques

• L'Arduino Uno possède 6 entrées analogiques notées A0 à A5.
• La tension d'entrée doit être omprise entre 0V et 5 V , sous peine de détérioration du système
éle tronique.

• La le ture d'une valeur sur la bro he patte se fait par l'instru tion :

int valeur =0;

valeur = analogRead( patte );

Remarque: Il n'est pas né essaire de pré iser que la patte est une entrée, ar la fon tion analogRead
le fait automatiquement.

Chapitre 8: Gestion des entrées-sorties - N. Lardenois - Ly ée Colbert - Page 17 / 20.

III. Sorties numériques
• Pour pouvoir utiliser es bro hes en sortie, il faut le pré iser avant l'utilisation ave la om-
mande :

pinMode(pinLed, OUTPUT); qui xe la patte pinLed en sortie. Cette dénition doit être faite
dans l'initialisation, 'est-à-dire dans la fon tion setup().

• Il est possible de modier l'état (haut ou bas) de la patte en sortie ave les instru tions :

 digitalWrite(pinLed, HIGH); pour xer un état haut (5 V ),

 digitalWrite(pinLed, LOW); pour xer au ontraire un état bas (0 V ).

Remarque: La patte 13 est souvent utilisée en sortie pour sa Led intégrée omme temoin de fon tion-
nement ou d'a tivité.

IV. Sorties analogiques

• Certaines pattes permettent de simuler une sortie analogique, sous forme d'une onde PWM
(Pulse Width Modulation, soit MLI : Modulation par largeur d'impulsion).

• Les pattes on ernées sur un Arduino Uno sont les pattes 3, 5, 6, 9, 10, 11. Elles sont repérées
à oté du onne teur ave un tilde.

• Pour pouvoir utiliser es bro hes en sortie, il faut le pré iser avant l'utilisation ave la om-
mande :

pinMode(pinLed, OUTPUT); qui xe la patte pinLed en sortie. Cette dénition doit être faite
dans l'initialisation, 'est-à-dire dans la fon tion setup().

• Il est alors possible de modier la valeur moyenne de la tension de sortie ave l'instru tion
analogWrite(pin, value). Cette fon tion permet de modier le rapport y lique de la ten-
sion sur la patte de sortie de 0 (toujours éteint) à 255 (toujours allumé).

Remarque: La fréquen e de l'onde PWM est d'environ 490 Hz .

Chapitre 8: Gestion des entrées-sorties - N. Lardenois - Ly ée Colbert - Page 18 / 20.

 Chapitre 9: Gestion du temps ave un Arduino

I. Le temps é oulé
Il y a deux fon tions pour retrouver le temps é oulé depuis de démarrage d'une arte Arduino :

• La fon tion millis() renvoie un entier long non signé (unsigned long) qui ontient le nombre
de millise ondes é oulées depuis le démarrage.
Cette fon tion déborde (retour à 0) au bout d'environ 50 jours.

• La fon tion mi ros() renvoie également un entier long non signé, mais ontenant ette fois
les mi rose ondes é oulées.
Cette fon tion déborde elle au bout d'environ 70 minutes.

II. Les fon tions d'attente

Il y a deux fon tions pour attendre un temps donné sur un Arduino :

• La fon tion delay(ms) attend le nombre ms de millise ondes avant de poursuivre.

• La fon tion delayMi rose onds(us) attend elle le nombre us de mi rose ondes avant de
rendre la main.
Cette fon tion ne donne un délai garanti que pour des délais supérieurs à 3 µs et inférieurs à
16383 µs.

III. Attendre autrement

Le prin ipal problème des fon tions d'attente est que le mi ro ontrleur ne fait plus rien pendant
qu'il attend, e qui bloque la ommuni ation ou les a tions ( ommande de servomoteurs, . . . )

Il existe une autre façon de ommander une a tion à intervalle régulier basée sur la fon tion
millis() (ou mi ros()). Cependant, il faut garder à l'esprit que le délai peut être un peu plus long.

onst int DELAY =500;

int instant;

void setup ()
{
instant= millis ();
}

void loop ()
{
if (( millis () - instant) > DELAY )
{
instant= millis ();
// A tion a faire tous les DELAY millise ondes
}
// Autres a tions
}

Chapitre 9: Gestion du temps ave un Arduino - N. Lardenois - Ly ée Colbert - Page 19 / 20.

 Chapitre 10: Les ommuni ations sérielles

I. Les bases de la ommuni ation sérielle

• Le système Arduino intègre une ommuni ation sérielle par défaut, à travers la liaison USB.
• Il faut tout d'abord dénir l'ouverture de la liaison dans la fon tion setup() ave la ommande
suivante :

void setup ()
{
Serial . begin (9600);
}

• L'envoi des données se fait à l'aide des deux fon tions suivantes :

 [Link]("Chaine"); pour a her le texte " haine" sur la onsole, sans retour à la
ligne,
 [Link](nombre); pour a her le nombre nombre sur la onsole, ave un retour
à la ligne.

• La onsole peut (et doit) être a hée ave le bouton 6 de la barre de menu (Serial Monitor) :

II. Envoi de données sur la liaison série

La partie pour envoyer une valeur entière sur deux o tets à partir d'Arduino sur une liaison série
peut être odée par :

int nombre =0;

void setup ()
{
Serial . begin (9600);
}

void SendValue( int value )

{
Serial . print ( lowByte( valeur ) , BYTE ); // O tet bas de valeur
Serial . println( highByte( valeur ) , BYTE ); // O tet haut de valeur
}

void loop ()
{
SendValue( nombre );
nombre ++; // In remente nombre
delay (500); // Attente 0 ,5 s
}

Chapitre 10: Les ommuni ations sérielles - N. Lardenois - Ly ée Colbert - Page 20 / 20.