En cours Pilotage pompe de circulation chaudière

  • Auteur de la discussion Madman
  • Date de début
Madman
Madman
Compagnon
14 Jan 2010
1 961
Bourgogne
  • Auteur de la discussion
  • #1
Je voulais séparer la gestion de la pompe de circulation d'eau chaude radiateurs de ma chaudière. En effet lorsque cette dernière s'arrête il reste beaucoup d'eau chaude dans les tuyaux, mais plus rien ne circule parce que la pompe s'arrête en même temps que la chaudière. Du coup les radiateurs en bout de circuit sont froids et ceux en début sont bouillants. L'énergie stockée dans l'eau chaude est mal répartie.

J'ai donc penser confier la gestion de la pompe à un Arduino. Le projet me paraissait simple, mais je ne connaissais que dalle du monde Arduino...

- Lecture de température sur le tuyau de départ d'eau pour les radiateurs.
- Si t>30°C, la pompe s'allume.
- Elle s'allume également si la chaudière s'enclenche (mais pas pour l'eau chaude sanitaire), indépendamment de la température de départ.
- La chaudière est nouvellement pilotée par un thermostat Nest 3.

Ça parait évident au premier abord, mais il y a des quantités de paramètres à maitriser : relais, points de mesure (température et chaudière ON mais pas si ECS), programmation, composants, alimentation, boitiers, connecteurs, etc. Et quand on part de zéro ce n'est pas évident.

arduino 1.jpg

Chaudière allumée, pompe aussi. Température de départ d'eau : 61.9°C, retour 38.1 La commande de la pompe se fait par un relais dans le petit boitier carré. Ainsi la haute tension est bien séparée. La diode rouge clignote quand la pompe fonctionne.

arduino 2.jpg

La chaudière s'est arrêtée, mais la pompe continue de faire circuler l'eau chaude pour distribuer l'entier de l'eau chaude jusque dans les radiateurs au bout du circuit. Elle s'arrêtera quand l'eau sera redescendue à 30°C.
 
Dernière édition:
E
Guest
Bonsoir

Sur ma chaudière il y deux modes :
- Mode hiver : le circulateur tourne tout le temps que le bruleur (commandé par le thermostat d'ambiance ET la température de l'eau de chauffage) fonctionne ou pas. Comme il y a une priorité eau chaude sanitaire, alors le circulateur chauffage s’arrête et un circulateur ECS se met en route pour chauffer le ballon dECS tant qu'elle n'est pas à la température de consigne. L'inertie des radiateurs fait que l’arrêt de circulation chauffage (10-15 min maxi) n'a pas d’incidence notable sur la température ambiante

- Mode été : seul le circulateur ECS fonctionne suivant la température de l'ECS. Le bruleur ignore le thermostat d'ambiance même s'il lui dit "chauffe il fait -15°C" et ne s'occupe que de ce que lui dit la consigne d'ECS.
 
albatros_del_sur
albatros_del_sur
Compagnon
22 Avr 2012
5 300
FR40 / FR64
Bonsoir
Curieux que le circulateur soit sur la même commande que le brûleur. Ici le circulateur est actif dès que la chaudière est en mode chauffage. Le thermostat d'ambiance agit sur une vanne 3 voies qui régule la température des radiateurs. Ainsi la chaleur est bien répartie quelle vienne du solaire ou de la chaudière.
 
moufy55
moufy55
Modérateur
23 Nov 2010
6 076
FR-55 Sud-Meusien
:smt038
C’est une chose à laquelle je réfléchis depuis longtemps, ayant fait le même constat, de l’arrêt stupide, des deux ensembles simultanés.
Par manque de temps, j’ai simplement mis un relais avec delay-off, qui retarde l’arrêt circulateur 3min après arrêt thermostat.
Mais il faut que je perfectionne la chose, lors de l’évolution de ma chaufferie.
 
tranquille
tranquille
Compagnon
12 Avr 2008
5 877
FR-12320 - Aveyron - Conques
Je pense que le principe de piloter la pompe n'est pas bon
En hiver, la pompe doit tourner tout le temps, on agit sur la vanne 3 voies en fonction de la température extérieure et de la température de retour avec des créneaux horaires normal/réduit si nécessaire
Mais je ne connais pas ton hydraulique. (partir à 60°C me parait bien haut)
 
P
picator
Ouvrier
22 Oct 2013
256
Un régulateur réglable à consigne de température haute et basse, plus ou moins couplé à un relais utilisé en contacteur de puissance, aurait largement suffi.
Mais il est vrai que le DIY est très gratifiant, surtout quand ça marche. Bravo néanmoins pour la réalisation qui comporte beaucoup de recherches, assemblage, ligne de code, tests ...
 
C
champimatic
Compagnon
2 Mar 2014
2 243
77 Seine et Marne
Je n'ai pas ce souci : le thermostat déclanche la chauffe et la pompe si elle est à l'arrêt , quand le thermostat coupe la chauufe la pompe continue de tourner et se coupe quand l'eau est à 30° environ sauf si entre temps le thermostat se remet en fonction.
 
coquillette
coquillette
Compagnon
31 Mai 2016
2 391
le wast
Bonjour
je crois que pour ne pas avoir de probleme de radiateur "froid" il faut agir sur les coudes de reglage d'abord.. :wink:
Une installation de chauffage doit s'"equilibrer"...

Jean Paul :drinkers:
 
Jope004
Jope004
Compagnon
15 Fev 2010
1 530
FR-95 Marines
Bonjour,
J'ai une chaudière gaz assez ancienne et que je trouve plutôt archaïque, mais on peut tout de même choisir le fonctionnement du circulateur : continu, temporisé après l'arrêt du brûleur, ou bien uniquement pendant que le brûleur fonctionne.
 
valoris
valoris
Compagnon
21 Avr 2008
782
Bonjour.

Toute installation d'une régulation nécessite de respecter le mode fonctionnement de la chaudière préconisé par le fabriquant. Ça c'est le premier point incontournable et à respecter impérativement.
Type de chaudière :
1 - à température variable (chaudière fonte, chaudière moderne, à condensation inférieures à 55°)
2 - à température constante (supérieure à 55°, chaudière acier ou tôle, et production d'ECS)
Pour une chaudière maintenue en température constante, la régulation du chauffage par action directe sur le circulateur, est fortement, déconseillée.
Dans la mesure du possible il convient de diminuer la température dans la chaudière, cela réduit les pertes et permet d'obtenir un meilleur rendement par abaissement des températures de fumée.
En fonction du mode de fonctionnement de la chaudière et de l'importance du circuit chauffage il faut parfois maintenir un circuit d'irrigation permanent dans la chaudière.
Pour utiliser toutes les calories produites dans le circuit chauffage, il est possible d'asservir le circulateur chauffage à la température retour ou à un delta de température.
Deuxième point à prendre en considération le mode de régulation,
- tout ou rien, proportionnel, intégral, progressif etc.è
- Boucle de régulation, ouverte ou fermée.
Bien d'autres facteurs interviennent, mais pour une étude sérieuse il faut connaître tous les éléments de l'installation. Généralement il convient de faire un schéma comprenant tous les constituants de votre installation, (Chaudière, circulateurs, ballons ECS, vannes de coupures, de régulation, les circuits ECS, de chauffage, de décharge, les types radiateurs, robinets et tés de réglage etc…
C'est en ayant une connaissance précise de votre installation que vous pourrez déterminer la meilleure régulation possible et faire des économies.

Salutations cordiales.
Valoris
 
FB29
FB29
Compagnon
1 Nov 2013
8 763
FR-29 Brest
Bonjour,

Comme @Jope004 sur ma chaudière gaz il y a un temporisation intégrée, réglable, pour prolonger le fonctionnement de la pompe. Sur ce genre de chaudière murale on ne monte pas de vanne trois voies à ma connaissance.

Sur la mienne la température de sortie est réglée par la modulation de la puissance du brûleur et le corps de chauffe a très peu d'inertie. Il est effectivement intéressant de diffuser toute l'eau chaude produite pour limiter les pertes, et par ailleurs cela permet de redémarrer avec un corps plus froid pour les chaudières à condensation.

Pour ne pas tout changer ne pourrais-tu pas envisager une simple solution électro-mécanique avec un relais temporisé prolongeant le fonctionnement de la pompe ? Ça doit se trouver assez facilement dans le commerce ...

Cordialement,
FB29
 
Dernière édition:
Madman
Madman
Compagnon
14 Jan 2010
1 961
Bourgogne
  • Auteur de la discussion
  • #13
Merci à tous pour vos partages !

Ma chaudière à gaz Chapée Edena 110x n'a aucune régulation possible, ni sur la partie chauffage, ni sur l'ECS. Juste ON ou OFF. La vanne 3 voies est manuelle. Pas de temporisation pour différer l'arrêt du circulateur. Pas de thermostat. Le seul réglage possible est un commutateur 1, 2, 3, 4 et auto, sans aucune indication à quoi cela correspond. Aucun réglage pour l'ECS. Un peu léger à mon goût !!!

Avec le projet n°1 j'ai associé un thermostat Nest pour régler la température dans la pièce de vie. Viendront par la suite des vannes thermostatiques sur les radiateurs des chambres à coucher, pour moduler à la baisse la température de ces pièces qui n'ont pas besoin d'être chauffées autant que le salon. En attendant j'ai simplement fermé "au pif" un peu les vannes actuelles. Cet ensemble fonctionne à satisfaction. Il me permet également d'allumer ou d'éteindre le chauffage à distance, par téléphone.

Le projet n°2 est la commande de circulateur illustrée en début de cette discussion. Il m'a semblé intéressant de mesurer précisément les températures de départ et d'arrivée d'eau chaude et de différer l'arrêt du circulateur jusqu'à un seuil de température. C'est le rôle de l'Arduino et il le remplit à satisfaction. Je pourrai moduler le seuil (aujourd'hui 30°) en fonction des observations futures.

Le projet n° 3 sera l'ajout d'une fonction de réveil du circulateur à périodicité donnée pour le faire tourner 5 minutes ou plus : en période d'été quand le chauffage est coupé. Cela évitera le gommage.

Il est vrai que ce genre de "bidouillages" n'a pas que des avantages. Je pense à la salade de câbles derrière la chaudière, les toiles d'araignée, le risque de panne et la revente de la maison. C'est pourquoi j'ai gardé et étiqueté précieusement le câble d'origine pour l'alimentation 220V du circulateur. Il reste dans la chaudière. Les nouvelles connexions sont étiquetées aussi.

L'autre inconvénient est que la chaudière s'arrête quand le thermostat indique que la température demandée est atteinte. Mais le circulateur continue de faire tourner l'eau chaude (qui va refroidir lentement). Conséquence : la température dans la pièce de vie monte momentanément 1 °C au dessus de la demande. Mais j'aime mieux cela que de perdre cette énergie latente dans les tuyaux (non isolés, maison ancienne). Je pourrais baisser la température demandée, mais le chauffage s'enclencherait ainsi plus tard, ce qui n'est pas souhaitable.

Chauffagiste est un métier !
 
tranquille
tranquille
Compagnon
12 Avr 2008
5 877
FR-12320 - Aveyron - Conques
Projet n°4 Mettre un moteur sur ta V3V et le piloter !
 
Madman
Madman
Compagnon
14 Jan 2010
1 961
Bourgogne
  • Auteur de la discussion
  • #15
@tranquille : c'est vrai, j'y pense aussi :wink: Pour l'instant c'est "a la mano"... Il y a tant à faire et les journées n'ont que 24h :smt022

J'attends la livraison d'un pressostat, l'ancien ayant rendu l'âme (tout rouillé).
 
tranquille
tranquille
Compagnon
12 Avr 2008
5 877
FR-12320 - Aveyron - Conques
Continue à nous régaler avec tes reportages "horlogistiques" la V3V attendra
 
tranquille
tranquille
Compagnon
12 Avr 2008
5 877
FR-12320 - Aveyron - Conques
et on voit le gars bien peu soigneux avec ces fils qui pendouillent... dès qu'il a un peu de place, c'est moins bien rangé que dans un boitier de tocante
 
chabercha
chabercha
Compagnon
9 Jan 2009
10 543
FR-84 Cavaillon
Bonjour
Continue à nous régaler avec tes reportages "horlogistiques" la V3V attendra
Oui mais si le bout de ses doigts commencent à tomber par manque de chaleur ça n'ira pas bien loin :mrgreen:
Perso depuis 45 ans mon installation n'as pas changé, chaudière mazout, radiateurs fonte, thermostat dans le couloir qui agit sur le circulateur, le thermostat de la chaudière gère la marche arrêt du bruleur.
Quand j'arrêterai la chaudière bois couplée cela va certainement me poser un problème pour choisir la bonne solution.
Je regarde systématiquement ce genre de discussion en espérant trouver celle qui s'adaptera à mon logement.
A+Bernard
 
Madman
Madman
Compagnon
14 Jan 2010
1 961
Bourgogne
  • Auteur de la discussion
  • #20
@moufy55 : bah vi ! Tu as essayé de mettre une chaudière dans la chambre photo pour lui tirer le portrait ? C'est dans ces situations qu'un portable est bien utile : vite une photo pour se souvenir des fils sur un bornier, une ch'tite pour la fin, etc.

Je n'ai pas mentionné le projet n°0, qui consistait à terminer la pièce technique : chaudière + buanderie. Placo, peinture, carrelage, faux plafond, rangements et tutti quanti. Ça non plus n'avait pas la place dans le studio :lol:
 
FB29
FB29
Compagnon
1 Nov 2013
8 763
FR-29 Brest
la chaudière s'arrête quand le thermostat indique que la température demandée est atteinte. Mais le circulateur continue de faire tourner l'eau chaude (qui va refroidir lentement). Conséquence : la température dans la pièce de vie monte momentanément 1 °C au dessus de la demande.
Il y a des thermostats avec boucle de régulation intégrée qui anticipent l'inertie de l'installation et module la production d'eau chaude pour stabiliser la température à la valeur de consigne. Par exemple ce modèle filaire Tybox 117 - DELTA DORE qui me donne toute satisfaction.

DSCN1503.JPG


Pas intéressé par un relais temporisé dans ce genre là ? ... 4 fils à brancher et une tempo à régler ...

Annotation 2020-01-28 175734.jpg
 
Madman
Madman
Compagnon
14 Jan 2010
1 961
Bourgogne
  • Auteur de la discussion
  • #24
...Pas intéressé par un relais temporisé dans ce genre là ? ... 4 fils à brancher et une tempo à régler ...
Si j'en avais eu connaissance avant, je me serais bien laissé tenter. Mais voilà : plusieurs chemins mènent à Rome et souvent on ne découvre le raccourci qu'après avoir arpenté la voie longue. Tiens, ça me rappelle le labyrinthe à rats chez Ikea...
 
  • Réagir
Reactions: JCS
tranquille
tranquille
Compagnon
12 Avr 2008
5 877
FR-12320 - Aveyron - Conques
Si j'en avais eu connaissance avant, je me serais bien laissé tenter. Mais voilà : plusieurs chemins mènent à Rome et souvent on ne découvre le raccourci qu'après avoir arpenté la voie longue. Tiens, ça me rappelle le labyrinthe à rats chez Ikea...
Il paraitrait même que leurs boulettes de viande seraient à base de clients qui n'ont jamais trouvé la sortie
 
P
psemel
Ouvrier
21 Mar 2009
403
oise
bonsoir,
voir également la loi d'eau : https://blog.elyotherm.fr/2013/08/reglage-optimisation-courbe-de-chauffe.html
pour la régulation par rapport à la température extérieure.
j'ai a peu près la même démarche sauf que je conserve sur une chaudière au fuel les circulateurs et thermostat d'ambiance et les vannes thermostatiques . j’agis uniquement sur la température de sortie de la chaudière en fonction de la température extérieure. j'ai suivi pour la programmation ce site ci dessus. l'arduino agit uniquement sur l'alimentation électrique du bruleur. les circulateurs et thermostat restent autonome.
voir : qui est fait à base d'un Arduino Mega et écran tft tactile. (Cette Vidéo est ancienne et maintenant intégré la mise en mémoire des paramètres).
Je suis en essais depuis 15 jours sur 3 jours par semaines pour l'instant et cela donne de bon résultat hormis la production ECS ou je suis obliger de "forcer "sur la température de sortie du fait que je produit ECS pour 3 jours et que je suis obliger de réchauffer la maison après la période d’inoccupation.
Ci joint le code


// thermo control d'une chaudiere fuel via un capteur de temperature exterieur (DHT11) et un capteur de temperature sur la sortie
// d'eau de la chaudiere et exterieur Dallas 18B20 et d'un capteur ( BMP085) pour la pression atmospherique et temperature du local.
// Le relais coupe l'alimentation electrique du bruleur en fonction des parametres de la loi de l'eau
// MATERIEL :
// ARDUINO MEGA 2560 et ecran tft tactile MCU FRIEND 320 x 240 et les capteurs de temperatures
// i.e. control pins A0-A4. Data D2-D9. microSD D10-D13.
// Touchscreens are normally A1, A2, D7, D6 but the order varies
// This demo should work with most Adafruit TFT libraries
// If you are not using a shield, use a full Adafruit constructor()
// e.g. Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// UN RELAIS

//DS18B20 TEMPERATURE CHAUDIERE PIN 21
//DS18B20 TEMPERATURE EXTERIEURE PIN 49
//DHT11 capteur humidité et temperature Exterieure PIN 22
//BMP085 SLC ET SDA EN 3 VOLTS
//Relais pin 30

//*************************capteur chaudiere egtexterieur DS************************
#include <DS18B20.h>
DS18B20 ds(51);// =======> pin 51
double tchaud;// temperature chaudiere
DS18B20 DS(49);// =======> pin 49
double TextDS;// temperature exterieur
//******************************************ECRAN TFT**********
#define CD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
#include <SPI.h> // f.k. for Arduino-1.5.2
#include <UTFTGLUE.h> //use GLUE class and constructor
#include <TouchScreen.h> //Global Library
#include "Adafruit_GFX.h"// Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#include <EEPROM.h>
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define TOUCH_ORIENTATION LANDSCAPE
UTFTGLUE myGLCD(0x9341,A2,A1,A3,A4,A0); //all dummy args
int XP = 7, XM = A1, YP = A2, YM = 6; //most common configuration
uint16_t TS_LEFT = 939;
uint16_t TS_RT = 176;
uint16_t TS_TOP = 122;
uint16_t TS_BOT = 881;
TouchScreen ts(XP, YP, XM, YM, 300);
TSPoint tp; //Touchscreen
void readResistiveTouch(void)
{
tp = ts.getPoint();
pinMode(YP, OUTPUT); //restore shared pins
pinMode(XM, OUTPUT);
}
//////////////////////////CAPTEUR d'HUMIDITE///////////////////////////////////////
#include <dht11.h> // capteur humidité et temperature Exterieure PIN 22
dht11 DHT11;
#define DHT11PIN 22
///////////////////////////CAPTEUR DE PressionBMP////////////////////////////////////
#include <Adafruit_BMP085.h>
Adafruit_BMP085 bmp;// capteur de PressionBMP et temperature
// Connect VCC of the BMP085 sensor to 3.3V (PAS DE 5.0V!)
// Connect GND to Ground
// Connect SCL to i2c clock - on '168/'328 Arduino Uno/Duemilanove/etc thats Analog 5
// Connect SDA to i2c data - on '168/'328 Arduino Uno/Duemilanove/etc thats Analog 4
//SDA et SCL pin 20 et 21 sur la DUE
#include <Wire.h>
//////////////////////////////RELAIS//////////////////////////////////////////////
//relais pin 30
int RELAY = 30;
///////////////////////// parametre loi sur l'eau//////////////////////////////////
double A;// temp ext de base -11
double B; //temp max de la chaudiere 80
double C;// temp ext coupure chauffage 20
double D;// temp mini de la chaudiere 38
double E; // temp exterieur de non chaufage 20
double F;// temp mini de la chaudiere 25
double G;// 18 TEMPERATURE DEMANDE
float pente=0.00;
float parallele=0.00;
float Calcul;// Calcul de la temperature sortie chaudiere
double Tempext;// du capteur DTH11
double PressionBMP;
double TempBMP;
///////////////////////////////////////Affichage/////////////////////////////////////////////
int selecteurPage=1;//variable de sélection de menu pour l'interface tactile
boolean comptAff= false;// compteur d'affichage permet de ne pas rafraichir en permanence
int i;
////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
Serial.begin(9600);

digitalWrite(RELAY,LOW);// on eteint le relais

//******************* capteur temp CHAUDIERE DS **********************************
tchaud=ds.getTempC();// temp chaudiere
TextDS=ds.getTempC();// temp ext
///////////////////////capteur BMP085///////////////////////////////////////////////
delay(10);
if (!bmp.begin()) {
// Serial.println("Could not find a valid BMP085 sensor, check wiring!");
while (1) {}
}
randomSeed(analogRead(0));
/////////////////////////////////// Setup the LCD///////////////////////////////////
myGLCD.InitLCD();
myGLCD.setFont(SmallFont);
myGLCD.setRotation(1);// 0=PORTRAIT, 1=LANDSCAPE, 2=PORTRAIT_REV, 3=LANDSCAPE_REV
pinMode(RELAY, OUTPUT); // Sortie relais
digitalWrite(RELAY,LOW);
delay(500);
////////////////////////////////////// LOGO SPSC
myGLCD.fillScreen(BLACK);
myGLCD.setColor(RED);
myGLCD.setTextSize(6);
myGLCD.print("SPSC",100,80);
myGLCD.setTextSize(4);
myGLCD.print("Electronique",20,120);
myGLCD.setTextSize(3);
myGLCD.setColor(YELLOW);
myGLCD.print("spsc@orange.fr",40,180);
delay(1500);
for (int x=0; x <= 200; x=x+8)
{
myGLCD.setColor(random(255), random(255), random(255));
myGLCD.drawCircle(160, 120, x);
myGLCD.drawCircle(160, 120, x+1);
myGLCD.drawCircle(160, 120, x+2);
}
delay(800);
myGLCD.fillScreen(BLACK);
myGLCD.setColor(RED);
myGLCD.setTextSize(3);
myGLCD.print(" THERMO CONTROL",15,80);
myGLCD.setColor(YELLOW);
myGLCD.print("V28",140,120);
delay(1500);
myGLCD.fillScreen(BLACK);

////////////////////// CHARGE LES PARAMETRES DE BASE EN MEMOIRE///////////////////////
if (EEPROM.read(0)==0) // si la memoire est vide, remplis les paramettres de base
{
A=11;// temp ext de base -11 en fonction du lieu
B=80; //temp max de la chaudiere 80
C=20;// temp ext coupure chauffage 20
D=35;// temp mini de la chaudiere 35
E=15; // temp exterieur de non chaufage 15
F=25;// temp mini de la chaudiere 25
G=18;// TEMPERATURE DEMANDE 18
pente=((B-D)/(C+A));// pente= ((B-D)/(C-A)) mais A est negatif --A=+A
parallele= ((D-(F+pente*(E-C))));

EEPROM.write(1, A);
EEPROM.write(2, B);
EEPROM.write(3, C);
EEPROM.write(4, D);
EEPROM.write(5, E);
EEPROM.write(6, F);
EEPROM.write(7, G);
EEPROM.put(20,pente);
EEPROM.put(30,parallele);
EEPROM.write(0,1);// mise en memoire du compteur a 1
}
else //(EEPROM.read(0)==1) // si la memoire est pleine, li la memoire
{
A= EEPROM.read(1);
B= EEPROM.read(2);
C= EEPROM.read(3);
D= EEPROM.read(4);
E= EEPROM.read(5);
F= EEPROM.read(6);
G= EEPROM.read(7);
EEPROM.get(20,pente);
EEPROM.get(30,parallele);
}
}
/////////////////////////////boucle principale//////////////////////////////////////////
void loop()
{
capteurs();// lit les capteurs
Calcul=0;// variable T° eau chaudiere
CALCUL();// calcul de la temperature d'eau de la chaudiere
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if(selecteurPage ==1)// PAGE PRINCIPALE de marche
{
Menu1();
}
if(selecteurPage ==11 && p.z > 20)// PARAMETRE
{
Menu11();
}
if(selecteurPage ==12&&p.z > 20)// PARAMETRE
{
Menu12();
}
if(selecteurPage ==13&&p.z > 20)// PARAMETRE
{
Menu13();
}
if(selecteurPage ==14&&p.z > 20)// PARAMETRE
{
Menu14();
}
if(selecteurPage ==15&&p.z > 20)// PARAMETRE
{
Menu15();
}
if(selecteurPage ==16&&p.z > 20)// PARAMETRE
{
Menu16();
}
if(selecteurPage ==17&&p.z > 20)// PARAMETRE
{
Menu17();
}
if(selecteurPage ==18&&p.z > 20)// PARAMETRE
{
Menu18(); // tracage de la courbe de chauffe
}
if(selecteurPage ==19&&p.z > 20)// PARAMETRE
{
Menu19(); // tracage de la courbe de chauffe
}
if(selecteurPage ==20&&p.z > 20)// PARAMETRE
{
Menu20(); // tracage de la courbe de chauffe
}
if(selecteurPage ==21&&p.z > 20)// PARAMETRE
{
Menu21(); // CONFIGURATION USINE
}
}// fin de la boucle

///////////////////////////////Sous programmes///////////////////////////////////////////////

void Menu1()// ********************menu MARCHE*************************************
{
switch(comptAff)
{
case 0:
myGLCD.fillScreen(BLACK);// AFFICHAGE DE FOND
myGLCD.setColor(WHITE);
myGLCD.drawRect(0, 0, 318, 239);
myGLCD.drawLine(0, 75, 318,75);
myGLCD.drawLine(159, 1, 159, 238);
myGLCD.drawLine(0, 150, 318,150);
myGLCD.setColor(BLUE);
myGLCD.setTextSize(2);
myGLCD.print("HUMIDITE Ext",5,3);
myGLCD.setColor(RED);
myGLCD.print("C",15,20);
myGLCD.setColor(BLUE);
myGLCD.print("%",80,20);
myGLCD.print("TEMP Ext",190, 3);
myGLCD.print("PRESSION/TEMP",3,80);
myGLCD.print("T.Chaudiere",180,80);
myGLCD.print(" CALCUL T" ,4, 160);
myGLCD.setColor(RED);
myGLCD.fillRect(160, 151, 317, 237);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);// 4
myGLCD.print("SETUP" ,185, 180);// MENU
comptAff=true;// on passe la variable d'affichage a vrai pour qu'au prochain cycle cette partie du code ne soit pas réécrite
break;
case 1:
// capteurs();// LI LES CAPTEURS
myGLCD.setTextSize(3);
myGLCD.setColor(BLUE);
myGLCD.print(" ",60,45);
myGLCD.println(DHT11.humidity);// HUMDITE EXTERIEURE
myGLCD.setColor(RED);
myGLCD.print(" ",5, 45);
myGLCD.setTextSize(3);
myGLCD.println(DHT11.temperature);// TEMPERATURE EXTERIEURE
myGLCD.setTextSize(4);
myGLCD.setColor(YELLOW);
myGLCD.print(" ",180, 30);
myGLCD.println( TextDS,1);//TEMPERATURE EXTERIEURE DS
myGLCD.print(" ",15, 100);
myGLCD.setTextSize(3);
myGLCD.setColor(MAGENTA);
myGLCD.println(int(PressionBMP)); //presson atmospherique
myGLCD.print(" ",15, 124);
myGLCD.println(TempBMP);// temperature systeme
myGLCD.setTextSize(4);
myGLCD.setColor(YELLOW);
myGLCD.print(" ",170, 100);
myGLCD.println(tchaud,1);//=============Temperature chaudiere DS
myGLCD.print(" ",10, 178);

if(Calcul<0 ) // erreure ??
{
myGLCD.setTextSize(3);
myGLCD.setColor(RED);
myGLCD.print("Erreure=>",2,178);
}
else{
myGLCD.println(Calcul);//
}
Relais();
break;
comptAff=false;// on oublie pas de réinitialiser notre variable d'affichage
}
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000 )
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
selecteurPage=11;// on passe au menu suivant
}
}
}
void Menu11()//===========================Temp mini hiver = A
{
digitalWrite(RELAY,LOW); // Serial.println("relay OFF");
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("Temp mini hiver",26,3);
touch();
Menu11_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
comptAff=false;// Changement de page
selecteurPage=12;
EEPROM.update(1,A);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
A=A+1;
Menu11_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
A=A-1;
Menu11_affvar();
}
if (A<=0 ) // chiffre positif pour la memoire (0 à 255)
{
A=0;
}
}
}
}
void Menu11_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 50, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("-",90,60);
myGLCD.println(A);
}
void Menu12()//===========================Temp mini hiver = B
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("T max chaudiere",26,3);
touch();
Menu12_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
comptAff=false;//
selecteurPage=13;
EEPROM.update(2,B);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
B=B+1;
Menu12_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
B=B-1;
Menu12_affvar();
}
}
}
}
void Menu12_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 50, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("",90,60);
myGLCD.println(B);
}
void Menu13()//===========================temp ext en été de la coupure chauffage C
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("Temp Ext Coupure",26,3);
myGLCD.print("en ete",26,28);
touch();
Menu13_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
comptAff=false;//
selecteurPage=14;
EEPROM.update(3,C);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
C=C+1;
Menu13_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
C=C-1;
Menu13_affvar();
}
}
}
}
void Menu13_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 50, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("",90,60);
myGLCD.println(C);
}
void Menu14()//===========================temp mini de l'eau en sortie en été de chaudiere D
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("T Mini Chaudiere",26,3);
myGLCD.print("en ete",26,28);
touch();
Menu14_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
comptAff=false;//
selecteurPage=15;
EEPROM.update(4,D);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
D=D+1;
Menu14_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
D=D-1;
Menu14_affvar();
}
}
}
}
void Menu14_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 50, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("",90,60);
myGLCD.println(D);
}
void Menu15()//===========================temp exterieur de non chaufage E
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("T EXT ARRET",26,3);
myGLCD.print("du chauffage",26,28);
touch();
Menu15_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
comptAff=false;//
selecteurPage=16;
EEPROM.update(5,E);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
E=E+1;
Menu15_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
E=E-1;
Menu15_affvar();
}
}
}
}
void Menu15_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 60, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("",90,60);
myGLCD.println(E);
}
void Menu16()//===========================temp demandée G
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("T DEMANDEE",26,3);
touch();
Menu16_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
comptAff=false;//
selecteurPage=17;
EEPROM.update(7,G);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
G=G+0.5;
Menu16_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
G=G-0.5;
Menu16_affvar();
}
}
}
}
void Menu16_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 50, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("",90,60);
myGLCD.println(G);
}
void Menu17()//===========================temp mini de l'Eau en sortie chaudiere F
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("T mini sortie",26,3);
myGLCD.print("Chaudiere",26,30);
touch();
Menu17_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 && p.z > 20 && p.z < 1000 )
{
comptAff=false;// on passe la variable d'affichage a vrai pour qu'au prochain cycle cette partie du code ne soit pas réécrite
selecteurPage=18;
EEPROM.update(6,F);// mise en memoire
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
F=F+1;
Menu17_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
F=F-1;
Menu17_affvar();
}
}
}
}
void Menu17_affvar()
{
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 60, 320, 130);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(5);
myGLCD.print("",90,60);
myGLCD.println(F);
}
void Menu18()//===========================COURBE DE CHAUFFE++++++++++++++++++++++++++++++
{
// recalcul de la pente et //
// float pente1=((B-D)/(C+A));// pente=((B-D)/(C-A)) mais A est negatif --A=+A
// float parallele1= ((D-(F+pente*(E-C))));//recalcul parallele

myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(2);
myGLCD.print("COURBE DE CHAUFFE",60,3);
myGLCD.setColor(BLUE);
myGLCD.fillRect(160, 151, 317, 239);
myGLCD.setColor(WHITE);
myGLCD.setTextSize(4);
myGLCD.print("Suite" ,190, 180); // axe Vertical et horizontal==============================
myGLCD.setColor(RED);
myGLCD.drawLine(34, 0, 34, 210);// axe Y
double ScaleY=210/90;// Echelle Y
double ScaleX=290/58; // Echelle X DEClAGE DE 34
for (i=1;i<=10;i++)// graduation Y
{
myGLCD.setColor(RED);
myGLCD.drawLine(20, int(i*ScaleY*10), 320, int(i*ScaleY*10));
myGLCD.setTextSize(1);
myGLCD.setColor(WHITE);
myGLCD.print( "" ,1, int(i*ScaleY*10));
myGLCD.println(100-(i*10));
}
int ZZ=25;
for (i=0;i<=10;i++)
{
myGLCD.setColor(RED);
myGLCD.drawLine(int(34+i*ScaleX*5),0,int(34+i*ScaleX*5),220);
myGLCD.setTextSize(1);
myGLCD.setColor(YELLOW);
myGLCD.print( "",int(34+i*ScaleX*5),225);
myGLCD.println(ZZ);
ZZ=ZZ-5;
}
// trace de la courbe ===================================================================================
myGLCD.setColor(YELLOW);// trace la courbe
int t;
for (t=-25;t<=25;t=t+1)
{
Calcul = (pente*(G-t))+parallele;
myGLCD.drawCircle(int(160-(t*290/58)), 200-int(ScaleY*int(Calcul)), 1);
}
myGLCD.setColor(RED);// POINT ACTUEL par rapport à la courbe de chauffe
myGLCD.fillCircle(int(160-(TextDS*290/58)), 200-int(ScaleY*int(Calcul)), 4);
myGLCD.setColor(YELLOW);
myGLCD.setTextSize(2);
myGLCD.print("Pente",30,20);
myGLCD.print("",100,20);
myGLCD.println(pente);
myGLCD.print("parallele",30,40);
myGLCD.print(" ",155,40);
myGLCD.println(parallele);
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )
{
// myGLCD.fillScreen(BLACK);
comptAff=false;// on passe la variable d'affichage a vrai pour qu'au prochain cycle cette partie du code ne soit pas réécrite
selecteurPage=19;
break;
}
}
}
}
void Menu19()//===========================REGLAGE PENTE========================
{

pente=((B-D)/(C+A));// pente=((B-D)/(C-A)) mais A est negatif --A=+A
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("Pente",26,3);
touch();
Menu19_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 && p.z > 20 && p.z < 1000 )
{
comptAff=false;// on passe la variable d'affichage a vrai pour qu'au prochain cycle cette partie du code ne soit pas réécrite
EEPROM.put(20,pente);// mise en memoire de la pente
selecteurPage=20;
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
pente=pente+0.1;
Menu19_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
pente=pente-0.1;
Menu19_affvar();
}
}
}
}
void Menu19_affvar()
{
myGLCD.setTextSize(5);
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 30, 319, 160);
myGLCD.print("",90,60);
myGLCD.setColor(YELLOW);
myGLCD.println(pente);
}
void Menu20()///////////////////////////PARALLELE////////////////////////////
{
parallele= ((D-(F+pente*(E-C))));//recalcul parallele
myGLCD.fillScreen(BLACK);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("Parallele",26,3);
touch();
Menu20_affvar();
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 && p.z > 20 && p.z < 1000 )
{
comptAff=false;// on passe la variable d'affichage a vrai pour qu'au prochain cycle cette partie du code ne soit pas réécrite
EEPROM.put(30,parallele);// mise en memoire //
EEPROM.write(0, 1);// compteur pour changement memoire
selecteurPage=21;//
break;
}
if (p.x > 650 && p.x < 922 && p.y > 553 && p.y < 735 )
{
parallele=parallele+0.1;
Menu20_affvar();
}
if (p.x > 649 && p.x < 928 && p.y > 768 && p.y < 913 )
{
parallele=parallele-0.1;
Menu20_affvar();
}
}
}
}
void Menu20_affvar()
{
myGLCD.setTextSize(5);
myGLCD.setColor(BLACK);
myGLCD.fillRect(0, 30, 319, 160);
myGLCD.print("",90,60);
myGLCD.setColor(YELLOW);
myGLCD.println(parallele);
}
void Menu21() //======================efface la memoire EEprom/ configuration origine ++++++++++++++++++++++++
{
myGLCD.fillScreen(BLACK);
myGLCD.setColor(RED);
myGLCD.setTextSize(3);
myGLCD.print("configuration",5,3);
myGLCD.print("d'usine ?",5,25);
myGLCD.fillRect(160, 151, 317, 240);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);
myGLCD.print("NON" ,180, 183);
myGLCD.setColor(GREEN);// TOUCHE -
myGLCD.fillRect(0, 151, 160, 240);
myGLCD.setColor(BLACK);
myGLCD.print("OUI" ,25, 183);
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
while(p.z<20)
{
digitalWrite(13, HIGH);
TSPoint p = ts.getPoint(); // Read touchscreen_test();
digitalWrite(13, LOW);
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 20 && p.z < 1000)
{
if (p.x > 635 && p.x < 902 && p.y > 134 && p.y < 490 )// N'EFFACE PAS LA MEMOIRE
{
comptAff=false;//
EEPROM.update(0,1);// mise en memoire du compteur a 1
selecteurPage=1;
break;

}
if (p.x > 650 && p.x < 922 && p.y > 768 && p.y < 913 ) //EFFACE LA MEMOIRE
{
myGLCD.fillScreen(RED);
myGLCD.setColor(MAGENTA);
myGLCD.setTextSize(3);
myGLCD.print("EFFACE LA MEMOIRE",5,3);
myGLCD.print("ATTENDRE",35,40);
for (int i = 0 ; i < 40 ; i++)
{
EEPROM.write(i, 0);// efface la memoire
}
void paramettres();// RECHARGE LES PARAMETRES
EEPROM.write(1, A);
EEPROM.write(2, B);
EEPROM.write(3, C);
EEPROM.write(4, D);
EEPROM.write(5, E);
EEPROM.write(6, F);
EEPROM.write(7, G);
EEPROM.put(20,pente);
EEPROM.put(30,parallele);
EEPROM.update(0, 1);// memoire pleine
selecteurPage=1;
break;

}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
void CALCUL()
{
Calcul = (pente*(G-TextDS))+parallele;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
void Relais()
{
if (tchaud >= Calcul && tchaud < B) // relais ouvert(pas de contact) B=temp max de la chaudiere
// si la temperature de la chaudiere > A la TEMERATURE DE CALCUL et TEMPERATURE CHAUDIERE < TEMPERATURE MAXI DE LA CHAUDIERE
{
digitalWrite(RELAY,LOW);// on eteint le relais
myGLCD.setTextSize(2);
myGLCD.setColor(BLACK);
myGLCD.fillRect(8, 220, 158, 238);
myGLCD.setColor(GREEN);
myGLCD.print( "Relay off",18,220);
myGLCD.fillCircle(10, 230, 5);
myGLCD.setColor(RED);
myGLCD.fillRect(160, 151, 317, 237);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);// 4
myGLCD.print("WAIT" ,185, 180);

delay(60000);// attendre 1 minutes

myGLCD.setColor(RED);
myGLCD.fillRect(160, 151, 317, 237);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);// 4
myGLCD.print("SETUP" ,185, 180);// MENU
}
if (tchaud < Calcul && tchaud < B) // relais en contact( en fonctionnement)
{
// ont attend avant le redemarrage du bruleur
delay(10000);
digitalWrite(RELAY,HIGH);
myGLCD.setColor(BLACK);
myGLCD.fillRect(8, 220, 158, 238);
myGLCD.setTextSize(2);
myGLCD.setColor(RED);
myGLCD.print( "Relay ON",20,220);
myGLCD.fillCircle(10, 230, 5);
myGLCD.setColor(RED);

}
delay(1000);
}


void touch()
{
myGLCD.setColor(BLUE);
myGLCD.fillRect(160, 151, 317, 239);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);
myGLCD.print("OK" ,220, 180);
myGLCD.setColor(GREEN);// TOUCHE -
myGLCD.fillRect(0, 151, 80, 239);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);
myGLCD.print("-" ,33, 183);
myGLCD.setColor(RED);// TOUCHE +
myGLCD.fillRect(80, 151, 160, 239);
myGLCD.setColor(BLACK);
myGLCD.setTextSize(4);
myGLCD.print("+" ,113, 183);
}
void capteurs()
{
// ******************************capteur tempderature DS de la chaudiereet exterieure ******************************
tchaud=ds.getTempC();// temp chaudiere
TextDS=DS.getTempC();//temp exterieure
//*************************************capteur BMP systeme*********************************
bmp.begin();
TempBMP= bmp.readTemperature();
PressionBMP= (bmp.readPressure()/100);
//*************************************capteur DHT11 *********************************
uint8_t chk = DHT11.read(DHT11PIN);
switch (chk)
{
case 0: Serial.print("DHT 11 OK"); break;
case -1: Serial.println("Checksum error"); break;
case -2: Serial.println("Time out error"); break;
case -3: Serial.println("The sensor is busy"); break;
default: Serial.println("Unknown error"); break;
}
double H=(DHT11.humidity, DEC);
double Tempext=(DHT11.temperature, DEC);// non utilisé
}
void paramettres()// ===============PARAMETTRES DE BASE=================================
{
A=11;// temp ext de base -11 en fonction du lieu
B=80; //temp max de la chaudiere 80
C=20;// temp ext coupure chauffage 20
D=35;// temp mini de la chaudiere 35
E=15; // temp exterieur de non chaufage 15
F=25;// temp mini de la chaudiere 25
G=18;// TEMPERATURE DEMANDE 18
pente=((B-D)/(C+A));// pente= ((B-D)/(C-A)) mais A est negatif --A=+A
parallele= ((D-(F+pente*(E-C))));
}





.
 
Haut