Rapport Du TPs Électronique Embarqué

Université Ibn Tofail
Faculté des sciences Kenitra

Master Spécialisé
Rapport TP : Systèmes
Embarqués
Elaboré par :
Encadré par :
El Amoury Khadija EE
Pr YOUNES ADNANI
Redaoui Soukaina ST
Ouldsenni Hafsa ST
Chahbi soufian EE
Année Universitaire
1 2023-2024
Sommaire :
I. Introduction : ........................................................................................................................................... 4
1. Qu'est-ce qu’Arduino ? ..................................................................................................................... 4
2. Pourquoi Arduino ?............................................................................................................................ 4
3. Relation EE et Arduino : ................................................................................................................... 5
4. Concurrent Arduino : ......................................................................................................................... 5
5. Domaine d'utilisation : ...................................................................................................................... 5
II. Matériel Arduino : ................................................................................................................................... 7
1. Les différentes cartes : ..................................................................................................................... 7
2. Brochage de la carte UNO : ............................................................................................................. 8
2.1. Entrées-sorties de l’Arduino UNO: ........................................................................................ 9
2.2. Alimentation de la carte Arduino Uno : .............................................................................. 10
III. IDE installation : ................................................................................................................................ 11
1. Présentation de l’interface IDE : ................................................................................................... 11
1.1. Description : ............................................................................................................................... 11
1.2. Principe général d’utilisation................................................................................................. 13
2. Le langage de programmation :.................................................................................................... 15
IV. Application TPs à l’aide d’un Arduino ........................................................................................ 17
TP1 : Clignoter un LED ...................................................................................................................... 18
TP 2 : Faire feu de circulation à deux voies à l’aide d’un Arduino. ............................................. 20
TP 3 : (minuterie de cage d'escalier) ........................................................................................ 24
TP 4 (Afficheur 7 segments standard) ...................................................................................... 26
TP 5 : Acquisition de la tension Vout et affichage de la température ........................................ 32
TP 6 : Commande d'un moteur à courant continu (DC motor) avec Arduino ....... 35
TP 7 : Commande d'un servomoteur avec une résistance variable ......................... 38
V. COCLUSION :......................................................................................................................................... 42
2
Listes des figures
Figure 1:domotique ........................................................................................................................ 6
Figure 2:robotique .......................................................................................................................... 6
Figure 3:Modelisme avionique ....................................................................................................... 6
Figure 4 Modelisme automobile..................................................................................................... 6
Figure 5:Diverses Cartes Ardouino ............................................................................................... 7
Figure 6:La carte Ardouino UNO ................................................................................................... 8
Figure 7:L'alimentation de la carte Ardouino ............................................................................. 10
Figure 8:Présentation de la fenêtre IDE Arduino ........................................................................ 11
Figure 9:Le moniteur série (Terminal série). ............................................................................... 12
Figure 10:Détaille de la barre des Boutons ................................................................................. 14
Figure 11:La console IDE Arduino............................................................................................... 14
Figure 12: Le téléversement du programme vers la carte Arduino ........................................... 15
3
I. Introduction :
Arduino est une plateforme de prototypage électronique open-source qui a révolutionné le
domaine de l'électronique en rendant le processus de développement de projets électroniques
accessible à tous, des débutants aux experts. Cette plateforme offre un ensemble de cartes
matérielles et un environnement de développement logiciel convivial, permettant aux
utilisateurs de créer rapidement et facilement une large gamme de projets interactifs.
Dans cette documentation, nous explorerons en profondeur divers aspects d'Arduino, depuis
sa définition et ses avantages jusqu'à son application pratique à travers une série de travaux
pratiques. Nous commencerons par une présentation générale d'Arduino, décrivant son
histoire, sa philosophie et ses caractéristiques clés. Ensuite, nous examinerons l'installation de
l'environnement de développement intégré (IDE) d'Arduino et la programmation en langage
Arduino, en mettant l'accent sur les concepts fondamentaux nécessaires pour commencer à
créer des projets.
Nous plongerons ensuite dans le matériel Arduino, en explorant les différentes cartes
disponibles, leur architecture et leur fonctionnement. Nous passerons également en revue les
principaux composants d'une carte Arduino typique, en mettant l'accent sur le brochage et les
fonctionnalités de la carte Arduino Uno, l'une des cartes les plus populaires de la gamme
Arduino.
Enfin, nous mettrons en pratique nos connaissances à travers une série de travaux pratiques
conçus pour illustrer diverses applications d'Arduino, telles que la commande de LED, la
lecture de capteurs, le contrôle de moteurs et bien d'autres encore. Chaque TP sera accompagné
d'instructions détaillées et de codes sources, permettant aux utilisateurs de suivre et de
reproduire facilement les expériences.
1. Qu'est-ce qu’Arduino ?
Arduino est une plate-forme de prototypage électronique open source, basée à la fois sur du
matériel et des logiciels faciles à utiliser. Les premiers Arduino disposaient d'un port série RS-
232, puis l'USB est apparu sur des modèles plus récents, tandis que certains modules destinés
à une utilisation portable se sont affranchis de l'interface de programmation, relocalisée sur un
module USB-série dédié.
2. Pourquoi Arduino ?
Avantages :
 Pas cher
 Développement des applications sans être forcément un spécialiste pointu de
l’électronique ou de la programmation
 Environnement de développement intégré (IDE) clair et simple et multiplateforme :
tourne sous Windows, Macintosh et Linux
 Nombreuses librairies disponibles avec diverses fonctions implémentées
 Logiciel et Matériel open source et extensible
 Nombreux conseils, tutoriaux et exemple en lignes (forum, sites perso, etc….)
4
 Existence de « shields» (boucliers en français) : ce sont des cartes d’extension qui se
connecte sur le module Arduino pour augmenter ses possibilités comme par exemple :
 Afficheur graphique couleur
 Interface Ethernet
 GPS
3. Relation EE et Arduino :
Arduino simplifie le processus de développement électronique en fournissant une plateforme
standardisée avec une documentation complète. Il permet aux utilisateurs de se concentrer sur
la logique de programmation plutôt que sur les détails techniques du matériel.
4. Concurrent Arduino :
Bien qu'Arduino soit populaire, il existe d'autres plateformes similaires telles que
Raspberry Pi, ESP32, et BeagleBone. Chacune a ses propres avantages et inconvénients,
mais Arduino reste populaire en raison de sa simplicité et de sa polyvalence.
5. Domaine d'utilisation :
 Physical computing : Au sens large, construire des systèmes physiques interactifs qui
utilisent des logiciels et du matériel pouvant s’interfacer avec des capteurs et des
actionneurs.
 Électronique industrielle et embarquée
 Art / Spectacle
 Domotique
 Robotique Modélisme
 DIY, Hacker, Prototypage,
 Education, Etc.
5
Figure 1:domotique
Figure 2:robotique
Figure3:Modélisme avionique Figure 4:Modelisme automobile
6
II. Matériel Arduino :
1. Les différentes cartes :
Il existe une bonne centaine de cartes Arduino différentes :
Certains constructeurs modifient le modèle original afin d’améliorer certains points,
 Le nombre d’entrées/sorties,
 la consommation,
 La fréquence de fonctionnement,
 L’espace mémoire,
 La réduction de la tension d’alimentation,
 Le Type de bus de programmation.
D’autre pour une question d’esthétisme ou encore pour l’orienter par exemple
expérimentations.
Figure 3:Diverses Cartes Ardouino
7
2. Brochage de la carte UNO :
La carte Arduino Uno est une carte à microcontrôleur basée sur l'ATmega328. Elle dispose
(voir figure.) :
1. Un microcontrôleur,
2. d'une connexion USB,
3. d'un connecteur d'alimentation jack,
4. LED de visualisation
5. a) de 14 broches numériques d'entrées/sorties (dont 6 peuvent être utilisées en sorties PWM
(largeur d'impulsion modulée)),
5. b) de 6 entrées analogiques (qui peuvent également être utilisées en broches entrées/sorties
numériques),
6. d'un quartz 16Mhz,
7. d'un connecteur ICSP (programmation "in-circuit"),
8. un bouton de réinitialisation (reset).
Figure 4:La carte Ardouino UNO
8
2.1. Entrées-sorties de l’Arduino UNO:
 Entrées analogiques :
La carte arduino possède de 6 entrées analogiques en utilisant l'instruction analogRead (), les
tensions sont toujours entre 0 et 5V, présentes sur ces broches, peuvent être numérisées via un
convertisseur analogique-numérique ou ADC (Analog Digital Converter). La conversion est
effectuée sur 10 bits, c’est à dire 2^10, soit 1024 valeurs donc il convertit la tension en un
nombre entier ayant une valeur de 0 à 1023.
 Les entrées et les sorties numériques :

La carte arduino possède de 14 broches numériques (numérotée de 0 à 13) fonctionnent en 5V
et peuvent être utilisées soit comme une entrée et une sortie numérique, en utilisant les
instructions pinMode (), digitalWrite () et digitalRead () du langage Arduino.
Chaque broche peut fournir ou recevoir un maximum de 40 mA d'intensité et dispose d'une
résistance interne pull-up (déconnectée par défaut) de 20-50 KOhms. Cette résistance interne
s'active sur une broche en entrée en utilisant l'instruction digitalWrite (broche, HIGH).
 La ligne série :
Broche TX la ligne d’émission série et RX la ligne de réception série. Ces lignes sont
principalement employées pour dialoguer avec l’ordinateur et avec certains modules comme
les modules Wi-Fi ou Bluetooth.
 Interruptions externes :
Les broches 2 et 3 peuvent être configurées pour déclencher une interruption sur une valeur
basse, sur un front montant ou descendant, ou sur un changement de valeur.
 Les sorties PWM :

Les broches étiquetées "~" 3, 5, 6, 9, 10, et 11. Fournissent une impulsion PWM 8-bits à l'aide
de l'instruction analogWrite (). C’est à dire 2^8 soit 256 valeurs, allant de 0 à 255.
 Les broches de spi :

10 (Slave Select).
11 (MOSI).
12 (MISO).
13 (SCK).
Ces broches supportent la communication SPI (Interface Série Périphérique) disponible avec
la librairie pour communication SPI.
 Les broche de I2C:

4 (SDA).
5 (SCL).
Ces broches supportent les communications de protocole I2C (Two Wire Interface), disponible
en utilisant la librairie Wire/I2C
9
 LED :
Il y a une LED incluse dans la carte connectée à la broche 13. Lorsque la broche est au niveau
HAUT (5V), la LED est allumée, lorsque la broche est au niveau BAS(0V), la LED est éteinte.
2.2. Alimentation de la carte Arduino Uno :
On a 3 possibilités pour alimenter la carte :

Vin – Permet d'alimenter la carte arduino ou de récupérer la tension d'alimentation externe. Si
l'alimentation est fournie par la prise JACK, accéder à la tension d'alimentation sur cette
broche. Il faudra se limiter aux valeurs suivantes :
- Alimentation 12 V : courant = 285 mA.
- Alimentation 9 V : courant= 500mA.
- Alimentation 7 V : courant= 1A.
3.3V – Fournie par le circuit intégré FTDI (circuit intégré faisant l'adaptation du signal entre
le port USB de votre ordinateur et le port série de l'ATMega) de la carte est disponible. Cette
broche alimente les circuits intégrés sous cette tension avec une intensité maximale d’environ
50 mA
5V - alimente le microcontrôleur et permet d'alimenter des circuits avec une tension

d'alimentation parfaitement stable dite "tension régulée" obtenue à l'aide d'un régulateur et qui
est intégré à la carte Arduino. Le 5V régulé fourni par cette broche peut donc provenir soit de
la tension d'alimentation VIN via le régulateur de la carte, ou bien de la connexion USB (qui
fournit du 5V régulé) ou de tout autre source d'alimentation régulée.
GND (Masse) - Il y a plusieurs de ces broches présentes sur la carte Arduino, qui peuvent
toutes être utilisées comme masse pour notre circuit.
Figure 5:L'alimentation de la carte Ardouino
Le bouton RESET à côté du connecteur USB sert à réinitialiser la carte Arduino.
10
III. IDE installation :
1. Présentation de l’interface IDE :

1.1. Description :
Le logiciel IDE 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
Cet environnement de développement intégré (EDI) dédié au langage Arduino et à la

programmation des cartes Arduino comporte (Figure. 7) :
 une BARRE DE MENUS comme pour tout logiciel une interface graphique (GUI),
 une BARRE DE BOUTONS qui donne un accès direct aux fonctions essentielles du
logiciel et fait toute sa simplicité d'utilisation,
 un EDITEUR (à coloration syntaxique) pour écrire le code de vos programmes, avec
onglets de navigation,
 une ZONE DE MESSAGES qui affiche indique l'état des actions en cours,
 une CONSOLE TEXTE qui affiche les messages concernant le résultat de la
compilation du programme.
Figure 6:Présentation de la fenêtre IDE Arduino
Le logiciel Arduino intègre également :
11
 Un TERMINAL SERIE (Figure. 8) qui permet d'afficher des messages textes reçus de
la carte Arduino et d'envoyer des caractères vers la carte Arduino. Cette fonctionnalité
permet une mise au point facilitée des programmes, permettant d'afficher sur
l'ordinateur l'état de variables, de résultats de calculs ou de conversions analogique-
numérique : un élément essentiel pour améliorer, tester et corriger ses programmes.
 Sur votre ordinateur, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire,
un simple clic sur le bouton « Sérial Monitor ».
 La fenêtre « Terminal » s'ouvre alors :

 Il faut alors régler le débit de communication sur la même valeur que celle utilisée par
le programme avec lequel nous allons programmer la carte Arduino.
Figure 7:Le moniteur série (Terminal série).
12
1.2. Principe général d’utilisation
Le code écrit avec le logiciel Arduino est appelé un programme (ou une séquence - sketch en
anglais) :
 Ces programmes sont écrits dans l'éditeur de texte. Celui-ci a les fonctionnalités
usuelles de copier/coller et de rechercher/remplacer le texte.
 la zone de messages donne l'état de l'opération en cours lors des sauvegardes, des
exportations et affiche également les erreurs.
 La console texte affiche les messages produits par le logiciel Arduino incluant des
messages d'erreur détaillés et autres informations utiles.
 la barre de boutons vous permet de vérifier la syntaxe et de transférer les programmes,
créer, ouvrir et sauver votre code, et ouvrir le moniteur série.
 la barre des menus vous permet d'accéder à toutes les fonctionnalités du logiciel
Arduino.
a. Description de la barre des boutons

La barre des boutons comporte (voir les détaille figure. 9) :
Vérifier/compiler : Vérifie le code à la recherche d'erreur.
Stop : Stoppe le moniteur série ou les autres boutons activés.
Nouveau : Crée un nouveau code (ouvre une fenêtre d'édition vide).
Ouvrir : Ouvre la liste de tous les programmes dans votre "livre de programmes". Cliquer sur
l'un des programmes l'ouvre dans la fenêtre courante.
Note : en raison d'un bug dans Java, ce menu ne défile pas. Si vous avez besoin d'ouvrir un
programme loin dans la liste, utiliser plutôt le menu File > Sketchbook.
Sauver : Enregistre votre programme.
Transférer vers la carte : Compile votre code et le transféré vers la carte Arduino. Voir ci-
dessous "Transférer les programmes" pour les détails.
Moniteur Série : Ouvre la fenêtre du moniteur (ou terminal) série.
13
Figure 8:Détaille de la barre des Boutons
b. Transfert des programmes vers la carte Arduino
 Poupremière programmation de la carte, aller dans le menu File>Examples>Digital>Blink:

un programme s'ouvre dans la fenêtre éditeur.
Appuyez alors sur le bouton Vérifier de la barre d'outils pour lancer la vérification du code.
Si tout va bien, aucun message d'erreur ne doit apparaître dans la console et la zone de message
doit afficher Compilation terminée attestant que la vérification s'est bien déroulée comme
montre la figure 10.
Figure 9:La console IDE Arduino
14
Avant de transférer votre programme vers la carte Arduino, vous devez vérifier que vous avez
bien sélectionné la bonne carte Arduino depuis le menu Tools>Board (Outils>Carte). Les
cartes sont décrites ci-dessous. Votre carte doit évidemment être connectée à l'ordinateur via
un câble USB.
Vous devez également sélectionner le bon port série depuis le menu Tools > Serial Port (Outils
> Port Série) :
 Sur un Mac, le port série ressemble probablement à quelque chose comme

/dev/tty.usbserial-1B1 (pour une carte USB), ou /dev/tty.USA19QW1b1P1.1 (pour une
carte série connectée avec un adaptateur USB-vers-Série).
 Sous Winsows, c'est probablement COM1 ou COM2 (pour une carte série) ou COM4,
COM5, COM7 ou supérieur (pour une carte USB) - pour trouver le bon, vous pouvez
chercher dans la rubrique des ports série USB dans la section des ports du panneau de
configuration ou du gestionnaire de périphériques.
 Sous Linux, çà devrait être /dev/ttyUSB0, /dev/ttyUSB1 ou équivalent.
Une fois que vous avez sélectionné le bon port série et la bonne carte Arduino, cliquez sur le
bouton Téléverser (Transfert vers la carte) dans la barre d'outils (Figure 11), ou bien
sélectionner le menu Croquis>Téléverser (ctrl+U). Avec les versions récentes (Duemilanove
notamment), la carte Arduino va alors automatiquement se réinitialiser et démarrer le transfert.
Avec les versions précédentes qui ne sont pas équipées de l'auto-réinitialisation, vous devez
appuyer sur le bouton "reset" de la carte juste avant de démarrer le transfert.
Figure 10: Le téléversement du programme vers la carte Arduino
2. Le langage de programmation :
 Structure globale d’un programme langage Arduino
Le programme Arduino comprend :
 un entête déclaratif
 une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ))
15
 une partie constituée d'une boucle sans fin que le programme répètera à l'infini «
fonction loop ( ) » : c'est le coeur du programme.
 Déroulement du programme
Le programme se déroule de la façon suivante :
 Après avoir pris en compte les instructions de la partie déclarative,

 puis après avoir exécuté la partie configuration (fonction setup( )),
 le programme bouclera sans fin (fonction loop ( )), exécutant de façon répétée le code
compris dans la boucle sans fin.
Le déroulement d’un programme Langage Arduino
Les programmes Arduino peuvent être divisés en trois parties principales : la structure, les
valeurs (variables et constantes) et les fonctions.
Le langage Arduino est basé sur les langages C/C++.
 Quelques instructions utiles
•Instructions de configuration I/O

pinMode (broche, OUTPUT) // broche configuré en sortie
pinMode (broche, INPUT) // broche configuré en entrée
16
•Instructions d’envoi en sortie
digitalWrite (broche, HIGH) // la sortie broche est positionnée à l’état haut digitalWrite
(broche, LOW) // la sortie broche est positionnée à l’état bas analogWrite (broche, value) //
concerne l’écriture dans les 6 sorties PWM
•Instructions de lecture des 6 entrées analogiques A0 à A5

analogRead (broche) // concerne les entrées analogiques A0 à A5 (0 à 5V). // Conversion
A/N 10 bits  mapping de 0 à 1023
IV. Application TPs à l’aide d’un Arduino
 Matériel Nécessaire
 Une plaque d'essai pour montage sans soudures

 Des straps,
 Arduino UNO
 Une résistance 1/4w de 200 Ohms environ
 Un bouton poussoir pour CI
 Un digit 7 segments à cathode commune,
 8 résistances 1/4w de 270 Ohms
 Un capteur de température TMP36 ou LM35.
 Un moteur DC 3 – 9 volt
 Une Diode 1N4001
 Un transistor 2N ou PN 2222
 Une résistance 1/4w de 2200 Ohms
 Un Servomoteur
 Une résistance variable de 10 KOhms environ
17
TP1 : Clignoter un LED
Objectif du TP : On désire clignoter un LED à l’aide d’un Arduino Uno comme donnée
par la figure suivante :
Le fonctionnement normal est décrit par le chronogramme suivant :
18
1) Montage Pratique :
2) Le programme :
// C++ code
void setup()
{
pinMode(2, OUTPUT);
}
void loop()
{
digitalWrite(2, HIGH);
delay(1000); // Wait for 1000 ms
digitalWrite(2, LOW);
delay(500); // Wait for 500 ms
}
Test du programme :
Après avoir téléversé ce programme sur la carte Arduino, la LED connectée à la broche 13
devrait clignoter selon les spécifications du cahier des charges (TH=1000 ms et TB=500 ms).
Conclusion :
À l'issue de ce TP, nous avons acquis une meilleure compréhension sur la manière de
contrôler une LED à l'aide d'une carte Arduino et de programmer un clignotement périodique.
Ce processus nous a permis de mettre en pratique les principes fondamentaux de la
programmation embarquée et de réaliser une tâche simple mais essentielle en électronique
19
TP 2 : Faire feu de circulation à deux voies à l’aide d’un
Arduino.
Objectif du TP : L'objectif de ce TP est de simuler le fonctionnement d'un feu de
circulation à deux voies en utilisant des LED rouges, jaunes et vertes connectées à u n
Arduino. Comme donnée par la figure suivante :
L’étude est simple simule les feux de circulation sur 2 groupes de 3 leds rouge-jaune-vert et
le fonctionnement normal est décrit par le chronogramme donné par la figure suivante.
20
1) Montage Pratique :
2) Le programme
// Broches des LED pour la première voie

const int R1 = 2;
const int O1 = 3;
const int V1 = 4;
// Broches des LED pour la deuxième voie

const int R2 = 5;
const int O2 = 6;
const int V2 = 7;
// Durées des états des feux

const int tempsRouge = 1000; // 1000 milisecondes pour le feu rouge
const int tempsVert = 1000; // 1000 milisecondes pour le feu vert
const int tempsJaune = 600; // 600 miliseconde pour le feu jaune
void setup() {
// Initialise les broches des LED en sortie
pinMode(R1, OUTPUT);
pinMode(O1, OUTPUT);
pinMode(V1, OUTPUT);
pinMode(R2, OUTPUT);
pinMode(O2, OUTPUT);
pinMode(V2, OUTPUT);
}
21
void loop() {
// Voie 1 : feu rouge
digitalWrite(R1, HIGH);
digitalWrite(O1, LOW);
digitalWrite(V1, LOW);
delay(tempsRouge);
// Voie 1 : feu rouge/jaune

digitalWrite(R1, LOW);
digitalWrite(O1, HIGH);
delay(tempsJaune);
// Voie 1 : feu vert

digitalWrite(V1, HIGH);
delay(tempsVert);
// Voie 1 : feu jaune

delay(tempsJaune);
// Voie 2 : feu rouge

digitalWrite(R2, HIGH);
delay(tempsRouge);
// Voie 2 : feu rouge/jaune

delay(tempsJaune);
// Voie 2 : feu vert

digitalWrite(V2, HIGH);
delay(tempsVert);
22
// Voie 2 : feu jaune
delay(tempsJaune);
}
Test du programme :
 Connectez les LED selon les instructions de montage.

 Téléversez le programme sur votre carte Arduino.
 Observez le fonctionnement des LED pour simuler le feu de circulation à deux voies.
Conclusion : Dans ce TP, nous avons réussi à simuler le fonctionnement d'un feu de
circulation à deux voies en utilisant un Arduino et des LED. En modifiant les temporisations
dans le programme,il est possible d'adapter le fonctionnement du feu en fonction de la densité
de la circulation. Ce TP démontre comment utiliser l'Arduino pour contrôler des périphériques
externes et simuler des systèmes du monde réel.
23
TP 3 : (minuterie de cage d'escalier)
Objectif du TP : L'objectif de ce TP est de créer une minuterie d'escalier à l'aide d'un

Arduino et d'un bouton poussoir. Lorsque le bouton poussoir est enfoncé, une LED doit
s'allumer pendant 300ms, puis puis s'éteint suite à l’action sur le bouton poussoir.
Le schéma du montage
1) Montage Pratique
24
2) Le programme
boolean buttonWasUp = true;

boolean ledEnabled = false;
void setup() {
pinMode(10, OUTPUT); // Définir la broche 10 comme sortie pour contrôler la
LED
pinMode(2, INPUT_PULLUP); // Définir la broche 2 comme entrée avec
résistance de pull-up interne pour le bouton poussoir
}
void loop() {
boolean buttonIsUp = digitalRead(2);
if (buttonWasUp && !buttonIsUp) {
delay(10);
buttonIsUp = digitalRead(2);
if (!buttonIsUp) {
ledEnabled = !ledEnabled; // Inverser l'état de la LED
digitalWrite(10, ledEnabled); // Allumer ou éteindre la LED en fonction de
ledEnabled
}
}
buttonWasUp = buttonIsUp; // Mettre à jour l'état précédent du bouton
}
Test du programme :
 Connectez le bouton poussoir à la broche 2 et la LED à la broche 10.
 Appuyez sur le bouton poussoir pour observer le fonctionnement de la minuterie
d'escalier : la LED doit s'allumer pendant 300ms puis s'éteint suite à l’action sur le
bouton poussoir.
Conclusion :
Ce TP nous a permis de mettre en œuvre une minuterie d'escalier simple à l'aide d'un
Arduino et d'un bouton poussoir. Le programme développé permet d'allumer la LED
pendant une durée déterminée (300ms) lorsqu'un utilisateur appuie sur le bouton
poussoir, ce qui simule le fonctionnement d'un éclairage d'escalier. Cette expérience
démontre comment contrôler des périphériques externes avec un Arduino pour créer
des fonctionnalités interactives.
25
TP 4 (Afficheur 7 segments standard)
Objectif du TP : L'objectif de ce TP est d'afficher les chiffres de 0 à 9 sur un afficheur 7
segments standard à l'aide d'un Arduino.
1) Montage Pratique
26
2) Le programme
byte segA = 2; //Display pin 11

byte segB = 3; //Display pin 7
byte segC = 4; //Display pin 4
byte segD = 5; //Display pin 2
byte segE = 6; //Display pin 1
byte segF = 7; //Display pin 10
byte segG = 8; //Display pin 5
byte digit1 = 9;
void setup() {
pinMode(segA, OUTPUT);
pinMode(segB, OUTPUT);
pinMode(segC, OUTPUT);
pinMode(segD, OUTPUT);
pinMode(segE, OUTPUT);
pinMode(segF, OUTPUT);
pinMode(segG, OUTPUT);
pinMode(digit1, OUTPUT);
}
void loop() {
for (int i = 0; i < 10; i++) {
lightNumber(i);
delay(1000);
}
}
void affiche(int toDisplay) {

#define DISPLAY_BRIGHTNESS 750
#define DIGIT_ON 0
#define DIGIT_OFF 1
for (int digit = 1 ; digit > 0 ; digit--) {
//Turn on a digit for a short amount of time
switch (digit) {
case 1:
digitalWrite(digit1, DIGIT_ON);
lightNumber(toDisplay % 10);
toDisplay /= 10;
delayMicroseconds(DISPLAY_BRIGHTNESS);
break;
27
}
//Turn off all segments
lightNumber(10);
//Turn off all digits
digitalWrite(digit1, DIGIT_OFF);
}
}
//Given a number, turns on those segments

//If number == 10, then turn off number
void lightNumber(int numberToDisplay) {
#define SEGMENT_ON 1 //ANODE = 0; CATHODE = 1;
#define SEGMENT_OFF 0 //ANODE = 1; CATHODE = 0;
switch (numberToDisplay) {
case 0:
digitalWrite(segA, SEGMENT_ON);
digitalWrite(segB, SEGMENT_ON);
digitalWrite(segC, SEGMENT_ON);
digitalWrite(segD, SEGMENT_ON);
digitalWrite(segE, SEGMENT_ON);
digitalWrite(segF, SEGMENT_ON);
digitalWrite(segG, SEGMENT_OFF);
digitalWrite(13, SEGMENT_OFF);
break;
case 1:
digitalWrite(segA, SEGMENT_OFF);
digitalWrite(segD, SEGMENT_OFF);
digitalWrite(segE, SEGMENT_OFF);
digitalWrite(segF, SEGMENT_OFF);
break;
case 2:
digitalWrite(segC, SEGMENT_OFF);
digitalWrite(segG, SEGMENT_ON);
28
break;
case 3:
break;
case 4:
break;
case 5:
digitalWrite(segB, SEGMENT_OFF);
break;
case 6:
break;
case 7:
29
break;
case 8:
break;
case 9:
break;
// all segment are ON
case 10:
digitalWrite(segC, SEGMENT_OFF);
break;
}
}
30
Test du programme :
 Connectez les broches de l'afficheur 7 segments aux broches de l'Arduino selon les
instructions de montage.
 Observez l'afficheur 7 segments pour voir les chiffres de 0 à 9 s'afficher en boucle.
Conclusion : Ce TP nous a permis de contrôler un afficheur 7 segments standard à l'aide

d'un Arduino. En utilisant un tableau de correspondance des segments pour chaque chiffre,
nous avons réussi à afficher les chiffres de 0 à 9 sur l'afficheur en boucle. Ce TP démontre
comment utiliser un Arduino pour contrôler des périphériques externes et afficher des
informations visuelles.
31
TP 5 : Acquisition de la tension Vout et affichage de la
température
Objectif du TP : L'objectif de ce TP est de mesurer une tension analogique à l'aide du
convertisseur analogique-numérique (CAN) de la carte Arduino, puis de convertir cette tension
en température en utilisant une formule de conversion prédéfinie. La température ainsi obtenue
sera affichée sur le moniteur série de l'IDE Arduino.
Le schéma du montage :
NB : La conversion du signal analogique en numérique de 0 à 1024 est donné par :

Vout=capteur_Pin0 * 5.0/1024
La conversion du voltage vers température en C est donnée par :
temperature = (Vout) *100
1) Montage Pratique
32
2) Le programme
const int capteurPin = A0; // Broche analogique utilisée pour le capteur

void setup() {
Serial.begin(9600); // Initialisation de la communication série
}
void loop() {
int valeurAnalogique = analogRead(capteurPin); // Lecture de la valeur
analogique
float Vout = valeurAnalogique * 5.0 / 1024.0; // Conversion de l'analogique à
voltage (0-5V)
float temperature = Vout * 100.0; // Conversion du voltage à température (en
°C)
Serial.print("Tension (Vout): ");
Serial.print(Vout, 2); // Affichage de la tension avec 2 décimales
Serial.print(" V, Température: ");
Serial.print(temperature, 2); // Affichage de la température avec 2 décimales
Serial.println(" °C");
delay(1000); // Attente d'une seconde avant la prochaine lecture
}
Test du programme :
 Connectez le capteur analogique à la broche A0 de l'Arduino.

 Ouvrez le moniteur série de l'IDE Arduino pour afficher les valeurs de tension et de
température.
33
 L'affichage de la tension Vout et de sa température correspondante
dans le moniteur série :
Conclusion :
Ce TP nous a permis de comprendre comment utiliser le convertisseur analogique-numérique
(CAN) de l'Arduino pour mesurer une tension analogique. En utilisant une formule de
conversion prédéfinie, nous avons converti cette tension en température en degrés Celsius. En
affichant les valeurs de tension et de température sur le moniteur série, nous pouvons surveiller
les variations de température en temps réel. Ce TP démontre l'importance et la facilité de
l'acquisition de données analogiques avec un Arduino.
34
TP 6 : Commande d'un moteur à courant continu
(DC motor) avec Arduino
Objectif du TP : L'objectif de ce TP est de contrôler la vitesse d'un moteur à courant continu
(DC) en utilisant une carte Arduino. Pour ce faire, nous allons utiliser la modulation de largeur
d'impulsion (PWM) pour ajuster le rapport cyclique et donc la vitesse du moteur.
Le schéma théorique du montage
Cahier de charge.
TON = 2500, TOFF =1000 et une largeur de « duty cycle » voulue : 39.215% , 74.509% et
100% de la période.
IMPORTANT
Ce programme exploite l'instruction analogWrite(broche, largeur) qui permet de générer très
simplement une impulsion PWM (Pulse Width Modulation en anglais). Cette instruction
permet de moduler la largeur d'impulsion, la fréquence restante fixe aux alentours de 490 Hz
par défaut.
L'instruction analogWrite() n'est disponible que sur les broches 3, 5,6,9,10,11.
Avec l'instruction analogWrite(broche, largeur), on va pouvoir générer une impulsion PWM
avec une largeur de « duty cycle » voulue :
si valeur = 0, le duty cycle sera de 0% de la période
si valeur = n, le duty cycle sera de (n/255)*100% de la période.
35
1) Montage Pratique
2) Le programme
int moteurPin = 3; // Connectez le moteur à la broche 9

int TOFF = 1000; // Temps d'activation en microsecondes
int TON = 2500; // Temps de désactivation en microsecondes
void setup() {
pinMode(moteurPin, OUTPUT);
}
void loop() {
// Duty cycle de 39.215%
analogWrite(moteurPin, 100 * TOFF / (TOFF + TON));
delay(TOFF + TON);
36
// Duty cycle de 74.509%
analogWrite(moteurPin, 100 * TON / (TOFF + TON));
delay(TOFF + TON);
// Duty cycle de 100%

analogWrite(moteurPin, 255); // La valeur maximale pour le duty cycle
delay(TOFF + TON);
}
Test du programme :
 Connectez le moteur à la broche 9 de l'Arduino.

 Observez le moteur fonctionner à différentes vitesses, contrôlées par la modulation de
largeur d'impulsion (PWM).
Conclusion : Ce TP nous a permis de contrôler efficacement la vitesse d'un moteur à

courant continu en utilisant une carte Arduino et la modulation de largeur d'impulsion (PWM).
En ajustant le rapport cyclique, nous avons pu modifier la vitesse du moteur à volonté. Cette
méthode est largement utilisée dans les applications où une commande de vitesse précise est
requise, telles que les robots, les ventilateurs, les tapis roulants, etc. Ce TP démontre
l'importance et la facilité de la commande des moteurs avec un Arduino.
37
TP 7 : Commande d'un servomoteur avec une
résistance variable
Objectif du TP : L'objectif de ce TP est de contrôler la vitesse et le sens de rotation d'un
servomoteur à l'aide d'une résistance variable et d'une carte Arduino. La position médiane de
la résistance doit mettre le servomoteur à l'arrêt, tandis que la rotation de la résistance vers la
droite ou la gauche doit faire tourner le moteur dans l'un ou l'autre sens à des vitesses variables.
De plus, la largeur d'impulsion courante doit être affichée sur le port série pour permettre
d'étalonner le servomoteur à rotation continue.
Préparation du montage et programmation de la carte Arduino

 Commencer par réaliser le montage indiqué sur plaque d'expérimentation
 Ecrire le programme langage Arduino qui permet de contrôler la vitesse et le sens de
rotation à l'aide d'une résistance variable conformément aux :
o La position médiane de la résistance met le servomoteur à l'arrêt.
38
o La rotation vers la droite/gauche de la résistance fait tourner le moteur dans l'un
ou l'autre sens à des vitesses variables.
o La largeur d'impulsion courante est affichée sur le port série pour permettre
d'étalonner le servomoteur à rotation continue.
1) Montage Pratique
2) Le programme
#include <Servo.h> // Inclure la bibliothèque Servo
// Broche utilisée pour lire la résistance variable
const int resistancePin = A0;
// Broche utilisée pour contrôler le servomoteur

const int servoPin = 2;
// Créer un objet Servo

Servo myservo;
// Définir les valeurs minimale et maximale pour l'angle du servomoteur

const int angleMin = 0; // Ajuster selon la position minimale souhaitée
const int angleMax = 180; // Ajuster selon la position maximale souhaitée
void setup() {
// Initialise la communication série
Serial.begin(9600);
// Attache le servomoteur à la broche de commande

myservo.attach(servoPin);
}
39
void loop() {
// Lecture de la valeur de la résistance variable
int resistanceValue = analogRead(resistancePin);
// Convertit la valeur lue de la résistance en angle pour le servomoteur

int angle = map(resistanceValue, 0, 1023, angleMin, angleMax);
// Affichage de la valeur de la résistance et de l'angle sur le port série

Serial.print("Resistance Value: ");
Serial.print(resistanceValue);
Serial.print(", Angle: ");
Serial.println(angle);
// Envoie l'angle calculé au servomoteur

myservo.write(angle);
// Affichage de la largeur d'impulsion courante sur le port série

Serial.print(" (microseconds): ");
Serial.println(myservo.readMicroseconds());
// Attente avant la prochaine lecture

delay(1000); // Peut être ajusté selon les besoins
}
Test du programme :
 Connectez la résistance variable (potentiomètre) à la broche A0 de l'Arduino.

 Connectez le servomoteur à la broche 9 de l'Arduino.
 Ouvrez le moniteur série de l'IDE Arduino pour observer la largeur d'impulsion
courante affichée.
 Tournez la résistance variable dans les deux sens pour observer le mouvement du
servomoteur.
40
 L'affichage de la largeur d'impulsion courante dans le moniteur série :
Conclusion :
Ce TP nous a permis de contrôler efficacement un servomoteur en utilisant une résistance

variable et une carte Arduino. En convertissant la valeur de résistance lue en angle pour le
servomoteur, nous avons pu contrôler la vitesse et le sens de rotation du moteur en fonction de
la position de la résistance. En affichant la largeur d'impulsion courante sur le port série, nous
avons pu observer le comportement du servomoteur en temps réel, ce qui nous a permis
d'étalonner le servomoteur selon nos besoins. Ce TP démontre l'importance et la facilité de
contrôler les servomoteurs avec un Arduino dans diverses applications.
41
V. COCLUSION :
En conclusion, Arduino s'est imposé comme une plateforme incontournable dans le domaine
de l'électronique grâce à sa simplicité d'utilisation, sa polyvalence et sa large communauté de
développeurs. Tout au long de cette documentation, nous avons exploré les bases d'Arduino,
depuis sa définition et ses avantages jusqu'à son application pratique à travers une série de
travaux pratiques.
Nous avons commencé par découvrir ce qu'est Arduino et pourquoi il est devenu si populaire
parmi les amateurs et les professionnels de l'électronique. Nous avons examiné son matériel,
en détaillant les différentes cartes disponibles et en expliquant leur fonctionnement. Nous
avons également exploré l'environnement de développement intégré (IDE) d'Arduino et appris
à programmer en utilisant le langage Arduino.
Ensuite, nous avons plongé dans des travaux pratiques concrets qui nous ont permis
d'appliquer nos connaissances et de créer divers projets, tels que le clignotement de LED, la
commande de moteurs et de servomoteurs, la lecture de capteurs, et bien d'autres encore.
Chaque TP nous a permis de comprendre davantage les possibilités offertes par Arduino et de
développer nos compétences en électronique et en programmation.
Enfin, nous avons constaté que les applications d'Arduino sont presque illimitées, allant de
simples projets de bricolage à des applications professionnelles complexes. Que vous soyez un
débutant curieux ou un professionnel expérimenté, Arduino offre un terrain fertile pour
l'innovation et la créativité dans le domaine de l'électronique.
En conclusion, Arduino est bien plus qu'une simple plateforme de prototypage électronique
c’est un outil puissant qui permet à chacun de donner vie à ses idées et de réaliser des projets
passionnants. Nous espérons que cette documentation vous a fourni les connaissances et les
compétences nécessaires pour explorer pleinement le monde d'Arduino et pour créer vos
propres projets électroniques.
42

Rapport Du TPs Électronique Embarqué

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

Rapport Du TPs Électronique Embarqué

Transféré par

Droits d'auteur :

Formats disponibles

Université Ibn Tofail

Faculté des sciences Kenitra

Figure3:Modélisme avionique Figure 4:Modelisme automobile

Figure 3:Diverses Cartes Ardouino

Figure 4:La carte Ardouino UNO

 Les entrées et les sorties numériques :

 Les sorties PWM :

 Les broches de spi :

 Les broche de I2C:

2.2. Alimentation de la carte Arduino Uno :

On a 3 possibilités pour alimenter la carte :

5V - alimente le microcontrôleur et permet d'alimenter des circuits avec une tension

Figure 5:L'alimentation de la carte Ardouino

Le bouton RESET à côté du connecteur USB sert à réinitialiser la carte Arduino.

1. Présentation de l’interface IDE :

 de pouvoir écrire et compiler des programmes pour la carte Arduino

Cet environnement de développement intégré (EDI) dédié au langage Arduino et à la

Figure 6:Présentation de la fenêtre IDE Arduino

Le logiciel Arduino intègre également :

 La fenêtre « Terminal » s'ouvre alors :

Figure 7:Le moniteur série (Terminal série).

a. Description de la barre des boutons

Vérifier/compiler : Vérifie le code à la recherche d'erreur.

Stop : Stoppe le moniteur série ou les autres boutons activés.

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

Sauver : Enregistre votre programme.

Moniteur Série : Ouvre la fenêtre du moniteur (ou terminal) série.

b. Transfert des programmes vers la carte Arduino

 Poupremière programmation de la carte, aller dans le menu File>Examples>Digital>Blink:

Figure 9:La console IDE Arduino

 Sur un Mac, le port série ressemble probablement à quelque chose comme

Figure 10: Le téléversement du programme vers la carte Arduino

 Structure globale d’un programme langage Arduino

Le programme Arduino comprend :

 Après avoir pris en compte les instructions de la partie déclarative,

Le déroulement d’un programme Langage Arduino

Le langage Arduino est basé sur les langages C/C++.

 Quelques instructions utiles

•Instructions de configuration I/O

•Instructions de lecture des 6 entrées analogiques A0 à A5

IV. Application TPs à l’aide d’un Arduino

 Une plaque d'essai pour montage sans soudures

Le fonctionnement normal est décrit par le chronogramme suivant :

// Broches des LED pour la première voie

// Broches des LED pour la deuxième voie

// Durées des états des feux

// Voie 1 : feu rouge/jaune

// Voie 1 : feu vert

// Voie 1 : feu jaune

// Voie 2 : feu rouge

// Voie 2 : feu rouge/jaune

// Voie 2 : feu vert

 Connectez les LED selon les instructions de montage.

Objectif du TP : L'objectif de ce TP est de créer une minuterie d'escalier à l'aide d'un

boolean buttonWasUp = true;

byte segA = 2; //Display pin 11

void affiche(int toDisplay) {

//Given a number, turns on those segments

Conclusion : Ce TP nous a permis de contrôler un afficheur 7 segments standard à l'aide

NB : La conversion du signal analogique en numérique de 0 à 1024 est donné par :

const int capteurPin = A0; // Broche analogique utilisée pour le capteur

 Connectez le capteur analogique à la broche A0 de l'Arduino.

Le schéma théorique du montage