Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

FOUR ÉLECTRIQUE TRIPHASÉ D'ÉTUVAGE

DE MOTEURS ASYNCHRONES
Avec Régulation PID — Simulation Proteus ISIS

Programme Arduino — Code Source Complet & Documenté

Conception et simulation d'un four électrique triphasé

Thème
d'étuvage

Filière DUT Génie Électrique

Microcontrôleur Arduino Uno (ATmega328P)

Logiciel sim. Proteus ISIS / Arduino IDE

Régulateur PID numérique discret (Kp=3.0 / Ki=0.25 / Kd=1.5)

Mémoire de Fin d'Études Page 1 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

1. Déclarations — Broches et Constantes

1.1 Tableau des broches Arduino

Broche Nom Type Rôle

A0 CAPTEUR_PIN Entrée analogique Lecture LM35 (température)

Commande résistances
D12 RELAIS_CHAUFFE Sortie numérique
chauffantes

Commande moteurs
D13 RELAIS_MOTEURS Sortie numérique
asynchrones (convection)

Alarme sonore/visuelle (T >

A1 RELAIS_ALARME Sortie numérique
270°C)

D8 BTN_START Entrée numérique Bouton démarrage cycle

D9 BTN_RESET Entrée numérique Bouton reset alarme

RS=D7, EN=D6, D4=D5,
D2–D7 LCD 16x2 Sorties 4 bits
D5=D4, D6=D3, D7=D2

1.2 Tableau des paramètres PID

Paramètre Valeur Unité Description

Gain proportionnel —
Kp 3.0 sans dimension
réactivité immédiate

Gain intégral — annule

Ki 0.25 sans dimension
l'erreur résiduelle

Gain dérivé — anticipe,

Kd 1.5 sans dimension
amortit les oscillations

Période d'échantillonnage
Te 100 millisecondes
(boucle 100 ms)

T_CONSIGNE 250 °C Consigne d'étuvage

T_PRECHAUFFA Cible de préchauffe avant

120 °C
GE étuvage

Seuil de déclenchement
T_ALARME 270 °C
alarme sécurité

Température de fin de
T_FIN 60 °C
refroidissement

Mémoire de Fin d'Études Page 2 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

2. Code Source Arduino Complet

2.1 En-tête et includes

Arduino Code
// ════════════════════════════════════════════════════════════
// FOUR ÉLECTRIQUE TRIPHASÉ D'ÉTUVAGE DE MOTEURS ASYNCHRONES
// Régulation PID numérique — Machine à 6 états
// Plateforme : Arduino Uno (ATmega328P)
// Simulation : Proteus ISIS
// ════════════════════════════════════════════════════════════

#include <LiquidCrystal.h>

2.2 Définition des broches

Arduino Code
// ─── Broches physiques ───────────────────────────────────────
#define CAPTEUR_PIN A0 // LM35 : sortie analogique
#define RELAIS_CHAUFFE 12 // Résistances chauffantes triphasées
#define RELAIS_MOTEURS 13 // Moteurs asynchrones (convection forcée)
#define RELAIS_ALARME A1 // Alarme sonore / LED rouge
#define BTN_START 8 // Bouton démarrage cycle
#define BTN_RESET 9 // Bouton reset alarme

// ─── LCD 16x2 mode 4 bits (RS, EN, D4, D5, D6, D7) ─────────
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

2.3 Constantes thermiques

Arduino Code
// ─── Seuils de température (°C) ──────────────────────────────
const float T_PRECHAUFFAGE = 120.0;
const float T_CONSIGNE = 250.0;
const float T_ALARME = 270.0;
const float T_FIN = 60.0;

// ─── Durée d'étuvage : 1 heure = 3 600 000 ms ────────────────

const unsigned long DUREE_ETUVAGE = 3600000UL;

2.4 Paramètres PID

Arduino Code
// ─── Gains PID ────────────────────────────────────────────────
const float Kp = 3.0;
const float Ki = 0.25;
const float Kd = 1.5;
const unsigned long Te = 100; // Période d'échantillonnage (ms)

// ─── Variables internes PID ───────────────────────────────────

float erreur = 0.0;
float erreurPrecedente = 0.0;
float sommeErreurs = 0.0; // Terme intégral accumulé
float commande = 0.0; // Sortie PID bornée [0, 255]

Mémoire de Fin d'Études Page 3 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

2.5 Machine à états — Enum et variables globales

Arduino Code
// ─── 6 états du four ──────────────────────────────────────────
enum Etat {
ATTENTE, // Four en veille, prêt au démarrage
PRECHAUFFAGE, // Montée vers 120°C
ETUVAGE, // Maintien à 250°C pendant la durée programmée
REFROIDISSEMENT, // Descente naturelle/forcée jusqu'à 60°C
ALARME, // T >= 270°C — sécurité activée
FIN // Cycle terminé
};

Etat etatActuel = ATTENTE;

// ─── Gestion temporelle ───────────────────────────────────────

unsigned long tPrecedent = 0; // Dernier instant d'échantillonnage
unsigned long chronoEtuvage = 0; // Instant de début d'étuvage
float temperature = 0.0; // Température mesurée courante

Mémoire de Fin d'Études Page 4 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

2.6 Fonction lireTemperature()

Le capteur LM35 délivre 10 mV par degré Celsius. L'ADC 10 bits de l'Arduino mesure une tension
entre 0 et 5 V, soit 1024 niveaux. La conversion est donc :
Arduino Code
float lireTemperature() {
int valADC = analogRead(CAPTEUR_PIN);
// Conversion ADC → tension (0..5V)
float tension = (valADC * 5.0) / 1023.0;
// LM35 : 10 mV/°C → tension * 100 = température en °C
return tension * 100.0;
}

2.7 Fonction reinitialiserPID()

Appelée à chaque transition d'état pour éviter le phénomène de windup intégral. Si cette
réinitialisation est omise, l'intégrale accumulée dans l'état précédent provoque un dépassement
brutal en début du nouvel état.
Arduino Code
void reinitialiserPID() {
erreur = 0.0;
erreurPrecedente = 0.0;
sommeErreurs = 0.0;
commande = 0.0;
}

2.8 Fonction calculerPID()

Implémentation numérique discrète (méthode d'Euler) du correcteur PID :
Arduino Code
float calculerPID(float consigne, float mesure) {

// ── Calcul de l'erreur courante ─────────────────────────

erreur = consigne - mesure;

// ── Terme intégral avec anti-windup ─────────────────────

sommeErreurs += erreur * (Te / 1000.0);
sommeErreurs = constrain(sommeErreurs, -1000.0, 1000.0);

// ── Terme dérivé (vitesse de variation de l'erreur) ─────

float derivee = (erreur - erreurPrecedente) / (Te / 1000.0);
erreurPrecedente = erreur; // Mémorisation pour le prochain cycle

// ── Commande PID totale bornée entre 0 et 255 ───────────

float u = Kp * erreur + Ki * sommeErreurs + Kd * derivee;
return constrain(u, 0.0, 255.0);
}

2.9 Fonction afficherLCD()

Arduino Code
void afficherLCD(const char* etatStr, float temp, float consigne) {
// Ligne 0 : État courant
[Link](0, 0);
[Link](etatStr);
// Complète avec espaces pour effacer les caractères restants
for (int i = strlen(etatStr); i < 16; i++) [Link](" ");

// Ligne 1 : T mesurée et consigne

[Link](0, 1);

Mémoire de Fin d'Études Page 5 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique
[Link]("T=");
[Link](temp, 1);
[Link]((char)223); // Symbole degré °
[Link]("C C=");
[Link](consigne, 0);
[Link]((char)223);
[Link]("C ");
}

Mémoire de Fin d'Études Page 6 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

3. Machine à États Finis — Fonction gererEtat()

La fonction gererEtat() est appelée toutes les 100 ms par la boucle principale. Elle lit la
température, vérifie l'alarme en priorité absolue, puis exécute la logique de l'état courant via un
switch/case.

3.1 Vérification alarme prioritaire + switch principal

Arduino Code
void gererEtat() {

// ── Lecture capteur ──────────────────────────────────────

temperature = lireTemperature();

// ── ALARME : priorité absolue, vérifiée avant tout ───────

if (temperature >= T_ALARME && etatActuel != FIN) {
etatActuel = ALARME;
}

switch (etatActuel) {

3.2 État ATTENTE

Arduino Code
// ════════════════════════════════════════════════════════
case ATTENTE:
digitalWrite(RELAIS_CHAUFFE, LOW);
digitalWrite(RELAIS_MOTEURS, LOW);
digitalWrite(RELAIS_ALARME, LOW);
[Link](0, 0); [Link]("FOUR PRET ");
[Link](0, 1); [Link]("Appuyer START ");
// Transition → PRECHAUFFAGE sur appui bouton
if (digitalRead(BTN_START) == HIGH) {
reinitialiserPID();
etatActuel = PRECHAUFFAGE;
}
break;

3.3 État PRECHAUFFAGE

Arduino Code
// ════════════════════════════════════════════════════════
case PRECHAUFFAGE:
digitalWrite(RELAIS_MOTEURS, HIGH); // Ventilateurs ON
commande = calculerPID(T_PRECHAUFFAGE, temperature);
digitalWrite(RELAIS_CHAUFFE, commande > 10.0 ? HIGH : LOW);
afficherLCD("PRECHAUFFAGE", temperature, T_PRECHAUFFAGE);
// Transition → ETUVAGE quand T atteint 120°C
if (temperature >= T_PRECHAUFFAGE) {
reinitialiserPID();
chronoEtuvage = millis(); // Démarrage chronomètre
etatActuel = ETUVAGE;
}
break;

3.4 État ETUVAGE

Arduino Code

Mémoire de Fin d'Études Page 7 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique
// ════════════════════════════════════════════════════════
case ETUVAGE:
digitalWrite(RELAIS_MOTEURS, HIGH);
commande = calculerPID(T_CONSIGNE, temperature);
digitalWrite(RELAIS_CHAUFFE, commande > 10.0 ? HIGH : LOW);
afficherLCD("ETUVAGE 250C", temperature, T_CONSIGNE);
// Transition → REFROIDISSEMENT après durée programmée
if (millis() - chronoEtuvage >= DUREE_ETUVAGE) {
reinitialiserPID();
etatActuel = REFROIDISSEMENT;
}
break;

3.5 État REFROIDISSEMENT

Arduino Code
// ════════════════════════════════════════════════════════
case REFROIDISSEMENT:
digitalWrite(RELAIS_CHAUFFE, LOW); // Chauffe coupée
digitalWrite(RELAIS_MOTEURS, HIGH); // Ventilation forcée ON
afficherLCD("REFROIDISSEMENT", temperature, 0.0);
// Transition → FIN quand T <= 60°C
if (temperature <= T_FIN) {
etatActuel = FIN;
}
break;

3.6 État ALARME

Arduino Code
// ════════════════════════════════════════════════════════
case ALARME:
digitalWrite(RELAIS_CHAUFFE, LOW);
digitalWrite(RELAIS_MOTEURS, LOW);
digitalWrite(RELAIS_ALARME, HIGH); // Sirène / LED rouge ON
[Link](0, 0); [Link]("!! ALARME !! ");
[Link](0, 1);
[Link]("T="); [Link](temperature, 1);
[Link]((char)223); [Link]("C DANGER!");
// Retour → ATTENTE après reset manuel opérateur
if (digitalRead(BTN_RESET) == HIGH) {
digitalWrite(RELAIS_ALARME, LOW);
reinitialiserPID();
etatActuel = ATTENTE;
}
break;

3.7 État FIN

Arduino Code
// ════════════════════════════════════════════════════════
case FIN:
digitalWrite(RELAIS_CHAUFFE, LOW);
digitalWrite(RELAIS_MOTEURS, LOW);
digitalWrite(RELAIS_ALARME, LOW);
[Link](0, 0); [Link]("CYCLE TERMINE ");
[Link](0, 1); [Link]("Moteur pret :) ");
break;

} // fin switch
} // fin gererEtat()

Mémoire de Fin d'Études Page 8 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

4. Fonctions setup() et loop()

4.1 setup() — Initialisation

Arduino Code
void setup() {
// ── LCD 16x2 ─────────────────────────────────────────────
[Link](16, 2);
[Link]();

// ── Modes des broches ─────────────────────────────────────

pinMode(RELAIS_CHAUFFE, OUTPUT);
pinMode(RELAIS_MOTEURS, OUTPUT);
pinMode(RELAIS_ALARME, OUTPUT);
pinMode(BTN_START, INPUT);
pinMode(BTN_RESET, INPUT);

// ── État initial sûr (tout OFF) ───────────────────────────

digitalWrite(RELAIS_CHAUFFE, LOW);
digitalWrite(RELAIS_MOTEURS, LOW);
digitalWrite(RELAIS_ALARME, LOW);

// ── Message d'accueil ─────────────────────────────────────

[Link](0, 0); [Link]("FOUR ETUVAGE");
[Link](0, 1); [Link]("Initialisation..");
delay(1500);
[Link]();
}

4.2 loop() — Boucle principale non bloquante

Arduino Code
void loop() {
unsigned long tActuel = millis();

// Exécution toutes les 100 ms (Te) — non bloquant

if (tActuel - tPrecedent >= Te) {
tPrecedent = tActuel;
gererEtat(); // Cœur du programme
}
}

Point clé Explication pour la soutenance

millis() est non bloquant : l'Arduino reste réactif entre deux cycles
millis() vs delay()
de 100ms. delay() fige tout le programme.

constrain() empêche la sommeErreurs de dépasser ±1000, évitant

Anti-windup
un dépassement brutal au démarrage d'un nouvel état.

Remet l'intégrale à zéro à chaque transition d'état pour éviter les

reinitialiserPID()
transitoires. C'est une pratique industrielle standard.

Vérifiée AVANT le switch() : garantit que même en plein étuvage,

Alarme prioritaire
une surchauffe déclenche immédiatement la sécurité.

Rend le code lisible et maintenable. Chaque état est un nom

enum Etat
explicite, pas un chiffre arbitraire.

Mémoire de Fin d'Études Page 9 / 10

Four Électrique Triphasé d'Étuvage — Programme Arduino | DUT Génie Électrique

5. Déploiement dans Proteus ISIS

5.1 Étapes de compilation et transfert

Éta
Action Détail
pe

1 Compiler dans Arduino IDE Sketch → Export compiled Binary → génère le fichier .hex

Double-cliquer sur le composant Arduino Uno dans le

2 Ouvrir Proteus ISIS
schéma

3 Charger le fichier .hex Propriétés → Program File → sélectionner le .hex compilé

Remplacer par une source de tension variable (10mV/°C)

4 Configurer le LM35 simulé
sur A0

Bouton Play ► — Observer le LCD et les relais qui

5 Lancer la simulation
commutent

Faire varier la tension source pour simuler

6 Valider les transitions
montée/descente en température

5.2 Composants Proteus requis

Composant Proteus Référence ISIS Rôle dans la simulation

Arduino Uno ARDUINO UNO R3 Microcontrôleur principal, reçoit le .hex

LCD 16x2 LM016L Affichage température et état courant

Source 0–2.5V (= 0–250°C) pilotée

LM35 (simulé) DC Voltage Source
manuellement

Simulation commande chauffe, moteurs,

Relais 5V × 3 RELAY
alarme

Résistances 10kΩ RES Pull-down sur BTN_START et BTN_RESET

✔ Note de déploiement : Le code est optimisé pour une fréquence d'horloge de 16 MHz
(Arduino Uno). Pour modifier la durée d'étuvage, changer uniquement la constante
DUREE_ETUVAGE. Pour ajuster la régulation, modifier Kp, Ki, Kd dans la section des paramètres
PID.

Mémoire de Fin d'Études Page 10 / 10