See

discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/286013065

TP Interface via Arduino Uno

Data · December 2015

DOI: 10.13140/RG.2.1.4574.0881

CITATIONS READS

0 329

1 author:

Saadaoui Abdelkader
ISET de Radès, Tunisia
10 PUBLICATIONS 0 CITATIONS

SEE PROFILE

All content following this page was uploaded by Saadaoui Abdelkader on 07 December 2015.

The user has requested enhancement of the downloaded file.

 Département Technologies de l’Informatique (TI)

Support de travaux pratiques

ATELIER COCEPTIO
D’ITERFACE
Classes : L2-SEM (Systèmes Embarqués et Mobiles)

Enseignant : SAADAOUI Abdelkader

Année universitaire : 2013/2014

SAADAOUI Abdelkader
 INTRODUCTION GENERALE

Ce support de travaux pratiques est consacré à l’atelier conception d’interface et destiné aux
étudiants de deuxième année du Parcours : Systèmes Embarqués et Mobiles (SEM) au
Département Technologies de l’Informatique.
On propose, Dans ces présentes notes, les principales caractéristiques de la carte d’Arduino
Uno et des outils de conception, de simulation et de réalisation utilisant un environnement à
base du Compilateur Arduino.
A fin de familiariser les étudiants à leurs exploitation, certaines données sont directement
tirées du document constructeur.
Ces manipulations pratiques occupent un semestre.
L’auteur remercie par avance tous les lecteurs qui lui fait part de leurs critiques
et de leurs remarques constructives.

SAADAOUI Abdelkader
 ELEME!T CO!STITUTIF (ECUE)
ATELIER CO!CEPTIO! D’I!TERFACE
Volume horaire Coefficient Crédit
Cours TD TP
0 0 45 2 2

Plan :

Semaine TP

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

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 Mise en œuvre une application d’interfaçage.

Séance 7 Conception et réalisation des applications embarquées.

Pré-requis :
• Microprocesseurs, 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.

Evaluations :
• Le mode de contrôle continue : chaque TP est noté.
• La note personnalisée (NP) : sur la présence, les recherches théoriques des applications.
• Note sur les compte rendu du TP.

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 1 : Prise en main de l’environnement de la carte d’Arduino.

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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

dé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.

SAADAOUI Abdelkader
 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ée
par 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

SAADAOUI Abdelkader
 Entrées/Sorties digitales 14 -19
Broches d’alimentations Entrées analogiques 0-5
5v et 3.3v GND

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 :

VI!. 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

G!D. 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 1
SAADAOUI Abdelkader
kilo-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.

SAADAOUI Abdelkader
• 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é.

SAADAOUI Abdelkader
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

SAADAOUI Abdelkader
Cet espace de développement intégré (EDI) dédié au langage Arduino et à la programmation
des 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

SAADAOUI Abdelkader
 Réglage de la vitesse de transmission

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 affiche
un 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 sur
une carte Arduino pour augmenter ses fonctionnalités. Quelques exemples de « shields » :

• Afficheur graphique
• Ethernet et carte SD
• GPS

SAADAOUI Abdelkader
• XBee
• GSM
• etc...

XXII. Travail demandé :

XXII.1. Installer l’espace de développement intégré (EDI) Arduino .
XXII.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 dans
la carte Arduino. ?
XXII.3. Réaliser ce montage où la LED est liée avec le pin 12.

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

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 2 : Programmation des interfaces parallèles.

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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);
}
}

SAADAOUI Abdelkader
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 :

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 3 : Conception d’interface pour manipuler un afficheur alphanumérique

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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.
SAADAOUI Abdelkader

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

SAADAOUI Abdelkader
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 :

SAADAOUI Abdelkader
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.

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 4 : Programmation d’ interface pour une luminosité variée d'une LED .

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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.

SAADAOUI Abdelkader
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 appelée
« 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

SAADAOUI Abdelkader
II. 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) en
série connectée au 0V

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

SAADAOUI Abdelkader
 // --- 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

SAADAOUI Abdelkader
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 :

SAADAOUI Abdelkader
  Le noir ou marron – La masse (GND)
 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);
}

SAADAOUI Abdelkader

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);
}
}

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 5 : Programmation de l’interface série

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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
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 :

SAADAOUI Abdelkader
 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:

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);
}
}

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 6 : Mise en œuvre d’une application d’interfaçage.

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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 :

SAADAOUI Abdelkader
Dans ce mode de fonctionnement, les bobines sont alimentées l’une après l’autre dans un
sens 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.

SAADAOUI Abdelkader
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 complet
et 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 complet
et demi-pas ?.

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 7 : Conception et réalisation des applications embarquées.

Classes : L2- SEM

ECUE: ATELIER COCEPTIO D’ITEFRACE Enseignant : SAADAOUI AK.

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 la
carte 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.

SAADAOUI Abdelkader

View publication stats