Electronique Programmable Cours Ingénieur Arduino

Electronique Programmable
CHAPITRE 2 : INITIATION A L’UTILISATION D’UNE CARTE ARDUINO

Objectif spécifique :
Connaître la description matérielle d’une carte Arduino UNO R3, comprendre son principe de
fonctionnement et apprendre les bases de sa programmation.
Introduction
Arduino est le nom d’une gamme de cartes électroniques à microcontrôleurs.
Une carte Arduino est donc une carte électronique programmable construite autour
du microcontrôleur associé à d’autres composants électroniques et disposant
d’interfaces pour l’alimentation électrique, la programmation et la communication
avec d’autres composants et modules électroniques externes.
Ce matériel peut être utilisé pour piloter un système embarqué grâce à un programme
informatique qui assure l’acquisition de données, le traitement informatique de ces
données et la transmission des ordres selon une stratégie prédéfinie.
Il existe une multitude de familles de cartes Arduino parmi lesquelles nous avons :
─ La carte Arduino UNO
─ La carte Arduino Leonardo.
─ La carte Arduino Mega
─ La carte Arduino Due.
─ La carte Arduino Esplora.
─ La carte Arduino Mini.
─ La carte Arduino Nano.
─ La carte Arduino Yun.
─ La carte Arduino MKR
─ La carte Arduino Zéro
Les cartes Arduino disposent d’un langage et d’un environnement de programmation
de base qui permettent de programmer toutes les cartes Arduino en fonction du
INP-HB/DFR Génie Électrique et Électronique
comportement désiré.
Dans le cadre de ce cours nous étudierons la carte Arduino UNO plus précisément
sa version 3 (R3).
1
KONE Siriky Youssouf Édition 2022
1. Présentation physique de la carte Arduino UNO

1.1. Description matérielle
Une carte Arduino UNO est une carte électronique programmable construite autour
du microcontrôleur ATmega328P associé à d’autres composants électroniques et
disposant de connecteurs Jack, USB, ICSP et GPIO servant d’interfaces pour
l’alimentation électrique, la programmation et la communication avec d’autres
composants et modules électroniques externes.
La description d’un point de vue physique de la carte Arduino UNO met en évidence
dix (10) principales composantes matérielles. Ci-dessous le schéma annoté de la carte
Arduino UNO.
Connecteur GPIO
MCU ATmega328P
Connecteur ICSP
Connecteur GPIO Connecteur Jack DC
Oscillateur à
quartz 16 MHz
Régulateur intégré
MCU ATmega16U2 de tension 3,3V
Connecteur ICSP Régulateur intégré
de tension 5V
Bouton RESET
Connecteur USB type B
Figure 1 : Schéma annoté de la carte Arduino UNO R3
 Microcontrôleur ATmega328P
Il s’agit d’un microcontrôleur 8 bits de la famille AVR créé par la société ATMEL
avec une architecture RISC avancée. C’est l’élément central de la carte Arduino UNO.
Il est chargé de recevoir le programme informatique en le stockant dans sa mémoire

puis de l’exécuter. C’est grâce à ce programme que la carte Arduino UNO peut
communiquer avec les autres composantes du système électronique intelligent.
Figure 2 : Microcontrôleur ATmega328P
2
Le microcontrôleur ATmega328P dispose de 32 Ko de mémoire FLASH pour

stocker le programme dont 0,5 Ko utilisée par le bootloader (programme de
démarrage). Il a également 2 Ko de mémoire volatile SRAM de données et 1 Ko de
mémoire EEPROM pour le stockage de données semi-permanentes.
Le microcontrôleur ATmega328P exécute les instructions élémentaires à une
fréquence d’horloge de 16 MHz c’est-à-dire 16 millions d’instructions élémentaires
par seconde. Ce signal horloge est généré par un oscillateur à quartz de 16 MHz
(CSTCE16M0V53-R0).
 Connecteur USB type B
Il s’agit d’un connecteur USB de type B qui peut être utilisé pour
alimenter électriquement la carte Arduino UNO (5V/500mA),
reprogrammer le microcontrôleur ATmega328P en reliant la
carte Arduino à un ordinateur ou pour communiquer avec la
carte Arduino via le « moniteur série » du logiciel Arduino IDE.
La connexion entre la carte Arduino et l’ordinateur ou le chargeur électrique se fait
à l’aide d’un câble USB de type A/B.
Figure 3 : Câble USB de type A/B

La communication entre un ordinateur et une carte Arduino UNO R3 est assurée
par le microcontrôleur ATmega16U2 qui est programmé comme un convertisseur
USB-UART. En effet, le MCU ATmega16U2 assure la communication entre le port

série UART et le port USB à l’aide d’un firmware spécial téléchargé dans sa mémoire.
Figure 4 : Microcontrôleur ATmega16U2
3
 Connecteur Jack DC
La carte Arduino UNO dispose d’un connecteur Jack DC
via lequel la carte peut être directement alimentée.
L’alimentation via ce connecteur doit être comprise entre
7V et 12V.
Ce connecteur est relié à un régulateur intégré de tension de 5V (NCP1117ST50T3G)
qui permet de fournir une tension continue et stable de 5V au microcontrôleur
ATmega328P et à d’autres éléments fonctionnant en 5V DC.
Figure 5 : Régulateur intégré de tension NCP1117ST50T3G
 Connecteur ICSP
Le connecteur ICSP (In-Circuit Serial Programming) est une connectique qui permet
entre autre de programmer directement le microcontrôleur ATmega328P sur les
couches les plus basses en langage bas niveau (bootloader, code ASM, etc.).
Le second connecteur ICSP permet de programmer directement le microcontrôleur
ATmega16U2.
 Bouton RESET
Le bouton RESET, une fois appuyé, permet de faire une réinitialisation matérielle de
la carte Arduino UNO en ramenant tous ses paramètres à leurs valeurs par défaut
c’est-à-dire toutes les variables sont réinitialisées à leurs valeurs d’origine et tous les
ports actifs sont désactivés et réinstallés.

Cette réinitialisation peut aussi être réalisée en appliquant un niveau bas sur le port
RESET du connecteur GPIO de la carte Arduino de manière matérielle ou logicielle.
 Connecteurs GPIO
Un connecteur GPIO (General Purpose Input/Output) est un support physique
permettant d’accéder à un ensemble de ports GPIO qui sont des ports
d'entrées/sorties à usage général très utilisés dans le domaine de l'électronique
embarquée pour permettre à une carte électronique programmable de communiquer
avec d’autres composants ou modules électroniques.
Les connecteurs GPIO de la carte Arduino UNO R3 dispose de :
4
 1 port NC
Ce port Non Connecté (NC) est une prévision d'usages ultérieurs.
 1 port IOREF
Ce port donne la tension de fonctionnement de la carte Arduino UNO.
 1 port RESET
Ce port est utilisé pour permettre une réinitialisation de la carte de
manière matérielle ou logicielle.
 1 port 3.3V
Ce port d’alimentation est utilisé par la carte Arduino UNO pour délivrer
une tension de 3,3V avec un courant maximal de 50 mA grâce à un
régulateur intégré de tension interne (LP2985-33DBVR) afin d’alimenter
des composants ou modules externes fonctionnant avec du 3.3 V.
 1 port 5V
Ce port d’alimentation est utilisé par la carte Arduino UNO pour délivrer
une tension de 5V avec un courant maximal de 500 mA afin d’alimenter des
composants ou modules externes fonctionnant avec du 5V.
 3 ports GND
Ces ports GND (GROUND) sont interconnectés à la masse (potentiel 0V) de la
carte Arduino UNO et peuvent être utilisés comme masse pour les différents
composants ou modules externes.
 1 Port Vin
Ce port est utilisé pour alimenter la carte Arduino UNO depuis une source
d’alimentation externe de 7V à 12V avec un courant maximal de 500 mA. Il est relié
au circuit d’alimentation principale de la carte Arduino UNO.
 6 ports d’entrées analogiques (A0 à A5)
La carte Arduino UNO dispose de 6 ports d’entrées analogiques numérotés A0, A1,
A2, A3, A4 et A5. Chaque port analogique permet de lire un signal analogique
provenant d’un capteur ou d’un circuit de commande. La carte Arduino UNO

dispose de 6 Convertisseurs Analogique/Numérique (CAN) 10 bits intégré au
microcontrôleur ATmega328P pour la conversion du signal analogique reçu par
chacun des 6 ports en signal numérique avant le traitement informatique par le
microcontrôleur. Par défaut ces ports reçoivent une tension analogique comprise
entre 0V et 5V correspondant à une valeur numérique comprise entre 0 et 1023. Mais
il est possible de modifier la référence supérieure de la plage de mesure en utilisant
le port AREF. Ces 6 ports d’entrées analogiques peuvent être configurés de façon
logicielle pour être utilisés comme des ports d’entrées/sorties numériques.
5
 14 ports d’entrées/sorties numériques (0 à 13)

La carte Arduino UNO dispose de 14 ports d’entrées/sorties
numériques identifiés sur la carte par la numérotation 0 à 13. Chaque
port numérique permet de lire ou de transmettre un signal numérique.
Le signal numérique peut avoir deux (02) états possibles, soit un état
HAUT (tension de 5 Volts avec un courant nominal de 20 mA), soit un
état BAS (tension de 0 Volt).
 1 port AREF
Ce port est utilisé pour définir la tension de référence des ports d’entrées
analogiques.
 1 interface I2C (SDA, SCL)
Il s’agit des 2 ports au-dessus du port AREF sans nom. Ce sont, du haut
vers le bas, les ports SCL et SDA pour I2C (Inter Integrated Circuit).
Cette interface I2C est également connectée aux ports analogiques A4
(SDA) et A5 (SCL).
 Ports spécifiques des connecteurs GPIO

Certains ports des connecteurs GPIO peuvent être utilisés pour réaliser des fonctions
spécifiques :
─ la génération de signaux PWM ;
─ la communication par liaison série UART, I2C ou SPI ;
─ le déclenchement d’une interruption externe.
 Ports de sortie PWM
Les 6 ports d’entrées/sorties numériques identifiés sur la carte Arduino UNO par la
numérotation 3, 5, 6, 9, 10 et 11 précédée du symbole « ~ » sont des ports de sortie
PWM (Pulse-Width Modulation) 8 bits. Ces ports permettent de générer une tension
modulée par largeur d'impulsion dont la valeur moyenne se situe entre 0V et 5V, et
ce, en alternant l’état bas (0V) et l’état haut (5V) et en contrôlant la largeur
d'impulsion (0 à 255).
Figure 6 : Tension PWM et valeur moyenne
6
 Interface série UART

La carte Arduino UNO dispose de 2 ports d’entrées/sorties numériques qui peuvent
être utilisés comme interface série du circuit UART (Universal Asynchronous
Receiver/Transmitter) de la carte Arduino UNO. Il s’agit des ports numéro 0 (RX)
et numéro 1 (TX).
L’interface série permet à la carte Arduino UNO de communiquer avec un circuit
électronique disposant d’une interface série UART par liaison série asynchrone full-
duplex à travers les ports de réception (RX) et de transmission (TX) de données
comme le montre la figure ci-dessous.
Figure 7 : Liaison série UART

Lorsque le port USB type B de la carte Arduino UNO est en cours d’utilisation pour
la communication série via le circuit UART, les ports RX et TX sont
automatiquement occupés par cette connexion.
Notons aussi que tous les autres ports numériques de la carte Arduino UNO peuvent
être configurés de manière logicielle pour la communication par liaison série UART.
 Interface SPI
être utilisés comme interface SPI (Serial Peripheral Interface). Il s’agit des ports
numéro 10 (SS), 11 (MOSI), 12 (MISO) et numéro 13 (SCLK).
Cette interface SPI permet à la carte Arduino UNO de communiquer avec un circuit
électronique disposant d’une interface SPI par liaison série synchrone full-duplex
selon une architecture maître/esclave comme le montre la figure ci-dessous.
Figure 8 : Liaison SPI

Le port SCLK permet d’envoyer le signal d’horloge pour la synchronisation. Le port
MOSI permet d’envoyer les données à l’esclave. Le port MISO permet au maître de
recevoir les données. Et le port SS permet de sélectionner l’esclave.
Plusieurs esclaves peuvent coexister sur un même bus. Les ports SPI sont également
connectés sur le connecteur ICSP
7
 Interface I2C
La carte Arduino UNO dispose de 2 ports d’entrées analogiques qui peuvent être
utilisés comme interface I2C (Inter Integrated Circuit). Il s’agit des ports analogiques
A4 (SDA) et A5 (SCL).
L’interface I2C (Inter Integrated Circuit) permet à la carte Arduino UNO de
communiquer par liaison série synchrone bidirectionnel half-duplex avec des circuits
électroniques disposant d’une interface I2C, grâce à seulement deux fils, un fil pour
le signal de donnée (SDA) et l’autre pour le signal d'horloge (SCL).
Une des particularités de la liaison I2C est que l'on peut faire communiquer le maître
(en général le microprocesseur) avec plusieurs esclaves (les autres circuits) en les
reliant tous au même bus. Il faut uniquement mettre deux résistances de tirage sur
les lignes SDA et SCL.
Figure 9 : Liaison I2C
 Ports d’interruptions externes

être utilisés comme ports d’interruptions externes. Il s’agit des ports numéro 2
(INT0) et numéro 3 (INT1).
Ces ports interruptions externes permettent à la carte Arduino UNO d’interrompre
momentanément le programme principal en cours d’exécution lorsqu’un évènement

est détecté sur l’un de ces ports et de déclencher automatiquement l’exécution d’un
autre programme appelé programme d’interruption ou routine d’interruption ou
encore ISR (Interrupt Service Routine). Quand l’exécution du programme
d’interruption est terminée, le programme principal reprend à l’endroit exact où il
s’était interrompu.
En général, une interruption est utilisée lorsque l’évènement extérieur est aléatoire,
bref et surtout prioritaire. En termes de priorité, une interruption sur le port INT0
est prioritaire sur une interruption sur le port INT1.
8
1.2. Caractéristiques techniques d’une carte Arduino UNO

Les caractéristiques de la carte Arduino UNO peuvent être résumées à travers les
principaux éléments ci-dessous.
 Microcontrôleur : ATMega328P, 16 MHz
 Mémoires : Flash 32 Ko, SRAM 2 Ko, EEPROM 1 Ko
 Interfaces :
─ 14 ports d'entrées/sorties numériques (0V/5V) dont 6 PWM
─ 6 ports d’entrées analogiques 10 bits
─ UART, I2C et SPI
 Intensité maximale par GPIO : 40 mA (200 mA pour l'ensemble des E/S)
 Alimentation en énergie électrique :
─ 5V/500 mA via le port USB type B
─ 7V à 12V/500 mA via le port Jack
─ 7V à 12V/500 mA via le port Vin
 Langage de programmation : Assembleur, C, C++, C Arduino, Python, etc.
Le brochage de la carte Arduino UNO R3 se présente comme suit :
Figure 10 : Brochage de la carte Arduino UNO R3
9
1.3. Fonctionnement de la carte Arduino Uno

La carte Arduino UNO peut jouer le rôle de l’unité de traitement informatique dans
un système embarqué.
En effet, par le biais de ses interfaces d’entrées/sorties, la carte Arduino UNO reçoit
les informations sur son environnement et les consignes de commande et les traitent
à l’aide du programme informatique embarqué. Le traitement des données engendre
éventuellement l’envoie des ordres et/ou données via les interfaces d’entrées/sorties
pour produire des effets sur l'environnement.
Pour que le système embarqué fonctionne de manière autonome, le programme
informatique en charge du traitement des données reçues et de l’envoie des ordres
et/ou données doit s’exécuter en boucle infinie.
Le fonctionnement à l’intérieur de cette boucle infinie est représenté par la figure
ci-dessous.
TANT QUE (Toujours Vrai) FAIRE :
 Acquisition de données
 Traitement de données
 Transmission des ordres
FIN TANT QUE
Figure 3 : Fonctionnement en boucle infinie
On distingue trois (03) modes de fonctionnement à l’intérieur de la boucle infinie :

─ Le mode cyclique ;
─ Le mode événementiel ;
─ Le mode mixte.
10
2. Présentation des langages et des outils logiciels de programmation

2.1. Langage de programmation « C Arduino »
Un langage de programmation est un langage informatique permettant à un être
humain d'écrire un code source qui sera analysé et exécuté par un système à
microprocesseur.
Un langage de programmation est mis en œuvre par un traducteur automatique
appelé compilateur. Le compilateur est un programme informatique qui transforme
un code source écrit dans un langage de programmation donné en un code objet en
langage machine qui pourra être directement exécuté par un ordinateur.
Les cartes Arduino offrent la possibilité d’être programmée en plusieurs langages de
programmation, entre autres les langages :
─ Assembleur
─ C
─ C++
─ C Arduino
─ Python
─ Scratch
Pour ce cours de carte électronique programmable, comme langage de
programmation nous utiliserons le langage « C Arduino ». C’est le langage principal
pour programmer une carte Arduino. Très proche du langage C/C++ c’est un
langage facile à apprendre avec une forte communauté et des ressources
documentaires accessibles.
2.2. Logiciel de programmation IDE Arduino
Pour programmer une carte Arduino, nous utiliserons le logiciel IDE Arduino. C’est
un environnement de développement intégré open source, gratuit et multiplateforme
(Windows, Linux et Mac) et qui comprend :

─ Un éditeur de code qui sert à écrire facilement un programme ;
─ Un compilateur qui permet de corriger les fautes de syntaxe dans les
programmes, d’éditer les liens (linker), de traduire les instructions en binaire
(traducteur), de transmettre les instructions du PC à la carte ARDUINO
(fonction de transfert) ;
─ Un ensemble de fonctions stockées dans une bibliothèque ;
─ Un langage de programmation. Il s’agit du « C Arduino ».
Pour télécharger l’IDE Arduino, il faut se rendre sur le site officiel Arduino à travers
ce lien https://www.arduino.cc/en/software.
11
L’interface de l’IDE Arduino peut être décomposée en quatre (04) zones comme
l’illustre la figure ci-dessous.
Figure 11 : Interface de l’IDE Arduino
 Zone 1 : la barre des menus

Cette zone contient les menus qui permettent d'accéder à toutes les fonctionnalités
de l’IDE Arduino. Il s’agit des menus « Fichier », « Edition », « Croquis », « Outils »
et « Aide ». Ci-dessous nous avons par exemple le contenu du menu « Croquis ».
Figure 12 : Contenu du menu « Croquis »
12
 Zone 2 : la barre des boutons

Cette zone contient les boutons qui servent à programmer les différentes cartes
Arduino et d’autres cartes compatibles. Ces boutons donnent un accès direct aux
fonctions essentielles de l’IDE Arduino.
La barre des boutons permet de vérifier la syntaxe et de transférer les programmes,
créer, ouvrir et enregistrer le code, et ouvrir le moniteur série.
Vérifier : Vérifie ou compile le code à la recherche d'erreur.
Téléverser : Compile le code et le transfère vers la carte Arduino.
Nouveau : Crée un nouveau code (ouvre une fenêtre d'édition vide)
Ouvre la liste de tous les programmes avec la possibilité d’ouvrir un

Ouvrir :
programme sélectionné dans la fenêtre courante.
Enregistrer : Enregistre votre programme.
Moniteur
Ouvre la fenêtre du moniteur (ou terminal) série.
Série :
La fenêtre du moniteur (ou terminal) série permet d'afficher des messages textes
reçus par la carte Arduino et d'envoyer des caractères vers la carte Arduino.
Cette fonctionnalité permet de faciliter la mise au point des programmes à travers
l'affichage sur l'ordinateur de l'état de variables, des résultats de calculs ou de
conversions analogique-numérique : un élément essentiel pour améliorer, tester et
corriger ses programmes.
 Zone 3 : l'éditeur de texte

Cette zone est l'éditeur de texte. C’est la zone qui va contenir le programme que nous
allons élaborer.
 Zone 4 : la console de texte
Cette zone est la console de texte. Elle permet d’afficher des informations liées à la
compilation ou au téléversement du programme avec éventuellement les messages
d’erreur détaillés et autres informations utiles.
13
2.3. Bibliothèques Arduino

Une bibliothèque ou une librairie Arduino est un ensemble de fonctions utilitaires,
regroupées et mises à disposition des utilisateurs de l'IDE Arduino afin de ne pas
avoir à réécrire des programmes parfois complexes. Les bibliothèques permettent de
faciliter la programmation et l’exploitation des cartes Arduino et des composants et
modules électroniques associables. Les fonctions sont regroupées selon leur
appartenance à un même domaine conceptuel.
Plusieurs bibliothèques externes sont incluses par défaut dans l’IDE Arduino. Nous
pouvons citer entre autres :
 LiquidCrystal : pour contrôler les afficheurs LCD.
 Servo : pour contrôler les servomoteurs.
 GSM : pour la connexion à un réseau GSM/GRPS à l’aide d’un module GSM.
 SPI : pour interfacer des modules électroniques à l’aide de l’interface SPI.
 SoftwareSerial : pour établir une communication sérielle supplémentaire sur
n’importe quel port d’entrées/sorties numérique.
 Wire : pour interfacer des modules électroniques à l’aide de l’interface I2C.
D'autres bibliothèques sont disponibles en téléchargement sur le site officiel Arduino
(https://www.arduino.cc/reference/en/libraries) et sur d’autres sites.
2.4. Installation de bibliothèques
Pour installer une bibliothèque dans l’IDE Arduino il faut au préalable télécharger le
dossier .zip de la bibliothèque. Une fois que le téléchargement de la bibliothèque est
terminé, il existe deux méthodes pour l’installer.
La première méthode consiste à exécuter l’IDE Arduino et à aller dans
« croquis/Inclure une bibliothèque/Ajouter la bibliothèque .ZIP ».
A partir de là, il suffit de sélectionner le dossier .zip de la bibliothèque et terminer
l’installation en cliquant sur « Ouvrir ».
La deuxième méthode consiste à décompresser le dossier .zip de la bibliothèque et le

déposer dans le dossier « Librairies » de l’IDE Arduino en allant dans
« C:\Users\*Nom_Utilisateur*\Documents\Arduino\libraries ».
Une fois que cela est fait, il suffit de relancer l’IDE Arduino afin de prendre les
modifications en compte.
14
3. Exploitation de la carte Arduino UNO

3.1. Structure générale d’un programme Arduino
La structure générale d’un programme en langage « C Arduino » pour l’exploitation
d’une carte Arduino dans un système embarqué se décompose en trois (03) parties
essentielles :
 L’en-tête déclarative
Cette première partie comprend la déclaration des bibliothèques, la définition des
constantes, la déclaration des variables globales et la déclaration des fonctions.
 Le programme principal
Cette partie peut être scindée en deux (02) blocs :
Le premier bloc du programme principal comporte les éléments liés à la
configuration et à l’initialisation matérielle et logicielle du système. Le contenu de ce
bloc est placé à l’intérieur de la fonction « void setup() » qui s’exécute une seule fois
et au début de l’exécution du programme principal lorsque la carte Arduino est
alimentée.
Le second bloc du programme principal comporte les éléments liés à l’acquisition de
données, au traitement de données et à la transmission d’ordres et/ou de données
du système. Le contenu de ce bloc est placé à l’intérieur de la onction « void loop() »
qui s’exécute en boucle infinie. L’exécution des instructions dans ce bloc se poursuit
jusqu’à ce que la carte Arduino ne soit plus alimentée ou jusqu’à un RESET.
 Les programmes secondaires
Cette dernière partie est dédiée aux autres fonctions en dehors des fonctions « void
setup() » et « void loop() ». Les fonctions de cette partie sont appelées dans le
programme principal.
L’une des manières de représenter le déroulement d’un programme est

l’organigramme. Ci-dessous l’organigramme général d’un programme Arduino.
15
Début
En-tête déclarative
Configuration
void setup()
Initialisation
Acquisition
Traitement void loop()
Transmission
Fin
Figure 13 : Organigramme général d’un programme Arduino

16
3.2. Base de la programmation en langage C Arduino

La programmation d’une carte Arduino en langage C Arduino passe par la
connaissance de certains éléments de base du langage C Arduino.
 Syntaxe de base et opérateurs
 Syntaxe de base
Le point-virgule (;) est obligatoire à la fin d’une instruction.
Les accolades ({}) marquent le début et la fin d'un bloc d’instructions.
Le double slash (//) indique un commentaire sur une ligne.
Le slash étoile (/*) et l’étoile slash (*/) encadrent un commentaire sur plusieurs
lignes.
 Quelques opérateurs
Opérateurs arithmétiques
Egalité =
Addition +
Soustraction -
Multiplication *
Division /
Modulo %
Opérateurs de comparaison
Egal à ==
Différent de !=
inférieur à <
supérieur à >
inférieur ou égal à <=
supérieur ou égal à >=
Opérateurs booléens
ET booléen &&
OU booléen ||
NON booléen !
17
 Quelques structures de contrôles conditionnelles

Les structures de contrôles conditionnelles sont des blocs qui permettent de tester si
une condition est vraie pour faire un traitement.
 Structure de contrôle « if »
La structure « if » est la structure de test la plus basique. Elle permet d’exécuter une
série d’instructions si une condition est vraie.
Syntaxe :
if (condition)
{
// Instructions à exécuter si la condition est vraie.
Traitement 1;
}
 Structure de contrôle « if … else »

La structure « if … else » permet d’exécuter une série d’instructions si une condition
est vraie avec une exécution alternative lorsque la condition est fausse.
Syntaxe :
if (condition)
{
// Instructions à exécuter si la condition est vraie.
Traitement 1;
}
else
{
// Instruction à exécuter si la condition est fausse.
Traitement21;
}
 Structure de contrôle « switch … case »

La structure « switch … case » permet de faire plusieurs tests sur une condition. La
structure « if … else » permet aussi de faire plusieurs tests mais avec beaucoup
d'imbrications de structures les unes dans les autres. La structure switch case simplifie
donc bien la chose.
18
Syntaxe :
Switch (Variable)
{
case valeur1 :
// Instructions à exécuter dans le cas où la variable « Variable » vaut « valeur1 ».
Traitement 1;
break ;
case valeur2 :
// Instructions à exécuter dans le cas où la variable « Variable » vaut « valeur2 ».
Traitement 2;
break ;
default :
/* Instructions à exécuter dans le cas où la variable « Variable » vaut une valeur
autre que « valeur1 » et « valeur2 ».*/
Traitement 3;
break ;
}
 Structures de contrôles de répétitions ou d’itérations
Les structures de contrôles de répétitions ou boucles sont des blocs qui permettent
de tester si une condition est vraie pour faire des traitements répétitifs (en boucle).
 Structure de contrôle « for »
La structure « for » permet d’exécuter le même bloc instructions plusieurs fois. Il faut
donc prévoir une variable qui sert de compteur, sa valeur initiale, sa valeur finale et
son pas d'incrémentation. Quand la variable atteint la valeur finale précisée, la boucle
s'arrête.
Syntaxe :
for (initialisation ; condition ; opération sur la variable de boucle)

{
// Instruction à exécuter tant que la condition est vraie.
Traitement ;
}
Elle est généralement utilisée lorsque l'on veut répéter une action un nombre de fois
connu.
19
 Structure de contrôle « while »

La structure « while » exécute le même bloc plusieurs fois. Elle signifie littéralement:
« Tant que la condition est vrai, faire le traitement ».
Syntaxe :
while (condition)
{
// Instruction à effectuer tant que la condition est vraie.
Traitement ;
}
 Structure de contrôle « do … while » (faire … tant que)

Il existe une variante de la structure précédente, nommée « do … while ». Dans ce
cas, le bloc d’instruction est exécuté une fois puis la condition est évaluée.
Syntaxe :
do
{
// Instructions à exécuter tant que la condition est vraie.
Traitement ;
}
while (condition);
Les instructions à l’intérieur de la boucle sont toujours exécutées au moins une fois.
 Les instructions de ruptures de séquence

Le langage C Arduino propose plusieurs instructions qui permettent d'altérer le
contrôle de boucles itératives, soit en forçant le programme à passer à l'itération
suivante sans finir d'exécuter les instructions correspondant à celle qui est en cours,
soit en forçant le programme à quitter la boucle, comme si la condition était fausse.
 Instruction « continue »
L'instruction « continue » permet de passer au cycle suivant d'une boucle sans
exécuter les instructions restantes de l'itération en cours.
Syntaxe : continue ;
20
 Instruction « break »
Cette instruction permet de sortir d’une boucle d’itération. Il ne peut sortir que d’un
niveau d’accolade.
Syntaxe : break ;
 Instruction « goto »
Il s’agit d’une instruction de saut inconditionnel permettant de renvoyer l'exécution
du programme vers une étiquette. Ce saut systématique entraîne une rupture du flot
d'exécution.
Syntaxe :
goto LABEL ;
// Instructions à sauter
LABEL :
 Instruction « return »
Cette instruction provoque la fin de l’exécution de la fonction dans laquelle elle se
trouve et un retour à la fonction appelante.
Syntaxe :
return ;
ou
return (expression) ;
21
 Déclaration des bibliothèques

Après avoir installé une bibliothèque, il faut par la suite l’importer au début du
programme.
Syntaxe : #include <Nom_Bibliothèque.h>
Cette instruction permet d’inclure la bibliothèque au programme et donc d’utiliser
les fonctions qu’elle contient. Les fonctions qu'elle contient peuvent alors être
appelées au même titre que les fonctions de base.
Exemples :
Pour gérer la communication par protocole SPI
#include <SPI.h>
Pour gérer la communication par liaison série
#include <SoftwareSerial.h>
Pour gérer la connexion à un réseau GSM / GRPS
#include <GSM.h>
Pour gérer les écrans alphanumériques LCD
#include <LiquidCrystal.h>
Pour gérer les capteurs DHT (DHT11, DHT22, etc.)
#include <DHT.h>
 Définition des constantes
Une constante est un espace mémoire réservé pour stocker des données constantes
pendant l’exécution du programme. Elle est caractérisée par un nom, un type et une
valeur constante.
Il s’agit principalement de la définition des ports GPIO, c’est-à-dire de
l’établissement d’une correspondance entre le numéro d’un port GPIO et un nom
significatif attribué au port GPIO. Seuls les ports GPIO via lesquels la carte Arduino
interagit avec son environnement sont à définir pour faciliter la compréhension et

éventuellement la modification du code.
Ne jamais définir les ports 3,3V ; 5V ; Vin et GND.
 Définition d’une constante avec « const »
Syntaxe : const Type Nom_Constante = Valeur ;
Ex : const int LED_VERTE = 3 ;
22
 Définition d’une constante avec « #define »

Syntaxe : #define Nom_Constante Valeur
Ex : #define LED_VERTE 3
Le compilateur remplace le nom de la constante par la valeur associée.
 Déclaration des variables et portée
Une variable est un espace mémoire réservé pour stocker des données. Elle est
caractérisée par un nom, un type et une valeur modifiable pendant l’exécution du
programme.
 Déclaration d’une variable
Syntaxe : Type Nom_ variable = Valeur ;
Ex : int delai = 30000 ;
 Portée d’une variable
Une variable locale est une variable qui n’est visible que dans la fonction où elle est
définie. Quant à une variable globale c’est une variable qui est visible dans tous les
fichiers sources du projet.
 Déclaration des fonctions
Une fonction est une séquence d’instructions permettant de réaliser un calcul ou une
tâche. Elle peut posséder des paramètres d’entrée (des arguments) et peut également
retourner des valeurs de sortie.
Une fonction doit être déclarée une seule fois et peut être appelée plusieurs fois dans
le programme principal.
Syntaxe : TypeFonction NomFonction (TypeParamètre Paramètre) ;
 Procédure ou fonction vide : élaboration et appel

Une procédure ou fonction vide ne renvoie aucune valeur et est de type « void ».
Syntaxe Elaboration de fonction :
void NomFonction ()
{
// Instructions à exécuter
}
Syntaxe Appel de fonction : NomFonction () ;
23
 Fonction : élaboration et appel

Une fonction renvoie une valeur et peut posséder des paramètres d’entrée.
Syntaxe Elaboration de fonction :
Type NomFonction (Type1 Param1, Type2 Param2)
{
Type VariableRenvoyer ;
// Instructions à exécuter
return VariableRenvoyer ;
}
Syntaxe Appel de fonction : NomFonction (Var1, Var2) ;
 Etats des ports GPIO

Un port GPIO numérique peut avoir deux (02) états possibles.
 Etat HAUT (tension de 5 Volts) : « HIGH », « 1 » ou « true »
 Etat BAS (tension de 0 Volt) : « LOW », « 0 » ou « false »
Un port GPIO analogique transforme la tension comprise entre 0 et 5V (par défaut
appliquée) sur son entrée en une valeur numérique entière comprise entre 0 et 1023.
 Configuration ou orientation des ports GPIO
 Port GPIO orienté en « Entrée »
Un port GPIO de la carte Arduino orienté en « Entrée » sert à faire de l’acquisition
de données ou à recevoir des consignes.
Syntaxe :
pinMode(Port, INPUT) ;
pinMode(Port, INPUT_PULLUP) ;
 Port GPIO orienté en « Sortie »
Un port GPIO de la carte Arduino orienté en « Sortie » sert à faire de la transmission
d’un ordre ou de données.
Syntaxe :
pinMode(Port, OUTPUT) ;
24
 Lecture d’un port GPIO

Selon l’orientation d’un port GPIO, la lecture d’un port GPIO peut correspondre à
une acquisition de données ou à une interrogation sur l’état ou la valeur du port.
 Port GPIO orienté en « Entrée »
La lecture d’un port GPIO orienté en « Entrée » correspond à une acquisition de
données.
Syntaxe Port numérique : Valeur = digitalRead(Port) ;
Syntaxe Port analogique : Valeur = analogRead(Port) ;
 Port GPIO orienté en « Sortie »
La lecture d’un port GPIO orienté en « Sortie » correspond à une interrogation de
l’état ou la valeur du port.
Syntaxe Port numérique : Etat = digitalRead(Port) ;
Syntaxe Port PWM : Valeur = analogRead(Port) ;
 Ecriture sur d’un port GPIO
L’écriture sur un port GPIO peut correspondre à la transmission d’un ordre ou de
données.
Syntaxe Port numérique : digitalWrite(Port, Etat_Port) ;
Syntaxe Port PWM : analogWrite(Port, Largeur_Impulsion) ;
La largeur d’impulsion est un entier compris entre 0 (0%) et 255 (100%)
 Inversion de l’état d’un port GPIO
L’inversion de l’état lu d’un port GPIO orienté en « Sortie » s’effectue selon la
syntaxe ci-dessous.
Syntaxe : digitalWrite(Port, not digitalRead(Port)) ;
 Configuration de la tension de référence via le port AREF

La configuration de la tension de référence utilisée avec les entrées analogiques
s’effectue selon la syntaxe ci-dessous.
Syntaxe : analogReference(TypeRef) ;
Cette fonction renvoie la valeur 1023 pour une entrée analogique égale à la tension
de référence.
TypeRef : DEFAULT (5V), INTERNAL (1,1V), EXTERNAL (tension sur la
broche AREF (0 à 5V)).
25
 Scrutage passive (interruption)

L’écoute passive sur un port GPIO peut se faire par l’usage d’une fonction prédéfinie
associée ou non à des structures de contrôle.
 Fonction « attachInterrupt() » :
La fonction « attachInterrupt () » scrute indépendamment un port GPIO
d’interruption externe sans bloquer l’exécution du programme et à la détection d’un
événement sur le port un sous‐programme d’interruption est automatiquement
exécuté.
Exemple :
void setup() {
attachInterrupt(Port_INT, programme_d’interruption , Type_détection) ;
}
void loop() {
}
programme_d’interruption : il s’agit d’une procédure
Type_détection : LOW (0V), HIGH (5V), RISING (front ↑), FALLING (front ↓) ou
CHANGE (↑↓)
 Les fonctions « noInterrupts() » et « interrupts() »
Ces fonctions permettent respectivement de désactiver et de réactiver une
interruption.
 Gestion du temps
Le langage « C Arduino » propose plusieurs fonctions pour gérer le temps.
 Fonction « millis () »
La fonction « millis () » permet de mesurer le temps écoulé en milliseconde (ms)
depuis le démarrage du programme.
Syntaxe : millis () ;
La fonction « millis () » est sans paramètre et elle est capable de mesurer une durée
allant jusqu’à 50 jours. La valeur retournée doit donc être stockée dans une variable
de type « unsigned long ».
26
 Fonction « micros () »
La fonction « micros () » permet de mesurer le temps écoulé en microseconde (μs)
depuis le démarrage du programme.
Syntaxe : micros () ;
La fonction « micros () » est aussi sans paramètre et elle est capable de mesurer une
durée allant jusqu’à 50 jours. La valeur retournée doit donc être stockée dans une
variable de type « unsigned long ».
 Fonction « delay () »
La fonction « delay () » permet de mettre en pause le programme pendant un temps
prédéterminé. C’est une fonction bloquante, car aucune action ne sera effectuée
pendant cette temporisation.
Syntaxe : delay (Param1) ;
Param1 : durée de temporisation en milliseconde (ms).
 Résistances de rappel
Un port GPIO numérique orienté en « Entrée » et non connecté à un état indéfini
dit « flottant ». Une résistance de rappel permet donc de fixer cette « Entrée »
numérique à un état stable (HIGH ou LOW).
Ce problème peut être résolu de manière physique en utilisant une résistance externe
à la carte Arduino ou de manière logicielle en utilisant une résistance interne à la carte
Arduino.
 Résistance Pull up : Résistance de tirage vers le haut (VCC)
Cette approche permet de fixer l’« Entrée » numérique à un état
HIGH en plaçant une résistance entre VCC et le port GPIO.
Syntaxe : pinMode (Port, INPUT_PULLUP);
 Résistance Pull down : Résistance de tirage vers le bas (GND)

Cette approche permet de fixer l’« Entrée » numérique à un état LOW en plaçant une
résistance entre GND et le port GPIO.
Syntaxe : pinMode (Port, INPUT_PULLDOWN);
27

Electronique Programmable Cours Ingénieur Arduino

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Electronique Programmable Cours Ingénieur Arduino

Transféré par

Droits d'auteur :

Formats disponibles

Electronique Programmable

CHAPITRE 2 : INITIATION A L’UTILISATION D’UNE CARTE ARDUINO

1. Présentation physique de la carte Arduino UNO

Il est chargé de recevoir le programme informatique en le stockant dans sa mémoire

Figure 2 : Microcontrôleur ATmega328P

Le microcontrôleur ATmega328P dispose de 32 Ko de mémoire FLASH pour

Figure 3 : Câble USB de type A/B

USB-UART. En effet, le MCU ATmega16U2 assure la communication entre le port

Figure 4 : Microcontrôleur ATmega16U2

Figure 5 : Régulateur intégré de tension NCP1117ST50T3G

ports actifs sont désactivés et réinstallés.

provenant d’un capteur ou d’un circuit de commande. La carte Arduino UNO

 14 ports d’entrées/sorties numériques (0 à 13)

 Ports spécifiques des connecteurs GPIO

Figure 6 : Tension PWM et valeur moyenne

 Interface série UART

Figure 7 : Liaison série UART

Figure 8 : Liaison SPI

Figure 9 : Liaison I2C

 Ports d’interruptions externes

momentanément le programme principal en cours d’exécution lorsqu’un évènement

1.2. Caractéristiques techniques d’une carte Arduino UNO

Figure 10 : Brochage de la carte Arduino UNO R3

1.3. Fonctionnement de la carte Arduino Uno

Figure 3 : Fonctionnement en boucle infinie

On distingue trois (03) modes de fonctionnement à l’intérieur de la boucle infinie :

2. Présentation des langages et des outils logiciels de programmation

(Windows, Linux et Mac) et qui comprend :

Figure 11 : Interface de l’IDE Arduino

 Zone 1 : la barre des menus

Figure 12 : Contenu du menu « Croquis »

 Zone 2 : la barre des boutons

Vérifier : Vérifie ou compile le code à la recherche d'erreur.

Téléverser : Compile le code et le transfère vers la carte Arduino.

Nouveau : Crée un nouveau code (ouvre une fenêtre d'édition vide)

Ouvre la liste de tous les programmes avec la possibilité d’ouvrir un

Enregistrer : Enregistre votre programme.

 Zone 3 : l'éditeur de texte

2.3. Bibliothèques Arduino

La deuxième méthode consiste à décompresser le dossier .zip de la bibliothèque et le

3. Exploitation de la carte Arduino UNO

L’une des manières de représenter le déroulement d’un programme est

Traitement void loop()

Figure 13 : Organigramme général d’un programme Arduino

3.2. Base de la programmation en langage C Arduino

 Quelques structures de contrôles conditionnelles

 Structure de contrôle « if … else »

 Structure de contrôle « switch … case »

for (initialisation ; condition ; opération sur la variable de boucle)

 Structure de contrôle « while »

 Structure de contrôle « do … while » (faire … tant que)

 Les instructions de ruptures de séquence

 Déclaration des bibliothèques

interagit avec son environnement sont à définir pour faciliter la compréhension et

 Définition d’une constante avec « #define »

 Procédure ou fonction vide : élaboration et appel

 Fonction : élaboration et appel

 Etats des ports GPIO

 Lecture d’un port GPIO

 Configuration de la tension de référence via le port AREF

 Scrutage passive (interruption)

 Résistance Pull down : Résistance de tirage vers le bas (GND)

Vous aimerez peut-être aussi

 Zone 1 : la barre des menus

 Zone 2 : la barre des boutons

 Zone 3 : l'éditeur de texte