Chapitre3

Chapitre3. Modélisation et simulation
Chapitre3. Modélisation et Simulation
3.1 Introduction :
La modélisation est la conception et l'utilisation d'un modèle. Selon son objectif
(représentation simplifiée, compréhension, prédiction) et les moyens utilisés, la
modélisation
est
dite
mathématique,
géométrique,
3D,
empirique,
mécaniste
(ex. : modélisation de réseau trophique dans un écosystème), cinématique... Elle nécessite
généralement d'être calée par des observations ou mesures faites in situ, lesquelles servent
aussi à paramétrer, calibrer ou ajuster le modèle, par exemple en intégrant des facteurs
d'influences qui s'avèreraient nécessaires.
La simulation de phénomènes est un outil utilisé dans le domaine de la recherche et
du développement. Elle permet d'étudier les réactions d'un système à différentes
contraintes pour en déduire les résultats recherchés en se passant d'expérimentation.
Pour ce chapitre on va voir la simulation et modélisation d’un système de consommation
de l’energie éléctrique sur Isis.
3.2 Modélisation et Simulation :
3.2.1 problématique :
On veut faire un mesure d’énergie à l’aide d’une Arduino et découvrire le compteur
d'énergie AC utilisant Arduino,comment mesurer l'énergie AC avec Arduino,comment
mesurer la tension alternative avec Arduino,comment mesurer le courant alternatif avec
Arduino,mesurez l'énergie AC avec Arduino - compteur d'énergie AC, et comment on peut
mesurer l’énergie AC avec mon Arduino ?
3.2.2 Solution :
On va faire une simulation sur Isis pour mesurer l’énergie à l’aide de :

Compteur de puissance Arduino 220V AC.

Compteur d'énergie AC simple avec Arduino.

Compteur d'énergie électrique utilisant Arduino.

Créez un simple compteur d'énergie Arduino.

Créez un wattmètre AC à l'aide d'Arduino UNO.

Compteur d’énergie domestique Arduino simple.
1|Page
Chapitre3. Modélisation et simulation

Compteur d’énergie électrique AC.

Compteur d'énergie Arduino.
3.2.2.1 Schéma sur Isis :
Figure3.1 : Schéma de compteur d'énergie AC utilisant Arduino.
Pour le mesure on a utilisé un capteur ACS712 , ce capteur se branche en série avec la
charge sur un circuit alternatif (AC) ou continu (DC) et permet de mesurer le courant qui
traverse le capteur. Il utilise le champ magnétique généré par le courant (et donc l'effet hall)
pour mesurer le courant qui le traverse. Le module propose en sortie une tension continue
proportionnelle au courant à raison de 0.066V/A (66mV par ampère). Vous pouvez donc lire
cette tension sur une entrée analogique de votre Arduino et obtenir une valeur de courant
voir une valeur de puissance (W, en multipliant le courant mesuré par la tension du circuit)
Ce capteur, fonctionnant par effet Hall, est donc sensible au champ magnétique qui pourrait
fausser vos mesures. Le simple fait d'approcher un aimant de l'ACS712 modifie la tension de
sortie du capteur.
Il est également important de faire une lecture a vide (sans courant) pour obtenir la valeur
de calibration Vref du module (qui devrait être Vcc/2 soit 2.5V). Enfin, si vous câblez
2|Page
Chapitre3. Modélisation et simulation
correctement la charge vous lirez une augmentation de la tension en sortie mais si vous
inversez le câblage vous lirez une diminution de la tension de sortie.
Figure3.2 : capteur ACS 712
Pour afficher les résultats on a utilisé une LCD LM044L , cette LCD transmet les informations
utiles d'un système à un utilisateur. Il affichera donc des données susceptibles d'être
exploiter par l'utilisateur d'un système, comme affichage de tension , de courant,etc…
Figure3.3 : LCD LM044L
Un transformateur pour modifier la tension efficace délivrée par une source d'énergie
électrique alternative, une transformation qu'il effectue avec un excellent rendement.
3|Page
Chapitre3. Modélisation et simulation
Figure3.4 : TRAN-2P2S
Un Arduin UNO qui permet de raccorder des capteurs (entrées) et des actionneurs (sorties).
Elle est constituée de plusieurs composants électroniques dont le principal est un
microcontrôleur permettant de stocker et d'exécuter notre programme informatique.
Dans l’entrée on a le capteur ACS712 et sortie on a LCD LM044L.
Figure3.5 :Arduino UNO
4|Page
Chapitre3. Modélisation et simulation
Des résistances pour faire la mesure de l'opposition appliquée au courant dans un circuit
électrique.
Figure3.6 :résistances
Un condensateur électronique pour stocker de l'énergie (une charge d'électrons), et la
rendre, si besoin. Par cela, il tend à stabiliser l'alimentation électrique en lissant les
variations qui peuvent survenir au sein de celle-ci.
Figure3.7 : Condensateur électronique
Des alternateurs pour fournir l'énergie électrique dans notre schéma.
Figure3.8 :Alternateur
5|Page
Chapitre3. Modélisation et simulation
3.2.2.2 Code Arduino :
#include <LiquidCrystal.h>
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);
#include "EmonLib.h"
EnergyMonitor emon1;
const int Sensor_Pin = A1;
int sensitivity = 185;
int offsetvoltage = 2542;
void setup()
{
emon1.voltage(A0,187, 1.7);
lcd.begin(20, 4);
lcd.setCursor(0,0);
lcd.print(" THE BRIGHT LIGHT ");
lcd.setCursor(0,1);
lcd.print(" AC ENERGY METER
");
}
void loop()
{
emon1.calcVI(20,2000);
int Voltage = emon1.Vrms;
lcd.setCursor(0,2);
lcd.print("V = ");
lcd.print(Voltage);
lcd.print("V ");
6|Page
Chapitre3. Modélisation et simulation
unsigned int temp=0;
float maxpoint = 0;
for(int i=0;i<500;i++)
{
if(temp = analogRead(Sensor_Pin), temp>maxpoint)
{
maxpoint = temp;
}
}
float ADCvalue = maxpoint;
double eVoltage = (ADCvalue / 1024.0) * 5000;
double Current = ((eVoltage - offsetvoltage) / sensitivity);
double AC_Current = ( Current ) / ( sqrt(2) );
lcd.print("I = ");
lcd.print(AC_Current,2);
lcd.print("A
");
int Power = (Voltage * AC_Current);
lcd.setCursor(0,3);
lcd.print("P = ");
lcd.print(Power);
lcd.print("W ");
long milisec = millis();
long time=milisec/1000;
float Energy = (Power*time)/3600;
lcd.print("E = ");
7|Page
Chapitre3. Modélisation et simulation
lcd.print(Energy,1);
lcd.print("Wh ");
delay(200);
}
3.2.2.3 Explication de code :
// include the library code:
#include <LiquidCrystal.h> //library for LCD
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

Premièrement inclure le code de la bibliothèque et initialiser la bibliothèque avec les
numéros des broches de l'interface.
// Measuring Voltage
#include "EmonLib.h"
EnergyMonitor emon1;

// Include Emon Library
// Create an instance
Mesure de voltage : inclure la bibliothèque Emon et créer une intance.
// Measuring Current Using ACS712
const int Sensor_Pin = A1; //Connect current sensor with A1 of Arduino
int sensitivity = 185; // use 100 for 20A Module and 66 for 30A Module
int offsetvoltage = 2542;

Mesure du courant à l'aide de l'ACS712 : Connectez le capteur de courant à l'A1
d'Arduino.

const int Sensor_Pin = A1 : Connectez le capteur de courant à l'A1 d'Arduino.

int sensitivity = 185 : utilisez 100 pour le module 20A et 66 pour le module 30A.

int offsetvoltage = 2542 : tension de décalage = 2542 ;
void setup()
{
emon1.voltage(A0,187, 1.7); // Voltage: input pin, calibration, phase_shift
lcd.begin(20, 4); // set up the LCD's number of columns and rows:
lcd.setCursor(0,0);
lcd.print(" THE BRIGHT LIGHT
");
lcd.setCursor(0,1);
lcd.print(" AC ENERGY METER
");
}
void loop()
{
8|Page
Chapitre3. Modélisation et simulation

Configurer les entrées de Lcd pour l’afficher.
//************************* Measure Voltage
******************************************
emon1.calcVI(20,2000); // Calculate all. No.of half wavelengths (crossings),
time-out
int Voltage
= emon1.Vrms; //extract Vrms into Variable
lcd.setCursor(0,2);
lcd.print("V = ");
lcd.print(Voltage);
lcd.print("V ");

Faire le mesure de voltage

extraire Vrms dans une variable.
//************************* Measure Current
******************************************
unsigned int temp=0;
float maxpoint = 0;
for(int i=0;i<500;i++)
{
if(temp = analogRead(Sensor_Pin), temp>maxpoint)
{
maxpoint = temp;
}
}
float ADCvalue = maxpoint;
double eVoltage = (ADCvalue / 1024.0) * 5000; // Gets you mV
double Current = ((eVoltage - offsetvoltage) / sensitivity);
double AC_Current = ( Current ) / ( sqrt(2) );
lcd.print("I = ");
lcd.print(AC_Current,2);
lcd.print("A
"); //unit for the current to be measured

faire le mesure de courant

Afficher la valeur de courant dans LCD
//************************* Measure Power
******************************************
int Power = (Voltage * AC_Current);
lcd.setCursor(0,3);
lcd.print("P = ");
lcd.print(Power);
lcd.print("W "); //unit for the current to be measured
9|Page
Chapitre3. Modélisation et simulation

Faire mesurer la puissance

Afficher la valeur de puissance dans LCD
//************************* Measure Energy
******************************************
long milisec = millis(); // calculate time in milliseconds
long time=milisec/1000; // convert milliseconds to seconds
float Energy = (Power*time)/3600; //Watt-sec is again convert to Watt-Hr
by dividing 1hr(3600sec)
lcd.print("E = ");
lcd.print(Energy,1);
lcd.print("Wh
"); //unit for the current to be measured
delay(200);
}

long milisec = millis() : calculer le temp en millisecond

long time=milisec/1000 : changer le millisecond en second

float Energy = (Power*time)/3600 : Watt-sec est à nouveau converti en
Watt-Heure en divisant 1 heure (3600 sec)

lcd.print("E = ");

lcd.print(Energy,1);

lcd.print("Wh ") ;

delay(200); : retard de 200 ms
Afficher la valeur d’énergie dans LCd
3.3 Conclusion :
Dans ce chapitre , on a vue comment on peut faire la modélisation et le simulation d’un
système de monitoring de la consommation d’énergie électrique à l’aide d’un Arduino UNO ,
Qui nous permet de meurer le courant , la tension, la puissance et l’énergie de notre système.
10 | P a g e
Chapitre3. Modélisation et simulation
11 | P a g e