Mise en Å“uvre d'une application à base d'une carte arduino.

	REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE Université Kasdi Merbah Ouargla Faculté des Nouvelles Technologies de l'information et de la communication Département de l'Electronique et de la communication PROJET DE FIN CYCLE En vue d'obtention du Diplôme de licence professionnelle Spécialité : Instrumentation pétrolière Thème
	MISE EN OEUVRE D'UNE APPLICATION A BASE D'UNE CARTE ARDUINO
	Présenté par : Encadré par: : BOUDERHEM BRAHIM AOUF ANOUR ESSADET SALHI YOUNES TAIBI DJAMEL ZIOUANE LAZHAR : 2014/2015

Dédicaces

Nous dédions ce modeste travail à nos très chers parents

pour

Leur soutient morale et financier pour leur

Encouragements et les sacrifices qu'ils ont endurés dans les

Moments les plus ardus.

A nos frères
A nos soeurs

Et à toute la famille BOUDERHEM ET SALHI ET ZIOUNE

A nos chers amis
A tous les amis (es) d'études surtout ceux
D'instrumentation promotion 2015
Tous ceux qui ont contribué à nos formation, de prés et
De loin

Remerciement

Nos remerciements s'adresse en premier lieu à ALLAH le tout puissant pour la volonté, la patience qu'il nous a donné durant toutes ces longues années.

Ainsi, nous tenons également à exprimer nos vifs remerciements à nos encadreurs M^r. AOUF ET M^r. .

TAIBI DJAMEL qui nous a apporté une aide précieuse. Nous lui exprimons notre gratitude pour sa grande disponibilité ainsi que pour sa compréhension et les encouragements qu'ils nous apporté.

Nos remerciements vont aussi à tous nos enseignants qui ont contribué à notre formation et à tous les membres du jury qui ont accepté de juger notre travail.

Enfin, nous tenons à exprimer notre reconnaissance à tous nos amis et collègues pour le soutien moral et matériel.

Sommaire

Introduction Général		.1
I. La carte ARDUINO Mega 2560		3
I.1.Introduction		3
I.2. Présentation de la carte ARDUINO		3		I.3. caractéristiques de la carte Arduino Mega 2560
5
I.4.STRUCTURE INTERNE DE LA CARTE		7
I.5.Le langage de programmation		.8
I.6. La structure d'un programme		.8
I.7.Conclusion	.11
II. Interface graphique sous MATLAB	13
II.1.Introduction	.13
II.2.Exemple	15
II.3.Conclusion	19

III. Réalisation d'une interface graphique sous la boite à outil GUI de MATLAB

pour la supervision		..21
III.1. Introduction		21
III.2.Présentation de l'application		..21
III.3.supervision de température, pression et niveau		23
III.3.1.définition de capteur		23
III.3.2.capteur de température		24
III.3.4.capteur de pression		25
III.3.5.capteur de niveau		..26
III.3.6 Notre programme de l'interface graphique		26
Bouton Connect		.31
Bouton Lire	31
III.4.Résultat pratique	..32
III.4.1. Température	32
III.4.2. Pression	32
III.4.3. Niveau	..33
III.5.Conclusion	..33

Conclusion Général .35

BIBLIOGRAPHIE ..36

1

Introduction générale

L'étude des applications à base d'une carte Arduino doit désormais faire intervenir l'acquisition de données. L'oscilloscope numérique actuel dont le convertisseur analogique numérique 8 bits n'est pas assez performant. Il sera utilisé en mode analogique comme instrument de contrôle indispensable pour bien préparer l'acquisition des mesures avec l'interface graphique par MATLAB (GUI). Le traitement informatique des données, la présentation des résultats sous forme des courbes faciles, rendent les Travaux Pratiques beaucoup plus démonstratif en ce qui concerne la compréhension des phénomènes physiques.

Ce travail est réalisé pour développer une carte d'acquisition et de supervision avec une interface graphique sous MATLAB communiqué à travers le bus USB. Cette carte doit permettre de réaliser plusieurs taches à faible coût et à faible consommation.

Dans notre projet, nous présentons l'acquisition de la température, de pression et de niveau de liquide qui sont réalisés par une carte à base d'ARDUINO Mega 2560, pour présenter la faisabilité de faire un environnement matériel et logiciel sous Matlab, pour un objectif éducatif et scientifique, et pour des applications sur les systèmes lents.

Pour visualiser en tems réel la modification de courbes en fonction de paramètres. La plupart des gens ignorent que cela peut se faire très facilement avec une programmation simple sous l'outil d'interfaçage graphique sous MATLB (GUI). L'objectif de ce mémoire est de réaliser une application à base d'une carte Arduino pour l'acquisition des données sous MATLAB.

Ce projet est organisé comme suit : dans la première partie nous présentons en détail la carte Arduino Mega 2560.

Dans la deuxième partie nous présentons l'outil d'interfaçage graphique sous MATLAB La troisième partie, présente le dispositif expérimental qui a permit de valider notre carte d'acquisition, ainsi que le test réalisé et les résultats obtenus. Enfin nous terminons par une conclusion.

CHAPITRE I

CARTE

ARDUINO

MEGA2560

CHAPITRE I CARTE ARDUINO MIGA 2560

3

I. La carte ARDUINO Mega 2560 I.1.Introduction

L'Arduino est une carte électronique en Matériel Libre pour la création artistique interactive. Elle peut servir:

1/ pour des dispositifs interactifs autonomes simples

2/ comme interface entre capteurs/actionneurs et ordinateur 3/ comme programmateur de certains microcontrôleurs.

Le projet Arduino comprend à la fois le développement matériel de cette carte, mais aussi le développement de son environnement de programmation, adaptation du logiciel de programmation pour la carte Waring, lui-même construit sur le Logiciel Libre de gestion d'événements multimédia interactifs Procession. L'Arduino n'est cependant pas exclusivement liée à Procession, et peut être utilisée en Fonctionnement piloté avec la quasi totalité des logiciels de gestion d'événements multimédia interactifs. L'Arduino peut également être utilisée comme carte de programmation pour des microcontrôleurs AVR Pour les utilisateurs chevronnés, la carte peut également être programmée en langage AVR-C.

L'Arduino est une carte basée sur un microcontrôleur (mini-ordinateur) Amel ATME2560 ou ATMEGA168. Elle Dispose dans sa version de base de 1 Ko de mémoire vive, et 8Ko de mémoire flash pour stocker ses programmes. Elle peut être connectée à 13 entrées ou sorties numériques, dont 3 PWM (pouvant donner 3 sorties analogiques et 6 entrées analogiques convertissant en 10 bit. Dans la version la plus courante, la communication avec l'ordinateur se fait par un port USB. Il existe plusieurs versions de l'Arduino, dont une version miniaturisée, et d'autres projets sont également en gestation. La carte dispose d'un logiciel système interne (modifiable) et des programmes utilisateur

I.2. Présentation de la carte ARDUINO

Arduino est un projet créé par une équipe de développeurs, composée de six individus, Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis et Nicholas Zambetti. Cette équipe a créé le "système Arduino". C'est un outil qui va permettre aux débutants, amateurs ou professionnels de créer des systèmes électroniques plus ou moins complexes. Le système Arduino, nous donne la possibilité d'allier les performances de la programmation à celles de l'électronique. Plus précisément, nous allons programmer des

CHAPITRE I CARTE ARDUINO MIGA 2560

systèmes électroniques. Le gros avantage de l'électronique programmée c'est qu'elle simplifie grandement les schémas électroniques et par conséquent, le coût de la réalisation, mais aussi la charge de travail à la conception d'une carte électronique. L'utilité est sans doute quelque chose que l'on perçoit mal lorsque l'on débute, mais une fois que vous serez rentré dans le monde de l'Arduino.

Le système Arduino nous permet de réaliser un grand nombre de choses, qui ont une application dans tous les domaines, l'étendue de l'utilisation de l'Arduino est gigantesque. Pour donner quelques exemples, vous pouvez :

> contrôler les appareils domestiques

> fabriquer votre propre robot

> faire un jeu de lumières

> communiquer avec l'ordinateur

> télécommander un appareil mobile (modélisme)

> etc.

4

Figure 1 : schéma simplifié de la carte ARDUINO Mega 2560

CHAPITRE I CARTE ARDUINO MIGA 2560

5

Figure 2 : structure interne d'une carte ARDUINOMega2560

I.3. caractéristiques de la carte Arduino Mega 2560

1/Microcontrôleur ATMEL ATMega328

Le microcontrôleur utilise sur la carte Arduino Mega est un microcontrôleur ATMega2560. C'est un microcontrôleur ATMEL de la famille AVR 8bits.

Manufacturer:	Amel
Product Catégorie:	8-bit Microcontrôleurs - MCU
RoHS:
Core:	AVR
Data Bus Width:	8 bit
Maximum Clock Fréquence:	16 MHz
Program Memory Size:	256 kB
Data RAM Size:	8 kB
Brand:	Atmel
ADC Resolution:	10 bit

CHAPITRE I CARTE ARDUINO MIGA 2560

6

Operating Supply Voltage:	4.5 V to 5.5 V
Maximum Operating Temperature:	+ 85 C
Mounting Style:	SMD/SMT
Package / Case:	TQFP-100
Data RAM Type:	SRAM
Data ROM Size:	4 kB
Data ROM Type:	EEPROM
Interface Type:	2-Wire, SPI, USART
Minimum Operating Température:	- 40 C
Number of ADC Channels:	16
Number of I/Os:	86 I/O
Processor Series:	megaAVR
Product:	MCU
Program Memory Type:	Flash
Series:	ATMEGA 2560
Factory Pack Quantity:	90
Supply Voltage - Max:	5.5 V
Supply Voltage - Min:	4.5 V
Tradename:	ATMEGA

CHAPITRE I CARTE ARDUINO MIGA 2560

Figure 3 : microcontrôleur ATMEL Mega 2560

I.4.STRUCTURE INTERNE DE LA CARTE

Microcontrôleur ATmega2560

Tension de fonctionnement 5V

Tension d'entrée (recommandé) 7-12 V

Tension d'entrée (limites) 6-20V

Digital I / O Pins 54 (dont 15 fournissent sortie PWM)

Broches d'entrée analogiques 16

DC Courant par I O Pin / 40 mA

Courant DC pour 3,3 Pin 50 mA

Mémoire Flash 256 KB dont 8 Ko utilisé par bootloader

SRAM 8 KB

EEPROM 4 KB

Vitesse d'horloge 16 MHz

7

CHAPITRE I CARTE ARDUINO MIGA 2560

8

I.5. Le langage de programmation

Un langage de programmation est un langage permettant à un être humain d'écrire un ensemble d'instructions (code source) qui seront directement converties en langage machine grâce à un compilateur (c'est la compilation). L'exécution d'un programme Arduino s'effectue de manière séquentielle, c'est-à-dire que les instructions sont exécutées les unes à la suite des autres. Voyons plus en détail la structure d'un programme écrit en Arduino.

I.6. La structure d'un programme :

Un programme Arduino comporte trois parties :

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 ()

CHAPITRE I CARTE ARDUINO MIGA 2560

9

Dans chaque partie d'un programme sont utilisées différentes instructions issues de la syntaxe du langage Arduino.

Les variables

Une variable est un espace réservé dans la mémoire de l'ordinateur. C'est comme un compartiment dont la taille n'est adéquate que pour un seul type d'information. Elle est caractérisée par un nom qui permet d'y accéder facilement.

Il existe différents types de variables identifiés par un mot-clé dont les principaux sont :

· nombres entiers (int)

· nombres à virgule flottante (float)

· texte (String)

· valeurs vrai/faux (boolean).

Un nombre à décimales, par exemple 3.14159, peut se stocker dans une variable de type float. Notez que l'on utilise un point et non une virgule pour les nombres à décimales. Dans Arduino, il est nécessaire de déclarer les variables pour leurs réserver un espace mémoire adéquat. On déclare une variable en spécifiant son type, son nom puis en lui assignant une valeur initiale (optionnel). Exemple :

int ma_variable = 45;

// int est le type, ma_variable le nom et = 45 assigne une valeur. Les fonctions

Une fonction (également désignée sous le nom de procédure ou de sous-routine) est un bloc d'instructions que l'on peut appeler à tout endroit du programme.

Le langage Arduino est constitué d'un certain nombre de fonctions, par exemple analogRead(), digitalWrite() ou delay().

Il est possible de déclarer ses propres fonctions par exemple :

void clignote(){

digitalWrite (brocheLED, HIGH) ; delay (1000) ; digitalWrite (brocheLED, LOW) ; delay (1000) ;

}

Pour exécuter cette fonction, il suffit de taper la commande : clignote();

CHAPITRE I CARTE ARDUINO MIGA 2560

10

On peut faire intervenir un ou des paramètres dans une fonction :

void clignote(int broche,int vitesse){ digitalWrite (broche, HIGH) ; delay (1000/vitesse) ;

digitalWrite (broche, LOW) ; delay (1000/vitesse) ;

}

Dans ce cas, l'on peut moduler leurs valeurs depuis la commande qui l'appelle :

clignote(5,1000); //la sortie 5 clignotera vite

clignote(3,250); //la sortie 3 clignotera lentement

Les structures de contrôle

Les structures de contrôle sont des blocs d'instructions qui s'exécutent en fonction du respect d'un certain nombre de conditions.

Il existe quatre types de structure :

if...else : exécute un code si certaines conditions sont remplies et éventuellement exécutera un autre code avec sinon.

exemple :

//si la valeur du capteur depasse le seuil

if(valeurCapteur>seuil){

//appel de la fonction clignote

clignote();

}

while : exécute un code tant que certaines conditions sont remplies.

exemple :

//tant que la valeur du capteur est supérieure à 250

while(valeurCapteur>250){

//allume la sortie 5

digitalWrite(5,HIGH);

//envoi le message "0" au port serie

Serial.println(1);

//en boucle tant que valeurCapteur est supérieue à 250

}

Serial.println(0);

digitalWrite(5,LOW);

for : exécute un code pour un certain nombre de fois. exemple :

//pour i de 0 à 255, par pas de 1 for (int i=0; i <= 255; i++){

analogWrite(PWMpin, i);

delay(10);

CHAPITRE I CARTE ARDUINO MIGA 2560

11

}

Switch/case : fait un choix entre plusieurs codes parmi une liste de possibilités

I.7.Conclusion

Quand il était conception Arduino et l'un des principaux objectifs de conception est d'être facile d'utilisation pour toutes les catégories de personnes , ce qui rend tout le monde en mesure de faire beaucoup de tâches du projet sans avoir à connaître une grande technique , qu'il était ici de la conception et de la fabrication couvre Arduino ou ce qui est connu comme boucliers (Shields Arduino).

CHAPITRE II

INTERFACE

GRAPHIQUE SOUS

MATLAB

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

13

II. Interface graphique sous MATLAB

II.1.Introduction

MATLAB (« matrix laboratory ») est un langage de programmation de quatrième génération é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 oeuvre des algorithmes, de créer des interfaces utilisateurs, et peut s'interfacer avec d'autres langages comme le C, C++, Java, et Fortran. Les utilisateurs de MATLAB (environ un million en 2004) sont de milieux très différents comme l'ingénierie, les sciences et l'économie dans un contexte aussi bien industriel que pour la recherche. Matlab peut s'utiliser seul ou bien avec des toolbox (« boîte à outils »).

Les interfaces graphiques (ou interfaces homme-machine) sont appelées GUI (pour Graphical User Interface) sous MATLAB. Elles permettent à l'utilisateur d'interagir avec un programme informatique, grâce à différents objets graphiques (boutons, menus, cases à cocher...). Ces objets sont généralement actionnés à l'aide de la souris ou du clavier.

Malgré le fait que les interfaces graphiques semblent secondaires par rapport au développement du coeur d'une application, elles doivent néanmoins être conçues et développées avec soin et rigueur.

Leur efficacité et leur ergonomie sont essentielles dans l'acceptation et l'utilisation de ces outils par les utilisateurs finaux.

Une bonne conception et un développement maitrisé permettent également d'en assurer une meilleure maintenabilité.

MATLAB possède un outil dédié à la création des interfaces graphiques appelé GUIDE (pour Graphical User Interface Development Environment).

Le GUIDE est un constructeur d'interface graphique qui regroupe tous les outils dont le programmeur à besoin pour créer une interface graphique de façon intuitive. Il s'ouvre, soit en

cliquant sur l'icône , soit en tapant guide dans le Command Window de MATLAB.

Le placement des objets est réalisé par sélection dans une boite à outils. Leur mise en place et leur dimensionnement se font à l'aide de la souris

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

14

Figure 4 : Fenêtre principale du GUIDE

Un double-clique sur un objet permet de faire apparaître le Property Inspector où les propriétés des objets sont facilement éditables. Leurs modifications et la visualisation de ces modifications sont immédiates.

Figure 5 : Property Inspector

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

15

Le GUIDE possède également des outils pour gérer l'alignement des objets et pour créer des barres d'outils ou des menus.

Une fois l'interface graphique terminée, son enregistrement donne deux fichiers portant le même nom mais dont les deux extensions sont .fig et .m.

Le fichier .fig contient la définition des objets graphiques (positions et propriétés). Ce fichier peut être ouvert ultérieurement avec le GUIDE pour modifier les objets graphiques.

Le fichier .m contient les lignes de code qui assurent le fonctionnement de l'interface graphique (actions des objets). Ce fichier peut être édité dans le MATLAB Editor pour y ajouter des actions à la main. C'est ce fichier qui doit être lancé pour utiliser l'interface graphique.

II.2.Exemple :

le GUIDE génère deux fichiers :

· un fichier .fig (non éditable) contenant les objets graphiques Figure, Axes et Pushbutton ;

· un fichier .m contenant le code du fonctionnement de l'interface graphique.

Il reste ensuite à ajouter au fichier .m, le code correspondant à l'action à effectuer lors du clique sur le bouton, à savoir le changement de couleur de l'objet Axes.

Dans notre cas, il faut ajouter la ligne suivante :

set(handles.axes1, 'color', rand(1,3))

Elle se place à la fin du code dans la fonction pushbutton1_Callback

Le contenu du fichier .m créé par le GUIDE devient donc :

function varargout = exemple_guide(varargin)

% EXEMPLE_GUIDE MATLAB code for exemple_guide.fig

% EXEMPLE_GUIDE, by itself, creates a new EXEMPLE_GUIDE or raises the existing % singleton*.

%

% H = EXEMPLE_GUIDE returns the handle to a new EXEMPLE_GUIDE or the handle

to

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

16

% the existing singleton*.

%

% EXEMPLE_GUIDE('CALLBACK',hObject,eventData,handles,...) calls the local

% function named CALLBACK in EXEMPLE_GUIDE.M with the given input

arguments.

%

% EXEMPLE_GUIDE('Property','Value',...) creates a new EXEMPLE_GUIDE or raises

the

% existing singleton*. Starting from the left, property value pairs are

% applied to the GUI before exemple_guide_OpeningFcn gets called. An

% unrecognized property name or invalid value makes property application

% stop. All inputs are passed to exemple_guide_OpeningFcn via varargin.

%

% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one

% instance to run (singleton)".

%

% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help exemple_guide

% Last Modified by GUIDE v2.5 16-Nov-2012 21:56:29

% Begin initialization code - DO NOT EDIT gui_Singleton = 1;

gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

17

'gui_OpeningFcn', @exemple_guide_OpeningFcn, ...

'gui_OutputFcn', @exemple_guide_OutputFcn, ...

'gui_LayoutFcn', [] , ...

'gui_Callback', []);

if nargin && ischar(varargin{1})

gui_State.gui_Callback = str2func(varargin{1});

end

if nargout

[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});

else

gui_mainfcn(gui_State, varargin{:});

end

% End initialization code - DO NOT EDIT

% --- Executes just before exemple_guide is made visible.

function exemple_guide_OpeningFcn(hObject, eventdata, handles, varargin)

% This function has no output args, see OutputFcn.

% hObject handle to figure

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% varargin command line arguments to exemple_guide (see VARARGIN)

% Choose default command line output for exemple_guide handles.output = hObject;

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

18

% Update handles structure guidata(hObject, handles);

% UIWAIT makes exemple_guide wait for user response (see UIRESUME) % uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line.

function varargout = exemple_guide_OutputFcn(hObject, eventdata, handles)

% varargout cell array for returning output args (see VARARGOUT);

% hObject handle to figure

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure varargout{1} = handles.output;

% --- Executes on button press in pushbutton1.

function pushbutton1_Callback(hObject, eventdata, handles)

% hObject handle to pushbutton1 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA) set(handles.axes1, 'color', rand(1,3));

CHAPITRE II INTERFACE GRAPHIQUE SOUS MATLAB

19

II.3.Conclusion :

Les interfaces graphiques sous MATLAB sont constituées d'objets graphiques répartis selon une hiérarchie parent-enfant. Chacun de ces objets possède de nombreuses propriétés que le programmeur doit apprendre à maîtriser.

De part son utilisation visuelle et intuitive, le GUIDE est un bon outil pour débuter la programmation des interfaces graphiques sous MATLAB.

Le contenu des fichiers générés automatiquement est assez déroutant au début (certaines actions sont cachées). La génération automatique du code permet certes d'éviter les erreurs de syntaxe (généralement périlleuses à corriger pour le débutant), mais elle masque une grande partie du code. La compréhension du fonctionnement interne de l'interface demande donc au final une lecture attentive de la documentation MATLAB.

On peut aussi noter, même si c'est plus anecdotique, que la compatibilité des fichiers .fig (qui sont en fait des fichiers .mat) n'est pas assurée entre les différentes versions de MATLAB.

La programmation des interfaces graphiques à la main est moins intuitive et demande plus d'efforts qu'en utilisant le GUIDE. En contre partie, le programmeur a le contrôle total sur le code. Il n'est pas limité par les automatismes du GUIDE.

CHAPITRE III

REALISATION

D'UNE

INTERFACE

GRAPHIQUE

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

21

III. Réalisation d'une interface graphique sous la boite à outil GUI de MATLAB pour la supervision

III.1. Introduction

Contrôlez la température, la pression et le niveau de liquides dépendent des systèmes de contrôle complexes qui permettent l'accès aux véritables valeurs des éléments précédents afin de rester contacter avec les systèmes de production. A partir de cette idée que nous avons dans ce travail de concevoir un système simplifié et électroniquement programmée pour visualiser les valeurs de température, de pression et de niveau de liquide pour tout système qui contient les éléments précédents. Le travail que nous avons effectué se repartie en deux parties principales : l'interfaçage graphique et la réalisation de la carte de supervision a base d'Arduino Mega 2560 ;

III.2. Présentation de l'application

L'interface graphique que nous avons réalisés permet à l'utilisateur de saisir le numéro de port COM et qu'il voudrait communiquer entre Arduino et PC et aussi de choisir le temps final de visualisation des courbes. Cette interface se présente donc comme suit :

Figure 6 : la fenêtre graphique de MATLAB

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

Figure 7 : la réalisation pratique

Figure 8 : le schéma capelage de la carte Arduino

22

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

23

L'utilisateur se servira donc de cette interface de la façon suivante :

- Saisie le numéro de port COM ;

- cliquer sur le bouton Connect afin de faire la connexion entre le PC et la carte Arduino; - choisir le temps final de visualisation.

- Lancement et visualisation des courbes des trois capteurs par un clique sur Lire

Nous avons développé une interface graphique sous MATLAB, qui rassemble la puissance de calcul et la simplicité de la programmation dite graphique, elle représente pour les utilisateurs un moyen puissant pour la supervision.

Dans ce qui suit, nous allons décrire en détails le fonctionnement de l'application.

La figure ci-dessous représente le Arduino et le programme interne de

bouton Connect pour la communication entre la carte

Figure 9 : le commun et le bouton d'exécution La figure ci-dessous représente le bouton et le temps de visualisation final

Figure 10 : le temps d'exécution

Trois graphes qui affichent en temps réel les valeurs instantanées des grandeurs électriques mesurées (Température, pression et le niveau).

III.3.supervision de température, pression et niveau III.3.1.définition de capteur : Un capteur est un dispositif transformant l'état d'une grandeur	physique observée en une
grandeur utilisable, telle qu'une tension électrique, une hauteur de mercure, une		intensité ou la

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

déviation d'une aiguille. On fait souvent (à tort) la confusion entre capteur et transducteur : le capteur est au minimum constitué d'un transducteur.

Le capteur se distingue de l'instrument de mesure par le fait qu'il ne s'agit que d'une simple interface entre un processus physique et une information manipulable. Par opposition, l'instrument de mesure est un appareil autonome se suffisant à lui-même, disposant d'un affichage ou d'un système de stockage des données. Le capteur, lui, en est dépourvu.

Les capteurs sont les éléments de base des systèmes d'acquisition de données. Leur mise en oeuvre est du domaine de l'instrumentation.

III.3.2.capteur de température :

Les sondes de température (ou capteurs de température) sont des dispositifs permettant de transformer l'effet du réchauffement ou du refroidissement sur leurs composants en signal électrique.

Jusqu'à l'invention du thermoscope de Galilée, les hommes étaient incapables de mesurer la température. Les thermomètres virent bientôt le jour, et avec eux les unités comme le degré Celsius et le kelvin. Par la suite, les techniques automatisées voyant le jour, il fallut trouver le moyen de traduire les températures en signaux analogiques compréhensibles par des machines.

1 : alimentation du capteur (+5 V) 2 : tension de sortie Us (fiche verte) 3 : masse (fiche noire)

24

Figure 11 : Caractéristiques du capteur de température LM 35

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

Caractéristiques principales :
Plage de la tension d'alimentation		0,2 Volt à 35 Volts
Sensibilité		10 mV / °C
Précision		+/- 0,5°C (à 25°C)
Type de boîtier		TO 92

	Brochage du capteur :
Broc hes		Désignation
	1	Alimentation du capteur
	2	Sortie du potentiel proportionnel à la température
	3	Masse du capteur

25

Figure 12 : présentation de capteur de température

III.3.4.capteur de pression :

Une sonde de pression (ou capteur de pression) est un dispositif destiné à convertir les variations de pression en variations de tension électrique.

Lorsque la sonde est reliée à un système numérique, les variations analogiques sont d'abord converties en signaux numériques binaires par un convertisseur analogique-numérique avant d'être transmises à l'ordinateur de contrôle et de gestion.

L'unité de pression fournie par la sonde peut être exprimée en différentes unités, telle que bar, pascal.

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

26

Figure 13 : capteur de pression

III.3.5.capteur de niveau :

Le mot "niveau" a de nombreux sens dans la langue française. En physique, le niveau correspond à la distance entre la surface d'un liquide et le fond du réservoir le contenant.

Le contrôle de niveau est utilisé dans de nombreux et divers domaines, afin de connaître l'état de remplissage de récipients, c'est-à-dire le niveau qu'y atteint le produit présent.

Figure 14 : capteur de niveau résistif III.3.6 Notre programme de l'interface graphique

Comme il est indiqué précédemment, l'ajout d'un élément sur l'interface graphique génère automatiquement le code associé à ce dernier. Nous avons donc pour notre interface :

function varargout = exampl1(varargin) % EXAMPL1 MATLAB code for exampl1.fig

% EXAMPL1, by itself, creates a new EXAMPL1 or raises the existing

% singleton*.

%

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

27

% H = EXAMPL1 returns the handle to a new EXAMPL1 or the handle to

% the existing singleton*.

%

% EXAMPL1('CALLBACK',hObject,eventData,handles,...) calls the local

% function named CALLBACK in EXAMPL1.M with the given input arguments.

%

% EXAMPL1('Property','Value',...) creates a new EXAMPL1 or raises the

% existing singleton*. Starting from the left, property value pairs are

% applied to the GUI before exampl1_OpeningFcn gets called. An

% unrecognized property name or invalid value makes property application

% stop. All inputs are passed to exampl1_OpeningFcn via varargin.

%

% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one

% instance to run (singleton)".

%

% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help exampl1 % Last Modified by GUIDE v2.5 01-Apr-2015 22:20:15

% Begin initialization code - DO NOT EDIT gui_Singleton = 1;

gui_State = struct('gui_Name', mfilename, ...

'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @exampl1_OpeningFcn, ... 'gui_OutputFcn', @exampl1_OutputFcn, ... 'gui_LayoutFcn', [] , ...

'gui_Callback', []);

if nargin && ischar(varargin{1})

gui_State.gui_Callback = str2func(varargin{1});

end

if nargout

[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});

else

gui_mainfcn(gui_State, varargin{:});

end

% End initialization code - DO NOT EDIT

% --- Executes just before exampl1 is made visible.

function exampl1_OpeningFcn(hObject, eventdata, handles, varargin)

% This function has no output args, see OutputFcn.

% hObject handle to figure

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to exampl1 (see VARARGIN)

% Choose default command line output for exampl1 handles.output = hObject;

% Update handles structure guidata(hObject, handles);

% UIWAIT makes exampl1 wait for user response (see UIRESUME) % uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line.

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

28

function varargout = exampl1_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT);

% hObject handle to figure

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure varargout{1} = handles.output;

axes(handles.axes7);x=imread('logo.jpg');imshow(x); axes(handles.axes8);y=imread('logo.jpg');imshow(y);

% --- Executes on button press in read_button.

function read_button_Callback(hObject, eventdata, handles)

% hObject handle to read_button (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

global a k;

x1=0;

x2=0;

x3=0;

for k=1:1:handles.xSamples

b=a.analogRead(0);

c=a.analogRead(1);

d=a.analogRead(2);

b=b*150/1024;

c=c*5/1024;

d=d*10/1024;

set(handles.edit2_recive,'String',b);

set(handles.edit3,'String',c);

set(handles.edit4,'String',d);

x1=[x1,b];

x2=[x2,c];

x3=[x3,d];

axes(handles.axes1);plot(x1,'LineWidth',2);grid on; axis([0 handles.xSamples

0 150]);

axes(handles.axes2);plot(x2,'LineWidth',2);grid on; axis([0 handles.xSamples

0 5]);

axes(handles.axes3);plot(x3,'LineWidth',2);grid on; axis([0 handles.xSamples

0 10]);

pause(0.01);

end

function edit_text_samples_Callback(hObject, eventdata, handles)

% hObject handle to edit_text_samples (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit_text_samples as text

% str2double(get(hObject,'String')) returns contents of edit_text_samples
as a double

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

29

handles.data1=get(hObject,'String');

handles.xSamples=str2double(handles.data1); guidata(hObject,handles);

% --- Executes during object creation, after setting all properties. function edit_text_samples_CreateFcn(hObject, eventdata, handles)

% hObject handle to edit_text_samples (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function edit2_recive_Callback(hObject, eventdata, handles)

% hObject handle to edit2_recive (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit2_recive as text

% str2double(get(hObject,'String')) returns contents of edit2_recive as a
double

% --- Executes during object creation, after setting all properties. function edit2_recive_CreateFcn(hObject, eventdata, handles)

% hObject handle to edit2_recive (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function edit3_Callback(hObject, eventdata, handles)

% hObject handle to edit3 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit3 as text

% str2double(get(hObject,'String')) returns contents of edit3 as a double

% --- Executes during object creation, after setting all properties. function edit3_CreateFcn(hObject, eventdata, handles)

% hObject handle to edit3 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles empty - handles not created until after all CreateFcns called

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

30

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function edit4_Callback(hObject, eventdata, handles)

% hObject handle to edit4 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit4 as text

% str2double(get(hObject,'String')) returns contents of edit4 as a double

% --- Executes during object creation, after setting all properties. function edit4_CreateFcn(hObject, eventdata, handles)

% hObject handle to edit4 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

function edit5_Callback(hObject, eventdata, handles)

% hObject handle to edit5 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit5 as text

% str2double(get(hObject,'String')) returns contents of edit5 as a double

% --- Executes during object creation, after setting all properties. function edit5_CreateFcn(hObject, eventdata, handles)

% hObject handle to edit5 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');

end

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

31

% --- Executes on button press in pushbutton4.

function pushbutton4_Callback(hObject, eventdata, handles)

% hObject handle to pushbutton4 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)
% delete(instrfind({'Port'},{'COM13'}))

global a;

comport=num2str(get(handles.edit5,'String'));

a=arduino(comport);

guidata(hObject, handles);

1- Bouton Connect :

% --- Executes on button press in pushbutton4.

function pushbutton4_Callback(hObject, eventdata, handles)

% hObject handle to pushbutton4 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)
% delete(instrfind({'Port'},{'COM13'}))

global a;

comport=num2str(get(handles.edit5,'String'));

a=arduino(comport);

guidata(hObject, handles);

2- Bouton Lire

% --- Executes on button press in read_button.

function read_button_Callback(hObject, eventdata, handles)

% hObject handle to read_button (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB

% handles structure with handles and user data (see GUIDATA)

global a k;

x1=0;

x2=0;

x3=0;

for k=1:1:handles.xSamples

b=a.analogRead(0);

c=a.analogRead(1);

d=a.analogRead(2);

b=b*150/1024;

c=c*5/1024;

d=d*10/1024;

set(handles.edit2_recive,'String',b);

set(handles.edit3,'String',c);

set(handles.edit4,'String',d);

x1=[x1,b];

x2=[x2,c];

x3=[x3,d];

axes(handles.axes1);plot(x1,'LineWidth',2);grid on;

axis([0handles.xSamples 0 150]);

axes(handles.axes2);plot(x2,'LineWidth',2);grid on; axis([0

handles.xSamples 0 5]);

axes(handles.axes3);plot(x3,'LineWidth',2);grid on; axis([0

handles.xSamples 0 10]);

pause(0.01);

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

III.4.Résultat pratique :

III.4.1. Température

Figure 15 : température

La figure1 représente l'évolution de la température et sa valeur en temps réel pendant le temps final choisi, d'après cette courbe on constante que la visualisation est bien faite en temps réel.

III.4.2. Pression

Figure 16 : Pression en Bar

32

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

33

La figure2 représente l'évolution de la pression et sa valeur en temps réel captée p

ar un

capteur de pression comme le capteur résistif, on constate d'après cette figure que la pression capté et visualisé est égale presque 3.32031 Bar.

III.4.3. Niveau

Figure 17 : Niveau de liquide en mètre

La figure 3 présente la courbe de niveau de liquide visualisé par l'interfaçage graphique sous MATLAB,

III.5.Conclusion

Ce chapitre est consacré à la conception et la supervision en temps réel des signaux sous MATLAB. Cette supervision permet la mesure, ainsi que l'acquisition de la température, de pression et de niveau de liquide . Il est constitué de trois parties: un étage de mesure et d'une carte Arduino Mega 2560 utilisée comme interface d'acquisition entre le bloc de mesure et un PC. Les résultats pratique valident le bon fonctionnement du banc de mesure..

CHAPITRE III REALISATION D'UNE INTERFACE GRAFIQUE

34

34

Conclusion Générale

Le travail présenté dans ce rapport de projet de fin d'études porte sur la conception et la réalisation d'une interface graphique assurant la visualisation en temps réel de la température, de pression et de niveau de liquide.

Dans un premier temps, nous avons donné un aperçu général sur la carte d'acquisition à base d'Arduino Mega 2560. Puis nous avons présenté une description sur l'utilisation de l'outil d'interfaçage graphique sous MATLAB.

Nous avons généré, dans un deuxième temps, la visualisation avec une interface graphique pour la supervision réalisée avec MATLAB GUIDE via la communication série UART.

Comme perspectives, nous envisageons:

- Introduire dans le système une régulation des trois phénomènes, la température, la pression et le niveau de liquide par des boucles de régulation PID.

- Réaliser une communication entre applications distantes.