Débuter avec ARDUINO

Sommaire
1. Les principaux avantages du système Arduino ................................................... 3
2. LA CARTE ARDUINO UNO ................................................................................ 4
2.1. Différents éléments de la carte Arduino Uno ................................................. 4
2.2. Principales caractéristiques ........................................................................... 5
2.3. Alimentation ................................................................................................... 5
2.4. Les entrées/sorties ........................................................................................ 5
2.5. Les mémoires ................................................................................................ 6
2.6. Communication.............................................................................................. 6
2.7. Reset ............................................................................................................. 6
2.8. Protection de surintensité USB ...................................................................... 6
2.9. PWM : définition rapide ................................................................................. 6
3. PROGRAMMATION DE LA CARTE ARDUINO .................................................. 7
3.1. L’IDE Arduino ................................................................................................ 7
3.2. Structure d’un programme ............................................................................. 8
4. LE PRINCIPE DE LA PROGRAMMATION ......................................................... 9
4.1. Le montage du schéma ................................................................................. 9
4.2. La programmation ......................................................................................... 9
4.3. Utilisation de variables................................................................................. 10
4.4. La notion de type de variables ..................................................................... 11
4.5. La notion de constante ................................................................................ 12
4.6. Les opérateurs............................................................................................. 13
5. LE LANGAGE ARDUINO .................................................................................. 13
5.1. Les fonctions les plus importantes............................................................... 14
5.2. La librairie Serial() ....................................................................................... 16
6. LES ACCESSOIRES ......................................................................................... 17
6.1. La carte de prototypage ou Breadboard ...................................................... 17
6.2. Les câbles Dupont ....................................................................................... 17
7. PREMIER PROGRAMME ARDUINO ................................................................ 18
7.1. Matériel nécessaire ..................................................................................... 19
7.2. Sketch ......................................................................................................... 19
7.3. Premier programme..................................................................................... 19
8. TRAVAUX PRATIQUES .................................................................................... 21
La carte de développement Arduino est une
plateforme matérielle et logicielle de
développement d'applications embarquées.
Côté matériel, elle se compose d'une carte
électronique basée autour d’un microcontrôleur
(ATMEL AVR) comportant un certain nombre
d’entrées et de sorties (les ports) permettant la
connexion de capteurs, ou d’actionneurs.

Le logiciel de programmation des modules

Arduino est ARDUINO IDE.
C’est une application Java, libre et multi-
plateformes, servant d’éditeur de code et de
compilateur, et qui peut transférer le firmware et
le programme au travers de la liaison USB.
Le langage de programmation utilisé est un
mélange de C et de C++, restreint et adapté aux
possibilités de la carte.
La compilation d’un programme informatique
consiste à le rendre compréhensible par
l’électronique (microcontrôleur).

1. Les principaux avantages du système Arduino

Matériel peu onéreux : Les cartes Arduino sont relativement peu coûteuses
comparativement aux autres plateformes de développement. La moins chère
des versions du module Arduino peut être assemblée à la main, et même les
cartes Arduino préassemblées coûtent moins de 25 €.

Matériel Open source et extensible : Les schémas des modules sont publiés
sous une licence Creative Commons, et il est possible de réaliser nos propres
versions des cartes Arduino, en les complétant et en les améliorant.

Logiciel gratuit et Open Source : Le logiciel Arduino et le langage Arduino

sont publiés sous licence open source, disponible pour être complété par des
programmeurs expérimentés. Le langage peut être aussi étendu à l'aide de
librairies C++.
 Logiciel multi-plateforme : Le logiciel Arduino, écrit en Java, tourne sous les
systèmes d'exploitation Windows, Macintosh et Linux.

Modules « Shield » : Cartes supplémentaires se connectant sur le module

Arduino pour augmenter les possibilités : afficheur graphique couleur, interface
Ethernet, GPS, etc...

Il existe de très nombres kits ARDUINO incluant la carte

ADRUINO UNO ainsi que tous les accessoires et certains shields
pour débuter avec ARDUINO. Ces kits coûtent entre 30 € et 120
€ selon la provenance et la quantité de shields qu’ils incluent.

2. LA CARTE ARDUINO UNO

Il existe plusieurs types de cartes Arduino. La carte Arduino Uno est une des versions
majeures des cartes Arduino. Il s’agit d’une carte au format « standard » Arduino c'est-
à-dire environ 52 mm sur 65 mm.
Deux rangées de connecteurs, situées de part et d'autre de la carte, permettent la
connexion des composants extérieurs ou des modules shields, au format Arduino, il
est possible d'enficher directement ces derniers dans la carte de base, sur plusieurs
niveaux si nécessaire.

2.1. Différents éléments de la carte Arduino Uno

 2.2. Principales caractéristiques

2.3. Alimentation
La carte Arduino UNO peut être alimentée par le câble USB, par un bloc secteur
externe connecté grâce à une prise « jack » de 2,1mm ou bien par un bloc de piles
dont le raccordement est réalisé par l’intermédiaire des « GND » et « VIN » du
connecteur d’alimentation (POWER). L’alimentation extérieure doit présenter une
tension comprise entre 7 à 12 V.
La carte génère, par l’intermédiaire de régulateurs intégrés, deux tensions stabilisées :
5 V et 3,3 V. Ces deux tensions permettent l’alimentation des composants
électroniques de la carte Arduino. Etant disponibles sur les connecteurs placés sur
le pourtour des cartes, elles permettent également l’alimentation des modules
shields.

2.4. Les entrées/sorties

La carte « Arduino Uno » dispose de 14 E/S numériques et de 6 entrées analogiques.
Entrées/sorties numériques :
Chacune des 14 broches numériques (repérées 0 à 13) peut être utilisée en entrée
(input) ou en sortie (output) sous le contrôle du programme. Le sens de fonctionnement
pouvant même changer de manière dynamique pendant son exécution.
Elles fonctionnent en logique TTL (0V-5V) ; chacune pouvant fournir (source) ou
recevoir un courant maximal de 40 mA.
Entrées analogiques :
Les six entrées analogiques, repérées A0 à A5, peuvent admettre toute tension
analogique comprise entre 0 et 5 V (par défaut mais cela peut être modifié). Ces
entrées analogiques sont gérées par un convertisseur analogique/numérique de 10
bits, dont la sortie peut varier de 0 à 1023.
Les entrées A4 et A5 peuvent également être utilisées respectivement comme la ligne
de donnée SDA et la ligne d’horloge SCL de l’interface série I2C.
 2.5. Les mémoires
Le microcontrôleur ATmega 328 dispose de 32 ko de mémoire de programme Flash.
Il contient aussi de 2 ko de mémoire vive (SRAM).
Cette mémoire est généralement utilisée pour stocker les résultats temporaires lors de
calculs. Elle peut être lue et écrite à tout instant par le microcontrôleur mais son
contenu est perdu dès qu’elle n'est plus alimentée.
L’ATmega 328 dispose également 1ko mémoire EEPROM. Le contenu de cette
mémoire est accessible grâce aux fonctions de la librairie « EEPROM ».

2.6. Communication
La carte « Arduino Uno » a de nombreuses possibilités de communications avec
l’extérieur. L’Atmega328 possède une interface de communication série UART
accessible, grâce aux broches numériques 0 (Rx) et 1 (Tx) (Digital 0 & 1)
D’autre part, elle supporte le bus I2C accessible, grâce aux broches analogiques 4
(SDA) et 5 (SCL) et la liaison série synchrone SPI grâce aux broches numériques 10
(SS), 11 (MOSI), 12(MISO) et 13 (SCX).

2.7. Reset
A la mise sous tension un reset automatique permet au programme contenu en
mémoire du microcontrôleur de démarrer automatiquement dès que la carte Arduino
est alimentée.
La carte « Arduino Uno » est également équipée d'un bouton poussoir de reset manuel.
Un appui sur celui-ci permet de relancer l'exécution d'un programme si nécessaire,
soit parce qu'il s'est « planté » soit tout simplement parce que l'on souhaite le faire
repartir de son début.

2.8. Protection de surintensité USB

Par mesure de sécurité pour l'ordinateur auquel sera relié l'Arduino, un fusible
réarmable ou « Polyfuse » est présent sur la connexion d'alimentation 5 V de la prise
USB. Toute consommation supérieure à 500 mA provoque le déclenchement de ce
fusible, protégeant ainsi le port USB de l'ordinateur auquel la carte est reliée.
Le fusible étant de type réarmable, il retrouvera son état normal quelques secondes
après que la consommation excessive aura cessée.

2.9. PWM : définition rapide

Il s'agit d'une technique de création de signaux qui permet de contrôler de l'analogique
avec des sorties numériques d'un microcontrôleur. La commande en PWM 1 consiste
en une succession rapide de signaux numériques. Par exemple, des signaux tout
ou rien, c'est-à-dire alternant sans transition entre une valeur minimale fixe A
(extinction) et une valeur maximale fixe B (allumage).

1 PWM : Pulse Width Modulation = Modulation en largeur d'impulsion = MLI

Cette technique permet de faire de la gradation (variation d’intensité) sur les LEDs par
exemple.

3. PROGRAMMATION DE LA CARTE ARDUINO

3.1. L’IDE Arduino

Le logiciel Arduino IDE2 est un environnement de développement (IDE) open source

et gratuit, téléchargeable sur le site officiel Arduino.

L’IDE Arduino permet :

D’éditer un programme : des croquis (sketch en Anglais),
De compiler ce programme dans le langage « machine » de l’Arduino,
De téléverser le programme dans la mémoire de l’Arduino,
De communiquer avec la carte Arduino grâce au terminal.

Barre des menus

Barre d’outils

Onglet(s)

Fenêtre d’édition
des programmes

Zone de messages

Console d’affichage des

messages de compilation

Information sur la carte

Arduino connectée

2IDE : environnement de développement « intégré » abrégé EDI en français ou IDE en anglais, pour integrated
development environment
Arduino IDE est un éditeur de texte à coloration syntaxique.
La « Barre d’outils » qui donne un accès direct aux fonctions essentielles du logiciel.
Elle propose les outils suivants :

3.2. Structure d’un programme

Un programme ou croquis (sketch) destiné à une carte Arduino est constitué de 4
parties dont 2 sont indispensables :

Indique au programme les

librairies à ajouter. Ex :
#include "LedControlMS.h"

Initialisation des variables du

programme. Ex :
int LedPin = 2

Fonction setup() qui contient les

instructions d’initialisation du
programme

Fonction loop() qui contient les

instructions de déroulement du
programme
4. LE PRINCIPE DE LA PROGRAMMATION
Le principe est simple :
On utilise les ports de communication, qu’il s’agisse des broches digitales ou
analogiques pour soit piloter des cartes d’interfaces soit recevoir des informations de
ces cartes d’interfaces (shields).

Dans cette logique, il est nécessaire d’utiliser différents éléments afin de construire le
dispositif électronique souhaité.

4.1. Le montage du schéma

+ + +

4.2. La programmation
La programmation représente le fait de donner des instructions au microcontrôleur afin
de piloter les objets utilisés dans le schéma.
Elle varie selon ce que l’on souhaite réaliser. Par exemple, avec une LED, on peut :
L’allumer
L’éteindre
La faire clignoter
Faire varier son intensité

Dans chacun des cas ci-dessus, la programmation sera différente.

Faire allumer la LED

Faire clignoter une LED

4.3. Utilisation de variables

La notion de variable existe dans tous les langages de programmation.
Une variable peut être vue comme une boîte stockée dans une zone de mémoire. Elle
porte un nom, elle est définie par un type et possède à un instant donné une valeur.
Les noms de variables doivent respecter les 3 règles suivantes :
Règle1 : le premier caractère est obligatoirement une lettre.
Règle2 : les seuls caractères autorisés sont les lettres (sans accents), les chiffres et
"_".
Règle3 : un nom de variable ne peut pas être un mot clé du langage.

Nom de la Validité Règles non

variable respectées
Prenom Oui
Prénom Non 2
Nom101 Oui
Nom_Eleve Oui
Nom Eleve Non 2
_Age Non 1
Age-Eleve Non 2
Integer Non 3

Exemple de programme utilisant des variables

4.4. La notion de type de variables

Le type d'une variable définit la manière dont elle est représentée en mémoire et les
opérations que l'on peut faire dessus.
 4.5. La notion de constante
En programmation, il est souvent nécessaire de définir des structures de données dont
la valeur ne doit pas changer au cours de l'exécution du programme. Ces structures
de données sont typiquement ce que l'on appelle des constantes.
La plus connue des constantes mathématiques est par exemple le nombre PI dont la
valeur est approximativement 3.1415926535898.

Une constante peut être définie au moyen de const ou de #define comme dans
l’exemple suivant :

Un certain nombre de noms de constantes sont prédéfinis dans le langage « Arduino

»:
 4.6. Les opérateurs

5. LE LANGAGE ARDUINO
Le langage Arduino, comme tous les langages de programmation contient un grand
nombre d’instructions. Elles sont réparties en 3 grandes familles :

Structure : elles permettent de structurer le déroulement d’un programme

Variables : elles contiennent des valeurs définies par programmation ou fixes

Fonctions : elles exécutent des opérations au niveau du microcontrôleur

Le langage Arduino est très largement détaillé sur Internet. Plus particulièrement sur

le site du fabricant à l’adresse :

C:\Program Files (x86)\Arduino\reference\www.arduino.cc\en\Reference

Dans l’IDE Arduino, on peut avoir accès directement à la référence du langage :

Tout le langage Arduino est

accessible sous forme de lien
hypertexte.

Malheureusement, le site de
référence n’est pas traduit dans
sa totalité en français…

5.1. Les fonctions les plus importantes

Les fonctions les plus utilisées lors de la création d’un programme Arduino sont :

pinMode()
digitalWrite()
digitalRead()
delay()
 5.2. La librairie Serial()
Utilisé pour la communication entre la carte Arduino et un ordinateur ou d'autres
appareils (Shield).

Toutes les cartes Arduino ont au moins un port série (également appelé UART ou
USART).
Il communique sur les broches numériques 0 (RX) et 1 (TX) ainsi qu'avec l'ordinateur
via USB. Ainsi, si vous utilisez ces fonctions, vous ne pouvez pas également utiliser
les broches 0 et 1 pour l'entrée ou la sortie numérique.

Le langage Arduino propose en standard une librairie de fonctions dédiées à la

communication au travers d’un port série.
Cette librairie est nécessaire pour établir une communication entre la carte Arduino et
d’autres éléments électroniques.

La librairie Serial() s’utilise le la manière suivante :

Serial.nom de la fonction(paramètres)

Ci-contre, la liste des fonctions de la librairies Serial()

6. LES ACCESSOIRES

6.1. La carte de prototypage ou Breadboard

L'objectif d'une " breadboard" est de pouvoir faire des connexions simplement entre
des composants (résistances, LEDs, Capacités, etc ...) sans souder. Elle est idéale
pour tester un circuit ou réaliser un montage temporaire.

Techniquement, une breadboard est une plaque pleine de trous reliés entre eux
selon un schéma bien spécifique et commun à toutes les plaques que voici :

Principe de câblage

6.2. Les câbles Dupont

Les câbles Dupont servent à réaliser des connexions
entre la carte Arduino et les différents composants
positionnés ou non sur la carte de prototypage
(breadboard).

Il existe des câbles Mâle/mâle ou Femelle/Femelle.

7. PREMIER PROGRAMME ARDUINO

J’allume un Led
Une LED est un dispositif opto-électronique capable d'émettre de la lumière lorsqu'il
est parcouru par un courant électrique.
Une LED est polarisée, c’est-à-dire qu’elle a une anode et une
cathode.
Pour s’allumer, une LED d ou DEL (light-emitting diode ou diode
électroluminescente) doit être parcourue par une tension de
l’anode vers la cathode (sens du courant électrique).

L’anode est toujours sur la patte la plus longue.

Le tableau ci-contre donne
les intensités et les tensions
pour chaque type de LED
avec une alimentation de
5V.

Nous allons utiliser une LED rouge dont la tension est comprise entre 2,1 et 2,3 V. La
tension nominale de la carte Arduino est donc trop élevée pour cette LED. Il va falloir
réguler cette tension. C’est le rôle des résistances.
Les résistances utilisent une propriété physique : l'aptitude d'un matériau conducteur
à s'opposer au passage d'un courant électrique sous une tension électrique donnée.
Selon la loi d’Ohm :

U=RxI

𝑼
Pour calculer la valeur d’une résistance : 𝑹=
𝑰

La valeur la plus proche de la résistance dont nous disposons est 220 ohms.

Pour plus d’infos : https://www.apprendre-en-ligne.net/crypto/passecret/ohm.html

 7.1. Matériel nécessaire

7.2. Sketch

7.3. Premier programme

Le développement d’un projet sous Arduino nécessite les phases suivantes :

1. Lancer l’IDE Arduino en cliquant sur l’icône ;

2. Sélectionner le port série sur lequel est connecté la carte Arduino

3. Editer le programme à partir de l’IDE Arduino ;

 4. Vérifier et compiler le code à l’aide du bouton « Vérifier ».

5. Charger le programme dans la carte Arduino avec le bouton « Téléverser »

6. Vérifier le fonctionnement du programme sur la carte Arduino.

Astuce :

Lors de la vérification d’un programme, Arduino IDE n’affiche que des informations
synthétiques.
Il est difficile quelques fois de comprendre l’origine d’un problème de vérification dans
un programme.

Pour avoir plus de détails, il faut activer 2 options.

Dans Fichier > Préférences

Cocher compilation et téléversement et valider par OK.

8. TRAVAUX PRATIQUES

TP 01

Sketch : montage avec 2 LEDs

1. Allumer les LEDs en même temps

2. Allumer les LEDS indépendamment l’une de l’autre.

TP 02

Sketch : montage avec 3 LEDs

1. Allumer les LEDs en même temps

2. Allumer les LEDs de gauche à droite indépendamment l’une de l’autre avec une
temporisation de 0,5 seconde.
3. Allumer les LEDs de droite à gauche indépendamment l’une de l’autre avec une
temporisation de 0,5 seconde.
4. Faire un chenillard aller/retour