Notes Du Cours de Systemes Embarques

Ministères de L'Enseignement
supérieur et Universitaire
<<UAK>
Travaux dirigés De systèmes embarques

.
Préparé par :
CT. PATRICE NGUZA
Année universitaire : 2023
P a g e 1 | 50
PARTIE A :
DÉCOUVERTE ET
PRISE EN MAIN
D’ARDUINO
P a g e 2 | 50
1. Présentation ARDUINO
ARDUINO est une plateforme matérielle et logicielle de développement d'applicatio ns
embarquées.
Côté matériel, elle se compose d'une carte électronique basée autour d’un microcontrôle ur
(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 une application Java, libre et multi-
plateformes, servant d’éditeur de code et de compilateur, et qui peut transférer le programme au
travers de la liaison USB. Le langage de programmation utilisé est un mélange de C Avancée et C++,
autre aussi en Java Processing restreint et adapté aux possibilités de la carte.
Les principaux avantages du système ARDUINO sont :
 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.
 Matériel : 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 : Le logiciel ARDUINO et le langage ARDUINO sont disponibles pour être
complétés par des programmeurs expérimentés. Le langage peut être aussi étendu à l'aide de
librairies C++ et JAVA Processing.
 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.…
2. La carte ARDUINO UNO
Le modèle UNO de la société ARDUINO est une carte électronique dont le cœur est un
microcontrôleur ATMEL de référence ATMega328. Le microcontrôleur ATMega328 est un
microcontrôleur 8bits de la famille AVR dont la programmation peut être réalisée en langage C.
P a g e 3 | 50
L s différents éléments
e
Les principales caractéristiques

Microcontrôleur ATMEGA 328
Tension d'alimentation interne 5V
Tension d'alimentation 7 à 12V

(recommandée)
Tension d'alimentation (limites) 6 à 20 V
Entrées/sorties numériques 14 dont 6 sorties PWM

(configurables)
Entrées analogiques 6
Courant max par broches E/S 40 mA (200mA cumulé pour

l’ensemble des broches)
Mémoire programme Flash 32 Ko dont 0,5 Ko sont utilisés par le

bootloader
Mémoire SRAM (mémoire 2 KB

volatile)
Mémoire EEPROM (mémoire non 1 KB

volatile)
Fréquence horloge 16 MHz
P a g e 4 | 50
Dimensions 68.6mm x 53.3mm
L’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. L’alimentatio n
extérieure doit présenter une tension comprise entre 7 à 12V.
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.
Étant disponibles sur connecteurs placés sur le pourtour des cartes, elles permettent également
l’alimentation des modules Shields.
Les entrées-sorties
La carte « ARDUINO UNO » dispose de 14 E/S numériques et de 6 entrées analogiques.
2.4.1. Les 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 et dispose si besoin est d’une résistance interne de ‘pull-up’.
Certaines broches peuvent avoir plusieurs fonctions différentes choisies par programmatio n
décrites ci-dessous :
N° E/S N° ligne de port Fonction
0 PD0 Rx : Entrée liaison série synchrone

1 PD1 Tx : Sortie liaison série synchrone
2 PD2 INT0 : Entrée interruption externe

INT1 : Entrée interruption externe
3 PD3
OC2B : PWM modulation à largeur d’impulsion
T0 : Entrée Timer/compteur 0
4 PD4
XCK : Entrée horloge
T1 : Entrée Timer/compteur 1
5 PD5 OC0B : Sortie module PWM modulation à largeur
d’impulsion
OC0A : Sortie module PWM modulation à largeur
6 PD6 d’impulsion
AIN0 : Entrée comparateur analogique
P a g e 5 | 50
7 PD7 AIN1 : Entrée comparateur analogique
CLKO : Sortie de l’horloge de fonctionnement

8 PB0
ICP1 : Entrée de capture Timer/compteur 1
9 PB1 OC1A : Sortie module PWM modulation à largeur

d’impulsion
SS : Sélect Slave liaison SPI
10 PB2 OC1B : Sortie module PWM modulation à largeur
d’impulsion
MOSI : Sortie liaison SPI

11 PB3 OC2A : Sortie module PWM modulation à largeur
d’impulsion
12 PB4 MISO : Entrée liaison SPI
13 PB5 SCK : Horloge liaison SPI
2.4.2. Les entrées analogiques

Les six entrées analogiques, repérées A0 à A5 (PC0 à PC5), peuvent admettre toute une tension
analogique comprise entre 0 et 5V (par défaut mais cela peut être modifié). Ces entrées analogiq ues
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.
Les mémoires
Le microcontrôleur ATmega 328 dispose de 32ko de mémoire Flash permettant de stocker le
programme à exécuter.
Il contient aussi de 2ko 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 que la n'est plus alimentée.
L’ATmega 328 dispose également 1ko mémoire EEPROM pour permettre au programme de
stocker des données persistantes. Le contenu de cette mémoire est accessible grâce aux fonctions de
la librairie « EEPROM ».
L’horloge
L’horloge est pilotée par quartz et fonctionne à la fréquence de 16 MHz.

La communication
La carte « ARDUINO UNO » a de nombreuses possibilités de communications avec l’extérie ur.
L’Atmega328 possède une interface de communication série accessible, grâce aux broche s
numériques 0 (Rx) et 1 (Tx).
P a g e 6 | 50
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).
Le 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.
La protection de surintensité USB
Par mesure de sécurité pour l'ordinateur auquel sera relié l'ARDUINO, un fusible est présent sur
la connexion d'alimentation 5 V de la prise USB. Toute consommation supérieure à 500mA,
provoque le déclenchement de ce fusible, protégeant ainsi le port USB de l'ordinateur auquel la carte
est reliée.
3. La programmation de la carte ARDUINO

Le logiciel ARDUINO a pour fonctions principales :
 De pouvoir écrire et compiler des programmes pour la carte ARDUINO

 De se connecter avec la carte ARDUINO pour y transférer les programmes
 De communiquer avec la carte ARDUINO
 Comme ARDUINO est « open source », il existe un grand nombre de clones et de platines
compatibles.


 Ici, nous utiliserons le plus connu : l’ARDUINO UNO.

L’interface de programmation
L’interface de programmation du logiciel ARDUINO est la suivante :
P a g e 7 | 50
La « Barre de Boutons » qui donne un accès direct aux fonctions essentielles du logiciel. Les
différents boutons sont :
La structure d’un programme

Un programme destiné à une carte ARDUINO est constitué de 3 parties :
P a g e 8 | 50
void setup()
{
pinMode (ledPin, OUTPUT ) ; // Définit la broche n°13 comme une sortie
}
void loop (
{
)
digitalWrite (ledPin,HIGH ) ; // Met la sortie ledPin au NL1 (diode allumée)
delay(3000) ; // Attendre 3 s
digitalWrite (ledPin,LOW) ; // Met la sortie ledPin au NL0 (diode éteinte)
delay(1000) ; // Attendre 1 s
}
Fonction setup() Fonction loop()

qui contient les instructions d’initialisation qui contient les instructions du programme
La première partie permet de définir les constantes et les variables en déclarant leur type.
Elle permet également l’inclusion des bibliothèques utilisées dans le programme au moyen de
#include.
La fonction setup() contient les instructions d’initialisation ou de configuration des
ressources de la carte comme par exemple, la configuration en entrée ou sorties des broches d’E/S
numériques, la définition de la vitesse de communication de l’interface série, etc.. Cette fonction n’est
exécutée qu’une seule fois juste après le lancement du programme.
La fonction loop() contient les instructions du programme à proprement parlé. Cette fonctio n
sera répétée indéfiniment tant que la carte ARDUINO restera sous tension.
La syntaxe du langage ARDUINO

La cinquantaine d’éléments de la syntaxe ARDUINO est visible ic i
http://www.arduino.cc/en/Reference/HomePage ainsi qu’à partir du document “index.html” (dans le
dossier “Reference” que vous avez téléchargé avec ARDUINO), également accessible dans le menu
“Aide” du logiciel.
Les commentaires
Pour placer des commentaires sur une ligne unique ou en fin de ligne, il faut utiliser la
syntaxe suivante :
// Cette ligne est un commentaire sur UNE SEULE ligne
Pour placer des commentaires sur plusieurs lignes :

/* Commentaire, sur PLUSIEURS lignes qui sera ignoré par le
programme, mais pas par celui qui lit le code */
Les données, variables et constantes

Les différents types utilisés avec la programmation ARDUINO sont :
Nom Description
boolean Donnée logique (true ou false) sur 8 bits
P a g e 9 | 50
byte Entier non signé sur 8 bits
int Entier signé sur 16 bits

unsigned Entier non signé sur 16 bits
int
long Entier signé sur 32 bits

unsigned Entier non signé sur 32 bits
long
float Nombre à virgule flottant sur 32 bits
char Caractère sur 8 bits. Seuls les caractères ayant pour code ASCII
une valeur 0 à 127 sont définis
Une constante peut être définie au moyen de const ou de #define :
//Toute variable N rencontrée dans le programme sera remplacée

#define N
par la valeur 2
2
const
// N est constante de type « byte » et de valeur 2
byte N=2
Un certain nombre de noms de constantes sont prédéfinis dans le langage « ARDUINO » :
Nom Description
true Donnée binaire égale à 1 ou donnée numérique différente de 0

false Donnée binaire ou numérique égale à 0
HIGH Génération d’un niveau de tension haut sur une des sorties
numériques
LOW Génération d’un niveau de tension bas sur une des sorties
numériques
INPUT Configuration d’une broche numérique en entrée
OUTPUT Configuration d’une broche numérique en sortie
Les opérateurs
3.6.1. Les opérateurs arithmétiques
Description Exemple
Symbole
+ Addition c
= a+ b ;
- Soustraction c
=a-b;
* Multiplication c
=a*b;
P a g e 10 | 50
/ Division c
=a/b;
% Modulo (reste de la c
division entière) =a%b
;
3.6.1. Les opérateurs logiques
Symbole Description Exemple

& ET c=a&b;
| OU c=a|b;
^ OU exclusif c=a^b;
~ NON b= ~a;
>> Décalage à droite des c = a >> b ; //a décalé

bits b fois à droite
<< Décalage à gauche c = a << b ; //a décalé

des bits b fois à gauche
3.6.2. Les affectations
Symbole Description Exemple
= Affection ordinaire a=b;

+= Additionner de a += b ; → a = a + b ;
-= Soustraire de a -= b ; → a = a - b ;
*= Multiplier par a *= b ; → a = a * b ;
/= Diviser par a /= b ; → a = a / b ;
%= Reste de la divis io n a %= b ; → a = a % b ;
entière par
&= ET avec a &= b ; → a = a & b ;
|= OU avec a |= b ; → a = a | b ;
-- Soustraire de 1 a -- ; → a = a - 1 ;
(décrémentation)
++ Additionner de 1 a ++ ; → a = a + 1 ;
(incrémentation)
3.6.3. Les opérateurs de comparaisons
Description Exemple
Symbole
P a g e 11 | 50
&& ET logique if
(a &&
b)
|| OU logique if
(a || b)
== Égal à if
(a ==
b)
!= Différent de if
(a != b)
> Supérieur à if
(a > b)
< Inférieur à if
(a < b)
>= Supérieur ou égal à if

(a >=
b)
<= Inférieur ou égal à if

(a <=
b)
P a g e 12 | 50
Les bibliothèques de fonctions
Une bibliothèque est un ensemble de fonctions utilitaires mises à disposition des
utilisateurs de l'environnement Arduino. Les fonctions sont regroupées en fonction de leur
appartenance à un même domaine conceptuel (mathématique, graphique, tris, etc).
L’IDE ARDUINO comporte par défaut plusieurs bibliothèques externes. Pour les
importer dans votre programme, vous devez utiliser le menu suivant :
L'instruction suivante sera alors ajoutée au début de votre programme : #include

<la_bibliothèque.h> Exemple :
//
#include Importation de
<SPI.h> la bibliothèque
SPI
Certaines fonctions sont déjà présentes dans l’IDE ARDUINO, les principales sont
expliquées ci-dessous.
3.7.1. Les fonctions de gestion du temps
La fonction « delay »
delay (tempo) ;
Cette fonction génère une pause dont la durée est égale à tempo × 1 ms.
La variable tempo doit être de type unsigned long ce qui peut autoriser des temporisations qui
peuvent être très longues.
delay(1000) ; // Pause de 1 s
La fonction « delayMicroseconds »
delayMicroseconds (tempo) ;
Cette fonction génère une pause dont la durée est égale à tempo × 1 μs.
La variable tempo doit être de type unsigned int.
La durée de la pause n’est assurée que des valeurs supérieures à 3 μs.
delayMicroseconds (100) ; // Pause de 100 µs
13
La fonction « millis() »
Valeur = millis() ;
Cette fonction retourne le nombre de millisecondes depuis le démarrage du programme
par la carte ARDUINO.
La valeur retournée est de type unsigned long. Le nombre de millisecondes retourne à zéro
environ après 50 jours.
P a g e 10 |
La fonction « micros() »
Valeur = micros() ;
Cette fonction retourne le nombre de microsecondes depuis le démarrage du

programme par la carte ARDUINO. La valeur retournée est de type unsigned long
Cette fonction a une résolution de de 4µs (avec une horloge de 16MHz), La valeur
retournée est donc un
multiple de 4.
Le nombre de millisecondes retourne à zéro environ après 70 minutes.
3.7.2. Les fonctions de gestion des E/S numériques
La fonction « pinMode »
pinMode(Numéro broche, Sens de fonctionnement) ;
Cette fonction permet de configurer le sens de fonctionnement, entrée ou sortie, de la
broche sélectionnée.
pinMode (12,OUTPUT ) ; // La broche 12 est configurée comme une sortie
La fonction « digitalWrite »
digitalWrite(Numéro broche, Niveau logique) ;
Cette fonction permet d’imposer un niveau logique haut ou bas sur la sortie numérique
sélectionnée.
digitalWrite(12,HIGH) ; // La sortie 12 est placée au niveau logique haut (NL1)
14
La fonction « digitalRead »
Valeur = digitalRead(Numéro broche) ;
Cette fonction permet de lire le niveau logique sur l’entrée numérique sélectionnée. Cette
fonction ne retourne que deux valeur HIGH ou LOW.
etat = digitalRead (11) ; // La variable etat est

égale au niveau logique de l’entrée 11
3.7.3. Les fonctions de gestion des sorties PWM

Les μC qui équipent les cartes Arduino sont capables de générer des signaux à
Modulation à Largeur d’Impulsions (MLI) ou « Pulse Width Modulation » (PWM). Il s’agit
de signaux logiques rectangulaires de fréquence égale à 490 Hz et à rapport cyclique
programmable.
La fonction « analogWrite »
analogWrite (Numéro sortie, Rapport cyclique) ;
Cette fonction permet de générer, sur la sortie sélectionnée, un signal PWM avec le rapport
cyclique désiré. La variable « Rapport cyclique » doit être de type int, c’est-à-dire qu’elle peut être
comprise entre 0 et 255 pour un rapport cyclique, pour le signal généré, compris entre 0 et 100 %.
Le signal PWM est généré à partir de l’instant de l’exécution de la fonction « analogWrite » et
jusqu’à ce qu’une nouvelle instruction « analogWrite » ou une instruction « digitalRead » ou «
digitalWrite » soit exécutée sur la même broche.
La valeur du rapport cyclique n’est garantie que pour des valeurs supérieures à 10 %.
analogWrite (2,64) ; // Signal PWM de rapport cyclique de 25 % sur la sortie analogique
3.7.4. Les fonctions de gestion des entrées analogiques

Les entrées analogiques sont connectées à un convertisseur analogique numériq ue
(CAN) 10 bits. La sortie du CAN génère une donnée égale à 0 lorsque la tension d’entrée est
nulle et une donnée égale à 1023 lorsque la tension d’entrée est égale à la tension de référence
du CAN.
15
La fonction « analogReference »
analogReference (Type) ;
Cette fonction permet de définir la tension de référence du CAN.
La variable type peut prendre les valeurs suivantes :
 DEFAUT : La tension de référence est égale à la tension d’alimentation de la carte

Arduino (5V pour la carte Arduino Uno) ;
 INTERNAL : La tension de référence est égale à 1,1 V pour la carte Arduino Uno ;
 EXTERNAL : La tension de référence est égale à la tension appliquée sur l’entrée externe
AREF de la carte Arduino.
La tension appliquée sur une entrée analogique ne doit jamais être supérieure à la
tension d’alimentation de la carte.
La fonction « analogRead »
Valeur = analogRead(Numéro entrée) ;
Cette fonction permet de lire le résultat de la conversion analogique numérique de la tension
présente sur l’entrée analogique sélectionnée.
La donnée retournée étant comprise entre 0 et 1023, doit être de type int.
La durée de la conversion est d’environ 100 μs.
tension = analogRead(1) ; // tension est égale au résultat de la CAN de l’entrée analogique

1
3.7.5. Les fonctions particulières de gestion des entrées-sorties

La fonction « tone »
tone(Numéro sortie, Fréquence, Durée) ;
Cette fonction permet de générer, sur la sortie sélectionnée, un signal carré (rapport cyclique
de 50 %) de fréquence programmable et pendant la durée désirée.
La donnée « Fréquence » doit être donnée en Hz et la donnée « Durée » doit être fixée en ms.
Si cette durée n’est pas précisée, le signal est généré jusqu’à ce que la fonction « notone » soit
exécutée.
La fonction « notone »
notone(Numéro sortie) ;
Cette fonction permet de stopper la génération du signal carré sur la sortie sélectionnée.
16
La fonction « pulseIn »
durée = pulseIn(Numéro entrée, Type, Delai max) ;
Cette fonction permet de mesurer la durée d’une impulsion sur l’entrée sélectionnée. Le
résultat retourné est du type unsigned long.
La valeur de la donnée « Type » peut être HIGH dans le cas d’une impulsion au NL1 ou LOW
d’une impulsion au NL0.
La variable « Delai max » permet de définir le délai d’attente de l’impulsion. Lorsque ce délai
est dépassé et qu’aucune impulsion ne s’est pas produite, la fonction retourne une valeur nulle. Cette
donnée est du type unsigned long et est exprimé en μs. Si cette donnée n’est pas précisée, la valeur
par défaut sera de 1 s.
Le résultat fourni n’est considéré comme correct que pour des impulsions de durée
comprise entre 10 μs et 3 min.
3.7.6. Les fonctions de manipulation de bits
La fonction « lowByte »
resultat = lowByte(Donnée) ;
Cette fonction permet d’extraire les 8 bits de poids faible de la variable « Donnée ».
La valeur retournée est de type byte alors que la variable « Donnée » peut être de n’importe
quel type (donc n’importe quelle taille).
La fonction « highByte »
resultat = highByte(Donnée) ;
Cette fonction permet d’extraire le deuxième octet en partant de la droite de la variable
« Donnée ».
La valeur retournée est de type byte alors que la variable « Donnée » peut être de n’importe
quel type.
La fonction « bitRead »
resultat = bitRead(Donnée, n) ;
Cette fonction permet de lire le nième bit de la variable « Donnée ».
La fonction « bitWrite »
bitWrite(Donnée, n, Niveau) ;
17
Cette fonction permet d’imposer un niveau logique sur le nième bit de la variable «
Donnée ».
La fonction « bitSet »
bitSet (Donnée, n) ;
Cette fonction permet d’imposer un 1 logique sur le nième bit de la variable « Donnée ».
La fonction « bitClear »
bitClear(Donnée, n) ;
Cette fonction permet d’imposer un 0 logique sur le nième bit de la variable « Donnée ».
3.7.7. Les fonctions de gestion du port série asynchrone

La carte ARDUINO UNO dispose d’un port série asynchrone accessible via les E/S
numériques 0 (ligne Rx) et 1 (Ligne Tx).
Le port série asynchrone des microcontrôleurs qui équipent les cartes ARDUINO
disposent d’une mémoire tampon capable de mémoriser jusqu’à 128 caractères reçus.
La fonction « Serial.begin »
Serial.begin(Vitesse) ;
Cette fonction qui doit être appelée au moins une fois, généralement dans la fonction setup(),
permet de définir la vitesse utilisée par la liaison série.
La valeur prise par la variable « Vitesse » doit être une des vitesses définies par la norme
RS232.
La fonction « Serial.end »
Serial.end() ;
Cette fonction permet de désactiver la liaison série asynchrone et donc de libérer les
broches numériques 0 et 1.
La fonction « Serial.available »
Serial.available () ;
Cette fonction permet de connaître le nombre de caractères reçus et donc contenus dans la
mémoire tampon en attente de lecture par le programme. La variable « nombre » est de type int.
18
La fonction « Serial.read »
Serial.available () ;
Cette fonction permet de lire le premier caractère disponible dans la mémoire tampon de
réception. La variable « caractère » est de type int. La valeur retournée est -1 si aucun caractère n’a
été reçu (mémoire tampon vide).
La fonction « Serial.flush »
Serial.flush() ;
Cette fonction permet de vider la mémoire tampon.
La fonction « Serial.write »
Serial.write (Donnée) ;
Cette fonction permet d’émettre une ou plusieurs données sur la liaison série sous la forme
binaire brute. Si la donnée est de type chaîne de caractères, les caractères sont transmis, sous le
format ASCII, les uns après les autres.
La fonction « Serial.print »
Serial.print (Donnée, format) ;
Cette fonction permet d’émettre une ou plusieurs données sur la liaison série en
précisant le codage utilisé.
Si la variable « Format » n’est pas précisée, une donnée numérique sera considérée comme
décimale, une chaîne de caractères sera transmise tel quelle et une donnée à virgule flottante sera
transmise uniquement avec deux décimales.
Sinon la variable « Format » permet de préciser le codage ou la base de numération pour les
données numériques. Elle peut prendre une des valeurs suivantes : BIN (binaire), OCT (Octal), HEX
(hexadécimal), DEC (Décimal) ou BYTE (codage ASCII). Pour les données à virgule flottante, la
variable « Format » peut prendre une valeur numérique comprise entre 0 et 7 correspondant au
nombre de décimales à transmettre.
Serial.print (100101,BIN) ; // Transmission de la donnée (100101)2
Serial.print (4B,HEX) ; // Transmission de la donnée (4B) 1 6
Serial.print (K,BYTE) ; // Transmission de la donnée (K) A SCII
Serial.print (1.23456,0) ; // Transmission de la donnée 1
Serial.print (1.23456,5) ; // Transmission de la donnée 1.23456
19
Les étapes de développement d’un programme
Éditer le programme
à partir de ARDUINO à l’aide du bouton
Vérifier et compiler le code
S’il n’y a pas d’erreurs on verra s’afficher : “ C

terminée”, suivi de la taille du programme.
Sélectionner la carte ARDUINO utilisée

à
partir du menu Outil → Type de carte Connectez votre carte ARDUINO à votre ordinateur
vot re câble USB. La LED verte d'alimentation (no
s'allumer.
à partir du menuOutils
Sélectionner le bon port série
Vérifier le fonctionnement du programme

sur la carte ARDUINO
Charger le programme dans la carte ARDUI

en c
bouton « Téléverser ».
Une fois le Téléversement terminé, le logiciel AR

Si nécessaire , appuyer sur le bouton de
aff cher un message "Téléversement terminé" O
réinitialisation de la carte pour redémarrer
votre programme i
20
4.EXERCICES
4.1 EXERCICE N°1 : FAIRE CLIGNOTER UNE LED
Ce programme doit permettre de faire clignoter une DEL connectée sur la broche
numérique n°10. Elle doit rester allumée pendant 2 s et éteinte pendant 1 s.
On va faire le premier programme ensemble. Voici l'algorithme
/* Ce programme fait clignoter une LED branchée sur la broche n°10 et fait également clignoter
la diode de test de la carte */
int // LED connectée à la broche n°10

ledPin = 10;
void setup(
{ )
pinMode (ledPin,OUTPUT) // Définit la broche n°10 comme une sortie
} ;
void loop(
{
)
digitalWrite(ledPin,HIG ); // Met la sortie ledPin au NL1 (diode allumée)
delay (3000) H // Attendre 3 s
digitalWrite(;ledPin,LO ) // Met la sortie ledPin au NL0 (diode éteinte)
delay (1000) W ; // Attendre 1 s
} ;
Fonction setup() Fonction loop()

qui contient les instructions d’initialisation qui contient les instructions du progr
 Lancer le logiciel ARDUINO.
 Éditer le programme à partir de l’algorithme ci-dessus sous ARDUINO.
 Compiler le programme.
Nous allons maintenant simuler ce programme sous PROTEUS qui est un logiciel de
CAO électronique qui permet de dessiner et simuler divers
montages.
 Lancer le logicie l PROTEUS 8
 Cliquer sur l'icône ISIS
 Sélectionner l’icône composants
21
 Dans la fenêtre du sélectionneur d’objets, cliquer sur P :
 Réaliser votre schéma. Vous avez besoin d'une LED (LED-RED) et d'une carte
ARDUINO UNO
 Une fois le schéma terminé, vous allez transférer le fichier .hex provenant de la
compilation de la carte ARDUINO. Attention vous devez d'abord mettre les
delays en seconde, car pour l'instant, ils sont en ms
Pour transférer le fichier .hex :
1. Dans ARDUINO, cliquez sur « Croquis » puis « Exporter les binaires compilées
» (Un fichier .hex doit se créer à côté du fichier .ino du programme.
2. Dans PROTEUS, cliquez droit sur le microcontrôleur puis « Edit properties ».
À la ligne « Program File », cliquez sur le petit dossier et allez chercher votre
fichier .hex. Cliquez sur OK.
 Simuler le fonctionnement sous PROTEUS
Maintenant avec le faire fonctionner en réel. Pour cela, vous avez besoin d'une
carte Arduino, une BREADBORD,
une LED, un câble de téléversement -PC
CARTE et des fils de connexions
 Remettre les delays en ms. Puis compiler le programme. Téléverser dans la

carte ARDUINO
 Réaliser le câblage. Puis tester le fonctionnement
22
Dorénavant pour les exercices suivants, vous suivrez cette procédure. Simulation
sous PROTEUS, puis câblage de la carte ARDUINO une fois la simulation validée
4.2 EXERCICE N°2: ALLUMER UNE LED PAR BOUTON POUSSOIR

Ce programme doit permettre d’allumer une LED connectée sur la broche
numérique N°12 lorsqu’un bouton poussoir, connecté sur la broche numérique N°13
est appuyé.
 Réaliser le programme sous ARDUINO, puis le compiler.
 Réaliser le schéma sous PROTEUS comme ci-dessous. Puis simuler
 Réaliser le câblage à l'aide d'une carte ARDUINO, une LED et un BP. Puis
téléverser dans la carte ARDUINO votre programme, puis tester le
fonctionnement
4.3 EXERCICE N°3: PILOTER UN MOTEUR DANS 1 SENS DE

ROTATION
On désire piloter un moteur à courant continu dans un sens de rotation à l'aide
d'une carte Arduino. Pour cela, on va le connecter à la broche numérique 12 et on
appuie sur un BP broche 13 qui permettra de lancer le fonctionnement
23
 Réaliser le câblage à l'aide d'une carte ARDUINO, un moteur à courant
continu, une résistance d'environ 500Ω et une de 10 kΩ, une diode de roue libre
1N4001, un transistor 2N2222A et un BP. Puis téléverser dans la carte
ARDUINO votre programme, puis tester le fonctionnement
4.4 EXERCICE N°4: PILOTER UN MOTEUR DANS 2 SENS DE

ROTATION PAR PONT EN H
On désire piloter un moteur à courant continu dans les 2 sens de rotation à l'aide
d'une carte Arduino et d'un pont en H (L293D). On appuie sur BP broche 13 qui
permettra de lancer le fonctionnement  Réaliser le programme sous ARDUINO, puis
le compiler.
 Réaliser le câblage à l'aide d'une carte ARDUINO, un moteur à courant continu,

une résistance de 10 kΩ, un pont en H (L293D) et un BP. Puis téléverser dans la
carte ARDUINO votre programme, puis tester le fonctionnement
24
4.5 EXERCICE N°5: GESTION D'UNE ENTREE ANALOGIQUE PAR LDR
Ce programme doit permettre de faire clignoter une LED connectée sur la broche
numérique n°12 avec une vitesse de clignotement proportionnelle à l’éclairage ambiant
capté une cellule photo-électrique (LDR).
 Réaliser le câblage à l'aide d'une carte ARDUINO, d'une résistance de 10 kΩ et

d'une LDR. Puis téléverser dans la carte ARDUINO votre programme, puis tester
le fonctionnement
4.6 EXERCICE N°6: COMMANDE D'UN SERVOMOTEUR PAR

POTENTIOMETRE
Un servomoteur (souvent abrégé en « servo ») est un moteur capable de maintenir une
opposition à un effort statique et dont la position est vérifiée en continu et corrigée en
fonction de la mesure. C'est donc un système asservi.
Un servomoteur est un système motorisé capable d'atteindre des positions
prédéterminées, puis de les maintenir. Parce que le servomoteur ne peut tourner que de 180°,
et que l’entrée analogue du potentiomètre varie entre 0 et 1023, nous allons devoir utilis er
une fonction appelée map() qui va nous permettre de calculer automatiquement l’angle de
rotation du moteur.
Afin de gérer le servomoteur sur la carte Arduino, nous allons utiliser la librair ie
externe Servo.
25
Voici le montage à réaliser avec les composants fournis :
1/ Etablir le programme à l’aide du logiciel ARDUINO qui permet le fonctionne me nt

d’un tel montage
2/ Réaliser ce montage à l’aide du logiciel PROTEUS. Insérer le fichier HEX de votre
programme ARDUINO et simuler le fonctionnement en présence du professeur
3/ Si votre montage fonctionne en simulation sous PROTEUS, vous pouvez l’essayer
en réalisant le montage de l’ensemble sur Breadboard. Faire vérifier le montage par votre
professeur. Simuler son fonctionnement
4.7 EXERCICE N°7: MESURE DE TEMPERATURE PAR CAPTEUR LM 35
Le capteur de température LM35 est un capteur analogique de température fabriqué
par Texas Instruments. Il est extrêmement populaire en électronique, car précis, peu
couteux, très simple d'utilisation. Le capteur de température LM35 est capable de mesurer
des températures allant de -55°C à +150°C dans sa version la plus précise
Attention !!!
- Le LM35 n'aime pas du tout être monté à l'envers (il part en

fumée)
- La patte 5 V est à connecter à la borne 5 V de la carte
- La patte Sortie est à connecter à une entrée analogique A0 par
exemple - La patte GND est à connecter à la borne GND de la
carte
26
Caracteristiques :
· sa tension de sortie est linéairement proportionnelle à la température exprimée

en degrés Celsius.
· Sensibilité : S = 10 mV/°C.
· Précision : LM35D: ± 1,5 °C (valeur garantie) et ± 0,6°C à 25°C (typique)
1/ D’après les données constructeurs, quelle sera la tension délivrée par le capteur
à 25°C ?
2/ Quelle sera donc l’intervalle de confiance (precision) à cette temperature ?
3/ On veut connecter notre capteur LM35 à la carte ARDUINO. Pour cela, on le
branche une entrée analogique de la carte. Quelle est la résolution du CAN de la carte
ARDUINO UNO ?
4/ Lorsque nous sommes branchés uniquement en USB la tension de référence est
légèrement inférieure à 5 V , calculer le quantum q si Vref = 4,82 V
5/ Réaliser à l’aide du logiciel ARDUINO, le programme qui retranscrit le
fonctionnement de ce capteur.
6/ On va simuler à l’aide du logiciel PROTEUS le fonctionnement de ce capteur pour
afficher la temperature de la salle de TP.
Réaliser le montage avec un capteur de temperature LM35, un afficheur LCD et le
microcontroleur ATMEGA 328P ou Carte Arduino (si librairie installée)
Insérer le fichier Hex de la question 5/ puis verifier le fonctionnement de
l’ensemble
7/ Mise en ouvre du capteur LM 35
Vous avez à votre disposition une carte ARDUINO UNO, une Breadboard et un
capteur de température
LM35. Réaliser le montage
- Faire vérifier par le professeur. Puis connecter la carte à l’aide du câble USB à
l’ordinateur
- Vérifier maintenant votre programme à l’aide du moniteur série ARDUINO. Vous

pincerez avec vos doigts le capteur pour faire évoluer la température
8/ Maintenant on veut signaler à l’aide d’une LED le dépassement d’un seuil de
température. Modifier votre programme sachant que l’on veut allumer cette LED lorsque
la temperature devient supèrieure à 23°C. Rajouter la LED sur la Breadboard et verifier le
bon fonctionnement de l’ensemble. Mesurer la température de la salle de TP à l'aide d'un
thermomètre. Comparer cette valeur avec celle du capteur LM35. Conclure sur les écarts
et les performances d'un tel capteur
27
5.BREADBORD
La Breadboard n'est pas une planche à pain comme son nom l'indique, mais
une "plaque à essai" ou plaquette de prototypage rapide pour
l'électronique. Il n'y a pas besoin de souder les composants sur la Breadboard,
car c'est prévu pour tester rapidement des circuits électroniques.
Ainsi, la plaquette est composée d'une multitude de trous dont certains
sont reliés électriquement entre eux. Il existe différents formats et différentes
tailles de Breadboard.
S IMULATION DE BREADBOARD
Voici un des formats de Breadboard les plus utilisés : SERVANT A ALLUMER UNE LED
Ces plaques à essai sont vraiment simples à utiliser. Dans une Breadboard standard, les
deux lignes du haut et du bas sont reliées électriquement. De même, chaque colonne au centre
est composée de points reliés électriquement. La création d'un circuit électronique est ainsi
grandement facilitée. Il suffit d'enficher quelques composants dans les trous et d'utiliser
quelques fils électriques. Un très grand nombre de composants électroniques peuvent être
enfichés directement et simplement dans une Breadboard. Et voici les fils que l'on peut
utiliser pour relier les composants entre les colonnes :
Le premier type de fil est pratique pour bien visualiser le rendu final du circuit
électronique. Le second type de fil est plus facile à manipuler, mais on est vite perdu
lorsque le nombre de fils utilisés augmente. Par ailleurs les fils souples ont tendance à dévier
sur les côtés et donnent parfois de mauvaises connexions lorsque les connecteurs de la plaque
à essai ont été utilisés plusieurs fois. Nous conseillons donc d'utiliser les fils rigides et de
toujours avoir une petite pince plate pour les enlever plus facilement.
28
) Rappel (plutôt utile) sur la LED
Une patte est plus longue que l'autre : la courte est la cathode (moyen
mnémotechnique)
Si l'on veut qu'une LED s'allume, on connecte la patte la plus longue (anode ou
+) du côté du 5 V et la patte la plus courte
(cathode ou -) du côté du 0 V ou GROUND (GND).
ATTENTION : pour connecter une LED, il faut lui joindre une résistance d'au
moins 100 Ω,
220 Ω est souvent la valeur conseillée.
Avec le logiciel Fritzing, la patte la plus longue (anode ou +) de la LED est

représentée par un petit décroché :
Anode (+)
PROJET I – Premiers montages avec des LED
1) Faire allumer une LED
Nous allons faire allumer une LED, connectée sur la broche 13.
La résistance utilisée est de 220 Ω (comme les résistances de tous les prochains
montages). Voici le schéma de montage (réalisé avec le logiciel Fritzing) :
En photo :
29
Broche la plus longue !
broches GND et 13
Dans le logiciel Arduino IDE, la programmation se fait de la façon suivante (au

choix) :
Sans variable Avec variable

void setup() int led1=13;
{
pinMode(13, OUTPUT); void setup()
} {
pinMode(led1, OUTPUT);
void loop() }
{
digitalWrite(13, HIGH); void loop()
} {
digitalWrite(led1, HIGH); }
Il s’agit du même montage.

La programmation est la suivante :
30
int led1=13;
void setup()
{
}
void loop()
{
digitalWrite(led1, HIGH);
delay(1000);
digitalWrite(led1, LOW);
delay(1000);
}
PROJET I – DEUX
4 résistances 220Ω
broches GND, 13, 12, 11 et 10

31
Sans boucle Avec une boucle for
int led1=13; int int led;
led2=12; int
led3=11; int
void setup()
led4=10;
{
void setup() for (led = 10; led < 14; led++)
{ {
pinMode(led1, OUTPUT); pinMode(led, OUTPUT);
pinMode(led2, OUTPUT); }
pinMode(led3, OUTPUT); }
}
void loop()
{
void loop()
{ for (led = 10; led < 14; led++)
digitalWrite(led1, HIGH); {
digitalWrite(led2, HIGH); digitalWrite(led, HIGH);
digitalWrite(led3, HIGH); }
digitalWrite(led4, HIGH); delay(1000); delay(1000);
for (led = 10; led < 14; led++)
digitalWrite(led3, LOW); {
digitalWrite(led4, LOW); delay(1000); digitalWrite(led, LOW);
} }
delay(1000);
}
2) Réaliser un chenillard à 4 LED (ou « l’œil de K2000 »)
C’est le même montage.
32
Sans boucle Avec une boucle for Avec un tableau
void setup() int led; int led[4] = {10, 11, 12, 13};
{ int i;
pinMode(10, OUTPUT); void setup() void setup()
pinMode(11, OUTPUT); { {
pinMode(12, OUTPUT); for (led = 10; led < 14; led++) for (i = 0; i < 4; i++)
pinMode(13, OUTPUT); { {
} pinMode(led, OUTPUT); pinMode(led[i], OUTPUT);
void loop() } }
{ } }
digitalWrite(10, HIGH);
digitalWrite(11, LOW); void loop()
void loop()
digitalWrite(12, LOW); {
{
digitalWrite(13, LOW);
for (led = 10; led < 14; led++) for (i = 0; i < 4; i++) {
delay(100);
{ digitalWrite(led[i], HIGH);
digitalWrite(10, LOW);
digitalWrite(led, HIGH); delay(100);
delay(100); digitalWrite(led[i], LOW);
delay(100);
digitalWrite(11, LOW); digitalWrite(led, LOW); }
digitalWrite(12, HIGH); } for (led = 13; led > 9; for (i = 3; i >= 0; i--)
delay(100); led--) {
digitalWrite(12, LOW); { digitalWrite(led[i], HIGH);
digitalWrite(13, HIGH); digitalWrite(led, HIGH); delay(100);
delay(100); delay(100); digitalWrite(led[i], LOW);
digitalWrite(13, LOW); digitalWrite(led, LOW); } }
digitalWrite(12, HIGH); } }
delay(100);
digitalWrite (12, LOW);
delay(100);
}
PROJET – TROIS
6) Les feux de circulation
L’objectif de cet exercice est de créer deux feux de circulation et de les faire
fonctionner selon les phases suivantes :
33
Voici le schéma de montage :
broches GND, 13, 12, 11, 10, 9 et 8
En photo :
34
//FEU 1 int
R1 = 13; int
J1 = 12; int
V1 = 11;
//FEU2 int
R2 = 10; int
J2 = 9;
int V2 = 8; //TEMPS
int temps1 = 6000; int
temps2 = 2000; void
setup()
{
pinMode(R1, OUTPUT); pinMode(J1,
OUTPUT); pinMode(V1, OUTPUT);
pinMode(R2, OUTPUT); pinMode(J2,
OUTPUT);
pinMode(V2, OUTPUT);
}
void loop()
{
//Phase 1: R1 et V2 allumés, J1, V1, R2 et J2 éteints, 6
s digitalWrite(R1, HIGH); digitalWrite(V2, HIGH);
digitalWrite(J1, LOW); digitalWrite(V1, LOW);
digitalWrite(R2, LOW); digitalWrite(J2, LOW);
delay(temps1);
//Phase 2: J2 allumé, V2 éteint, 2 s
digitalWrite(J2, HIGH);
digitalWrite(V2, LOW); delay(temps2);
//Phase 3: V1 et R2 allumés, R1 et J2 éteint, 6 s
digitalWrite(V1, HIGH);
digitalWrite(R2, HIGH);
digitalWrite(R1, LOW);
digitalWrite(J2, LOW); delay(temps1);
//Phase 4: J1 allumé, V1 éteint, 2 s
digitalWrite(J1, HIGH);
digitalWrite(V1, LOW); delay(temps2);
}
On pourrait passer au carrefour à 4 feux mais cela multiplie les LED et les résistances
sur la plaque de montage !
35
PROJET – QUATRE
III – Les entrées numériques : exemple du bouton poussoir
1) Préambule
Jusqu'alors, nous avons traité des sorties (outputs), c'est-à-dire qu'un signal sortait
du microcontrôleur sous la forme d'un courant électrique (HIGH) ou de son absence
(LOW) grâce à la commande DigitalWrite. On a utilisé jusqu'ici ce signal (un
courant électrique) pour allumer des LED.
L'utilisation d'un bouton poussoir, et plus généralement d'un contacteur, va amener
à gérer non plus les sorties, mais les entrées (inputs) de la carte Arduino : il va être
possible d'envoyer un signal au microcontrôleur depuis ce bouton poussoir. Ce signa l
est un courant électrique entrant dans la broche. En fonction du signal reçu, le
microcontrôleur effectuera une tâche prévue : allumer une LED lorsqu'on appuyera
sur le bouton poussoir par exemple. Pour cela, nous utiliserons la commande
DigitalRead.
Un bouton poussoir peut se trouver sous plusieurs formes dans
le commerce. Celui qui nous intéresse est un bouton avec 4
pattes, une forme carrée, et un rond au centre qui est le bouton
lui-même.
Attention, même s'il a 4 pattes, le bouton poussoir est un dipôle.
En fait les pattes sont reliées deux par deux. Si la LED reste allumée en permanence,
il faut tourner le bouton d'un quart de tour.
Tous les montages suivants contiennent une résistance de 10 kΩ, qu’on appelle pull-
down : cette résistance permet de tirer le potentiel vers le bas. Le but d'une
résistance de pull-down est donc d’évacuer les courants vagabonds et de donner un
signal clair.
2) Actionner l’allumage d’une LED avec un bouton poussoir
Lorsqu’on appuie sur le bouton poussoir, La LED doit s’allumer. Et naturelleme nt,
lorsqu’on relâche le bouton poussoir, la LED s’éteint. Cette action n'est pas
mécanique, mais logique. Ce n'est pas la fermeture d'un circuit électrique qui allume
la LED, mais l'information transmise à l'Arduino, par le biais d'un INPUT qui lui
ordonne d'allumer la LED.
Voici le schéma de montage : En photo :
36
fil rouge sur +5V
fil noire sur GND
fil vert sur 2
fil jaune s ur 12
220 Ω
10 kΩ

Version classique Version « élégante »
int bouton = 2; int bouton = 2; int
int led = 12; led = 12;
boolean boutonEtat = 0;
void setup()
{ void setup()
pinMode(led, OUTPUT); {
pinMode(bouton, INPUT); pinMode(led, OUTPUT);
} pinMode(bouton, INPUT);
}
void loop()
{ void loop()
if (digitalRead(bouton) == HIGH) {
{ boutonEtat = digitalRead(bouton);
digitalWrite(led, HIGH); if (boutonEtat == 1)
} {
else { digitalWrite(led, HIGH);
digitalWrite(led, LOW); }
} else {
} digitalWrite(led, LOW);
}
}
V – Utilisation des librairies de code

Les librairies (bibliothèques) pour Arduino sont nombreuses et abordent la plupart
des besoins courants. On trouve ainsi les bibliothèques standards, pour par exemple
gérer le Wifi, les écrans à cristaux liquides, une carte SD, ou encore des moteurs.
37
Pour l'occasion, nous allons nous intéresser à la bibliothèque de moteurs un peu
particuliers que l'on retrouve dans le monde du modélisme : les servomoteurs.
PROJET – CINQ
1) Exemple du servomoteur
Pour charger cette bibliothèque et obtenir du même coup la boîte à outils

correspondante, il faut saisir l’instruction :
#include <Servo.h>
fil rouge sur +5V, fil marron sur GND, fil orange sur 9
38
PROJET – SIX
2) Prolongement : barrière avec feu bicolore et bouton poussoir
Le montage à réaliser comporte :
• un servomoteur qui jouera le rôle de barrière,
• un bouton pour demander l'ouverture de la barrière,
• un feu bicolore qui passera au vert lorsque la barrière sera complèteme nt
ouverte.
Le fonctionnement normal est un feu allumé au rouge (le feu vert est éteint) et une
barrière fermée (0°). Le fonctionnement normal est interrompu par l'appui sur un
bouton poussoir. Si l'appui du bouton est détecté, alors la barrière (actionnée par le
servomoteur) se relève doucement. Lorsque la barrière est à la verticale (90°), le feu
vert s'allume pendant 5 secondes pendant lesquelles la barrière reste ouverte (90°) et
le feu rouge s'éteint. Après les 5 secondes, le feu repasse au rouge, la barrière
redescend doucement et le fonctionnement normal reprend.
39
220 Ω
Broches +5V et GND
10 kΩ
Broches 9, 4, 3 et 2
40
#include <Servo.h>
Servo
barriere; int
pos = 0; int
rouge = 3; int
vert = 4; int
bouton = 2;
int etatbouton = 0;
void setup()
{
barriere.attach(9);
pinMode(rouge, OUTPUT);
pinMode(vert, OUTPUT);
pinMode(bouton, INPUT);
}
void loop()
{ digitalWrite(rouge, HIGH);
digitalWrite(vert, LOW);
etatbouton = digitalRead(bouton);
if (etatbouton == HIGH)
{
for (pos = 0; pos <= 90; pos++)
{
barriere.write(pos);
delay(15);
}
digitalWrite(vert, HIGH);
digitalWrite(rouge, LOW);
delay(5000);
digitalWrite(rouge,
HIGH);
digitalWrite(vert, LOW);
for (pos = 90; pos >=
0; pos--)
{
barriere.write(pos);
delay(15);
}
}
}
PROJET – SEPT
41
) Créer un détecteur de présence ou d’obstacle
On souhaite qu’une LED s’allume si la distance à l’obstacle est inférieure à 10 cm.
broches GND et 12
42
int trig = 8; int
echo = 9; int
avertisseur=12;
int dmin=10; // distance (en cm) en dessous de laquelle la LED s'allume
long temps;
long distance;
void setup()
{
pinMode(trig, OUTPUT); pinMode(echo,
INPUT); pinMode(avertisseur,
OUTPUT);
Serial.begin(9600);
}
void loop()
{
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW); temps =
pulseIn(echo, HIGH); distance =
temps*340*100/1000000/2;
if (distance<dmin)
{
digitalWrite(avertisseur, HIGH);
} else
{
digitalWrite(avertisseur, LOW); }
}
PROJET – HUIT
43
IV – Utilisation d’un haut-parleur : produire la note La3 (module acoustique –
seconde
bac pro)
Nous allons produire la note La3 (440 Hz) grâce à un haut-parleur 8 Ω 5 W, connecté
sur la broche 9.
La résistance utilisée est de 220 Ω (résistance de limitation de courant).

int hp=9; void
setup()
{
pinMode(hp,OUTPUT);
}
void loop()
{ digitalWrite(hp,HIGH);
digitalWrite(hp,LOW);
}
44
Autre alternative : la fonction tone()
Elle permet de générer un signal carré (50 % du temps à 5 V, 50 % du temps à 0 V)
d'une fréquence et d’une durée donnée : tone(broche,fréquence,durée);
int hp=9; void
setup()
{
pinMode(hp,OUTPUT);
}
void loop()
{
tone(hp,440,400);
}
Prolongement : Au clair de la lune
Dans la gamme 3 : Do (261,63 Hz), Ré (293,66 Hz), Mi (329,63 Hz)
45
int hp=9;
void setup()
{
pinMode(hp,OUTPUT);
}
void loop()
{
tone(hp,262,400);
delay(800);
tone(hp,262,400);
delay(800);
tone(hp,262,400);
delay(800);
tone(hp,294,400);
delay(800);
tone(hp,330,800);
delay(1000);
tone(hp,294,800);
delay(1000);
tone(hp,262,400);
delay(800);
tone(hp,330,400);
delay(800);
tone(hp,294,400);
delay(800);
tone(hp,294,400);
delay(800);
tone(hp,262,1600);
delay(2000);
}
EVALUATION
I- Contrôle des connaissances
46
Annexe 1 : Simulation d’un dé à 6 faces
broches GND, 7, 6, 5, 4, 3 et 2
47
int de;
int led;
int led1=2; // les 6 LED sont sur les broches 2 à
7 int led2=3; int led3=4; int led4=5; int led5=6;
int led6=7;
void setup()
{
Serial.begin(9600); randomSeed(analogRead(0)); // sinon, le hasard
sera toujours le même !
for (led = 2; led < 8; led++)
{
pinMode(led, OUTPUT); // toutes les LED en
output digitalWrite(led, LOW); // on les éteintes
toutes }
}
void loop()
{
de=random(1,6); // un nombre au hasard entre 1 et 6
Serial.println(de); // affiche le nombre sur le moniteur série
affichage(de);//appel de la fonction d'allumage des LED
delay(5000);
}
48
void setZero() //cette fonction sert à éteindre toutes les diodes
{
for (led=2;led<8;led++)
{
digitalWrite(led,LOW);
}
}
void affichage(int de) //cette fonction récupère un nombre et allume les LED en conséquence
{
setZero(); //appel de la fonction qui éteint toutes les LED if
(de==1)
{
digitalWrite(led1,HIGH);
return;//sortie de la fonction
}
if (de==2)
{
return;
}
if (de==3)
{
return;
}
if (de==4)
{
return;
}
if (de==5)
{
return;
}
if (de==6)
{ Pour voir la vidéo digitalWrite(led1,HIGH); correspondante :
digitalWrite(led2,HIGH); digitalWrite(led3,HIGH); digitalWrite(led4,HIGH);
digitalWrite(led5,HIGH); digitalWrite(led6,HIGH); return;
}
delay(5000);
}
49
50

Notes Du Cours de Systemes Embarques

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

Notes Du Cours de Systemes Embarques

Transféré par

Droits d'auteur :

Formats disponibles

Ministères de L'Enseignement

Travaux dirigés De systèmes embarques

Les principaux avantages du système ARDUINO sont :

Les principales caractéristiques

Tension d'alimentation interne 5V

Tension d'alimentation 7 à 12V

Tension d'alimentation (limites) 6 à 20 V

Entrées/sorties numériques 14 dont 6 sorties PWM

Courant max par broches E/S 40 mA (200mA cumulé pour

Mémoire programme Flash 32 Ko dont 0,5 Ko sont utilisés par le

Mémoire SRAM (mémoire 2 KB

Mémoire EEPROM (mémoire non 1 KB

Fréquence horloge 16 MHz

0 PD0 Rx : Entrée liaison série synchrone

2 PD2 INT0 : Entrée interruption externe

AIN0 : Entrée comparateur analogique

CLKO : Sortie de l’horloge de fonctionnement

9 PB1 OC1A : Sortie module PWM modulation à largeur

MOSI : Sortie liaison SPI

13 PB5 SCK : Horloge liaison SPI

2.4.2. Les entrées analogiques

L’horloge est pilotée par quartz et fonctionne à la fréquence de 16 MHz.

3. La programmation de la carte ARDUINO

 De pouvoir écrire et compiler des programmes pour la carte ARDUINO

La structure d’un programme

Fonction setup() Fonction loop()

La syntaxe du langage ARDUINO

Pour placer des commentaires sur plusieurs lignes :

Les données, variables et constantes

int Entier signé sur 16 bits

long Entier signé sur 32 bits

//Toute variable N rencontrée dans le programme sera remplacée

true Donnée binaire égale à 1 ou donnée numérique différente de 0

OUTPUT Configuration d’une broche numérique en sortie

Symbole Description Exemple

>> Décalage à droite des c = a >> b ; //a décalé

<< Décalage à gauche c = a << b ; //a décalé

3.6.2. Les affectations

Symbole Description Exemple

= Affection ordinaire a=b;

>= Supérieur ou égal à if

<= Inférieur ou égal à if

L'instruction suivante sera alors ajoutée au début de votre programme : #include

La durée de la pause n’est assurée que des valeurs supérieures à 3 μs.

delayMicroseconds (100) ; // Pause de 100 µs

Cette fonction retourne le nombre de microsecondes depuis le démarrage du

pinMode (12,OUTPUT ) ; // La broche 12 est configurée comme une sortie

digitalWrite(12,HIGH) ; // La sortie 12 est placée au niveau logique haut (NL1)

etat = digitalRead (11) ; // La variable etat est

3.7.3. Les fonctions de gestion des sorties PWM

analogWrite (2,64) ; // Signal PWM de rapport cyclique de 25 % sur la sortie analogique

3.7.4. Les fonctions de gestion des entrées analogiques

 DEFAUT : La tension de référence est égale à la tension d’alimentation de la carte

La durée de la conversion est d’environ 100 μs.

tension = analogRead(1) ; // tension est égale au résultat de la CAN de l’entrée analogique

3.7.5. Les fonctions particulières de gestion des entrées-sorties

3.7.6. Les fonctions de manipulation de bits

3.7.7. Les fonctions de gestion du port série asynchrone

Cette fonction permet de vider la mémoire tampon.

Serial.print (100101,BIN) ; // Transmission de la donnée (100101)2

Serial.print (4B,HEX) ; // Transmission de la donnée (4B) 1 6

Serial.print (K,BYTE) ; // Transmission de la donnée (K) A SCII

Serial.print (1.23456,0) ; // Transmission de la donnée 1