Bonjour,
Ca fait un moment que je parcours le forum avec beaucoup de cas de résolutions de problème bien pratique. Je suis débutant en programmation et là par contre, je n'arrive pas à trouver comment faire.
Je m'explique :
Je suis en cours de réécriture ou d'adaptation d'un programme pour la gestion de mon systeme de chauffage/rafraichissement chez moi.
Pour cela, je me suis basé sur le programme qu'avait fais JML et j'essaye de le transposer à mon projet.
```cpp
/*
********************************************************
AUTEUR d'origine J-M-L (merci à lui) pour forum Arduino revu par Ralph
http://forum.arduino.cc/index.php?topic=509552.0 pour le projet de J-M-L
Le programme a été revu et adapté pour un système bioclimatique compilant 1 puit Canadien / 2 tunnels à galets /
10m² de panneaux solaire thermique à air
Pour Arduino MEGA
Code libre de droits, mention de l'origine appréciée
Librairies propriété de leurs auteurs respectifs
Sans garantie aucune de bon fonctionnement :) (là c'est toujours le cas :) )
********************************************************
PINS UTILISEES
--------------
0,1 =
2 =
3 = PWM 0-10v angle ouverture volet 1
4 = pin PWM ventilo puit canadien
5 = pin PWM ventilo tunnels à galet
20 SDA I2C pour écran 16 x 2
21 SCL
22 à 28 = Pin pour module 8 relays pour ouverture/fermeture volets
30 BP pour mode STANDARD ou ETE
31 BP pour CANICULE et BOOST
32 BP pour gérer la décharge ou recharge des tunnels
33 BP HIVER pour optimiser la récupération de chaleur
40 à 49 Pin diverse, pour le moment pas grand interet
50 Bus OneWire pour les sondes DS18B20
A0
A1
A2
A3
SDA, SCL = I2C communication (MEGA = 20 (SDA) + 21 (SCL))
COMPOSANTS UTILISES
-------------------
4 boutons
un LCD 2 lignes 16 caractères
un DS18820 avec la résistance de 4.7KΩ qui va bien pour la température (le code gère plusieurs DS18820)
LIBRAIRIES UTILISEES
--------------------
LiquidCrystal_I2C https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
RTClib https://github.com/adafruit/RTClib
OneButton https://github.com/mathertel/OneButton
DallasTemperature.h> https://github.com/milesburton/Arduino-Temperature-Control-Library
OneWire https://github.com/PaulStoffregen/OneWire
EEPROM en standard dans l'IDE
CABLAGE
-------
boutons en INPUT_PULLUP donc 1 côté vers la pin Arduino, un côté vers GND
LCD en I2C sous 5V (SDA, SCL, 5V, GND)
Mars 2026, décision de passer sur ARDUINO MEGA car je n'ai pas reussi à piloter le module relay avec les PCF
*/
// **********************************************************
// les définitions
// **********************************************************
//enum : byte {automatique, manuel, param, eteint } mode = manuel; // pour le mode de fonctionnement
enum recette : byte { MARCHE = HIGH,
ARRET = LOW }; // pour la commande des modules, module éteint sur HIGH (inverser sinon les valeurs)
// Les PINS PWM pour gerer les 0-10v
byte pinvolet1 = 3; // PWM pour gérer l'angle d'ouverture du volet n°1
byte pinVentilPCan = 4; // Pin en PWM du puit canadien pour la vitesse du ventilo
byte pinVentilTAGal = 5; // Pin en PWM du tunnel à galet pour la vitesse du ventilo
// Les pins pour les relays des volets
const byte pinalimVolets = 22; // Autorise le passage de courant 230V vers les volets (hors V1 qui a sa propre alimentation)
const byte pinvolet2 = 23;
const byte pinvolet3 = 24;
const byte pinvolet4 = 25;
const byte pinvolet5 = 26;
const byte pinvolet6 = 27;
const byte pinvolet7 = 28;
// Les PINS pour les boutons
const byte BPSTDPin = 30; // BP, simple clic mode standard double clic ETE Puit canadien actif
const byte BPCANICULEPin = 31; // Bouton poussoir, active le scenario CANICULE, double clic BOOST, puit Canadien + TAG dans maison
const byte BPRECDECTUNPin = 32; // Bouton poussoir, permet la décharge (avant l'été) ou la recharge (après l'été) des tunnels à galet
const byte BPHIVERPin = 33; // Bouton poussoir active le mode HIVER qui dans un second temps sera cumulé avec les panneaux solaire thermiques
// Les sortie analogiques
const byte pinVMC = 40; // Vitesse GV de la VMC
//const byte CHeau = 41; // Pin pour le déclenchement du chauffe eau à asservir avec une sonde de temperature
const byte pinLED = 42; // Pin pour remonter en cas d'erreur
// Les pins pour les sondes
const byte onewireBusPin = 50; // pin 50 pour le bus 1 wire avec une résistance de 4.7KΩ entre 5V et pin 3
// les éléments d'affichage
const byte xClock = 0, yClock = 0;
const byte xScenario = 0, yScenario = 1;
const byte xVPCanConsigne = 7, yVPCanConsigne = 0;
const byte xVTAGConsigne = 7, yVTAGConsigne = 1;
const byte xTempPCan = 9, yTempPCan = 0;
const byte xTempTempSolthermConsigne = 13, yTempSolthermConsigne = 0;
const byte xTempPanneaux = 13, yTempPanneaux = 1;
const byte xTempTAG = 9, yTempTAG = 1;
// adresse LDC 0x27 16 caractères, 2 lignes
const byte adresseI2CLCD = 0x27;
const byte nbCol = 16;
const byte nbLignes = 2;
// Le nombre de capteurs de t° DS18820 sur le bus oneWire
const byte nbCapteursDS18820 = 4;
const int resolution = 10; // en bits --> Max 12 bit, min 9 bit (9bit prends 95ms, 10bit 187ms, 11bit 375ms et 12bit 750ms)
const unsigned long periodeTemperature = 250; // 250ms est OK pour une résolutoin en 10 bits. au minimum attendre (750 / (1 << (12 - resolution)));
const float tempTropChaudDelta = 2; // déclenchement chauffage si T° sous la consigne, arrêt au dela de la consigne + tempTropChaudDelta
const int minTemp = -30, maxTemp = 100;
// **********************************************************
// Gestion EEPROM
// **********************************************************
#include <EEPROM.h>
const uint32_t motClef = 0xBEEFDEAD;
const uint16_t adresseMotClef = 0x00;
// __attribute__ ((packed)) permet de forcer la conservation de l'ordre des champs
// c'est utile pour éviter que le compilateur mette le bazar quand on en rajoute au fil du temps
struct __attribute__((packed)) _paramS {
int16_t ventConsignebassePCan;
int16_t ventConsignemoyPCan;
int16_t ventConsignehautePCan;
int16_t ventConsignebasseTAGal;
int16_t ventConsignemoyTAGal;
int16_t ventConsignehauteTAGal;
int16_t ventConsignemaxTAGal;
int16_t TempSolthermConsigne; // Temperature de déclenchement des panneaux solaire thermiques
byte vitesseInitiventilPCan; // PWM d'origine pour le ventilateur du puit Canadien
byte vitesse250M3ventilPCan;
byte vitesse400M3ventilPCan;
byte vitesseMINITAGal; // PWM d'origine pour le ventil du TAG
byte vitesse250M3TAGal;
byte vitesse400M3TAGal;
byte vitesse500M3TAGal;
} lesParametres;
const uint16_t adresseDesParametres = adresseMotClef + sizeof(motClef);
// **********************************************************
// Gestion du LCD
// **********************************************************
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(adresseI2CLCD, nbCol, nbLignes);
// les caractères fréquents
const char* degree = "\337"; // °
const char space = ' '; // espace
const char colon = ':'; // symbole pour séparer les heures des minutes (on peut aussi mettre 'h')
const char zero = '0';
const char symboleSTANDARDOn = 'STD';
const char symboleCANICULEOn = 'CAN';
const char symboleETEOn = 'ETE';
const char symboleRechargeTunnelOn = 'RECH';
const char symboleDechargeTunnelOn = 'DECH';
const char symboleHIVEROn = 'HIV';
const char symboleBOOSTOn = 'BOOS';
// **********************************************************
// Les Ventilateurs
// **********************************************************
// Les 2 variables pour définir quelle vitesse donner aux ventilateurs
byte VPCan = 1;
byte VTAG = 1;
// Réglage vitesse du ventilateur du puit canadien
void VentilPCan() {
digitalWrite(pinVentilPCan, HIGH);
if (VPCan == 1) analogWrite(pinVentilPCan, lesParametres.vitesseInitiventilPCan);
if (VPCan == 2) analogWrite(pinVentilPCan, lesParametres.vitesse250M3ventilPCan);
if (VPCan == 3) analogWrite(pinVentilPCan, lesParametres.vitesse400M3ventilPCan);
}
void VentilPCanSTOP() {
digitalWrite(pinVentilPCan, LOW);
}
// Réglage vitesse du ventilateur du tunnel à galet
void VentilTAGal() {
digitalWrite(pinVentilTAGal, HIGH);
if (VTAG == 1) analogWrite(pinVentilTAGal, lesParametres.vitesseMINITAGal);
if (VTAG == 2) analogWrite(pinVentilTAGal, lesParametres.vitesse250M3TAGal);
if (VTAG == 3) analogWrite(pinVentilTAGal, lesParametres.vitesse400M3TAGal);
if (VTAG == 4) analogWrite(pinVentilTAGal, lesParametres.vitesse500M3TAGal);
}
void VentilTAGSTOP() {
digitalWrite(pinVentilTAGal, LOW);
}
// **********************************************************
// LES SCENARIOS DES VOLETS
// **********************************************************
void VoletsLOW() // Pin des volets à 0
{
digitalWrite(pinalimVolets, HIGH);
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, HIGH);
digitalWrite(pinvolet4, HIGH);
digitalWrite(pinvolet5, HIGH);
digitalWrite(pinvolet6, HIGH);
digitalWrite(pinvolet7, HIGH);
}
void VoletsSTD() // Volets en position la plus courante
{
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, HIGH);
digitalWrite(pinvolet4, LOW);
digitalWrite(pinvolet5, LOW);
digitalWrite(pinvolet6, LOW);
digitalWrite(pinvolet7, LOW);
analogWrite(pinvolet1, 51); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
digitalWrite(pinalimVolets, LOW);
}
void VoletsPCVERSTAG() // Volets ou l'air passe par le PC et par les TUNNELS maximisant l'échange thermique
{
digitalWrite(pinvolet2, LOW);
digitalWrite(pinvolet3, LOW);
digitalWrite(pinvolet4, LOW);
digitalWrite(pinvolet5, LOW);
digitalWrite(pinvolet6, LOW);
digitalWrite(pinvolet7, HIGH);
analogWrite(pinvolet1, 255); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
digitalWrite(pinalimVolets, LOW);
}
void VoletsSURVENTILETAGE() // Volets permetant de surventiler l'étage avec la turbine du TAG, le PC alimente la maison
{
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, LOW);
digitalWrite(pinvolet4, LOW);
digitalWrite(pinvolet5, HIGH);
digitalWrite(pinvolet6, LOW);
digitalWrite(pinvolet7, HIGH);
analogWrite(pinvolet1, 0); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
digitalWrite(pinalimVolets, LOW);
}
void VoletsRECHARGETUNNEL() // Volets permetant de charger les tunnels en calorie
{
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, HIGH);
digitalWrite(pinvolet4, HIGH);
digitalWrite(pinvolet5, LOW);
digitalWrite(pinvolet6, LOW);
digitalWrite(pinvolet7, HIGH);
analogWrite(pinvolet1, 102); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
}
void VoletsDECHARGETUNNEL() // Volets permetant de décharger les tunnels en calorie
{
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, HIGH);
digitalWrite(pinvolet4, LOW);
digitalWrite(pinvolet5, LOW);
digitalWrite(pinvolet6, LOW);
digitalWrite(pinvolet7, HIGH);
analogWrite(pinvolet1, 0); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
}
void VoletsSOLTHERMIQUE() // Volets pour chauffage solaire
{
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, LOW);
digitalWrite(pinvolet4, LOW);
digitalWrite(pinvolet5, HIGH);
digitalWrite(pinvolet6, HIGH);
digitalWrite(pinvolet7, LOW);
analogWrite(pinvolet1, 255); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
}
void VoletsBOOST() // Volets en position la plus courante
{
digitalWrite(pinvolet2, HIGH);
digitalWrite(pinvolet3, LOW);
digitalWrite(pinvolet4, LOW);
digitalWrite(pinvolet5, LOW);
digitalWrite(pinvolet6, HIGH);
digitalWrite(pinvolet7, HIGH);
analogWrite(pinvolet1, 0); // PWM pour signal 0-10v : 2v = 51 / 4v = 102 / 10v = 255
digitalWrite(pinalimVolets, LOW);
//delay (500); //Temps de mouvement des volets
digitalWrite(pinvolet6, HIGH);
//delay (500); //Temps de mouvement tronqué pour que le volet 6 se trouve entre 2 mouvements
}
/*
// **********************************************************
// L'HORLOGE RTC
// **********************************************************
#include "RTClib.h" // https://github.com/adafruit/RTClib (import adafruit RTCLib library)
RTC_DS3231 rtc;
void lcdPrint2Digits(uint8_t n, const char padding = space)
{
if (n < 10) lcd.print(padding);
lcd.print(n);
}
void displayTime(boolean forceUpdate = false)
{
const unsigned long updatePeriod = 1000ul; // UL = unsigned long
static unsigned long t0 = 0;
static byte _h = 0, _m = 0;
byte h, m;
DateTime now;
if (mode == eteint) return;
if (forceUpdate) {
now = rtc.now();
_h = h = now.hour();
_m = m = now.minute();
lcd.setCursor(xClock, yClock);
lcdPrint2Digits(h); lcd.write(colon);
lcdPrint2Digits(m, zero);
t0 = millis();
} else if ((millis() - t0 >= updatePeriod) || (t0 == 0)) {
now = rtc.now();
h = now.hour();
m = now.minute();
if (_h != h) {
lcd.setCursor(xClock, yClock); lcdPrint2Digits(_h = h);
}
if (_m != m) {
lcd.setCursor(xClock + 3, yClock); lcdPrint2Digits(_m = m, zero);
}
t0 += updatePeriod;
}
}
*/
// **********************************************************
// Gestion des DS18820 (dans ce code on n'affiche que le dernier)
// **********************************************************
#include <OneWire.h>
#include <DallasTemperature.h> // https://github.com/milesburton/Arduino-Temperature-Control-Library
OneWire oneWire(onewireBusPin);
DallasTemperature sensors(&oneWire);
float temperaturesDS18820[nbCapteursDS18820];
unsigned long chronoTemperatures = 0;
// Addresses of DS18B20s
DeviceAddress DS18820Address[nbCapteursDS18820] = {
{ 0x28, 0xA8, 0x26, 0x55, 0x00, 0x00, 0x00, 0xDE },
{ 0x28, 0xBC, 0xFA, 0x57, 0x04, 0x18, 0x3C, 0x38 },
{ 0x28, 0x09, 0x6E, 0x57, 0x04, 0x3A, 0x3C, 0x2C },
{ 0x28, 0xCF, 0x05, 0x57, 0x04, 0x21, 0x3C, 0xAF },
};
void lcdTemperature(int t, byte x, byte y) {
// on sait que la température est entre -55° et 125°, donc la longeur max de la chaîne 125° = 4 caractères
char affichage[5]; // 4 carcatères + 1 pour le '\0'
char tmpBuffer[5];
// on s'assure de tenir sur 3 digits
if (t < -99) t = -99;
else if (t > 999) t = 999;
itoa(t, tmpBuffer, 10); // connvertir en chaîne, cf http://www.cplusplus.com/reference/cstdlib/itoa/?kw=itoa
strcat(tmpBuffer, degree); // ajoute le symbole '°'
memset(affichage, space, sizeof(affichage)); // on replit d'espaces
strcpy(affichage + sizeof(affichage) - strlen(tmpBuffer) - 1, tmpBuffer); // on cadre à droite
lcd.setCursor(x, y);
lcd.print(affichage);
}
void displayTemperature(boolean forceDisplay = false) {
if (forceDisplay) {
while (millis() - chronoTemperatures < periodeTemperature)
; // on attend que les t° soient prêtes
}
// est-ce le moment le lire les capteurs de température?
if (millis() - chronoTemperatures >= periodeTemperature) {
float t;
for (int i = 0; i < nbCapteursDS18820; i++) {
t = sensors.getTempCByIndex(i); // lire les T°
Serial.print("Temperature : "); //
Serial.println(t);
if ((i == nbCapteursDS18820 - 1) && ((((int)t) != ((int)temperaturesDS18820[i])) || forceDisplay)) {
lcdTemperature((int)t, xTempPCan, yTempPCan);
}
temperaturesDS18820[i] = t; // mais on stocke bien la bonne valeur
}
// on relance une requete pour la prochaine fois
sensors.requestTemperatures();
chronoTemperatures = millis();
}
}
// **********************************************************
// Les Boutons
// **********************************************************
#include <OneButton.h> // https://github.com/mathertel/OneButton
OneButton BPSTD(BPSTDPin, INPUT_PULLUP, true); // true pour le mettre en INPUT_PULLUP
OneButton BPCANICULE(BPCANICULEPin, INPUT_PULLUP, true); // pour le mettre en INPUT_PULLUP
OneButton BPRECHTUN(BPRECDECTUNPin, INPUT_PULLUP, true); // true pour le mettre en INPUT_PULLUP
OneButton BPHIVER(BPHIVERPin, INPUT_PULLUP, true); // true pour le mettre en INPUT_PULLUP
void tickBoutons() {
BPSTD.tick();
BPCANICULE.tick();
BPRECHTUN.tick();
BPHIVER.tick();
}
// Les fonctions de call back, appellées quand on clique sur un des boutons
void doubleClickMode() {
eteindreTousLesSystemes(); // quand on change de mode on éteint les systèmes
}
// **********************************************************
// utilitaires
// **********************************************************
void forceDisplay() {
//displayTime(true);
displayTemperature(true);
}
// **********************************************************
// Les scenarios suivant les saisons
// **********************************************************
// Les differents scenarios
boolean STANDARDOn = false;
boolean ETEOn = false;
boolean CANICULEOn = false;
boolean RechargeTunnelOn = false;
boolean DechargeTunnelOn = false;
boolean HIVEROn = false;
boolean BOOSTOn = false;
void STANDARD(recette c) // Ce cycle servira à l'entre 2 saisons et aussi l'été tant que seul le puit canadien est necessaire
{
if ((STANDARDOn ? MARCHE : ARRET) != c) { // si on change d'état
STANDARDOn = (c == MARCHE);
Serial.print(F("MODE STANDARD"));
(VPCan = 1);
VentilPCan();
(VTAG = 1);
VentilTAGal();
digitalWrite(pinVMC, ARRET);
VoletsSTD();
lcd.setCursor(xScenario, yScenario);
lcd.write(STANDARDOn ? symboleSTANDARDOn : space);
}
}
void ETE(recette c) // A lancer quand la temperature de la journée se situe entre 33 et 35°C A intégrer la VMC et l'heure
{
if ((ETEOn ? MARCHE : ARRET) != c) { // si on change d'état
ETEOn = (c == MARCHE);
Serial.print(F("MODE ETE"));
(VPCan = 3);
VentilPCan();
(VTAG = 1);
VentilTAGal();
digitalWrite(pinVMC, MARCHE);
VoletsSTD();
lcd.setCursor(xScenario, yScenario);
lcd.write(ETEOn ? symboleETEOn : space);
}
}
void HIVER(recette c) // Ce cycle est à utiliser dans la periode la plus froide, de novembre à avril
{
if ((HIVEROn ? MARCHE : ARRET) != c) { // si on change d'état
HIVEROn = (c == MARCHE);
if (temperaturesDS18820[0] < (lesParametres.TempSolthermConsigne)) {
(VPCan = 1);
VentilPCan();
(VTAG = 1);
VentilTAGal();
digitalWrite(pinVMC, ARRET);
VoletsPCVERSTAG();
} else if (temperaturesDS18820[0] < (lesParametres.TempSolthermConsigne) + tempTropChaudDelta) {
(VPCan = 2);
VentilPCan();
(VTAG = 2);
VentilTAGal();
digitalWrite(pinVMC, MARCHE);
VoletsSOLTHERMIQUE();
} else if (temperaturesDS18820[0] < (lesParametres.TempSolthermConsigne) + 10) {
VoletsSOLTHERMIQUE();
(VPCan = 3);
VentilPCan();
(VTAG = 3);
VentilTAGal(); //Partie tronquée à rajouter quand les panneaux solaires thermiques seront en place
digitalWrite(pinVMC, MARCHE);
}
lcd.setCursor(xScenario, yScenario);
lcd.write(HIVEROn ? symboleHIVEROn : space);
}}
// Les fonctions de call back, appellées quand on clique sur un des boutons
void clickSTANDARD() {
STANDARD(STANDARDOn ? ARRET : MARCHE);
}
void clickETE() {
ETE(ETEOn ? ARRET : MARCHE);
}
void clickHIVER() {
HIVER(HIVEROn ? ARRET : MARCHE);
}
void eteindreTousLesSystemes() {
// ici éteindre tous les ventilateurs
VentilPCanSTOP();
VentilTAGSTOP();
digitalWrite(pinalimVolets, HIGH);
STANDARD(ARRET);
ETE(ARRET);
//CANICULE (ARRET);
//RechargeTunnel (ARRET);
//DechargeTunnel (ARRET);
//HIVER (ARRET);
}
// force l'affichage des symboles
void afficheEtatSystemes() {
lcd.setCursor(xScenario, yScenario);
lcd.write(STANDARDOn ? symboleSTANDARDOn : space);
lcd.write(CANICULEOn ? symboleCANICULEOn : space);
lcd.write(RechargeTunnelOn ? symboleRechargeTunnelOn : space);
lcd.write(DechargeTunnelOn ? symboleDechargeTunnelOn : space);
lcd.write(HIVEROn ? symboleHIVEROn : space);
lcd.write(BOOSTOn ? symboleBOOSTOn : space);
}
// **********************************************************
void etablirValeursParDefaut() {
uint32_t lectureMotClef;
EEPROM.get(adresseMotClef, lectureMotClef);
if (lectureMotClef == motClef) {
// la mémoire a déjà été initialisée, on peut charger les paramètres
EEPROM.get(adresseDesParametres, lesParametres);
} else {
// la mémoire n'avait pas encore été initialisée
lesParametres.TempSolthermConsigne = 25; //Temperature de démarrage des panneaux solaire thermique
lesParametres.ventConsignebassePCan = 6; // entre 0 (ventilateur vitess min) et 17 PWM ventilateur)
lesParametres.ventConsignemoyPCan = 10; // Vitesse moyenne
lesParametres.ventConsignehautePCan = 15; // Vitesse haute
lesParametres.vitesseInitiventilPCan = lesParametres.ventConsignebassePCan * 17;
lesParametres.vitesse250M3ventilPCan = lesParametres.ventConsignemoyPCan * 17;
lesParametres.vitesse400M3ventilPCan = lesParametres.ventConsignehautePCan * 17;
lesParametres.ventConsignebasseTAGal = 2; // entre 0 (ventilateur vitess min) et 17 PWM ventilateur)
lesParametres.ventConsignemoyTAGal = 10; // Debit équivalent au puit Canadien
lesParametres.ventConsignehauteTAGal = 12; // Debit maximum des tunnels à gales
lesParametres.ventConsignemaxTAGal = 17; // Debit max admissible par le réseau
lesParametres.vitesseMINITAGal = lesParametres.ventConsignebasseTAGal * 17;
lesParametres.vitesse250M3TAGal = lesParametres.ventConsignemoyTAGal * 17;
lesParametres.vitesse400M3TAGal = lesParametres.ventConsignehauteTAGal * 17;
lesParametres.vitesse500M3TAGal = lesParametres.ventConsignemaxTAGal * 17;
EEPROM.put(adresseDesParametres, lesParametres);
EEPROM.put(adresseMotClef, motClef);
}
}
// **********************************************************
void setup() {
Serial.begin(115200);
// LES SORTIES
pinMode(pinVentilPCan, OUTPUT);
digitalWrite(pinVentilPCan, HIGH);
pinMode(pinVentilTAGal, OUTPUT);
digitalWrite(pinVentilTAGal, HIGH);
pinMode(pinvolet1, OUTPUT);
digitalWrite(pinvolet1, HIGH);
pinMode(pinVMC, OUTPUT);
digitalWrite(pinVMC, ARRET);
pinMode(pinLED, OUTPUT);
digitalWrite(pinLED, LOW);
// Volets NF en HIGH (au repos position à privilégier si non utilisé) et NO en LOW
pinMode(pinalimVolets, OUTPUT);
digitalWrite(pinalimVolets, HIGH);
pinMode(pinvolet2, OUTPUT);
digitalWrite(pinvolet2, HIGH);
pinMode(pinvolet3, OUTPUT);
digitalWrite(pinvolet3, HIGH);
pinMode(pinvolet4, OUTPUT);
digitalWrite(pinvolet4, HIGH);
pinMode(pinvolet5, OUTPUT);
digitalWrite(pinvolet5, HIGH);
pinMode(pinvolet6, OUTPUT);
digitalWrite(pinvolet6, HIGH);
pinMode(pinvolet7, OUTPUT);
digitalWrite(pinvolet7, HIGH);
// on définit les consignes en lisant l'EEPROM
etablirValeursParDefaut();
//initialiser the LCD
lcd.begin(16, 2);
lcd.backlight();
/* initialiser l'horloge
if (! rtc.begin()) {
Serial.print(F("RTC introuvable!"));
while (1); // can't go further
}
// si l'horloge n'est pas à jour, décommenter, compiler et uploader. puis commenter et recharger à nouveau le code
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
*/
//on initialise les capteurs de températures en assignant leurs adresses pour créer l'ordre de l'index
sensors.begin();
for (byte i = 0; i < nbCapteursDS18820; i++) {
sensors.setResolution(DS18820Address[i], resolution);
if (!sensors.getAddress(DS18820Address[1], 0)) Serial.println("Unable to find address for Device 0");
if (!sensors.getAddress(DS18820Address[2], 1)) Serial.println("Unable to find address for Device 1");
if (!sensors.getAddress(DS18820Address[3], 2)) Serial.println("Unable to find address for Device 2");
if (!sensors.getAddress(DS18820Address[4], 3)) Serial.println("Unable to find address for Device 4");
}
sensors.setWaitForConversion(false); // on travaillera en asynchrone, on n'attend pas les lectures
sensors.requestTemperatures(); // on lance une demande de lecture qui sera prête plus tard
chronoTemperatures = millis();
// on attend un peu l'initialisation de tous les capteurs
delay(100);
// On affiche tout
forceDisplay();
// On attache une fonction comme callBack en cas de click
BPSTD.attachClick(clickSTANDARD);
BPSTD.attachDoubleClick(clickETE);
// BPCANICULE.attachClick(clickCANICULE);
//BPCANICULE.attachDoubleClick(clickBOOST);
// BPRECHTUN.attachClick(clickRechargeTunnel);
// BPRECHTUN.attachDoubleClick(clickDechargeTunnel);
BPHIVER.attachClick(clickHIVER);
BPHIVER.attachDoubleClick(eteindreTousLesSystemes);
// état initial
STANDARD(MARCHE);
}
void loop() {
//displayTime(); // on vérifie s'il faut mettre à jour l'heure
tickBoutons(); // test des boutons - certains capateurs sont lents, pour la réactivité
displayTemperature(); // on vérifie si on peut mettre à jour les T°
}
Dans mon projet, j'appelle un scenario (HIVER/ETE...ect) en apuyant sur un bouton. Si le scenario n'a pas de sonde de temperature, ca marche mais si c'est le cas, ca ne fonctionne pas comme ca devrait.
De ce que je comprend quand j'appui sur le bouton ca démarre un scenario, celui ci est parcouru 1 fois puis retour au "loop".
Il faudrait pour que mon code marche, que j'arrive à appeler en continu le scenario que j'active tant que je ne change pas de scenario, mais là je ne sais pas comment faire, les argments semblent faire barriere quand je mets les void dans le loop.
Avez vous une solution pour que je puisse avoir les sondes de temperature actives dans le scenatio actif?
En vous remerciant.
Raph.