Support de travaux pratiques

ATELIER DE CONCEPTION ET D’ETUDE

DES SYSTEMES PROGRAMMES
Classes : Master I (EEA)

NOM DE L’ETUDIANT:

Enseignant: Dr GOUNE CHENGUI

Année universitaire : 2022/2023

Page 1 sur 53
Plan :

Semaine TP

Séance 1 Prise en main de l’environnement de la carte d’Arduino.

Faire clignoter une LED et Feux de signalisation
Séance 2
Programmation des interfaces parallèles.
Séance 3
Conception d’interface pour manipuler un afficheur alphanumérique
Séance 4
Programmation d’ interface pour une luminosité variée d'une LED .
Séance 5
Programmation de l’interface série
Séance 6

Séance 7 Mise en œuvre d’une application d’interfaçage.

Séance 8 Capteur à ultrason avec Arduino
Séance 9 Mesure de température et d’humidité à l’aide des
capteurs DHT11, DHT22
Séance 10 module Bluetooth HC-05.
Séance 11 La photorésistance et Arduino.
Séance 12 Clavier matriciel /Ecran
Séance 13 Conception et réalisation des applications embarquées.

Pré-requis :
Microprocesseurs, Microcontroleurs, Systèmes logiques, Architecture des Ordinateurs

Objectifs Spécifiques:

Apprendre à concevoir une interface parallèle et série.

Être capable de mettre en œuvre une application d’interfaçage.

Moyens et Outils Pédagogiques

Fascicule de travaux pratiques
Environnement de développement (carte d’Arduino, Logiciel porteuse)
Documentation constructeur.

Page 2 sur 53
TP N1: Prise en main de l’environnement de la carte d’Arduino.

Classes : M1- EEA

UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif: se familiariser avec l’environnement de la carte d’Arduino et son espace dedéveloppement

intégré (EDI) Arduino.

I. Introduction :
Le système Arduino est une solution simple et abordable pour développer des montages électroniques
numériques programmables à base de microcontrôleurs.
C’est une plateforme open-source qui est basée sur une simple carte à microcontrôleur, et un logiciel,
véritable environnement de développement intégré, pour écrire, compiler et transférer le programme
vers la carte à microcontrôleur.

Arduino peut être utilisé pour développer des applications matérielles industrielles légères ou des
objets interactifs (création artistiques par exemple). Les cartes Arduino peuvent recevoir sur les
broches d’entrées une très grande variété de capteurs et contrôler sur les broches de sortie une grande
variété d’actionneurs (lumières, moteurs ou toutes autres sorties matériels).
Les projets Arduino peuvent être autonomes, ou communiquer avec des logiciels sur un ordinateur.
Les cartes électroniques peuvent être fabriquées manuellement ou bien être achetées préassemblées;
le logiciel de développement open-source est téléchargeable gratuitement.

Page 3 sur 53
 II. L’Arduino UNO
Résumé des caractéristiques de la carte Arduino uno:

Microcontrôleur ATmega328
Tension d'alimentation interne 5V
Tension d'alimentation externe 7 à 12V
Entrées/sorties numériques 14 dont 6 sorties PWM
Entrées analogiques 6
Courant max par broches E/S 40 mA
Courant max sur sortie 3,3V 50mA
Mémoire Flash 32 Ko
Mémoire SRAM 2 Ko
mémoire EEPROM 1 Ko
Fréquence horloge 16 MHz

III. Dimensions et organisation

Dimensions = 68.6mm x 53.3mm
La carte s'interface au PC par l'intermédiaire de sa prise USB.
La carte s'alimente par le jack d'alimentation (utilisation autonome) mais peut être alimentéepar
l'USB (en phase de développement par exemple).

Bouton Reset
Entrées/Sorties digitales 0-13

Connecteur USB
Microcontrôleur ATmega328

Jack d’alimentation externe

Broches d’alimentations
IV. Alimentation
La carte Arduino UNO peut être alimentée par l’USB ou par une alimentation externe. La source est
sélectionnée automatiquement.
La tension d’alimentation extérieure (hors USB) peut venir soit d’un adaptateur AC-DC ou de
piles. L’adaptateur peut être connecté grâce à un ‘jack’ de 2.1mm positif au centre. Le raccordement
vers un bloc de piles peut utiliser les bornes GND et VIN du connecteur d’alimentation (POWER).
La carte peut fonctionner à l’aide d’une tension extérieure de 7 à 12 volts. Les broches (pins)
d’alimentation sont les suivantes:

VIN. La tension d’entrée positive lorsque la carte Arduino est utilisée avec une source de tension
externe (à distinguer du 5V de la connexion USB ou autre source 5V régulée). Vous pouvez
alimenter la carte à l’aide de cette broche, ou, si l’alimentation est fournie par le jack d’alimentation,
accéder à la tension d’alimentation sur cette broche.

5V. La tension régulée utilisée pour faire fonctionner le microcontrôleur et les autres composants de
la carte (pour info : les circuits électroniques numériques nécessitent une tension d’alimentation
parfaitement stable dite « tension régulée » obtenue à l’aide d’un composant appelé 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.

3V3. Une alimentation de 3.3V fournie par un régulateur 3.3v LP2985 est disponible sur la carte.
Ceci est intéressant pour certains circuits externes nécessitant cette tension au lieu du 5V.
L’intensité maximale disponible sur cette broche est de 50mA

GND. Broche de masse (ou 0V).

V. Mémoire

L'ATmega 328 dispose de 32 kilo-octets de mémoire de programme. Cette mémoire est de type Flash,
analogue à celle que l'on trouve par exemple dans les clés USB.
L'ATmega 328 contient aussi de la mémoire vive ou RAM, analogue dans son principe à la mémoire
vive de vos PC, mais en beaucoup plus petite quantité puisque l'on ne dispose ici que de 2 kilo-
octets (contre plusieurs Giga octets dans un PC par exemple). Cette mémoire est généralement
utilisée pour les variables employées dans les programmes, pour stocker des résultats temporaires
lors de calculs, etc. Elle présente la particularité de pouvoir être lue et écrite à tout instant par le
microcontrôleur mais elle « oublie » son contenu dès qu'il n'est plus alimenté.
L’ATmega 328 dispose également de mémoire EEPROM, acronyme qui signifie mémoire
programmable et effaçable électriquement. La taille de cette EEPROM est seulement de 1kilo-
octets. Cette mémoire EEPROM est une mémoire dans laquelle le microcontrôleur peut lire à
tout instant. Il peut aussi y écrire et effacer son contenu, avec plus de facilité comme dans la
mémoire Flash de programme, mais avec moins de facilité que dans la mémoire vive. En
contrepartie, et comme c'est le cas pour la mémoire flash de programme, le contenu de
l'EEPROM est conservé même lorsqu'elle n'est plus alimentée. C'est donc une mémoire qui
sera utilisée pour conserver des données ou des paramètres que l'on doit pouvoir retrouver
d'une utilisation à l'autre de l'Arduino.

VI. Horloge
L’horloge est pilotée par quartz et fonctionne à la fréquence de 16 MHz.
Ainsi par exemple, la fonction delay(xxx), qui génère un délai de xxx ms, sait que l'horloge
fonctionne à 16 MHz et fait donc automatiquement appel aux instructions nécessaires pour générer le
délai que vous avez réellement demandé dans votre programme.

VII. Entrées et sorties

Chacune des 14 broches numériques de la carte Uno peut être utilisée en entrée (input) ou en sortie
(output), en utilisant les fonctions pinMode(), digitalWrite(), et digitalRead().
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’.
En outre, certaines broches ont des fonctions spécialisées :
• Serial : broche 0 (RX) et broche1 (TX). Permet de recevoir (RX) et de transmettre (TX) des données
séries TTL. Ces broches sont raccordées à leurs homologues sur le chip Atmega16U2 spécialisé
dans la conversion USB-to-TTL série.
• Interruptions externes 2 et 3. Ces broches peuvent être configurées pour déclencher une interruption
sur une valeur LOW, sur un front montant ou descendant, ou encore sur le changement de valeur.
(voir la fonction attachInterrupt() pour des détails).
• PWM : 3, 5, 6, 9, 10, and 11. Output 8-bit de PWM avec la fonction analogWrite(). • SPI :
10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Ces broches fournissent le support de communication SPI
en utilisant la ‘librairie’ spécialisée
• LED : Il y a une LED repérée L connectée à la broche digitale 13.
La carte Uno à 6 broches d’entrée analogiques, A0 à A5, chacune avec 10 bits de résolution (1024
valeurs différentes).
Par défaut les mesures sont effectuées de la masse à 5V (valeur de référence), mais il est possible de
spécifier la valeur de référence en utilisant la broche VREF et la fonction analogReference().
En outre, certaines broches ont des fonctions spécialisées :
• I2C : 4 (SDA) and 5 (SCL). Permettent le support du bus I2C (TWI) en utilisant le ‘library’Wire.
Autres broches sur la carte :
• AREF. Tension de référence déjà mentionnée.
• Reset. Permet au niveau bas (LOW° de faire un reset du contrôleur. Elle est utilisée typiquement
pour monter un bouton ‘reset’ aux cartes additionnelles (‘shields’) bloquant celui de la carte
principale.

VIII. Communication
La carte Arduino Uno a de nombreuses possibilités de communications avec l’extérieure.
L’Atmega328 possède une communication série UART TTL (5V), grâce aux broches numériques 0
(RX) et 1 (TX).
Un contrôleur Atmega16U2 sur la carte, gère cette communication série vers l’USB et apparaît
comme un port de communication virtuel pour le logiciel sur l’ordinateur.
Le firmware de l’16U2 utilise le protocole USB, et aucun driver externe n’est nécessaire. Windows a
cependant besoin d’un fichier .inf, à l’installation. Le logiciel Arduino possède un logiciel série
(Telnet) intégré permettant l’envoi et la réception de texte. Les DELs RX et TX sur la carte
clignoteront pour indiquer la transmission de données vers l’ordinateur.
Une librairie ‘SoftwareSerial’ permet la transmission de données série à partie de chacune des
broches numériques du Uno.
L’Atmega328 supporte le bus I2C (TWI) et le protocole de communication synchrone maître-esclave
SPI. Le logiciel Arduino inclut un ensemble de fonctions pour mettre en œuvre l’un ou l’autre.
IX. Programmation
La carte Arduino Uno peut être programmée directement avec « l’Arduino software ». L’Atmega328
sur la carte Uno est pré programmé avec un ‘bootloader’ qui permet de charger le code d’une
nouvelle application sans utiliser un programmateur hardware externe. Il communique avec un
ordinateur en utilisant le protocole STK500 d’ATMEL.
Mais vous pouvez programmer le contrôleur de la carte en utilisant le port ICSP (In-Circuit Serial
Programming).
Le code source du firmware du contrôleur auxiliaire Atmega16U2 est disponible.

X. Reset automatique

Toutes les cartes Arduino actuelles sont équipées d'un poussoir de reset manuel. Un appui
sur celui-ci permet donc 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.
Mais il existe aussi sur les cartes Arduino une autre source de reset.
Un reset automatique à la mise sous tension qui permet ainsi au programme contenu en
mémoire du microcontrôleur de démarrer automatiquement dès que la carte Arduino est
alimentée.

XI. Protection de surintensité USB

La carte Arduino Uno possède une protection par fusible pour le port USB si un courant de plus de
500mA est demandé. La déconnexion durera tant que la source de consommation excessive n’aura
pas cessé.

XII. Schéma structurel

XIII. Présentation de l’Espace de développement Intégré (EDI) 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 cet espace de développement intégré (EDI) dédié au langage
Arduino et à la programmationdes cartes Arduino comporte:
 Barre de menus

Barre de boutons

Onglets des fichiers ouverts

Fenêtre d’édition
des programmes

Zone de messages des actions

en cours

Console d’affichage des

messages de compilation

Le logiciel Arduino intègre également :

 Un terminal série (fenêtre séparée) 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.

Zone de saisie des valeurs à envoyer vers la carte Arduino bouton pour envoyer les valeurs vers la carte Arduino

Zone d’affichage des messages et caractères reçus

 XIV. Description de la structure d’un programme
Le langage Arduino est basé sur les langages C/C++.
Un programme utilisateur Arduino est une suite d’instructions élémentaires sous forme textuelle,
ligne par ligne. La carte lit puis effectue les instructions les unes après les autres, dans l’ordre défini
par les lignes de code, comme lors d’une programmation classique. Cette structure se décompose en
trois parties :

Définition des constantes et variables globales

Directive de compilation ; Define, Include, etc

Fonction principale : VOID SETUP()

Initialisation des ressources de la carte
Configuration des entrées/sorties
Définition de la vitesse de fonctionnement
du port série, etc.
Cette partie ne sera exécutée qu’une seule fois

Fonction boucle : VOID LOOP()

Description du fonctionnement général
du programme
Gestion des interactions entre les entrées/sorties
Cette partie sera exécutée en boucle

La structure d’un programme Arduino doit toujours comporter les fonctions Setup( ) et loop ()
Note :
Sur la plupart des cartes, vous devez voir les LEDs des lignes RX et
TX clignoter rapidement, témoignant que le programme est bien
transféré. Durant le transfert, le bouton devient jaune et le logiciel
Arduino afficheun message indiquant que le transfert est en cours.

XV. Les shields

Il existe de nombreux shields. Un « shield » Arduino est une petite carte qui se connecte surune carte
Arduino pour augmenter ses fonctionnalités. Quelques exemples de « shields » :

• Afficheur graphique
• Ethernet et carte SD
• GPS
• XBee
• GSM
• etc...

Dr GOUNE CHENGUI
 TP N2 : Faire clignoter une LED et Feux de signalisation
Classes : M1- EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Travail demandé:
I.1. Installer l’espace de développement intégré (EDI) Arduino.
I.2. Lancer le compilateur d’Arduino et écrire le programme suivant :

int led = 13;

void setup() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, LOW);
delay(500);
digitalWrite(led, HIGH);
delay(500);
}

Après compilation et s'il n’y a pas d'erreurs le fichier .hex est créé. Ce fichier sera implémenté dans la
carte d’Arduino. Que remarquez-vous dans la led intégrée dansla carte Arduino. ?
I.3. Réaliser ce montage où la LED est liée avec le pin 12.

I.4. Ecrire un programme pour clignoter la LED de ce montage avec un temps de 1s.

II. On désire automatiser la gestion de feux tricolores, réglant la circulation d’uncarrefour à deux voies à
l’aide d’un Arduino Uno.
Dr GOUNE CHENGUI
Le schéma du montage Arduino est donné comme montre la figure suivante :

Instructions de montage

Connecter sur la broche 2 (configurée en sortie) une LED rouge connectée avec sa résistance au 0V
Connecter sur la broche 3 une LED jaune connectée en série avec sa résistance au 0V
Connecter sur la broche 4 une LED verte connectée en série avec sa résistance au 0V
Connecter sur la broche 5 une LED rouge connectée en série avec sa résistance au 0V
Connecter sur la broche 6 une LED jaune connectée en série avec sa résistance au 0V
Connecter sur la broche 7 une LED verte connectée en série avec sa résistance au 0V

Le cahier des charges stipule la possibilité de moduler les temporisations par l’opérateur en
fonction de la densité de la circulation. 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.

Préparation du montage et programmation de la carte Arduino :

II.1. Commencer par réaliser le montage indiqué sur plaque d'expérimentation

II.2. Proposer un programme Arduino répondant à ce cahier de charge.
II.3. Ensuite, tester le programme.
Dr GOUNE CHENGUI
TP N3 : Programmation des interfaces parallèles.

Classes : M1- EEA

UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif : se familiariser avec la programmation des interfaces parallèles.

I. Introduction :
L’interface parallèle est un outil de traduction entre deux différents dialogues pour deux différents
environnements. Il permet une communication rapide où toute la donnée (octet) est envoyée en
même temps, libère le microcontrôleur pour faire d’autre taches…etc. Pour la bonne
compréhension de la manipulation de ce type d’interface, ce TP permet de programmer des
applications de manipulation d’afficheurs 7 segments via l’interface parallèle de la carte Arduino.

II. Travail demandé :

II.1. Lancer le compilateur d’Arduino et écrire le programme suivant qui permet de

commander l’afficheur 7 segments :

byte tab[10][7]={{ 1,1,1,1,1,1,0 }, // = 0

{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,0,0,1,1 } // = 9
};
int i,j,k;
void setup()
{for (i=1;i<10;i++) {pinMode(i, OUTPUT); }
}
void loop()
{for (i=0;i<10;i++) {
for (j=0;j<7;j++)
{ digitalWrite(j+2,tab[i][j]);}delay(1000);
}
}

Dr GOUNE CHENGUI
II.2. On donne le montage de la figure suivante :

II.3. Donner le programme qui permet d’afficher les chiffres de 00 a 99 avec le montage
suivant :

Dr GOUNE CHENGUI
TP N4 : Conception d’interface pour manipuler un afficheur alphanumérique

Classes : M1- EEA

UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif : Comprendre la conception d’interface pour manipuler un afficheur alphanumérique

1- Introduction sur les LCD :

Ce TP permet de se familiariser avec la conception d’interface pour manipuler et afficher

des textes sur un afficheur alphanumérique à savoir les LCDs.
L’afficheur LCD le HD44780 est un LCD 2 * 16 caractères. Un afficheur LCD, est un
petit écran sur lequel s’affichent des petits messages « alphanumériques » (c'est-à-dire
avec des chiffres et des lettres) Les modules standardisés avec microcontrôleur intégré
pour une utilisation simplifiée. Utilisés depuis de nombreuses années en électronique
numérique, les fabricants ont standardisé ces afficheurs sous forme de modules, avec un
brochage et un mode de fonctionnement identique quelque soit le fabricant. En fait c’est
un véritable petit microprocesseur (ou microcontrôleur) qui est associé à l’écran et qui en
assure le bon fonctionnement : le microcontrôleur de référence est le HD44780 de
Hitachi. Ces modules fonctionnent en 5V et ont une consommation faible
comparativement par exemple aux digits, de l’ordre de 2 ou 3 mA pour un module à
LCD entier. Le fait de la présence d’un microcontrôleur associé, on parle de modules
d’affichage LCD, ils disposent d’un véritable jeu d’instructions qui permettent
l’utilisation de fonction d’affichage élaboré. Le module LCD contient un microcontrôleur
interne qui lui permet de comprendre puis d’exécuter des instructions et d’utiliser des
données.
Pour faire fonctionner un module LCD, on aura besoin de lui fournir deux types
d’informations :
 Soit on lui dit ce qu’il doit faire (effacer l’écran, afficher le curseur, etc.) ; Ceci fait
grâce aux instructions.
 Soit on lui transmet les caractères à afficher (A, B, >, n…) ; Ce sont les codes
caractères ou données.

Dr GOUNE CHENGUI
  Pour faire la distinction entre instruction et donnée, le module LCD dispose de deux
registres, un pour les données s’appelle le « Data Register » (DR), et l’autre pour les
instructions s’appelle le « Instruction Register » (IR)
 Pour informer le module LCD de la nature de ce qu’on lui écrit sur les broches de
données, on utilise la ligne de commande RS (Register Select).
 Si RS = 0, le module sait que c’est une instruction et va donc l’écrire dans le
registre d’instruction.
 Si RS = 1, le module sait que c’est un code caractère et va donc l’écrire dans le
registre donné.
2- Les Broches numériques de Commande

 La broche E (Enable) : sert à valider les données ou les instructions écrites sur les
broches des données du module, la validation se fait sur le front descendant.

 La broche R / W (Read / Write) : sert à dire au module, si les broches des données
du module sont en entrée ou en sortie, c’est à dire si les données sont << écrites
>> vers le module, ou << lues >> depuis le module.

 La broche RS (Register Select) : sert à dire au module dans quel registre il doit
écrire les données présentes sur les broches de données.
Le brochage de LCD est donné dans le tableau suivant :

Avant d’afficher sur un LCD il faut bien évidement effacer l’écran et choisir le sens de
l’écriture, ainsi que la taille de matrice (DOT). En effet pour effacer un LCD il faut envoyer

Dr GOUNE CHENGUI
la commande 01H (voir tableau de commande) puis envoyer 0EH et 06H pour définir
respectivement la taille du caractère ainsi que le sens de l’écriture.
II. Travail demandé :

II.1. Lancer le compilateur d’Arduino et écrire un programme qui permet d’afficher un

message sur l’afficheur LCD :

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
lcd.begin(16, 2);
lcd.print("hello, world!");
}
void loop() {
lcd.setCursor(0, 1);
lcd.print(millis()/1000);
}

II.2. réaliser le schéma de la figure suivante :

Dr GOUNE CHENGUI
II.3. Ecrire le programme qui permet d’afficher la grandeur analogique sur le LCD :

int sensorPin = A0;

int ledPin = 13
int sensorValue = 0;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
sensorValue = analogRead(sensorPin);
digitalWrite(ledPin, HIGH);
}

II.4. Réaliser le schéma de la figure suivante en implémentant le programme de l’II.3.

Dr GOUNE CHENGUI
 TP N5: Programmation d’ interface pour une luminosité variée d'une LED .

Classes :M1- EEA

UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif : Ce TP a pour objectif de programmer une luminosité variée d'une LED .

I. Introduction :

Ce TP permet de comprendre COMMENT programmer une variation de la valeur moyenne de la

tension qui alimente un actionneur, dans notre cas c’est une LED.
Ce programme permet de faire varier la luminosité d'une LED sur une broche d'une carte Arduino. il
exploite l'instruction analogWrite(broche, largeur) qui permet de générer une impulsion PWM (Pulse
Width Modulation en anglais ou Modulation de Largeur d'Impulsion (MLI) en français). Cette
instruction permet de moduler la largeur d'impulsion, la fréquence restant fixe aux alentours de 490 hz
par défaut.
Note: L'instruction analogWrite() n'est disponible que sur les broches 3, 5,6,9,10,11.

I. 1/ Principe :
Une impulsion PWM est une impulsion (ou onde) carrée, c'est à dire que le niveau de l'onde est soit
HAUT soit BAS. Cette impulsion se répète dans le temps de façon continue.

Dr GOUNE CHENGUI
 Une telle onde, comme toute onde est caractérisée par sa période, c'est à dire la durée entre 2
impulsions. La définition d'une onde PWM (Pulse Width Modulation en anglais ou Modulation de
Largeur d'Impulsion (MLI) en français) se fait en modifiant la largeur du niveau HAUT par rapport à
la durée de la période : la largeur du niveau HAUT est appellee « duty cycle ».

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 = 255, le duty cycle sera de 100% de la période

 si valeur = 127, le duty cycle sera de 50% de la période

 si valeur = n, le duty cycle sera de (n/255)*100% de la période.

 
Vmoy  A.  5.
T T
Travail demandé :

II.1. Réalisation de la première manipulation:

Connecter sur la broche 3 (configurée en sortie) une LED et sa résistance (330 Ohms) ensérie
connectée au 0V

Dr GOUNE CHENGUI
 Figure : Le schéma théorique du montage

IMPORTANT : L'instruction analogWrite () n'est disponible que sur les broches 3,5,6,9,10,11
(notée PWM sur le brochage ci-dessous).

Figure : Le schéma du montage à réaliser

II.2. Ecrire le programme suivant en remarquant la variation luminosité de la LED :

const int LED=3; //déclaration constante de broche

Dr GOUNE CHENGUI
 // --- Déclaration des variables globales ---
int i=0; // variable de boucle

// --- Initialisation des fonctionnalités utilisées ---

//**************** FONCTION SETUP = Code d'initialisation *****

// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du
programme

void setup() { // debut de la fonction setup()

// --- ici instructions à exécuter au démarrage ---

pinMode(LED, OUTPUT); //met la broche en sortie

} // fin de la fonction setup()

// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme

*************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino
est sous tension

void loop(){ // debut de la fonction loop()

for (i=0; i<=255;i++){ // boucle for compte de 0 à 255

analogWrite(LED,i); // génère une impulsion sur la broche de largeur i = la

luminosité augmente

delay(10); // pause de 10 ms

} // fin de la boucle for

for (i=0; i<=255;i++){ // boucle for compte de 0 à 255

analogWrite(LED,255-i); // génère une impulsion sur la broche de largeur 255-i

// = la luminosité baisse

delay(10); // pause de 10 ms

} // fin de la boucle for

// --- ici instructions à exécuter par le programme principal ---

} // fin de la fonction loop() - le programme recommence au début de la fonction

loop sans fin
// ********************************************************************************

Remarque :
Avec l'instruction analogWrite(LED, largeur), on va pouvoir générer une impulsion PWM
avec une largeur de « duty cycle » voulue :
 si i = 0, le duty cycle sera de 0% de la période =>composante continue=0V

 si i = 127, le duty cycle sera de 50% de la période => composante continue=2.5V

 si i = 254 le duty cycle sera de( 254/255).100% de la période => composante continue=5*(254/255)V

 si i = 255, le duty cycle sera de 100% de la période => composante continue=5V

Dr GOUNE CHENGUI
La luminosité de la LED va ainsi varier de façon continue, augmentant puis diminuant de
façon répétée.

II.2. Commande d’un servomoteur à l'aide d'une résistance variable :

Le Servomoteur : est un moteur où on peut contrôler l’angle de rotation avec précision. Le
servomoteur contient :
 un moteur DC

 un driver : contrôler le sens de rotation

 un potentiomètre : régulation pour avoir une précision sur l’angle de rotation

 des engrenages

On vous propose le schéma théorique du montage :

Le schéma théorique du montage

Les servomoteurs classiques possèdent 3 fils de connexion de couleurs différentes:

 Le noir ou marron – La masse (GND)

Dr GOUNE CHENGUI
  Le rouge – La tension d’alimentation continue (+Vcc)

 Le jaune, orange ou blanc – Le signal de commande (PIN_PWM), on connecte ce fil à une des
sorties numériques (type PWM) du microcontrôleur. Ce signal de commande n’est rien d’autre
qu’un signal logique périodique. C’est pour ça qu’il est facile à générer à partir d’un
microcontrôleur. La largeur des créneaux va commander l’angle de l’arbre du servomoteur. La
durée du créneau doit être comprise entre 1 et 2ms pour la majorité des servomoteurs. Une
durée de 1ms correspond à l’angle 0° et 2ms correspond à l’angle 180°.

Le déroulement du programme

II.3. Ecrire les programmes suivants en expliquant leur fonctionnement utilisant II.2.:

 Programme N1 :

#include <Servo.h>

Servo myservo;

int potpin = 0;
int val;

void setup()
{
myservo.attach(9); }

void loop()
{
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 179);
myservo.write(val);
delay(15);
}

Dr GOUNE CHENGUI
 Programme N2:

#include <Servo.h>

Servo myservo;
int pos = 0;

void setup()
{
myservo.attach(9); }

void loop()
{
for(pos = 0; pos < 180; pos += 1)
{
myservo.write(pos);
delay(15);
}
for(pos = 180; pos>=1; pos-=1) {
myservo.write(pos);
delay(15);
}
}

 Programme N3:

#include <Servo.h>
Servo servo;
void setup()
{
servo.attach(9);
Serial.begin(9600);
}
void loop()
{

for(pos = 0; pos < 151; pos += 1)

{
servo.write(pos);
delay(40);
}
for(pos = 150; pos>=0; pos-=1)
{
servo1.write(pos);
delay(40);
}
}

Dr GOUNE CHENGUI
TP N6 : Programmation de l’interface série

Classes : M1- EEA

UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif : se familiariser avec la programmation d’interface série

1- Introduction sur d’interface série:
Ce TP permet de présenter un nouveau moyen de communication grâce à la voie série (ou “liaison
série”), qui va vous permettre de communiquer des informations à un ordinateur ou une autre carte
Arduino.

Lorsque l’on communique des informations, il faut nécessairement un émetteur, qui va transmettre
les informations à communiquer, et un récepteur, qui va recevoir les informations pour les traiter.

Fig.1. communication entre deux cartes Arduino

Dans le cas présent, deux carte Arduino communiquent. L’une communique à l’autre tandis que
l’autre réceptionne le message envoyé par la première.

Arduino est capable de faire des communications de type full-duplex, puisqu’elle est capable de
comprendre son interlocuteur tout en lui parlant en même temps.

1.1.Protocole de communication :

C’est un ensemble de règles qui régissent la façon dont communiquent deux dispositifs entre eux.
Cela définit par exemple le rythme de la conversation (le débit de parole des acteurs si vous
préférez), l’ordre des informations envoyées, le nombre d’informations, etc…
On peux citer quelques normes de liaisons séries : RS-232, USB, SATA…
La norme RS-232 s’applique sur des champs d’une communication de type série. Elle définit le
signal électrique, le protocole. Pour communiquer via la voie série, on utilise au minimum trois
fils, deux câbles permettent la transmission des données. L’un sert à l’envoi des données, l’autre
pour la réception. Le troisième représente la référence électrique, communément appelée masse
électrique.
1.2. Croisement de données
Dr GOUNE CHENGUI
Comme les microcontrôleurs utilisent quasiment tous cette norme, il n’y a aucun problème à
connecter deux microcontrôleurs entre-eux. Cette norme s’appelle alors UART (Universal
Asynchronous Receiver Transmitter) plutôt que RS232 (interface entre Arduino et PC). maintenant
simplement on croise les fils. On connecte le Tx (broche de transmission) d’un microcontrôleur au
Rx (broche de réception) de l’autre microcontrôleur. Et inversement, le Tx de l’autre au Rx du
premier. Et bien sûr, la masse à la masse pour faire une référence commune. comme c’est indiqué
ci-dessous :

Fig.2. communication série entre deux cartes Arduinos

On utilise la fonction Serial.write(val) pour envoyer une donnée et sur l'autre carte Arduino
Serial.read() pour la lire.
Lors de l'envoi par série, tout est envoyé en octets. Ces octets sont ensuite lus un octet à la fois par
l'autre Arduino.
1- realiser le cablage entre deux cartes arduino uno

2- écrire le programme suivant dans le cote émetteur :

char str[4];
void setup() {
Serial.begin(9600); // vitesse de transmission
}
void loop() {
int value=1234; //valeur
itoa(value, str, 10); // la valeur dans un tableau de caractères
Serial.write(str, 4);
}
3- Le récepteur reçoit alors le tableau d'octets de l'autre Arduino. il interprète les données reçues
puis les imprime sur le Serial Monitor. On vous demande alors d’écrire le programme suivant dans
le cote récepteur:

Dr GOUNE CHENGUI
char str[4];
void setup() {
Serial.begin(9600);
Serial1.begin(9600);
}
void loop() {
int i=0;
if (Serial1.available()) {
delay(100);
while(Serial1.available() && i<4) {
str[i++] = Serial1.read();
}
str[i++]='\0';
}

if(i>0) {
Serial.println(str,4);
}
}

Dr GOUNE CHENGUI
TP N7 : Mise en œuvre d’une application d’interfaçage.

Classes : M1- EEA

UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif : se familiariser avec une application d’interfaçage : « la commande d’un moteur pas à
pas »

I. Introduction :
La robotique utilise souvent les moteurs pas à pas. Ainsi et dans ce but, ce TP permet de Mettre en
œuvre une application d’interfaçage.
Les moteurs pas à pas sont utilisés dans de nombreux appareils (imprimantes, fax, photocopieurs,
traceurs ....) le but étant de faire déplacer des ensembles mobiles avec une grande précisions par
rapport à des moteurs à courant continu classique. Avec un moteur pas à pas, on peut
déterminer l’angle exact de rotation, l’accélération ou le sens de rotation en modifiant l’alimentation
des bobines.
Un moteur pas à pas est un moteur qui tourne en fonction des impulsions électriques reçues dans ses
bobinages. L'angle de rotation minimal entre deux modifications des impulsions électriques s'appelle
un pas. On caractérise un moteur par le nombre de pas par tour (c'est à dire pour 360°). Les
impulsions électriques sont du type tout ou rien alors que les tensions d'utilisation des moteurs sont de
3,3V à 48V continues.

Le moteur pas à pas bipolaire à aimant permanent bipolaire est le modèle le plus simple dans son
fonctionnement. Le rotor est constitué d’un aimant permanent, et le stator comporte 2 bobinages (ou 2
groupes de bobinages). La rotation est obtenue en contrôlant l'alimentation des bobines ainsi que le
sens du courant dans celles-ci, on peut faire varier le champ dans le moteur.
II. Fonctionnement :
II.1. Fonctionnement en pas entier :

Dr GOUNE CHENGUI
Dans ce mode de fonctionnement, les bobines sont alimentées l’une après l’autre dans unsens
puis dans l’autre, pour faire un tour complet, il faut 4 pas.

 pas complet
Phase 1 2 3 4 5 6 7 8
Phase 1 1 0 0 0 1 0 0 0
(A+)
Phase 2 0 1 0 0 0 1 0 0
(B+)
Phase 3 0 0 1 0 0 0 1 0
(A-)
Phase 4 0 0 0 1 0 0 0 1
(B-)

Note : le fonctionnement avec couple maximal est obtenu si on alimente les bobines, deux par
deux à chaque fois.

II.2. Fonctionnement en demi-pas :

Pour augmenter l’intensité du flux magnétique créé par le stator, et donc le couple moteur, on peut
ajouter au mode de pas complet l’alimentation des deux bobines en même temps, pour faire un tour
complet, il faut 8 pas.

 Demi-pas

Phase 1 2 3 4 5 6 7 8
Phase 1 1 1 0 0 0 0 0 1
(A+)
Phase 2 0 1 1 1 0 0 0 0
(B+)
Phase 3 0 0 0 1 1 1 0 0
(A-)
Phase 4 0 0 0 0 0 1 1 1
(B-)

Remarque : Dans les exemples précédents, on a vu que l'on alimente les enroulements dans
les deux sens de courant, il existe aussi les moteurs à aimant permanent unipolaire possédant des
demi-bobines (avec un point milieu). L'avantage est que l'on n'inverse jamais le sens du courant,
donc la commande est plus simple. Tout le problème est que l'on « double » le nombre
d'enroulements, donc le moteur est plus coûteux et encombrant, néanmoins cela reste très
courant pour les petites puissances.
Dr GOUNE CHENGUI
III. Travail demandé :
III.1. Dessiner le schéma sous Proteus-ISIS.

III.2. Quel est le type de ce moteur pas à pas ( bipolaire ou unipolaire ) ?

III.3. Donner les programmes qui permettent de présenter les fonctionnements du pas completet
demi-pas ?.
III.4. Refaire III.1. avec l’autre type du moteur pas à pas.
III.5. Donner les programmes qui permettent de présenter les fonctionnements du pas completet
demi-pas ?.

III.6. Réaliser le montage ci-dessous et faire un programme pour la rotation complete du moteur
dans les deux sens.

Dr GOUNE CHENGUI
Dr GOUNE CHENGUI
 TP N8 : Capteur à ultrason avec Arduino
Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

1) Présentation du module HC-SR04 :

Les caractéristiques techniques du module sont les suivantes :

- Alimentation : 5v.
- Consommation en utilisation : 15 mA.
- Gamme de distance : 2 cm à 5 m.
- Résolution : 0.3 cm.
- Précision : 1 cm
- Angle de mesure : < 15°.

Le fonctionnement du module est le suivant :

Il faut envoyer une impulsion niveau haut (à + 5v) pendant au moins 10 µs sur la broche ‘Trig Input’; cela
déclenche la mesure. En retour la sortie ‘Output’ ou ‘Echo’, va fournir une impulsion + 5v dont la durée est
proportionnelle à la distance si le module détecte un objet.
Voici une représentation graphique de la séquence de fonctionnement du module :
 2) Montage
Le détecteur SR04 possède 4 broches : 2 pour l’alimentation avec VCC pour le 5V et le GND pour la masse de
l’Arduino.
Les autres broches echo et trig sont à brancher sur des broches numériques 11 et 12 disponibles de l’Arduino.

3) Code Arduino
1. Utilisation du capteur Ultrason HC-SR04 */
2. // définition des broches utilisées
3. int trig = 12;
4. int echo = 11;
5. long lecture_echo;
6. long cm;
7.
8. void setup()
9. {
10. pinMode(trig, OUTPUT);
11. digitalWrite(trig, LOW);
12. pinMode(echo, INPUT);
13. Serial.begin(9600);
14.}
15.
16.void loop()
17.{
18. digitalWrite(trig, HIGH);
19. delayMicroseconds(10); // envoi d'une impulsion sur trig de 10 microsecondes
20. digitalWrite(trig, LOW);
21. lecture_echo = pulseIn(echo, HIGH);
 22. cm = lecture_echo/58
23. Serial.print("Distance en cm : ");
24. Serial.println(cm);
25. delay(1000); }

Le programme effectue une mesure à peu près toutes les secondes et envoie le résultat sur la voie série (le terminal
de l’IDE Arduino dans « outils »)
- Effectuer le montage
- Recopier le code dans l’environnement Arduino
- Brancher la carte sur le PC
- Téléverser le programme dans la carte
- Ouvrir le moniteur série dans « outil »

4) Modification du code

a) Modifier le code pour que l’on ait l’affichage « Attention ! Distance inférieure à 8 cm !! » si la distance
est inférieure à 8cm. Utiliser le « if » de la manière suivante :
if (condition)
instruction à effectuer

b) Modifier le code pour que la diode de la carte s’allume ou clignote si la distance est inférieure à 8cm. (voir
le code « Faire clignoter une diode » en annexe)

5) Analyse du code
a) Dans quelles lignes du code sont définies les branchements des broches echo et trig ?
b) Indiquer les lignes du code où est envoyée une impulsion de 10 µs. A quoi sert cette impulsion ?
c) La vitesse du son à 25 °C est v = 346,375 m/s.
Déterminer la distance d en cm pour ΔT = 150 µs, (tenir compte de l’aller-retour)

Exprimer la formule donnant la distance d en cm pour une durée ΔT en µs de l’impulsion Echo.

Expliquer la ligne :
cm = lecture_echo/58

6) Etalonnage du capteur
Pour différentes positions du capteur par rapport à un écran, remplir un tableau où figurent les distances et
l’affichage du capteur.
 TP N9 : Mesure de température et d’humidité à l’aide des capteurs
DHT11, DHT22
Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

I. Objectif du TP :
La mise en pratique des connaissances acquises dans le cours ̋Acquisition de l’information ̎ pour mesurer le
taux d’humidité et/ou le degré de la température et de les afficher sur un écran LCD ou les imprimer sur le
moniteur série.

Matériels nécessaires :
 Une carte Arduino (UNO, MEGA , DUE……)
 Un capteur d’humidité et de température DHT11 (ou DHT22)
 Un écran LCD 2×16
 Une plaque d’essai
 Résistances 220Ω, 1kΩ , 4.7kΩ, 10kΩ)
 Potentiomètre 1kΩ
 Fils de connexion.

II. Présentation des matériels:

Le capteur DHTxx est un capteur de température et d’humidité à sortie numérique sérielle. La liaison entre la carte
Arduino et le capteur est assuré par un microcontrôleur 8 bits intégré dans le corps du DHTxx. Une bibliothèque
permet la communication entre le capteur et la carte ARDUINO.
III. Travail à faire

1. Réalisez le montage suivant sous proteus :

Taper le code qui permet d’afficher le degré de la température et le taux d'humidité sur le moniteur série et sur
l’écran LCD en utilisant la fonction dht.temperature et dht.humidity après avoir charger la bibliothèque
<DHT.h>.
Remarque : La lecture des données se fait avec la fonction dht.read (DHT11_PIN) où DHT11_Pin est la broche
qui relie le capteur à la carte Arduino, se reférer au programme ci-dessous

#include "DHT.h" // Librairie des capteurs DHT

#define DHTPIN 2 // Changer le pin sur lequel est branché le DHT
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(9600);
Serial.println("Test du composant DHT11 !");
dht.begin();
}
void loop() {
delay(2000); // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes
float h = dht.readHumidity(); // Lecture du taux d'humidité
float t = dht.readTemperature(); // Lecture de la température en Celcius
float f = dht.readTemperature(true); // Pour lire la température en Fahrenheit
// Stop le programme et renvoi un message d'erreur si le capteur ne renvoi aucune mesure
if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println("Echec de lecture !");
return;}
Serial.print("Humidite: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C ");
}
 TP N10: module Bluetooth HC-05.
Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Matériel nécessaire:
- une carte Arduino Uno
- un module Bluetooth HC-05
- un jeu de câbles de connexion M/F
- un cordon USB B
- un PC
- un smartphone sous Android

Rappel:
Ce module communique via une liaison série avec une carte Arduino. Cette liaison s’établit sur deux broches RX
et TX définies dans notre programme en tant que broches 11 et 10. La broche RX de la carte Arduino doit être
raccordée à la broche TX du module Bluetooth HC-05. La broche TX de la carte Arduino doit être raccordée à la
broche RX du module HC-05.
Exemple de programme:
Ce programme (à copier dans l’IDE Arduino) permet la réception et l’émission de données via le moniteur série de
l’IDE avec un autre périphérique Bluetooth (second Arduino, un PC ou comme dans notre exemple avec un
smartphone).

Communication entre le Smartphone et l’Arduino Uno:

Il faudra ensuite installer sur le smartphone un programme comme Bluetooth Terminal HC-05 pour Android et
appairer le module HC-05. Le code pin par défaut est : 1234.
Il est maintenant possible de dialoguer entre le moniteur série du PC et le smartphone. La vitesse de
transfert série doit être paramétrée sur 38400 bauds sinon une série de caractères illisibles apparaitra
dans le moniteur.

Question: modifier le code Arduino et commander les deux LEDs de la figure.

 TP N11 : La photorésistance et Arduino.
Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Une photorésistance est un composant électronique dont la résistance (en Ohm Ω) varie en fonction de
l'intensité lumineuse. Plus la luminosité est élevée, plus la résistance est basse. On peut donc l'utiliser comme
capteur lumineux pour:
• Mesure de la lumière ambiante pour une station météo.
• Détecteur de lumière dans une pièce.
• Suiveur de lumière dans un robot.
• Détecteur de passage.

Ses symboles électroniques sont les suivants:

L'avantage des photorésistances est qu'elles sont très bon marché. Par contre, leur réaction à la lumière est
différente pour chaque photorésistance, même quand elles ont été produites dans le même lot. On peut ainsi noter
une différence de résistance de plus de 50% entre deux photorésistances du même modèle pour la même
luminosité. On ne peut donc pas l'utiliser pour une mesure précise de la lumière. Par contre, elles sont
idéales pour mesurer des changements simples de la luminosité.

Travail à faire:

1. Faire le schema de la figure sur ISIS proteus et simuler le montage

2. Réaliser la figure puis charger le code Arduino.
3. Observer le fonctionnement et présicer le seuil de fonctionnement.
4. Remplacer la LED par un relais et donner les applications au montage.
/*
Code 16 - Edurobot.ch, destiné à l'Arduino
Objectif: Eteindre une LED dès que la luminosité est suffisante
*/
//***** EN-TETE DECLARATIVE *****
int lightPin = 0; //On renomme la broche A0 en "lightPin"
int ledPin = 9; //On renomme la broche 9 en "ledPin"
//***** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et une seule fois, au démarrage du programme
void setup()
{
pinMode (ledPin, OUTPUT);
Serial.begin(9600);
}
void loop()
{
int seuil = 900; //On définit un seuil de luminosité (sur 1023) à
partir duquel la LED s'éteint
if (analogRead (lightPin)> seuil) //Si la luminosité est plus élevée que le seuil...
{
digitalWrite (ledPin, LOW); //... alors on éteint la LED.
}
else //Sinon...
{
digitalWrite (ledPin, HIGH); //...on allume la LED
}
}
 TP N12 : Utilisation d’une Matrice de LED 8×8 avec Arduino

Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

I. Principe de fonctionnement
La module matrice de LED contient une platine de pilotage avec un registre MAX7219 qui permet de s’interfacer
simplement avec un microcontrôleur tout en gérant l’état de 64 LEDs. Il existe plusieurs dimensions de matrice en
fonction du nombre de registres à décalage utilisés.

Schéma
Le module matrice utilise 3 broches du microcontrôleur. Il peut être alimenté grâce à la sortie 5V du
microcontrôleur.
 Code
Pour gérer la matrice de LED, il n’y a pas de bibliothèque particulière; Il faut venir sélectionner l’état de la LED
pour chaque pixel. Pour cela il est possible d’envoyer une valeur hexadécimale pour chaque ligne. Pour obtenir les
valeur hexadécimales en fonction de ce que vous souhaitez dessiner, vous pouvez utiliser cet outil.
int DIN_pin = 11;
int CS_pin = 10;
int CLK_pin = 12;

int D[8] = {0xC0, 0xA0, 0x90, 0x88, 0x84, 0x98, 0x90, 0xE0}; //afficher la lettre D
int A[8] = {0x18, 0x24, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42}; //afficher la lettre A
int M[8] = {0xC3, 0xA5, 0x99, 0x99, 0x81, 0x81, 0x81, 0x81}; //afficher la lettre M
int I[8] = {0x7C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C}; //afficher la lettre I
int E[8] = {0x00, 0x7E, 0x40, 0x40, 0x7E, 0x40, 0x40, 0x7E}; //afficher la lettre E
int N[8] = {0xC1, 0xA1, 0x91, 0x89, 0x85, 0x82, 0x80, 0x80}; //afficher la lettre N

void write_pix(int data)

{
digitalWrite(CS_pin, LOW);
for (int i = 0; i < 8; i++)
{
digitalWrite(CLK_pin, LOW);
digitalWrite(DIN_pin, data & 0x80); // masquage de donnée
data = data << 1; // on décale les bits vers la gauche
digitalWrite(CLK_pin, HIGH);
}
}

void write_line(int adress, int data)

{
digitalWrite(CS_pin, LOW);
write_pix(adress);
write_pix(data);
digitalWrite(CS_pin, HIGH);
}

void write_matrix(int *tab)

{
for (int i = 0; i < 8; i++) write_line(i + 1, tab[i]);
}
void init_MAX7219(void)
{
write_line(0x09, 0x00); //decoding BCD
write_line(0X0A, 0x01); //brightness
write_line(0X0B, 0x07); //scanlimit 8leds
write_line(0X0C, 0x01); //power-down mode 0, normalmode1;
write_line(0X0F, 0x00);
}

void clear_matrix(void)
{
const int clean[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
write_matrix(clean);
}

int intToHex(int x)
{
switch (x)
{
case 0: return 0x01; break; //LED sur la première case
case 1: return 0x02; break; //LED sur 2 case
case 2: return 0x04; break; //LED sur 3 case
case 3: return 0x08; break; //LED sur 4 case
 case 4: return 0x10; break; //LED sur 5 case
case 5: return 0x20; break; //LED sur 6 case
case 6: return 0x40; break; //LED sur 7 case
case 7: return 0x80; break; //LED sur 8 case
}
}

void setup()
{
pinMode(CS_pin, OUTPUT);
pinMode(DIN_pin, OUTPUT);
pinMode(CLK_pin, OUTPUT);
delay(50);

init_MAX7219();
clear_matrix();

void loop()
{
write_matrix(D);
delay(500);
write_matrix(A);
delay(500);
write_matrix(M);
delay(500);
write_matrix(I);
delay(500);
write_matrix(E);
delay(500);
write_matrix(N);
delay(500);
}

Dans cet exemple, nous avons décrit le prénom « Damien » avec les valeurs hexadécimales pour chaque LED. A
vous de définir les valeurs pour pouvoir afficher les caractères alphabétiques, numériques ou tout autre dessin que
vous souhaitez.

Travail a faire: après avoir fait l’example, écrire un programme qui fait defiler votre nom.
 TP N13 : Clavier matriciel /Ecran

Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Vous disposez d'un clavier matriciel de quatre lignes et quatre colonnes.

Question:
1. Décrire le fonctionnement d'un clavier matriciel
2. Connecter le clavier à la carte Arduino
3. Aidez-vous de Datasheet pour réaliser un programme qui affiche dans la console la touche du clavier
appuyée
4. Une bibliothèque gérant le clavier existe Keypad.h Installer là
5. En vous aidant du code ci-dessous, utiliser la bibliothèque pour récupérer les touches du clavier entrées
Code
 Mise en oeuvre d'un écran LCD

Les écrans dont vous disposez sont de "récupération". Il faudra adapter ce qui suit en fonction de l'écran LCD
fourni.

Question:
1. Connecter l'écran à la carte Arduino (souvent en liaison série)
2. Aidez-vous de Datasheet pour réaliser un programme qui affiche "bonjour le monde" sur l'écran.
Remarque : deux bibliothèques sont nécessaire : Wire.h et LiquidCrystal_I2C.h
Uilisation simultanée Ecran/Clavier et simulation sa saisie de code

Question:
1. Mixer les deux programmes pour pouvoir afficher directement à l'écran la touche appuyée
2. Récupérer dans une String quatre chiffres entrés
3. Comparer cette String avec une String "mot de pass". Ecrire OK si elles sont identiques, sinon écrire KO
4. Mettre votre programme sur la maquette. Si le code est bon, ouvrir le verrou de la porte, sinon aafficher
une invite pour recommencer
TP N14 : Conception et réalisation des applications embarquées.
Classes : M1-EEA
UE: Microprocesseurs et microcontroleurs Enseignant : Dr GOUNE

Objectif : se familiariser avec les applications embarquées.

Travail demandé :

Pour le reste des séances pratiques, chaque groupe d’étudiants est appelé à concevoir et réaliser une
des applications embarquées suivantes utilisant le simulateur Proteus puis lacarte Arduino:
1- variation de la vitesse d’un moteur à courant continu à excitation indépendante via un
hacheur série
2- conception et réalisation d’un onduleur monophasé
3- conception et réalisation d’un gradateur monophasé
4- conception et réalisation de la commande d’un moteur pas à pas.
View publication stats