Université Sultan Moulay Slimane

Faculté des Sciences et Techniques

Département de Physique
LST-IETEL

Rapport de Projet de Fin d’Etudes

Sous thème

Carte d’Interface Avec MATLAB à base

de l’ARDUINO

Encadré par : Réalisé par :

Pr. Abderrahim Salhi Mourad El Harcha

Année universitaire : 2019/2020

 Dédicace
Je tiens à dédier ce travail :

A ma chère mère,

A mon cher père,

Qui n’ont jamais cessé, de me soutenir et de m’épauler pour que je puisse atteindre mes
objectifs et d’être tout le temps à la hauteur.

A mon frère pour ses soutiens et à ma petite sœur qui sait toujours comment procurer
la joie pour toute la famille.

A mes grands-parents, à Qui je souhaite une bonne santé.

A mon binôme Abderrahim, Pour son soutien moral, sa patience et sa compréhension

tout au long de ce projet.

A mes chers amis,

A toute ma famille,

A tous ceux que j’aime et ceux qui m’aiment.

2
 Remerciement
Avant tout développement de mon projet de fin d’étude.

Je rends mes profondes gratitudes à Dieu tout puissant qui nous a aidé à réaliser ce
modeste travail.

J’exprime mes profondes gratitudes à mes parents pour leurs encouragements, leurs
soutiens et pour les sacrifices qu’ils ont enduré.

Je remercie, Mon encadrant Mr. SALHI ABDERRAHIM pour les efforts qu’il déployé
pour nous aider, conseiller, corriger et encourager.

Je remercie les membres de jury d’avoir accepté d’examiner mon travail.

Je remercie aussi tout le corps enseignant dans la filière I.E.TEL qui ont donné une grande
formation durant cette année scolaire.

Que tous ceux qui ont contribué de près ou de loin à la réalisation de ce travail, trouvent
ici mon sincère reconnaissance.

3
 Table des matières
Dédicace.................................................................................................................................2

Remerciement ........................................................................................................................3

Table des matières ..................................................................................................................4

Liste des figures .....................................................................................................................9

Liste des tableaux ................................................................................................................. 12

Introduction générale ............................................................................................................ 13

GENERALITES ................................................................................................................... 14

I.1. Comment Choisir une carte d’interface ....................................................................... 14

I.1.1. Interface matérielle ............................................................................................... 14

I.1.2. Interface logicielle ................................................................................................ 14

I.1.3. Interface utilisateur ............................................................................................... 15

I.2. Comment programmer une carte d’interface ................................................................ 15

I.2.1. Carte d’interface à base d’un microcontrôleur ....................................................... 15

I.2.2. Carte d’interface à base d’automate programmable industriel................................ 15

I.3. Les produits équivalents sur le Marché........................................................................ 16

I.3.1. Surveillance du monde physique ...........................................................................17

I.3.2. Pilotage de petit matériel....................................................................................... 17

I.3.3. Automatisation à petite échelle .............................................................................18

I.3.4. Performances artistiques ....................................................................................... 18

4
 I.3.5. Thermostat intelligent à base d’une Carte Arduino ................................................ 18

I.3.6. Les architectures et les technologies utilisées ........................................................ 19

ARDUINO ET SIMULATION SOUS ISIS ..........................................................................20

II.1. Définition Arduino..................................................................................................... 20

II.2. Les différents types de l’Arduino ............................................................................... 20

II.2.1. La carte Arduino UNO ........................................................................................ 21

II.2.2. La carte Arduino Leonardo .................................................................................. 21

II.2.3. La carte Arduino Mega ........................................................................................ 21

II.2.4. La carte Arduino Mega ADK............................................................................... 22

II.2.5. La carte Arduino Mega ........................................................................................ 22

II.2.6. La carte Arduino Nano ........................................................................................ 22

II.3. Partie matérielle ......................................................................................................... 23

II.3.1. La constitution de la carte Arduino UNO ............................................................. 24

II.3.2. Le microcontrôleur ATMega328 ......................................................................... 24

II.4. Logiciel ..................................................................................................................... 25

II.4.1. Bibliothèque Serial .............................................................................................. 26

II.4.2. La Structure du programme ................................................................................. 27

II.4.3. Données, variables et constantes ..........................................................................28

II.4.4. Fonctions de gestion des Entrés et des Sorties numériques et Analogiques. ..........28

II.4.5. Fonctions de gestion du port série asynchrone. .................................................... 29

II.4.6. Bibliothèque. ....................................................................................................... 30

5
 II.5. Simulation en Proteus ................................................................................................ 30

II.5.1. La fenêtre du logiciel ........................................................................................... 31

II.5.2. Placement et câblage des composants .................................................................. 32

II.5.3. Schéma de l’exemple sur Isis .............................................................................. 33

II.6. Le code Arduino ........................................................................................................ 33

II.6.1. Organigramme du fonctionnement de code Arduino. ...........................................33

II.6.2. Les commandes ................................................................................................... 34

II.6.3. Les règlements .................................................................................................... 34

II.6.4. Les erreurs...........................................................................................................35

II.7. Les commandes programme pour le port série. .......................................................... 35

II.7.1. Virtuel terminal ................................................................................................... 35

II.8. Conclusion................................................................................................................. 37

SIMULATION SOUS MATLAB ......................................................................................... 38

III.1. Définition de Matlab................................................................................................. 38

III.2. Interface graphique et environnement de développement (IDE) ................................ 39

III.3. Le programme en Proteus. ........................................................................................ 39

III.4. Simulation sous Matlab et Isis .................................................................................. 42

III.5. Les fonctions ............................................................................................................ 43

III.5.1. La première fonction : Communication Arduino Matlab. .................................... 43

III.5.2. Deuxième fonction : Configuration des pins. ...................................................... 44

III.5.3. Troisième fonction : Lecture des pins. ................................................................ 44

6
 III.5.4. Quatrième fonction : L’écriture. ......................................................................... 44

III.5.5. Cinquième fonction : Les pins Analogique. ........................................................ 44

III.6. Les Test .................................................................................................................... 45

III.6.1. Test n°1.............................................................................................................. 45

III.6.2. Test n°2.............................................................................................................. 46

III.7. Conclusion ............................................................................................................... 46

APPLICATION FEU DE CIRCULATION INTELLIGENT ................................................ 47

IV.1. Feu de circulation routière ........................................................................................ 47

IV.1.1. Définition du feu de circulation ..........................................................................47

IV.1.2. Objectifs et domaine d'emploi. ...........................................................................47

IV.1.3. Principe du feu de la circulation. ........................................................................ 48

IV.2. Le problème .............................................................................................................48

IV.3. Réalisation d’un feu de circulation intelligent. .......................................................... 48

IV.3.1. Les composants .................................................................................................. 48

IV.3.2. Schéma sur Proteus Isis du montage avec l’organigramme. ................................ 49

IV.4. Tableau de vérité et tableau de Karnaugh ................................................................. 50

IV.4.1. Table de vérité ................................................................................................... 50

IV.4.2. Tableaux de Karnaugh ....................................................................................... 51

IV.5. Mode de fonctionnement et Organigrammes............................................................. 51

IV.5.1. Organigramme du programme principale (carrefour) ..........................................52

IV.5.2. Organigramme OuvrirDirectionAC .................................................................... 52

7
 IV.5.3. Organigramme OuvrirDirectionBD .................................................................... 53

IV.6. Les codes sous Matlab .............................................................................................. 54

IV.6.1. Configurations des pins. ..................................................................................... 54

IV.6.2. Code décompteur ............................................................................................... 54

IV.6.3. Code principal (carrefour) .................................................................................. 55

IV.6.4. OuvrirDirectionAC (Code Matlab). .................................................................... 55

IV.6.5. Feucroisement .................................................................................................... 56

IV.6.6. OuvrirDirectionBD ............................................................................................ 56

IV.6.7. Test .................................................................................................................... 57

IV.7. Conclusion ............................................................................................................... 57

Conclusion générale .............................................................................................................58

Annexe ................................................................................................................................. 59

BIBLIOGRAPHIE ............................................................................................................... 63

Webographie ........................................................................................................................ 63

8
 Liste des figures
Figure 1 : les différentes interfaces de l’ordinateur. ............................................................... 14

Figure 2 : schéma bloc carte d’interface à base d’un Microcontrôleur. .................................. 15

Figure 3 : Exemple d’une carte d’entrée typique d’un API. ................................................... 16

Figure 4 : station de météo automatisée. ............................................................................... 17

Figure 5 : Suivi de soleil. ......................................................................................................17

Figure 6 : Exemple d’un thermostat à base d’une carte Arduino. ...........................................19

Figure 7 : Exemple d’une carte Arduino UNO. ..................................................................... 21

Figure 8 : Exemple d’une carte Arduino Leonardo. ............................................................... 21

Figure 9 : Exemple d’une carte Arduino Mega ADK. ........................................................... 22

Figure 10 : Exemple d’une carte Arduino Mega. ................................................................... 22

Figure 11 : Exemple d’une carte Arduino Nano. ................................................................... 22

Figure 12 : les composants de la carte Arduino UNO. ........................................................... 23

Figure 13 : les composants de la carte Arduino UNO en détaillent. ....................................... 23

Figure 14 : Microcontrôleur ATMega 328. ...........................................................................24

Figure 15 : Interface d’Arduino IDE. .................................................................................... 25

Figure 16 : Description de l’interface d’Arduino IDE. .......................................................... 26

Figure 17 : listes des boutons. ............................................................................................... 26

Figure 18 : les pins RX et TX. .............................................................................................. 27

Figure 19 : Exemple d’un programme Arduino. .................................................................... 27

9
Figure 20 : Fenêtre principale d’ISIS. ................................................................................... 30

Figure 21 : les éléments de la fenêtre du logiciel. .................................................................. 31

Figure 22 : Choix des composants. ....................................................................................... 32

Figure 23 : Circuit électronique de l’exemple. ......................................................................33

Figure 24 : Organigramme du code Arduino. ........................................................................ 34

Figure 25 : Virtuel Terminal. ................................................................................................ 35

Figure 26 : Simulation dans ISIS avec Virtuel Terminal. ...................................................... 36

Figure 27 : Interface Matlab.................................................................................................. 38

Figure 28 : Environnement de développement IDE. .............................................................. 39

Figure 29 : COMPIM. ..........................................................................................................40

Figure 30 : L’ouverture de logiciel virtuel serial port. ........................................................... 40

Figure 31 : Simulation dans ISIS avec COPMIM. ................................................................. 41

Figure 32 : Configuration de VSPE, (b) Configuration de COMPIM. ................................... 41

Figure 33 : Ouverture port 14 pour Matlab............................................................................42

Figure 34 : Simulation et commande sous Matlab. ................................................................ 42

Figure 35 : Instructions indique une fausse commande. ........................................................ 43

Figure 36 : Communication Arduino avec Matlab................................................................. 43

Figure 37 : Configuration des pins ........................................................................................ 44

Figure 38 : Lecture des pins. ................................................................................................. 44

Figure 39 : l’écriture dans les pins. ....................................................................................... 44

Figure 40 : Configuration des pins Analogique. .................................................................... 44

10
Figure 41 : Test n°1. .............................................................................................................45

Figure 42 : Résultat du premier test. ..................................................................................... 45

Figure 43 : Code Matlab pour Test n°1. ................................................................................ 46

Figure 44 : feux tricolores à l’aide des LEDS. ....................................................................... 47

Figure 45 : Le circuit électronique du feu rouge intelligent. .................................................. 49

Figure 46 : Organigramme du programme principal. ............................................................. 52

Figure 47 : Organigramme OuvrirDirectionAC. .................................................................... 52

Figure 48 : Organigramme OuvrirDirectionBD. .................................................................... 53

Figure 49 : Configuration des pins. ....................................................................................... 54

Figure 50 : Code principal (carrefour). .................................................................................. 55

Figure 51 : Code OuvrirDirectionAC. ................................................................................... 55

Figure 52 : Code feucroisement. ........................................................................................... 56

Figure 53 : Code OuvrirDirectionBD. ................................................................................... 56

Figure 54 : Code test............................................................................................................. 57

11
 Liste des tableaux
Tableau 1 : Type de systèmes et leurs fonctions .................................................................... 17

Tableau 2 : Commandes et leurs significations......................................................................35

Tableau 3 : Table de vérité.................................................................................................... 50

Tableau 4 : Tableaux de karnaugh ........................................................................................ 51

Tableau 5 : Le mode de fonctionnement d’un décodeur ........................................................ 54

12
 Introduction générale
Généralement, quand on parle de périphériques permettant à un ordinateur de
communiquer avec le mode extérieur, on pense tout de suite à un clavier, un écran, une souris,
une imprimante

En réalité dans la majeure partie des applications ou il est nécessaire de contrôler des
systèmes électroniques de tels organes ne sont évidemment pas suffisants, mais il faut utiliser
des cartes spécifiques constituant des interfaces vers l’extérieur.

Les cartes d’interface désignent le plus souvent des cartes pour ordinateur qui se logent
en interne sur l’un des bus de la carte mère tel que le bus PCI (Peripheral Component
Interconnect) ou ISA (Industry Standard Architecture), ou bien en externe sur l’un des ports
périphériques, par exemple un port USB. Ces cartes permettent d’ajouter de nouvelles fonctions
ou d’étendre les fonctions existantes.

D’une manière plus générale, les cartes d’interface sont utilisées pour associer
fonctionnellement deux entités distinctes. Pour bien détailler à quoi sert ces cartes d’interfaces
on peut dire que : Ces interfaces doivent relier les circuits électroniques au PC et permettre
l’échange des informations entre les deux entités. Dans la plupart des cas, les cartes sont
constituées d’un certain nombre de ressources d’I/O (Input/Output- Entrées/Sorties numériques
et analogiques). Les Inputs sont dument codes et transmis à un logiciel de gestion présent dans
l’ordinateur. Par contre, dans le cas des Outputs c’est en revanche le programme qui peut
modifier les valeurs précises par chaque ressource particulière.

Dans ce projet on va réaliser une Carte d’interface Matlab à base d’Arduino cette carte
qui va nous servir à faire n’importe quelle application.

Dans un premier temps ; nous abordons l’étude du code Arduino avec le code Matlab
et après on va exploiter ces résultats pour réaliser une application à base de cette carte.

Nous terminons notre travail par une conclusion générale.

13
 GENERALITES
I.1. Comment Choisir une carte d’interface

Lors du choix d'une carte d'interface, le type d'interface qui s’ajoute à l’ordinateur est un
point important. Il faut également vérifier la méthode de connexion entre l’ordinateur et la carte
d'interface par méthode de connexion PC et carte d'interface

En termes de PC, il existe trois catégories principales :

• Interface matérielle : entre le matériel.

• Interface logicielle : entre logiciels.
• Interface utilisateur : entre le matériel et l'utilisateur.

I.1.1. Interface matérielle

Le matériel avec différentes fonctions et formes, comme les ordinateurs personnels et les
périphériques, peut désormais communiquer via l’interface. L’USB est l’interface la plus
couramment utilisée pour les ordinateurs personnels et les périphériques.
Il y a une souris /clavier/une imprimante, un disque dur.
Ces différentes interfaces sont indiquées dans la (figure 1).

Figure 1 : les différentes interfaces de l’ordinateur.

I.1.2. Interface logicielle

Le pont entre les logiciels est l’interface logicielle. Contrairement au matériel, elle n’est
pas vraiment tangible, mais il permet aux logiciels d’interagir. Typiquement, celui-ci est appelé
l’interface de programmation de l’application API. Par exemple, Windows possède d’une API
Windows qui assure la communication entre le logiciel et le système d’exploitation.

14
 I.1.3. Interface utilisateur
L'interface utilisateur désigne le point de contact entre l’utilisateur et l’appareil. Elle
s’appelle aussi l’interface humaine.

I.2. Comment programmer une carte d’interface

I.2.1. Carte d’interface à base d’un microcontrôleur

Une Carte d’interface à base d’un Microcontrôleur est un équipement électronique
programmable qui sert à acquérir des signaux de son environnement en utilisant des capteurs,
et d’agir dans celui-ci en commandant des actionneurs via des port d’entrée/sortie et des bus de
communication dédiés, de mettre une carte électronique multifonctionnelle agir et acquisition
en même temps.

Le choix du type de liaison utilisée pour relier notre carte avec le PC est assuré par un
programme spécifique. Le schéma de la (figure 2) explique le fonctionnement de l’interface qui
se développe autour d’un bloc de contrôle constitué essentiellement du PIC et assure 5 fonctions
majeures :

Figure 2 : schéma bloc carte d’interface à base d’un Microcontrôleur.

I.2.2. Carte d’interface à base d’automate programmable

industriel
L’interface d’entrée comporte des adresses d’entrée. Chaque capteur est relié à une de ces
adresses. L’interface de sortie comporte de la même façon des adresses de sortie. Chaque pré
actionneur est relié à une de ces adresses. Le nombre de ces entrées et sorties

15
 Varient en se basant sur le type d’automate. Les cartes d'E/S ont une modularité de 8.16
ou 32 voies.

Cartes d'entrées :

Elles sont destinées à recevoir l'information en provenance des capteurs et adapter le

signal en le mettant en forme, en éliminant les parasites et en isolant électriquement l'unité de
commande de la partie opérative.

La structure de cette carte est montre dans la (figure 3).

Figure 3 : Exemple d’une carte d’entrée typique d’un API.

Exemple de cartes :

• Cartes de comptage rapide : Elles permettent d'acquérir des informations de

fréquences élevées incompatibles avec le temps de traitement de l'automate. (Signal issu
d'un codeur de position)
• Cartes de commande d'axe : Elles permettent d'assurer le positionnement avec
précision d'élément mécanique selon un ou plusieurs axes. La carte permet par exemple
de piloter un servomoteur et de recevoir les informations de positionnement par un
codeur. L'asservissement de position pouvant être réalisé en boucle fermée.

I.3. Les produits équivalents sur le Marché

Après avoir expliqué le rôle des cartes d’interface au niveau de travail et la réalisation des
projets, nous dévoilons dans cette section une brève sélection des domaines d’application
possibles d’une carte d’interface.

16
 I.3.1. Surveillance du monde physique
Station de météo automatisée : composants qui mesurent, enregistrent et transmettent
souvent des paramètres météorologiques tels que la température, la vitesse et la direction du
vent, le rayonnement solaire et les précipitations. La figure (4) donne une image concerne une
station de météo automatisée.

Figure 4 : station de météo automatisée.

Détecteur de foudre : est un appareil qui permet de capter l'onde

électromagnétique des parasites atmosphériques générés par un éclair provenant d'un orage.
Les détecteurs de foudre sont utilisés par les services météorologiques.

Suivi du soleil pour des panneaux solaires : l'héliostat est un dispositif qui
permet de suivre la course du soleil. Il oriente les rayons du soleil, grâce à des miroirs mobiles,
vers une surface fixe enfermant un liquide caloporteur chauffé par la concentration des rayons.
Une image sur la (figure 5) représente Un suivi du soleil.

Figure 5 : Suivi de soleil.

I.3.2. Pilotage de petit matériel

Les petits robots : Ils permettent l'exécution de séquences d'instruction ou de logiciels
commandant la réalisation d'actions ou de fonctions du robot. On trouve souvent, dans
les robots de petite taille, des composants à très faible consommation électrique, car ils ne
peuvent emporter que des sources d'énergie limitées.

Système humain Système robotique Fonction

Cerveau Les processeurs embarqués Direction des opérations

Tableau 1 : Type de systèmes et leurs fonctions.

17
 • Avions radiocommandés.
• Drones et quadricoptères.
• Contrôle de machines-outils à commande numérique.

I.3.3. Automatisation à petite échelle

Au niveau de l’automatisation à petite échelle nous citons les cas suivants :

• Contrôle de serres automatisé.

• Contrôle d’échantillons de laboratoire.
• Systèmes de test électronique automatisé.

I.3.4. Performances artistiques

Les performances artistiques se manifeste par exemple dans :

• Contrôle dynamique d’éclairage.

• Contrôle dynamique de musique.
• Structures climatiques.

Compte tenu de ce qui précède, les cartes d’interfaces disposent d’un rôle important dans
tous les domaines avec différentes manières de réalisation.

I.3.5. Thermostat intelligent à base d’une Carte Arduino

Dans ce cette section, nous allons détailler l’exemple de Thermostat intelligent à base
d’une Carte Arduino afin d’expliquer d’une façon plus claire l’utilisation des cartes d’interface
dans le marché.

Le premier objectif est de remplacer un thermostat traditionnel de maison. Il n’y a pas

tant de possibilités de combiner un circuit Arduino, un capteur de température, un afficheur et
deux relais. En revanche ce thermostat se distingue par l’utilisation d’un capteur d’humidité et
la possibilité de mettre en route la fonction de ventilation de façon indépendante, afin de
déplacer l’air qui est à la bonne température sans avoir besoin aussi souvent de mettre en route
le chauffage ou le rafraîchissement.

18
 Ce thermostat va être capable d’exploiter la température intérieure et son humidité pour
régler si nécessaire le temps de cycle. En option, il y’a la possibilité d’ajouter un capteur de
température et d’humidité extérieures. Le thermostat utilise des relais pour piloter en 24 V la
plupart des modèles de climatiseurs domestiques. Il n’y a donc pas de risque d’électrocution,
sauf celui de programmer un cycle trop rapide qui brutaliserait le compresseur ou le système de
chauffage. Le montage du thermostat est très simple. Il n’y aura que très peu de soudure à
prévoir. Le schéma ci-dessus de la (figure 6) explique le mode de fonctionnement de ce
thermostat.

Figure 6 : Exemple d’un thermostat à base d’une carte Arduino.

I.3.6. Les architectures et les technologies utilisées

Pour programmer une carte il faut utiliser une interface de programmation et pour le faire,
Il y’a plusieurs méthodes comme :

Arduino : Arduino est devenu le couteau suisse de l’électronicien amateur et de tous ceux
qui veulent créer un objet utile, remarquable, interactif, électrique et bien d’autres
caractéristiques.

Picaxe : Un Picaxe est un microcontrôleur qui signifie un circuit intégré rassemblant

dans le même boitier un microprocesseur, une mémoire (dans laquelle, il y aura le programme
nécessaire à son fonctionnement) ainsi que les périphériques d’entrée et de sortie permettant de
communiquer avec l’extérieur.

19
 ARDUINO ET SIMULATION SOUS
ISIS
II.1. Définition Arduino

Arduino est une plate-forme de prototypage d'objets interactifs à usage créatif constituée
d'une carte électronique et d'un environnement de programmation. Cet environnement matériel
et logiciel qui est accessible même pour les non spécialistes de l’électronique permet à
l'utilisateur de formuler ses projets par l'expérimentation directe avec l'aide de nombreuses
ressources disponibles en ligne. Pont tendu entre le monde réel et le monde numérique, Arduino
permet d'étendre les capacités de la relation humain/machine ou environnement/machine. En
plus, il est un projet en source ouverte avec une communauté importante d'utilisateurs et de
concepteurs qui permet à chacun de trouver les réponses à ses questions.

La carte Arduino repose sur un circuit intégré (un mini-ordinateur appelé également
microcontrôleur) associé à des entrées et des sorties qui permettent à l'utilisateur de brancher
différents types d'éléments externes :

• Côtés entrés : des capteurs qui collectent des informations sur leur environnement
comme la variation de température via une sonde thermique, le mouvement via un
détecteur de présence ou un accéléromètre, le contact via un bouton-poussoir, etc.
• Côtés sortis : des actionneurs qui agissent sur le monde physique tel qu’une petite lampe
qui produit la lumière, un moteur qui actionne un bras articulé, etc. Comme le logiciel
Arduino, le circuit électronique de cette plaquette est libre et ses plans sont disponibles
sur internet. On peut donc les étudier et créer des dérivés. Plusieurs constructeurs
proposent ainsi différents modèles de circuits électroniques programmables et
utilisables avec le logiciel Arduino.

II.2. Les différents types de l’Arduino

Il y’a plusieurs types de cartes Arduino dans le marché qui ont presque le même rôle, sauf
un petit développement entre eux à cause de la révolution dans le domaine. Dans ce qui suit
nous allons citer quelques exemples :

20
 II.2.1. La carte Arduino UNO
C’est la carte idéale pour découvrir l’environnement ARDUINO. Elle permet à tout
débutant de se lancer dans tous ses premiers petits projets. Comme c’est la carte la plus utilisée,
il est très facile de se référer aux nombreux tutoriels sur internet et de découvrir les expériences
de la communauté pour une exploration optimal. Sa simplicité devient par contre un obstacle
lorsqu’il s’agit d’une multiplier des périphériques, de manipuler des algorithmes lourds ou
d’interagie avec les OS Android pour lesquels d’autres cartes Arduino sont plus adaptées.
L’image de la carte est indiquée dans la figure (7).

Figure 7 : Exemple d’une carte Arduino UNO.

II.2.2. La carte Arduino Leonardo

C’est la carte qui succède la carte Arduino Uno en présentant des caractéristiques
équivalentes mais une ergonomie revue et une stabilité plus éprouvée. Sa diffusion moins
importante limite le support utilisateur disponible sur internet. L’image de la carte Arduino
Leonardo est indiquée dans la figure (8).

Figure 8 : Exemple d’une carte Arduino Leonardo.

II.2.3. La carte Arduino Mega

La carte Arduino Mega est la carte la plus diffusée après la carte Arduino Uno. Elle offre
un nombre d’entrées/sorties beaucoup plus important, un processeur plus puissant doté d’une
mémoire plus vaste qui permet d’exploiter des algorithmes plus complexes.

21
 II.2.4. La carte Arduino Mega ADK
La carte Arduino Mega ADK comme indique dans la figure (9), offre les mêmes
caractéristiques techniques que la carte Arduino Mega, mais sont port USB permet de la
connecter avec un environnement Android ouvrant de nouvelles perspectives d’interaction avec
le monde des smartphones et des capteurs dont ils sont dotés. Sa mise en œuvre nécessite par
contre, de solides connaissances en Java et la capacité à développer ses propres applications.

Figure 9 : Exemple d’une carte Arduino Mega ADK.

II.2.5. La carte Arduino Mega

La carte Arduino Due est une évolution de la carte Arduino Mega avec des performances
réputées 3 fois supérieures. Elle permet de manipuler rapidement des algorithmes lourds
particulièrement utiles dans le monde de la robotique par exemple. L’image de la carte Arduino
Mega est indiquée dans la figure (10).

Figure 10 : Exemple d’une carte Arduino Mega.

II.2.6. La carte Arduino Nano

La carte Arduino nano est une carte Arduino Uno miniaturisée. A cause de sa taille et son
poids restreint, elle est utilisable dans des espaces réduits (en textile par exemple), dans des
applications de robotique ou de modélisme pour lesquels le poids et la taille sont des facteurs
déterminant (hélicoptères, drones…). L’image de la carte Arduino Nano est indiquée dans la
figure (11).

Figure 11 : Exemple d’une carte Arduino Nano.

22
 II.3. Partie matérielle

Nous expliquons les principaux composants du carte Arduino Uno à travers la (figure 7).
Il faut noter ici, que les différentes versions des Arduino fonctionnent sous le même principe
général. La (figure 17) est pour expliquer le rôle de chaque composant.

Figure 12 : les composants de la carte Arduino UNO.

• A : sont les broches dites numériques 1 ou 0 (HIGH ou LOW en anglais) et (tout ou rien
en français) ; elles offrent en sortie du 5V et acceptent en entrée du 5V sur le même
principe.
o Fonctions digitalWrite et digitalRead.
Et pour les ports Analogiques on distingue entre trois types :

• B : ce sont les broches dites analogiques, valeur entre 0V et 5V.

o Fonction analogRead.
• C : les différentes broches d'alimentation :
o Rouge : sortie 5V (+) ;
o Orange : sortie 3,3V (+) ;
o Noire : les masses (−) ;
o Jaune : entrée reliée à l'alimentation (7V-12V).

La (figure 13) explique en détails le rôle de chaque composant dans la carte Arduino.

Figure 13 : les composants de la carte Arduino UNO en détaillent.

23
 II.3.1. La constitution de la carte Arduino UNO
Un module Arduino est généralement construit autour d’un microcontrôleur ATMEL
AVR, et de composants complémentaires qui facilitent la programmation et l’interfaçage avec
d’autres circuits. Chaque module possède au moins un régulateur linéaire 5V et un oscillateur
à quartz 16 MHz (ou un résonateur céramique dans certains modèles). Le microcontrôleur est
préprogrammé avec un boot loader de façon à ce qu’un programmateur dédié ne soit pas
nécessaire.

II.3.2. Le microcontrôleur ATMega328

Un microcontrôleur ATMega328 est un circuit intégré qui rassemble sur une puce
plusieurs éléments complexes dans un espace réduit au temps des pionniers de l’électronique.
Aujourd’hui, en soudant un grand nombre de composants encombrants ; tels que les transistors
; les résistances et les condensateurs tout peut être logé dans un petit boîtier en plastique noir
muni d’un certain nombre de broches dont la programmation peut être réalisée en langage C.
(la figure 14) montre un microcontrôleur ATMega 328, qu’on trouve sur la carte Arduino UNO.

Figure 14 : Microcontrôleur ATMega 328.

Le microcontrôleur ATMega328 est constitué d’un ensemble d’éléments avec une

fonction bien déterminée chacun. Il est en fait constitué des mêmes éléments de la carte mère
d’un ordinateur. Globalement, l’architecture interne de ce circuit programmable se compose
essentiellement de :

• La mémoire Flash : C'est celle qui contiendra le programme à exécuter. Cette

mémoire est effaçable.
• RAM : c'est la mémoire dite "vive", elle va contenir les variables du programme. Elle
est dite "volatile" car elle s'efface s’il y a une coupure d'alimentation du
microcontrôleur. Sa capacité est 2 ko.
• EEPROM : C'est le disque dur du microcontrôleur, Où les informations qui ont
besoin de survivre dans le temps peuvent être enregistré. Contrairement à la RAM,

24
 cette mémoire ne s'efface pas lors de l’arrêt le microcontrôleur ou lorsqu'on le
reprogramme.

II.4. Logiciel

Dans les parties précédentes, nous avons présenté la partie matérielle de l’Arduino. Dans
cette section nous allons projeter la partie logicielle de la carte. Le logiciel de programmation
de la carte Arduino sert d'éditeur de code (langage proche du C). Une fois le programme tapé
ou modifié au clavier, il sera transféré et mémorisé dans la carte à travers la liaison USB. Le
câble USB alimente à la fois en énergie la carte et transporte l'information du programme appelé
IDE Arduino. Dans notre cas nous allons travailler avec Arduino depuis Isis, sans aucune
utilisation du câble USB

Pour écrire, modifier ou injecter les programmes dans le microcontrôleur nous utiliserons
une interface graphique appelée IDE (Integrated Développent Environnent). Cette interface
souple est exécutable sur n’importe quel système d’exploitation. Arduino est basé sur la
programmation en C et C++ à l’aide des règles spéciales de structuration du code.

L’IDE Arduino utilise le programme pour convertir le code exécutable en un fichier

texte contenant un codage hexadécimal. Le résultat est chargé au niveau de la carte Arduino par
un programme de chargement intégré dans le microprogramme de la carte.

La (figure 15) montre l’interface Arduino IDE.

Figure 15 : Interface d’Arduino IDE.

25
 Après l’ouverture du logiciel, une fenêtre composée de plusieurs sections s’affiche dans
la (figure 16).

Figure 16 : Description de l’interface d’Arduino IDE.

• La rubrique 1 : montre les options de la configuration du logiciel.

• La rubrique 2 : contient les boutons qui servent lors de la programmation des cartes.
• La rubrique 3 : contiendra les lignes de codes du programme à écrire.
• La rubrique 4 : est le débogueur qui aide le développeur d’identifier et corriger les
problèmes et les bugs du programme.

Figure 17 : listes des boutons.

Les boutons de la (figure 17) servent à :

• Bouton 1 : permet de vérifier le programme. Il actionne un module pour chercher les

erreurs dans le programme.
• Bouton 2 : Charge (téléverse) le programme dans la carte Arduino.
• Bouton 3 : Crée un nouveau fichier.
• Bouton 4 : Enregistre le fichier.
• Bouton 5 : Ouvre le moniteur série.

II.4.1. Bibliothèque Serial

Cette bibliothèque fait donc partie intégrante de l’outil de développement ’Arduino’, elle
est installée de base. Il suffit juste de l’importer dans le programme. Le circuit UART de
l’Arduino UNO possède un port série, nommé Serial , qui utilise les ports numériques 0 (RX)

26
et 1 (TX). La carte Arduino Mega dispose de trois ports série supplémentaires). Ses ports sont
montres dans la (figure 18).

• Serial 1 : 19 (RX) et 18 (TX).

• Serial 2 : 17 (RX) et 16 (TX).
• Serial 3 : 15 (RX) et 14 (TX).

Figure 18 : les pins RX et TX.

La voie série est une des possibilités de communication entre un Arduino et un autre
périphérique, que ce soit un autre Arduino, un microcontrôleur ou un ordinateur.

Il faut marquer ici qu’il y a des précautions à prendre :

• Utiliser le même niveau de voltage pour la communication entre deux périphériques ;

• Bien brancher les fils entre deux Arduino ou avec un autre périphérique que ce soit entre
deux Arduino (avec la voie série 1) ou avec un PC, l’utilisation de la voie série rend les
broches digitales 0 et 1 (respectivement Tx et Rx) inopérants. Elles ne peuvent plus être
utilisées comme entrées ou sorties digitales.

II.4.2. La Structure du programme

Un programme Arduino comporte trois parties indiquées dans la (figure 19) :

Figure 19 : Exemple d’un programme Arduino.

1. La partie déclaration des variables (optionnelle)

2. La partie initialisation et configuration des entrées/sorties : la fonction setup ()
3. La partie principale qui s'exécute en boucle : la fonction loop ()

27
 L'interface de programmation affiche certains mots en différentes couleurs, cela revient
au statut des différents éléments :

La couleur orange désigne les mots-clés reconnus par le langage Arduino comme
des fonctions prédéfinie. La sélection d’un mot coloré en orange avec un clic droit de la souris,
offre la possibilité de choisir « Find in reference » : cette commande ouvre directement la
documentation de la fonction sélectionnée.

La couleur bleue, indique les mots-clés reconnus par le langage Arduino comme
des constantes.

La couleur grise, signale les commentaires qui ne seront pas exécutés dans le
programme. Il est utile de bien commenter son code pour s'y retrouver facilement ou pour le
transmettre à d'autres personnes. Un commentaire est déclaré en deux manières différentes :

1. Pour commenter une seule ligne, il faut utiliser « // », cela transforme le reste de la ligne
en commentaire.
2. Pour commenter un bloc de lignes, il faut insérer au début du bloc « /* » et terminer le
commentaire par « */ ».

II.4.3. Données, variables et constantes

Les différents types utilisés avec la programmation Arduino sont :

• Boolean : Donnés logique (true ou false) sur 8 bits ;

• Byte : Octet ;
• Int : Entiersignésur16 bits ;
• Float : Nombre a virgule flottant sur 32 bits ;
• Char : Caractère sur 8 bits. Seuls les caractères ayant pour code ASCII une valeur 0 à
127 sont définis ;
• Une constante peut être définie au moyen de const ou de #define.

II.4.4. Fonctions de gestion des Entrés et des Sorties

numériques et Analogiques.
Fonction pinMode : Cette fonction permet de configurer le sens de fonctionnement,
entré ou sortie, de la broche sélectionnée. L’écriture est comme suit pinMode (Numéro broche,
Sens de fonctionnement) ;

28
 Fonction digitalWrite : Cette fonction permet d’imposer un niveau logique haut et bas
sur la sortie numérique sélectionnée. digitalWrite (Numéro broche, Niveau logique) ;

Fonction digitalRead : Cette fonction permet de lire le niveau logique sur l’entrée
numérique sélectionnée. Cette fonction ne retourne que deux valeur HIGH ou LOW. Valeur =
digitalRead (Numéro broche) ;

Fonction analogWrite : Cette fonction permet de générer, sur la sortie sélectionnée, un

signal PWM avec le rapport cyclique désiré. La variable « Rapport cyclique » doit être de type
int, elle peut être comprise entre 0 et 255 pour un rapport cyclique, pour le signal généré,
compris entre 0 et 100 %. analogWrite (Numéro sortie, Rapport cyclique) ;

Fonction analogRead : Cette fonction permet de lire le résultat de la conversion

analogique numérique de la tension présentée sur l’entrée analogique sélectionnée. Valeur =
analogRead (Numéro entrée) ;

II.4.5. Fonctions de gestion du port série asynchrone.

Fonction Serial.begin : Cette fonction qui doit être appelée au moins une fois,
généralement dans la fonction setup (), permet de définir la vitesse utilisée par la liaison série.
Serial.begin(Vitesse) ;

Serial.end () : Cette fonction permet de désactiver la liaison série asynchrone et donc de

libérer les broches numériques 0 et 1.

Le port série asynchrone des microcontrôleurs qui équipent les cartes Arduino disposent
d’une mémoire tampon capable de mémoriser jusqu’à 128 caractères reçus.

Fonction Serial.read : cette fonction peut lire le premier caractère disponible dans la
mémoire de réception. Caractère = Serial.read() ;

Fonction Serial.print : Cette fonction permet d’émettre une ou plusieurs données sur la
liaison série en précisant le codage utilisé.

29
 II.4.6. Bibliothèque.
La bibliothèque est un ensemble de fonctions utilitaires mise au service des utilisateurs
de l’environnement Arduino. L’IDE Arduino comporte plusieurs bibliothèques du milieu
extérieur. Pour les ajouter aux programmes, il faut utiliser le menu « Add Library ». Nous avons
utilisé le logiciel Arduino pour programmer les différents circuits nécessaires pour cette
application dans l’environnement virtuel Proteus.

II.5. Simulation en Proteus

En pratique, chaque système dans le domaine électronique avant sa réalisation est exécuté
dans un logiciel. Dans notre cas nous avons eu recours à un logiciel sous le nom Proteus montré
dans la (figure 20) qui est un très bon logiciel de la simulation en électronique. Ce logiciel
permet de simuler toutes différentes parties du système.

Figure 20 : Fenêtre principale d’ISIS.

La simulation dans ce logiciel permet d'ajuster et de modifier le circuit comme si on

manipulait un montage réel. Ceci permet d’accélérer le prototypage et de réduire son cout. Il
faut toujours prendre en considération que les résultats obtenus de la simulation sont un peu
différents de celles de la réalité car toujours la réalisation en réalité est différente de celle en
simulation dans n’importe quel logiciel.

ISIS est un éditeur de schémas qui intègre un simulateur analogique, logique ou mixte.
Toutes les opérations se fassent dans cet environnement, aussi bien la configuration des
différentes sources que le placement des sondes et le tracé des courbes.

30
 II.5.1. La fenêtre du logiciel
Dans cette étape, nous allons commencer par la présentation de la fenêtre du logiciel ISIS
les éléments de cette fenêtre sont indiqués dans la (figure 21), la méthode de son utilisation et
l’emplacement de chaque icone et son utilité.

Figure 21 : les éléments de la fenêtre du logiciel.

1. Fenêtre d’ensemble (Vue d’ensemble)

Le cadre en bleu indique les extrémités de l'espace de travail tel qu'il a été défini par la
commande 'Définir taille des feuilles' du menu 'système'. Le cadre en vert délimite La zone de
travail, c'est à dire la partie du schéma visible dans la fenêtre principale.

• Nous pouvons déplacer cette zone de travail en pointant la souris sur la zone désirée de la
fenêtre d'ensemble et en effectuant un clic gauche.

2. Fenêtre d’édition

La surface la plus grande de l'écran s'appelle "Fenêtre d’édition" et se comporte comme

une fenêtre de dessin. C'est là que nous plaçons et câblons les composants.

3. La boite à outils

Elle est composée d'un ensemble d'icônes dont les fonctions seront détaillées
ultérieurement et d'un sélecteur d'objet utilisé pour choisir les boîtiers, le style des pastilles, des
traces et des traversées.

31
 II.5.2. Placement et câblage des composants
Commençons par un clic gauche sur l’icône d’un composant, Nous avons ainsi accès aux
bibliothèques de composants. Un clic sur "P", du "sélecteur d’objets" ouvre une nouvelle
fenêtre.

Figure 22 : Choix des composants.

Nous pouvons maintenant choisir un composant dans les différentes bibliothèques comme
indiques dans la (figure 22). Un double clic place le composant sélectionné dans le sélecteur
d’objet et le rend éditable.

Ce logiciel a la possibilité d’emporter même des codes hexadécimaux pour les réalisations
qui contiennent des composants programmables ou des cartes programmables « Arduino »
comme dans notre réalisation.

Notre objectif est de réaliser une application à base d’Arduino commandé par Matlab.
Dans un premier temps nous allons effectuer et tester un petit exemple sous Isis. Cette étape est
nécessaire pour la confirmation du teste. Apres validation, nous allons faire le test sous Matlab.

32
 II.5.3. Schéma de l’exemple sur Isis

Figure 23 : Circuit électronique de l’exemple.

Les composants du schéma est représenté sur la (Figure 23) :

• Arduino.
• LED branche sur le pin 7 par protection d’une résistance d’1 ohm.
• Résistance variable branche sur le pin analogique A0.
• Interrupteur.

II.6. Le code Arduino

Le but de ce code Arduino est de configurer les ports d’Arduino comme entrés ou sorties
et de faire la lecture et l’écriture au niveau des ports soit les ports numériques ou les ports
analogiques. Ce processus est programmé avec des instructions très clair et souple. (Voir
l’annexe pour le code source).

II.6.1. Organigramme du fonctionnement de code Arduino.

L’organigramme dans la (figure 24) explique le fonctionnement du programme du code
Arduino en indiquant la procédure et la logique utilisé dans le programme.

33
 Figure 24 : Organigramme du code Arduino.

II.6.2. Les commandes

Dans ce code, nous avons 4 commandes principales. Les commandes de configuration,
de lecture, de l’écriture et de lire la valeur du pin analogique :

• La configuration on a CXXY le X a l’objectif d’indiquer le pin de travail et le Y prend de

valeur soit 1 soit 0 (soit entrée soit sortie).
• La lecture se fait par RXXY comme toujours le X pour les pins et le Y dans ce cas est
ignoré.
• Le WXXY c’est l’écriture de la valeur Y dans le pin XX.
• La configuration du pin analogique ANXX qui peut être un pin analogique ou avoir un
comportement d’un pin numérique.

II.6.3. Les règlements

Les règlements sont les décisions d’un exécutif. Par exemple, dans ce code toutes les
commandes et les réponses se terminent par un « \r », cela est nécessaire quand on communique
avec un milieu externe via le port série. Ainsi, les commandes de lecture et d’écriture doivent
retourner une valeur lue et un code d’information, si non, un code d’erreur.

34
 II.6.4. Les erreurs
Avant de discuter l’aspect des erreurs. Il faut noter d’une part, que pour chaque
commande juste, une réponse « ok » est affecté. D'autre part, une liste des erreurs est conçue
pour une identification précise de l’erreur. Le C00, R00, W00, ANO sont des erreurs de
paramétrage lors de la configuration, de la lecture analogique et de l’écriture. Au niveau du
switcher dans le cas d’erreur il retourne S00 une commande non reconnue et le S01 une taille
de commande invalide.

II.7. Les commandes programme pour le port série.

Pour bien comprendre nous allons appliquer les commandes dans le tableau 2, sur
l’exemple que nous avons fait sur Isis. Le tableau explique la signification de chaque
commande :

Tableau 2 : Commandes et leurs significations.

Nous pouvons tester ces commandes dans Isis à l’aide du VIRTUEL TERMINAL pour
voir la manière de déroulement de communication.

II.7.1. Virtuel terminal

Virtuel terminal est un outil de Proteus utilisé pour afficher et envoyer les données. Il est
lié avec Arduino à l’aide du pin TX et RX. Rappelons que le TX et RX sont des pins numériques
assure la communication avec l’Arduino. L’image de cet outil est montrée dans la (figure 25).

Figure 25 : Virtuel Terminal.

35
 La (figure 26) montre le résultat de lancement de la simulation sur Proteus et d’exécution
des commandes sur Virtual Terminal.

Figure 26 : Simulation dans ISIS avec Virtuel Terminal.

Les commandes affichent les réponses comme suit : le premier « ok » signifie que la
configuration C071 est correcte. Ensuite, un tapage incorrect dans Virtual terminal se voit par
l’affichage de l’erreur W00. Après, nous entrons W071 pour allumer la LED et un R07 pour
lire que la LED est dans l’état haut ‘1’. Par la suite, nous avons configuré le pin 8 et lié la
valeur 1 de switch L’étape final est la configuration du pin analogique et la lecture de la valeur.
En conséquence, à l’aide du Virtual terminal nous avons eu les réponses codées dans le
programme Arduino ainsi de contrôler avec succès les composants liés avec l’Arduino. Au
niveau de S01, S00 sont des erreurs au niveau de l’écriture des commandes comme nous avons
indiqué précédemment dans le paragraphe des erreurs.

36
 II.8. Conclusion

Après l’explication l’Arduino, son fonctionnement et la définition de logiciel Proteus.

Nous avons construit un code Arduino qui permet de configurer les ports numériques et
analogiques. Nous avons ainsi, effectué un test et une petite simulation sous l’environnement
Proteus Arduino sans passer à un milieu extérieur à l’aide de Terminal Virtuel. Le résultat de
ce processus de simulation nous ramène à conclure que le programme fonctionne correctement
sans erreur.

Dans le chapitre suivant, nous allons refaire le même travail et la même simulation avec
un milieu extérieur qui s’appelle Matlab.

37
 SIMULATION SOUS MATLAB
III.1. Définition de Matlab

Matlab est un langage de script émulé par un environnement de développement du même

nom ; il est utilisé à des fins de calcul numérique. Développé par la société The MathWorks,
MATLAB permet de manipuler des matrices, d'afficher des courbes et des données, de mettre
en œuvre des algorithmes, de créer des interfaces utilisateurs, et peut s’interfacer avec d’autres
langages comme le C, C++, Java, et Fortran.

Figure 27 : Interface Matlab.

En plus, MATLAB est un environnement de développement ("progiciel") à part entière :

son langage d'assez haut niveau, doté notamment de structures de contrôles, fonctions d'entrée-
sortie et de visualisation 2D et 3D, outils de construction d'interface utilisateur graphique (GUI),
etc. permet à l'utilisateur d'élaborer ses propres fonctions ainsi que de véritables programmes
("M-files") appelés scripts vu le caractère interprété de ce langage. MATLAB est disponible
sur tous les systèmes d'exploitation standards (Windows, GNU/Linux, MacOs). Le champ
d'application de MATLAB peut être étendu aux systèmes non linéaires et aux problèmes
associés de simulation avec le produit complémentaire SIMULINK. Les capacités de
MATLAB peuvent en outre être enrichies par des fonctions spécialisées regroupées au sein de
dizaines de "toolboxes" (boîtes à outils qui sont des collections de "M-files") couvrant des
domaines très variés tels que :

• Analyse de données ;
• Mathématiques symboliques (accès au noyau Maple V) ;
• Analyse numérique (accès aux routines NAG) ;
• Traitement de signaux (et du son en particulier) ;
• Acquisition de données et contrôle de processus (gestion ports série/parallèle, cartes
d'acquisition, réseau TCP ou UDP.

38
 Une interface de programmation applicative (API) rend finalement possible l'interaction
entre MATLAB et les environnements de développement classiques (exécution de routines C
ou Fortran depuis MATLAB, ou accès aux fonctions MATLAB depuis des programmes C ou
Fortran). Ces caractéristiques et d'autres encore font aujourd'hui de MATLAB un standard
incontournable en milieu académique, dans les différents domaines de l'ingénieur et la
recherche scientifique.

III.2. Interface graphique et environnement de

développement (IDE)

Comme Arduino, Matlab offre en standard un IDE (Integrated Développement

Environnement), c'est-à-dire qu'il présente une interface graphique (GUI) composé d’une
fenêtre de commande, des fenêtres de graphiques et de divers autres outils sous forme de
fenêtres graphiques tel que : Workspace, Editor, Current Directory, Command History, Profiler,
Help. Comme représenté dans la (figure 28).

Figure 28 : Environnement de développement IDE.

Nous allons refaire le même travaille précèdent commander à partir de Virtual Terminal
avec Matlab. Nous garderons donc le même code Arduino.

III.3. Le programme en Proteus.

Pour faire cette communication, on est besoin de deux choses :

39
 • COMPIM : Modélise un port série physique. Il tamponne les communications série reçues
et les présente sous forme de signaux numériques au circuit. Toutes les données série
transmises à partir du Modèle UART ou de la CPU transitent également par le port série
de l’ordinateur.

Figure 29 : COMPIM.

Idéalement, un port série virtuel serait créé dans Proteus pour simuler l’interaction avec
une interface physique. Ensuite, On peut simplement exécuter la simulation de périphérique et
utiliser VSPE en tant que programme hôte pour tester la connexion. Ce logiciel VSPE a été créé
pour aider les ingénieurs à créer, tester et déboguer les applications qu’utilise les ports en série.
Par conséquent, nous allons l’utiliser pour créer deux ports imaginaires pour faciliter la
communication entre Arduino et Isis.

Figure 30 : L’ouverture de logiciel virtuel serial port.

La (figure 31) montre le circuit complet électronique de notre système que nous avons
simulé avec Proteus. Le circuit contient un appareil de « COMPIM », cet appareil représente le
port sérial de PROTEUS, avec sa configuration avec VSPE et Matlab.

40
 Figure 31 : Simulation dans ISIS avec COPMIM.

Pour voir les résultats voici quelques étapes représentées dans la (figure 32) que nous avons
suivies en Proteus et en VSPE.

Figure 32 : Configuration de VSPE, (b) Configuration de COMPIM.

• Choisir la vitesse de transfert de donnes (9600 bauds).

• Choisir les bits de données.
• Créé 2 ports imaginaire dans VSPE l’un pour COMPIM et l’autre pour Matlab.
• Indiquer l’un des deux Pour faire fonctionner le circuit il faut exécuter les commandes à

Partir de Matlab. Puisque on a choisi les ports 13,14 et le COMPIM s’occupe du port 13
donc, nous allons indiquer le port 14 pour assurer une communication correcte.

Nous allons reprendre le travail fait au niveau du Terminal Virtuel précédemment sous
Matlab à l’aide d’un code diffèrent mais avec le même objectif :

41
 • Configuration des ports « entres, sortis ».
• La lecture et l’écriture des composants qui sont liés aux ports « Analogiques,
Numériques ».

III.4. Simulation sous Matlab et Isis

Dans cette étape nous allons connecter Matlab et Arduino avec Le VSPE et donner les
commandes de Matlab. Les résultats seront affichés sous ISIS. La capture de cette simulation
est projetée ci-dessous dans la (figure 33).

Figure 33 : Ouverture port 14 pour Matlab.

La (Figure 34) montre que la configuration du port avec Matlab est faite correctement
avec l’indication du numéro du port ‘14’, la vitesse du transfert utilisée ‘9600’ et l’état initial
de la communication. Par exemple il n’y a aucun message reçu ou bien transmis entre Matlab
et Arduino.

Figure 34 : Simulation et commande sous Matlab.

Les figures montrent que les commandes sont effectuées de Matlab vers Isis à l’aide de
VSPE, après l’écriture d’une commande et avec l’instruction suivante :
char(fread(s,s.BytesAvailable)’), Nous obtenons la réponse du Arduino si la commande est
correcte nous aurons un ‘OK’, avec ces commandes nous avons configuré le port 7 comme
sortie, allumé la LED, et configuré le port 8 comme entré avec la lecture de l’état de
l’interrupteur.

42
 Dans le cas d’une fausse commande et d’une lecture de la réponse d’Arduino on doit
trouver à un des erreurs suivant C00, R00, W00, AN0, S00, S01.

Figure 35 : Instructions indique une fausse commande.

Après la confirmation de la bonne communication entre Matlab et Isis, nous pouvons

développer le programme Matlab de tels sortes avoir un programme facile et court dans la
fenêtre command Window. Pour cela nous allons ajouter 5 fonctions dans lesquelles nous
écrirons des fonctions pour :

• La liaison entre Matlab, Isis.

• La configuration des ports.
• L’écriture dans les ports.
• La lecture des ports.
• Configuration des ports analogiques.

III.5. Les fonctions

III.5.1. La première fonction : Communication Arduino

Matlab.

Figure 36 : Communication Arduino avec Matlab.

43
III.5.2. Deuxième fonction : Configuration des pins.

Figure 37 : Configuration des pins

III.5.3. Troisième fonction : Lecture des pins.

Figure 38 : Lecture des pins.

III.5.4. Quatrième fonction : L’écriture.

Figure 39 : l’écriture dans les pins.

III.5.5. Cinquième fonction : Les pins Analogique.

Figure 40 : Configuration des pins Analogique.

44
 Sur les figures 36 ,37,38,39 et 40 on a représenté les codes écrit sur Matlab qui gère la
communication Arduino Matlab et la configuration des pins numériques ainsi la lecture et
l’écriture dans ses pins et puis de lire les pins Analogiques respectivement.

Après l’écriture des fonctions nous pouvons les tester avec un test de notre choix.

III.6. Les Test

III.6.1. Test n°1

Un test est représenté sur la (figure 41)

Figure 41 : Test n°1.

Maintenant il suffit d’indiquer le port utilisé et d’écrire le mot test dans command
Window pour voir la communication entre Matlab et Arduino. A partir de la (figure 42), nous
pouvons conclure l’utilité des fonctions programmé sous l’éditeur, parce qu’ils permettent de
minimiser l’écriture dans cette fenêtre.

Figure 42 : Résultat du premier test.

45
 Le test est bien fait sans erreurs. Lors de lancement de la simulation, Matlab communique
avec Arduino pour configurer les pins après la validation qu’il est exempt de problèmes.
L’objectif de test est : si l’interrupteur égal à 1 il va allumer et éteindre la LED 10 fois.

III.6.2. Test n°2

Ce test a pour but de faire clignoter la LED 10 fois avec une pause entre chaque allumage
et extinction du lumière. Tant qu’il y’a pas de possibilité d’enregistrer une vidéo nous allons
donner le code écrit sous Matlab. Et ce code est représenté sur (la figure 43).

Figure 43 : Code Matlab pour Test n°1.

III.7. Conclusion

Dans ce chapitre nous avons parlé du rôle du logiciel Matlab, et l’utilisé pour commander
Arduino avec plusieurs essaies. Ainsi, nous avons introduit un code depuis Matlab pour faire
fonctionner le petit exemple. Nous avons réussi donc de rendre Matlab une interface d’Arduino.

Maintenant, nous sommes capables de faire n’importe quelle application, il suffit de

réaliser le schéma dans Isis, d’écrire un code Matlab dans un script et le simuler. Nous allons
réaliser ces opérations dans le chapitre suivant.

46
 APPLICATION FEU DE
CIRCULATION INTELLIGENT
IV.1. Feu de circulation routière

IV.1.1. Définition du feu de circulation

Un feu de circulation routière est un dispositif régulation du feu tricolore entre les
utilisateurs de la voiture et les piétons. Les feux sont destinés aux véhicules et piétons sont
généralement de type tricolore pour les voitures... et pour les piétons sont bicolores. Un
croisement a feux tricolores est commandé par un contrôleur de feux.

Les feux de circulation sont à base de 3 couleurs est représenté sur la figure 44 : le rouge
pour fermer, le vert pour ouvrir et le l'orange est utilisé afin de signaler le passage du feu vert
vers le feu rouge.

Figure 44 : feux tricolores à l’aide des LEDS.

IV.1.2. Objectifs et domaine d'emploi.

L’utilisation des feux de circulation a pour but d'assurer la sécurité de tous les utilisateurs
de la route, piétons et conducteurs. Cette sécurité se manifeste dans différents cas tel que :

• La gestion de la circulation dans les intersections.

• La gestion d'un point de contrôle des personnes ou des véhicules nécessitant leur arrêt
comme les péages par exemple.
• La protection d'obstacles interdits, comme les passages à niveau, ponts mobiles, passages
d'avions.

47
 IV.1.3. Principe du feu de la circulation.
Dans les intersections ou les carrefours, les feux de circulation ont trois principales
séquences qui se répètent durant toutes la journée.

• Quand le feu rouge s'allume, tout conducteur doit marquer l'arrêt total devant ce feu fixe
ou clignotant.
• Quand le feu vert s'allume, il indique l'autorisation du passage du véhicules sous la
condition du respect des piétons.
• Le dernier cas est le feu orange, qui informe tout conducteur de marquer l'arrêt devant un
feu de signalisation orange ou plutôt la préparation pour l’arrêt.

Chaque invention peut être développé à cause des nouvelles situations à gérer ou bien des
nouveaux problèmes. Il faut donc définir et résoudre ces problèmes puisque le feu de circulation
fait partie de ces inventions.

IV.2. Le problème

• Comment gérer un croisement dans le cas d'embouteillage dans une seule direction ?
• En cas de nuit comment gérer la gestion du feu de la circulation dans la présence d’un
véhicule.
• Est-ce que le rôle d’un policier de circulation peut être joué, au cas d’embouteillage dans
les deux directions

Pour répondre à ces questions, nous avons pensé à faire un feu tricolore intelligent, qui
est basé sur des capteurs de présences de véhicule et des capteurs placés à une petite distance
de feu de circulation pour détecter l’embouteillage.

IV.3. Réalisation d’un feu de circulation intelligent.

Pour réaliser ce projet il faut un environnement de travail pour placer les composants et
des programmes pour faire fonctionner le feu rouge. Pour ce faire, nous allons utiliser Proteus
comme environnement, et développer des codes sous forme de fonctions sous Matlab avec un
test qui regroupe tous ces fonctions.

IV.3.1. Les composants

Dans cette application nous allons utiliser :

48
 • Arduino UNO R3
• 4 Traffic lights 1 pour chaque voie.
• 4 capteurs (LOGIC STATE) pour présence de la voiture.
• 4 capteurs (LOGIC STATE) pour l’indication du l’embouteillage.
• COMPIM.
• 4 Afficheurs 7 SEGMENT.
• Un décodeur

IV.3.2. Schéma sur Proteus Isis du montage avec

l’organigramme.
La (figure 45), montre l’emplacement de chaque composant dans la fenêtre de travail sur
Isis. Donc nous pouvons déterminer les états de feu de circulation :

• Les voies A, C ouvertes et B, D fermées ;

• Les voies A, C fermées et B, D ouvertes ;
• L’état normal permutation entre les deux états précédents avec l’allumage du compteur
dans chaque état.

Figure 45 : Le circuit électronique du feu rouge intelligent.

49
 Pour bien comprendre ce schéma et le fonctionnement de ce travail, il faut faire un tableau
de vérité et les tableaux de Karnaugh pour établir les équations des 3 états possibles, en utilisant
seulement les capteurs de présences de la voiture.

IV.4. Tableau de vérité et tableau de Karnaugh

Dans un premier temps, nous allons établir les 3 équations concernant la circulation
routière seulement avec les capteurs de présences sans intervenir la notion d’embouteillage.

IV.4.1. Table de vérité

Tableau 3 : Table de vérité.

50
 IV.4.2. Tableaux de Karnaugh
Pour établir les équations il faut faire les tableaux de Karnaugh

Tableau 4 : Tableaux de Karnaugh.

IV.5. Mode de fonctionnement et Organigrammes.

Après l’établissement des équations nous pouvons faire un organigramme qui explique la
démarche du feu rouge en se basant sur les capteurs de présences et en ajoutant 4 capteurs (e,
f, g, h) qui contrôlent l’embouteillage.

Condition 1 : Les capteurs (a, b, c, d) =0 ou bien les capteurs (a, b, c, d, e, f, g, h) =1 ou

bien les capteurs de présence de la voiture de 2 voies opposées égal à 1.’feu croisement’

Condition 2 : Un seul capteur de présence de la voiture égal à 1, ou deux capteurs de

présence de la voiture avec une va1 de mêmes voies, Ou bien la présence de la voiture sur la
même direction avec des capteurs d’embouteillage à 1. Dans le cas d’une erreur ou d’une
plantation du système le feu rouge fonctionne suivant la condition 1.

51
 IV.5.1. Organigramme du programme principale (carrefour)

Figure 46 : Organigramme du programme principal.

Cet organigramme de la (figure 46) nous a donné 3 autres Cas et on va donner l’organigramme
de chaque cas.

IV.5.2. Organigramme OuvrirDirectionAC

Figure 47 : Organigramme OuvrirDirectionAC.

52
 Cet organigramme de la (figure 47) explique comment on va procéder pour allumer les
feux de circulation de la Route AC qui se situent dans la même direction. Nous citons 3 cas qui
gèrent l’allumage du feu de cette direction comme suit :

• Cas 1 : tous les feux de circulation de deux directions sont éteints.

• Cas 2 : Seulement le feu vert de la direction AC et le rouge de direction BD sont allumés.
• Cas 3 : Seulement le feu rouge de direction AC et le feu vert de direction BD sont allumés.

IV.5.3. Organigramme OuvrirDirectionBD

• Cas 1 : tous les feux de circulation de deux directions sont éteints.
• Cas 2 : Seulement le feu vert de direction BD et le rouge de direction AC qui sont allumés.
• Cas 3 : Seulement le feu rouge de direction BD et le feu vert de direction AC qui sont
allumés.

Figure 48 : Organigramme OuvrirDirectionBD.

Pour l’organigramme du feucroisement il va contenir l’organigramme du

OuvrirDirectionAC et l’organigramme du OuvrirDirectionBD, nous allons juste donner le code
sous Matlab de feucroisement sans établir son organigramme.

53
 IV.6. Les codes sous Matlab

IV.6.1. Configurations des pins.

Dans la configuration des pins nous allons configurer les capteurs comme entrées et les
pins du feu de la circulation et du décodeur comme sorties. Comme il est indiqué dans la (figure
49)

Figure 49 : Configuration des pins.

IV.6.2. Code décompteur

Pour réaliser un décompteur, nous avons utilisé un décodeur lié avec 4 afficheurs 7
segments, chaque afficheur responsable d’une voie dans chaque intersection. Le mode de
fonctionnement de ce décodeur avec l’afficheur est expliqué dans tableau suivant :

Tableau 5 : Le mode de fonctionnement d’un décodeur.

54
 IV.6.3. Code principal (carrefour)
Ce programme va tester tous les cas possibles dans la circulation à partir des capteurs de
présences de la voiture et les capteurs d’embouteillage, le code va distinguer entre trois états du
feu tricolores : l’ouverture de la direction A, C ou bien l’ouverture de la direction B, D ou bien
faire la permutation entre les deux directions, nous avons nommé cette dernière par feu
croisement. La (figure 50) représente le programme écrit

Figure 50 : Code principal (carrefour).

IV.6.4. OuvrirDirectionAC (Code Matlab).

Figure 51 : Code OuvrirDirectionAC.

55
 IV.6.5. Feucroisement

Figure 52 : Code feucroisement.

IV.6.6. OuvrirDirectionBD
Après l’identification de tous les éléments du programme il ne reste qu’écrire le code du
test. Qui est représenté sur la (figure 53).

Figure 53 : Code OuvrirDirectionBD.

56
 IV.6.7. Test
A la fin de chaque fonction nous écrivons le mot carrefour qui contient le code des
différents cas possibles, pour une seule raison qui est de jouer avec les capteurs au cours de
simulation et voir le nouveau résultat sans éteindre la simulation. Le code du test est représenté
sur la Figure 54.

Figure 54 : Code test.

IV.7. Conclusion

Dans ce chapitre on a exploité toutes les connaissances qu’nous avons vue dans les deux
derniers chapitres afin de réaliser une application sou) le nom feu rouge intelligent qui gère le
lancement du feu lors du présence des voitures à l’aide des capteurs et l’embouteillage dans un
carrefour, toutes ces opérations sont réalisées sous l’environnement virtuel Proteus. Ce qui nous
a ramener à réaliser une carte d’interface Matlab à base d’Arduino.

57
 Conclusion générale
Ce travail d’étude et de recherche concernant la carte d’interface Matlab à base d’Arduino
a été une excellente occasion pour augmenter mes connaissances dans le domaine
d’électronique et de programmation. J’ai découvert l’importance de ce type de ces cartes
d’interfaces sous diverses applications dans le monde réel comme mentionné dans le premier
chapitre.

En effet, dans le deuxième chapitre, j’ai fait une étude sur la carte d’Arduino pour
accumuler assez d’information afin d’écrire un programme qui va gérer toute la carte Arduino,
soit au niveau des pins soit au niveau de communication avec cette carte Arduino et un milieu
extérieur.

Ensuite, j’ai entamé la partie de Matlab et la méthode de contrôle de la carte Arduino en

utilisant Matlab comme un autre environnement qui n’a pas de relation avec Arduino.

A la fin de ce travail, au niveau du dernier chapitre, nous avons exploité les résultats
obtenus pour réaliser une application du feu de circulation intelligent.

En conclusion, la carte d’interface Matlab à base d’Arduino est une technologie

importante qui peut nous aider dans la vie réelle pour faire n’importe quel projet ou application.

58
 Annexe
Annexe 1 : Programme général

/*** VARIBALES GLOBALES ******************/

char cmd[5]; // Buffer de commande
int cmd_taille=0; // Taille de commande
int X; // Pin numérique
int Y; // Valeur
int XA; // Pin analogique

/*** POROGRAMME D'INITIALIDSATION *******/

Void setup(){
Serial.begin(9600); // Overture de la connexion
Serial.print("ARDUINO STARTED V1.0\r"); // ..Message de bienvenue, et la version du firmeware}
/*** PROGRAMME DE BOOUCLE **************
void loop() {
wait_cmd();
}

/*** PROGRAMME D'ATTENTE DE COMMANDE ***/

void wait_cmd(){
if (Serial.available()){
char car = Serial.read();
if(int(car)==13){
cmd_taille=0;
cmd_switcher();
}elseif(cmd_taille>3){
cmd_taille=0;
Serial.print("S01\r");
}else{
cmd[cmd_taille]=car;
cmd_taille=cmd_taille+1;
}
}
}

59
/*** PROGRAMME DE SELECTION DE COMMANDE ***/
void cmd_switcher(){
switch(cmd[0]){
case 'C':{
C(); //faire la commande Configuration quand on tape C
break;
}
case 'R':{
R(); //la lecture des pins lorsque on tape R
break;
}
case 'W':{
W(); //l'écriture lorsque on tape W
break;
}
case 'A':{
AN(); // permet la configuration des pins analogique
break;
}
default:{
Serial.print("S00\r"); // Erreur
}
}

/*** Programme de teste des paramètres de commandes numériques ***/

boolean test_digital_params(){
// caractère chiffre [0-9] = [48-59] ASCII
boolean test_X1=(cmd[1]>47 && cmd[1]<50); // entre 0-1
boolean test_X2=(cmd[2]>47 && cmd[2]<60); // entre 0-9
boolean test_Y=(cmd[3]==48 || cmd[3]==49); // entre 0-1
if(test_X1 && test_X2 && test_Y){
int X1=cmd[1]-48;
int X2=cmd[2]-48;
X=X1*10+X2;
Y=cmd[3]-48;
return true;

60
}else{
return false;
}
}

/*** Programme de teste des paramètres de commandes analogiques ***/

boolean test_analog_params(){
boolean test_A=(cmd[2]=='A'); // Caractère A du pin analogique
boolean test_X=(cmd[3]>47 && cmd[3]<54); // Numéro du pin analogique de 0-5
if(test_A && test_X){
XA=cmd[3]-48+14; // A0=14 A1=15 .... A5=19
return true;
}else{
return false;
}}

/************* C() ******************/

void C(){
if (test_digital_params()){
pinMode(X, Y);
Serial.print("OK\r"); // Information
}else{
Serial.print("C00\r"); // Erreur}
}

/************* R() ******************/

void R(){
if (test_digital_params()){
int value=digitalRead(X);
Serial.print(value); // Valeur envoyée à Matlab
Serial.print("\r"); // Terminaison selon le règlement
}else{
Serial.print("R00\r"); // Erreur
}
}

61
/************* W() ******************/
void W(){
if (test_digital_params()){
digitalWrite(X, Y);
Serial.print("OK\r"); // Information
}else{
Serial.print("W00\r"); // Erreur
}
}

/************* AN() ******************/

void AN(){
if (test_analog_params()){
int value=analogRead(A0);
Serial.print(value); // Valeur envoyée à Matlab
Serial.print("\r"); // Terminaison selon le règlement
}else{
Serial.print("AN0\r"); // Erreur
}
}

62
 BIBLIOGRAPHIE
- Cours d’électronique numérique S5 IETEL.

Webographie
- https://www.cours-gratuit.com/cours-arduino/cours-d-introduction-a-arduino-matlab-
et- Simulink.

- https://www.arduino.cc/reference/en/.

- https://fr.scribd.com/document/441592464/Arduino-le-guide-complet-Une-re-fe-
rence-pdf.

- https://fr.scribd.com/document/408483362/AHMED-pdf.

- https://fr.wikipedia.org/wiki/Arduino.

- https://fr.wikipedia.org/wiki/Feu_de_circulation.

63