#include <Time.h>
#include <LiquidCrystal.h>
#include <Wire.h>
#include <DS1307RTC.h>
#include <Arduino.h>
/*
sorties /entrees Arduino
Analog Pin 1 = sonde lm 35 température
Analog Pin 4 = SDA pour ds1307
Analog Pin 5 = SCL pour ds1307
Digital Pin 4 = LCD
Digital Pin 5 = LCD
Digital Pin 6 = LCD
Digital Pin 7 = LCD
Digital Pin 8 = LCD
Digital Pin 9 = LCD
Digital pin 11 = relais/chauffage
Digital pin 12 = relais/neon bleu
Digital pin 13 = relais/neon bleublanc
*/
LiquidCrystal lcd(8, 9, 7, 6, 5, 4);
int sensorPin = 1;
int chauffage = 11;
int bleu = 12;
int bleublanc = 13;
int chauffage_on_temp= 22; //allume chauffage à cette température ( Format HHMM )
int chauffage_off_temp = 27; //éteint le chauffage à cette température( Format HHMM )
int bleu_on_time = 900; //allume les bleu à cette heure ( Format HHMM )
int bleu_off_time = 2200; //éteint les bleu à cette heure ( Format HHMM )
int bleublanc_on_time = 1100; //allume les bleublanc à cette heure ( Format HHMM )
int bleublanc_off_time = 2000; //éteint les bleublenc à cette heure ( Format HHMM )
int minut;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
void setup() {
/* RTC.stop();
RTC.set(DS1307_SEC,00); //réglage secondes
RTC.set(DS1307_MIN,59; //réglage minutes
RTC.set(DS1307_HR,15); //réglage heures
RTC.set(DS1307_DOW,6); //réglage jour de la semaine
RTC.set(DS1307_DATE,11); //réglage date
RTC.set(DS1307_MTH,12); //réglage mois
RTC.set(DS1307_YR,10); //réglage année
RTC.start();
*/
pinMode(chauffage, OUTPUT); // digital pin chauffage
pinMode(bleu, OUTPUT); // digital pin pour bleu
pinMode(bleublanc, OUTPUT); // digital pin pour bleublanc
}
void loop(){
lcd.begin(16, 2);
delay(10);
//Récupérer l'heure du DS1307**********************************************************************************************
heure = RTC.get(DS1307_HR,true);
minut = RTC.get(DS1307_MIN,false);
seconde = RTC.get(DS1307_SEC,false);
date = RTC.get(DS1307_DATE,false);
mois = RTC.get(DS1307_MTH,false);
annee = RTC.get(DS1307_YR,false);
temps_perso = (heure * 100) + minut;
//Récupérer la température du LM35 ***************************************************************************************
int reading = analogRead(sensorPin);
float voltage = reading * 5.0 / 1024;
int temp = voltage * 100 ;
//Affichage température*****************************************************************************
lcd.setCursor(6,0);
lcd.print("Temp : ");
delay(10);
lcd.print(temp);
lcd.println("C");
//Affichage heure******************************************************************************************
lcd.setCursor(0,0);
if (heure < 10)
{
lcd.print("0");
}
lcd.print(RTC.get(DS1307_HR,true));
lcd.print("H");
if (minut < 10)
{
lcd.print("0");
}
lcd.print(RTC.get(DS1307_MIN,false));
lcd.print(" ");
delay(500);
//*****Controles des sorties neon *********
//*****Chauffage*****
if((temp < chauffage_on_temp) || (digitalRead(BP2)==LOW)) {
digitalWrite(chauffage, HIGH);
}
else if (temp > chauffage_off_temp)
{
digitalWrite(chauffage, LOW);
}
//**on off*******bleu*************
if(bleu_on_time > temps_perso || bleu_off_time <= temps_perso)
//if((temp < bleu_on_temp) || (digitalRead(BP1)==LOW)) {
{
lcd.setCursor(0, 1);// mettre le curseur sur la colonne 0 deuxieme ligne
digitalWrite(bleu, LOW);
lcd.print(" BONNE NUIT ");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(bleu, HIGH);
lcd.print(" BONNE JOURNEE ");
delay(2000);
}
//***Affichage****on ***off***bleublanc***
if(bleublanc_on_time > temps_perso || bleublanc_off_time <= temps_perso){
lcd.setCursor (0, 1);
digitalWrite(bleublanc, LOW);
lcd.print(" bleublanc OFF ");
delay(2000);
}
else{
lcd.setCursor (0, 1);
digitalWrite(bleublanc, HIGH);
lcd.print(" bleublanc ON ");
delay(2000);
}
//****Affichage chauffage ********
lcd.setCursor(0,1);
if(digitalRead(chauffage) == HIGH)
{
lcd.println("Chauffage ON ");
}
else
{
lcd.println("Chauffage OFF ");
}
}
Un peu plus de précision stp?
Qu'est ce qui ne marche pas ?
Yan_duino
excuse moi j'ai voulu modifier mon post j'ai du faire une bêtise.
le prg me donne cette erreur
sketch_jul09c.ino: In function 'void loop()':
sketch_jul09c:68: error: 'DS1307_HR' was not declared in this scope
sketch_jul09c:69: error: 'DS1307_MIN' was not declared in this scope
sketch_jul09c:70: error: 'DS1307_SEC' was not declared in this scope
sketch_jul09c:71: error: 'DS1307_DATE' was not declared in this scope
sketch_jul09c:72: error: 'DS1307_MTH' was not declared in this scope
sketch_jul09c:73: error: 'DS1307_YR' was not declared in this scope
sketch_jul09c:112: error: 'BP2' was not declared in this scope
Euh Patoche,
//Récupérer la température du LM35 ***************************************************************************************
sont sur deux lignes ou bien la même?
Si tu vas récupérer les heures et que tu n'as pas besoin des minutes et secondes, passe toi en
S'est sur une ligne et j'aurais aimé les heures et les minutes si possible.
J'ai réussi a trouver un prg qui fonctionne est ce qui il a une âme charitable qui pourrait me le modifier
retirer les 2 BP qui me serve pas
remplacer les 2 sorties pwm par des relais (marche et arrêt heure reglabe dans le prg)
SVP
#include <LiquidCrystal.h>
#include "LCDKeypad.h"
#include <Time.h>
#include <Wire.h>
#include <DS1307RTC.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
/*
Arduino Masterbalby Controller
Analog Pin 1 = Temperature Sensor
Analog Pin 4 = SDA pour ds1307
Analog Pin 5 = SCL pour ds1307
Digital Pin 4 = LCD
Digital Pin 5 = LCD
Digital Pin 6 = LCD
Digital Pin 7 = LCD
Digital Pin 8 = LCD
Digital Pin 9 = LCD
Digital Pin 11 = Relais Chauffage
Digital Pin 12 = PWM moon_light
Digital Pin 13 = PWM day_light
Digital Pin 16 = Bouton poussoir 1 day light
Digital Pin 15 = Bouton poussoir 2 chauffage
*/
LCDKeypad lcd;
int sensorPin = 1;
int chauffage = 11;
int pwm1 = 12;
int pwm2 = 13;
int time;
int BP1=16; //interrupteur Day_light
int BP2=15; //interrupteur Chauffage
int val_up=0;
int val_down=0;
long last_time1 = 0;
long last_time2 = 0;
void setup() {
Serial.begin(9600);
pinMode(chauffage, OUTPUT); // digital pin pour chauffage en sortie
pinMode(BP1, INPUT); //met la broche en entree
digitalWrite(BP1, HIGH) ; // activation du pullup de la broche en entree
pinMode(BP2, INPUT); //met la broche en entree
digitalWrite(BP2, HIGH) ; // activation du pullup de la broche en entree
analogWrite(pwm1,0);
analogWrite(pwm2,0);
lcd.begin(16, 2);
delay(10);
lcd.print("MasterBalby 3.4");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
setSyncProvider(RTC.get);
if(timeStatus()!= timeSet)
lcd.println("Unable to sync");
else
lcd.println("RTC system time ");
delay(2000);
lcd.clear();
delay(10);
}
void loop() {
val_up = (map (minute(), 0, 59, 0, 150));
val_down = (map (minute(), 0, 59, 150, 0));
time = ((hour() * 100) + minute());
//Recuperer la temperature du LM35 ***************************************************************************************
int reading = analogRead(sensorPin);
float voltage = reading * 5.0 / 1024;
int temp = voltage * 100 ;
//Chauffage******************************************************************************
if((temp < 24) || (digitalRead(BP2)==LOW)) {
digitalWrite(chauffage, HIGH);
}
else if (temp > 26)
{
digitalWrite(chauffage, LOW);
}
//****************Day Lights**********************************************************************************
if (hour() == 15) { // entre 15:00:00 et 15:59:59
analogWrite (pwm1, val_up); // allumage progressif
}
else if (hour() == 20) { // entre 20:00:00 et 20:59:59
analogWrite (pwm1, val_down); // extinction progressive
}
else if ((hour() > 15 ) && (hour() < 20)) { // entre 16:00:00 et 19:59:59
analogWrite(pwm1, 150);
}
else if ((((hour() > 0 && hour() < 15)) && (digitalRead(BP1)==LOW)) || (((hour() > 20 && hour() < 24)) && (digitalRead(BP1)==LOW)) || ((hour() == 0) && (digitalRead(BP1)==LOW))){
analogWrite(pwm1, 150);
}
else if ((((hour() > 0 && hour() < 15)) && (digitalRead(BP1)==HIGH)) || (((hour() > 20 && hour() < 24)) && (digitalRead(BP1)==HIGH)) || ((hour() == 0) && (digitalRead(BP1)==HIGH))){
analogWrite(pwm1, 0);
}
//****************Moon Lights****************************************************************************
if ((hour() > 19) && (hour() < 24)) { // de 20:00:00 à 23:59:59
analogWrite(pwm2, 255);
}
else{
analogWrite(pwm2, 0);
}
//Affichage chauffage allumé********************************************************
lcd.setCursor(0,1);
if(digitalRead(chauffage) == HIGH)
{
lcd.println("Chauf ON ");
}
else
{
lcd.println("Chauf OFF ");
}
//Affichage heure***************************************************************************************
if ( millis() >=(last_time1 + 1000))
{
lcd.setCursor(0, 0) ;
lcd.print(hour());
printDigits(minute());
printDigits(second());
last_time1 = millis();
}
//Affichage temperature*****************************************************************************
if ( millis() >=(last_time2 + 5000))
{
lcd.setCursor(9,0);
lcd.print("T:");
lcd.print(temp);
lcd.println("C ");
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}
void printDigits(int digits){
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if(digits < 10)
lcd.print('0');
lcd.print(digits);
}
Bonjour
je ne suis pas sur que ton prog fasse ce que u veux à la finale
j'ai fais les modifs
j'ai changé la lib
ton prg ne se compilait que sous la version 1.05
le prg modifié se compile sous la version 1.64
donc cherche la lib sur le net et installe là
et vérifie que dans le prg que je te passe, les pins du LCD chez moi (4, 5, 6, 7, 8, 9 ) sont ok pour toi
j'ai laissé les lignes du prg d'origine avec des //
ce qui va te permettre de voir ce qu'il fallait faire pour avoir tes modifs
il y a qq lignes qui ne pouvaient pas être adaptées digital soit 0 soit 255 alors que analog est de 0 à 255
en partant d'un code qui se compile et fonctionne il te sera sans doute plus facile de l'adapter à tes besoins
#include "Arduino.h"
#include <LiquidCrystal.h>
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
/*
//#include "LCDKeypad.h"
#include <Time.h>
#include <Wire.h>
#include <DS1307RTC.h>
#if defined(ARDUINO) && ARDUINO >= 100
#else
#include "WProgram.h"
#endif
Arduino Masterbalby Controller
Analog Pin 1 = Temperature Sensor
Analog Pin 4 = SDA pour ds1307
Analog Pin 5 = SCL pour ds1307
Digital Pin 4 = LCD
Digital Pin 5 = LCD
Digital Pin 6 = LCD
Digital Pin 7 = LCD
Digital Pin 8 = LCD
Digital Pin 9 = LCD
Digital Pin 11 = Relais Chauffage
Digital Pin 12 = PWM moon_light
Digital Pin 13 = PWM day_light
Digital Pin 16 = Bouton poussoir 1 day light
Digital Pin 15 = Bouton poussoir 2 chauffage
*/
//LCDKeypad lcd;
int sensorPin = 1;
int chauffage = 11;
//int pwm1 = 12;
//int pwm2 = 13;
int relais_1 = 12;
int relais_2 = 13;
int time;
//int BP1=16; //interrupteur Day_light
//int BP2=15; //interrupteur Chauffage
int val_up = 0;
int val_down = 0;
unsigned long last_time1 = 0;
unsigned long last_time2 = 0;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
void setup() {
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin();
lcd.begin(16,2);
//delay(10);
Serial.begin(9600);
pinMode(chauffage, OUTPUT); // digital pin pour chauffage en sortie
//pinMode(BP1, INPUT); //met la broche en entree
//digitalWrite(BP1, HIGH) ; // activation du pullup de la broche en entree
//pinMode(BP2, INPUT); //met la broche en entree
//digitalWrite(BP2, HIGH) ; // activation du pullup de la broche en entree
pinMode(relais_1, OUTPUT);
pinMode(relais_1, OUTPUT);
digitalWrite(relais_1, 0);
digitalWrite(relais_2, 0);
lcd.print("MasterBalby 3.4");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
if (! rtc.isrunning()) {
Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
else
{
Serial.println("RTC is running!");
DateTime now = rtc.now();
}
delay(2000);
lcd.clear();
delay(10);
}
void printDigits(int digits)
{
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if (digits < 10)
lcd.print('0');
lcd.print(digits);
}
void loop()
{DateTime now = rtc.now();
val_up = (map (now.minute(), 0, 59, 0, 150));
val_down = (map (now.minute(), 0, 59, 150, 0));
time = ((now.hour() * 100) + now.minute());
//Recuperer la temperature du LM35 ***************************************************************************************
int reading = analogRead(sensorPin);
float voltage = reading * 5.0 / 1024;
int temp = voltage * 100 ;
//Chauffage******************************************************************************
//if((temp < 24) || (digitalRead(BP2)==LOW))
if ((temp < 24) )
{
digitalWrite(chauffage, HIGH);
}
else if (temp > 26)
{
digitalWrite(chauffage, LOW);
}
//****************Day Lights**********************************************************************************
if (now.hour() == 15) // entre 15:00:00 et 15:59:59
{
//analogWrite (pwm1, val_up); // allumage progressif
digitalWrite(relais_1, HIGH);
}
else if (now.hour() == 20) // entre 20:00:00 et 20:59:59
{
//analogWrite (pwm1, val_down); // extinction progressive
digitalWrite(relais_1, HIGH);
}
/*
//µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
//cette partie de code ne peut etre changée car les pwm sont à 150 ce qui correspond à une demi puissance de l'eclairage
//hors la transformation des analogwirte en digitalwrite ne permet de faire que du "tout ou rien" donc HIGH ou LOW mais pas de "demi"
else if ((hour() > 15 ) && (hour() < 20)) // entre 16:00:00 et 19:59:59
{
analogWrite(pwm1, 150);
}
else if ((((hour() > 0 && hour() < 15)) && (digitalRead(BP1)==LOW)) || (((hour() > 20 && hour() < 24)) && (digitalRead(BP1)==LOW)) || ((hour() == 0) && (digitalRead(BP1)==LOW)))
{
analogWrite(pwm1, 150);
}
else if ((((hour() > 0 && hour() < 15)) && (digitalRead(BP1)==HIGH)) || (((hour() > 20 && hour() < 24)) && (digitalRead(BP1)==HIGH)) || ((hour() == 0) && (digitalRead(BP1)==HIGH)))
{
analogWrite(pwm1, 0);
}
//µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
*/
//****************Moon Lights****************************************************************************
if ((now.hour() > 19) && (now.hour() < 24)) // de 20:00:00 à 23:59:59
{
//analogWrite(pwm2, 255);
digitalWrite(relais_2, HIGH);
}
else
{
//analogWrite(pwm2, 0);
digitalWrite(relais_2, LOW);
}
//Affichage chauffage allumé********************************************************
lcd.setCursor(0,1);
if (digitalRead(chauffage) == HIGH)
{
lcd.print("Chauf ON ");
}
else
{
lcd.print("Chauf OFF ");
}
//Affichage heure***************************************************************************************
if ( millis() >= (last_time1 + 1000))
{
lcd.setCursor(0, 0) ;
lcd.print(now.hour());
printDigits(now.minute());
printDigits(now.second());
last_time1 = millis();
}
//Affichage temperature*****************************************************************************
if ( millis() >= (last_time2 + 5000))
{
lcd.setCursor(9, 0);
lcd.print("T:");
lcd.print(temp);
lcd.print("C ");
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}
Bonsoir
C'est tout a fait se que je voulais je te remercie beaucoup.
Bonjour
Je te remercie dfgh j'ai encore une petite demande je voudrais mettre une Sonde de température DS18B20 a la place du LM35 peux tu me faire la modif du pgr SVP .
Merci
hello, je n'ai pas de quoi tester
voici ton code qui se compile correctement ( visu avec moniteur en 9600 bauds)
Nota: ne perd pas de vue que le but du forum n'est pas de te faire ton code mais de t'aider à le faire toi meme.
je t'encourage donc à étudier le code ci joint. cela te permettra de pouvoir progressivement faire tes codes toi même.
un lien qui t'aidera pour mettre en place ton capteur et tu y trouvera le code que j'ai intégré au tien
#include "Arduino.h"
#include <LiquidCrystal.h>
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
#include <OneWire.h> // Inclusion de la librairie OneWire
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
//#define BROCHE_ONEWIRE 7 // Broche utilisée pour le bus 1-Wire
//la broche 7 est déjà utilisée par le LCD
#define BROCHE_ONEWIRE 10 // Broche utilisée pour le bus 1-Wire
OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds
float temp;
//LCDKeypad lcd;
int sensorPin = 1;
int chauffage = 11;
//int pwm1 = 12;
//int pwm2 = 13;
int relais_1 = 12;
int relais_2 = 13;
int time;
//int BP1=16; //interrupteur Day_light
//int BP2=15; //interrupteur Chauffage
int val_up = 0;
int val_down = 0;
unsigned long last_time1 = 0;
unsigned long last_time2 = 0;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
void setup() {
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin();
lcd.begin(16, 2);
//delay(10);
Serial.begin(9600);
pinMode(chauffage, OUTPUT); // digital pin pour chauffage en sortie
//pinMode(BP1, INPUT); //met la broche en entree
//digitalWrite(BP1, HIGH) ; // activation du pullup de la broche en entree
//pinMode(BP2, INPUT); //met la broche en entree
//digitalWrite(BP2, HIGH) ; // activation du pullup de la broche en entree
pinMode(relais_1, OUTPUT);
pinMode(relais_1, OUTPUT);
digitalWrite(relais_1, 0);
digitalWrite(relais_2, 0);
lcd.print("MasterBalby 3.4");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
if (! rtc.isrunning()) {
Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
else
{
Serial.println("RTC is running!");
DateTime now = rtc.now();
}
delay(2000);
lcd.clear();
delay(10);
}
void printDigits(int digits)
{
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if (digits < 10)
lcd.print('0');
lcd.print(digits);
}
void loop()
{ DateTime now = rtc.now();
val_up = (map (now.minute(), 0, 59, 0, 150));
val_down = (map (now.minute(), 0, 59, 150, 0));
time = ((now.hour() * 100) + now.minute());
//Recuperer la temperature du DS18B20**************************************************
if (getTemperature(&temp)) {
// Affiche la température
Serial.print("Temperature : ");
Serial.print(temp);
Serial.write(176); // caractère °
Serial.write('C');
Serial.println();
// }
//Chauffage******************************************************************************
//if((temp < 24) || (digitalRead(BP2)==LOW))
if ((temp < 24) )
{
digitalWrite(chauffage, HIGH);
}
else if (temp > 26)
{
digitalWrite(chauffage, LOW);
}
}
//****************Day Lights***************************************************************
if (now.hour() == 15) // entre 15:00:00 et 15:59:59
{
//analogWrite (pwm1, val_up); // allumage progressif
digitalWrite(relais_1, HIGH);
}
else if (now.hour() == 20) // entre 20:00:00 et 20:59:59
{
//analogWrite (pwm1, val_down); // extinction progressive
digitalWrite(relais_1, HIGH);
}
/*
//µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
//cette partie de code ne peut etre changée car les pwm sont à 150 ce qui correspond à une demi puissance de l'eclairage
//hors la transformation des analogwirte en digitalwrite ne permet de faire que du "tout ou rien" donc HIGH ou LOW mais pas de "demi"
else if ((hour() > 15 ) && (hour() < 20)) // entre 16:00:00 et 19:59:59
{
analogWrite(pwm1, 150);
}
else if ((((hour() > 0 && hour() < 15)) && (digitalRead(BP1)==LOW)) || (((hour() > 20 && hour() < 24)) && (digitalRead(BP1)==LOW)) || ((hour() == 0) && (digitalRead(BP1)==LOW)))
{
analogWrite(pwm1, 150);
}
else if ((((hour() > 0 && hour() < 15)) && (digitalRead(BP1)==HIGH)) || (((hour() > 20 && hour() < 24)) && (digitalRead(BP1)==HIGH)) || ((hour() == 0) && (digitalRead(BP1)==HIGH)))
{
analogWrite(pwm1, 0);
}
//µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
*/
//****************Moon Lights****************************************************************************
if ((now.hour() > 19) && (now.hour() < 24)) // de 20:00:00 à 23:59:59
{
//analogWrite(pwm2, 255);
digitalWrite(relais_2, HIGH);
}
else
{
//analogWrite(pwm2, 0);
digitalWrite(relais_2, LOW);
}
//Affichage chauffage allumé********************************************************
lcd.setCursor(0, 1);
if (digitalRead(chauffage) == HIGH)
{
lcd.print("Chauf ON ");
}
else
{
lcd.print("Chauf OFF ");
}
//Affichage heure***************************************************************************************
if ( millis() >= (last_time1 + 1000))
{
lcd.setCursor(0, 0) ;
lcd.print(now.hour());
printDigits(now.minute());
printDigits(now.second());
last_time1 = millis();
}
//Affichage temperature*****************************************************************************
if ( millis() >= (last_time2 + 5000))
{
lcd.setCursor(9, 0);
lcd.print("T:");
lcd.print(temp);
lcd.print("C ");
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}
// Fonction récupérant la température depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp) {
byte data[9], addr[8];
// data : Données lues depuis le scratchpad
// addr : adresse du module 1-Wire détecté
if (!ds.search(addr)) { // Recherche un module 1-Wire
ds.reset_search(); // Réinitialise la recherche de module
return false; // Retourne une erreur
}
if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
return false; // Si le message est corrompu on retourne une erreur
if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
return false; // Si ce n'est pas le cas on retourne une erreur
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0x44, 1); // On lance une prise de mesure de température
delay(800); // Et on attend la fin de la mesure
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0xBE); // On envoie une demande de lecture du scratchpad
for (byte i = 0; i < 9; i++) // On lit le scratchpad
data[i] = ds.read(); // Et on stock les octets reçus
// Calcul de la température en degré Celsius
*temp = ((data[1] << 8) | data[0]) * 0.0625;
// Pas d'erreur
return true;
}
Salut
Merci beaucoup
J'ai déjà modifier le prg , compris plusieurs partie du prg , mais il y a des parties que je doit
encore potasser .
Je te mets le prg que j'ai modifié.
#include "Arduino.h"
#include <LiquidCrystal.h>
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
#include <OneWire.h> // Inclusion de la librairie OneWire
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
//#define BROCHE_ONEWIRE 7 // Broche utilisée pour le bus 1-Wire
//la broche 7 est déjà utilisée par le LCD
#define BROCHE_ONEWIRE 1 // Broche utilisée pour le bus 1-Wire
OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds
float temp;
//LCDKeypad lcd;
int sensorPin = 1;
int chauffage = 2;
int relais_1 = 3;
int relais_2 = 11;
int relais_3 = 12;
int time;
int val_up = 0;
int val_down = 0;
unsigned long last_time1 = 0;
unsigned long last_time2 = 0;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int backLight = 10;
void setup() {
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin();
analogWrite(backLight, 10);
lcd.begin(16, 2);
//delay(10);
Serial.begin(9600);
pinMode(chauffage, OUTPUT); // digital pin pour chauffage en sortie
pinMode(relais_1, OUTPUT);
pinMode(relais_2, OUTPUT);
pinMode(relais_3, OUTPUT);
digitalWrite(relais_1, 0);
digitalWrite(relais_2, 0);
digitalWrite(relais_3, 0);
lcd.print("MasterBalby 3.4");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
if (! rtc.isrunning()) {
Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
else
{
Serial.println("RTC is running!");
DateTime now = rtc.now();
}
delay(2000);
lcd.clear();
delay(10);
}
void printDigits(int digits)
{
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if (digits < 10)
lcd.print('0');
lcd.print(digits);
}
void loop()
{ DateTime now = rtc.now();
val_up = (map (now.minute(), 0, 59, 0, 150));
val_down = (map (now.minute(), 0, 59, 150, 0));
time = ((now.hour() * 100) + now.minute());
//Recuperer la temperature du DS18B20**************************************************
if (getTemperature(&temp)) {
// Affiche la température
Serial.print("Temperature : ");
Serial.print(temp);
Serial.write(176); // caractère °
Serial.write('C');
Serial.println();
// }
//Chauffage******************************************************************************
//if((temp < 24)
if ((temp < 24) )
{
digitalWrite(chauffage, LOW);
}
else if (temp > 26)
{
digitalWrite(chauffage, HIGH);
}
}
//****************Led**********************************************************************************
if ((now.hour() > 13) && (now.hour() < 21))
{
lcd.setCursor (0, 1);
digitalWrite(relais_1, LOW);
lcd.print("Rampe Led-on");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_1, HIGH);
lcd.print("Rampe Led-off ");
delay(2000);
}
//****************Pompe Led****************************************************************************
if ((now.hour() > 13) && (now.hour() < 21))
{
lcd.setCursor (0, 1);
digitalWrite(relais_2, LOW);
lcd.print("Pompe Led-on");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_2, HIGH);
lcd.print("Pompe Led-off");
delay(2000);
}
//****************Pompe filtre****************************************************************************
if ((now.hour() > 13) && (now.hour() < 21))
{
lcd.setCursor (0, 1);
digitalWrite(relais_3, LOW);
lcd.print("Pompe filtre-on");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_3, HIGH);
lcd.print("Pompe filtre-off");
delay(2000);
}
//Affichage chauffage allumé********************************************************
lcd.setCursor(0,1);
if (digitalRead(chauffage) == LOW)
{
lcd.print("Chauffage-on ");
delay(2000);
}
else
{
lcd.print("Chauffage-off ");
delay(2000);
}
//Affichage heure***************************************************************************************
if ( millis() >= (last_time1 + 1000))
{
lcd.setCursor(0, 0) ;
lcd.print(now.hour());
printDigits(now.minute());
// printDigits(now.second());
last_time1 = millis();
}
//Affichage temperature*****************************************************************************
if ( millis() >= (last_time2 + 5000))
{
lcd.setCursor(9, 0);
lcd.print("T:");
lcd.print(temp);
lcd.print((char)223);
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}
// Fonction récupérant la température depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp) {
byte data[9], addr[8];
// data : Données lues depuis le scratchpad
// addr : adresse du module 1-Wire détecté
if (!ds.search(addr)) { // Recherche un module 1-Wire
ds.reset_search(); // Réinitialise la recherche de module
return false; // Retourne une erreur
}
if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
return false; // Si le message est corrompu on retourne une erreur
if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
return false; // Si ce n'est pas le cas on retourne une erreur
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0x44, 1); // On lance une prise de mesure de température
delay(800); // Et on attend la fin de la mesure
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0xBE); // On envoie une demande de lecture du scratchpad
for (byte i = 0; i < 9; i++) // On lit le scratchpad
data[i] = ds.read(); // Et on stock les octets reçus
// Calcul de la température en degré Celsius
*temp = ((data[1] << 8) | data[0]) * 0.0625;
// Pas d'erreur
return true;
}
ok continue et n'hésite pas à mettre des commentaires
attention: les pinoches 0 et 1 sont à garder pour la liaison série
#define BROCHE_ONEWIRE 1 // Broche utilisée pour le bus 1-Wire
Bonjour
Je remercies les personnes qui mon aidé pour se projet , j'ai reçu le
reste de mon matériel tout est connecté .
J'ai une interférence entre le défilement des secondes de la température et de l'affichage des états
des relais.
J'ai l'affichage des secondes qui s'arrêt 2s , 3s puis repart sans altérer le temps réel .
hello
j'ai regardé ton code, je t'y ai fait des remarques
revois ton code, essaies quand même d'y mettre des commentaires.
(je suis persuadé que si tu l'avais fait, tu aurais vu les erreurs que je te signale)
nous verrons après s'il y a des dysfonctionnements.
moi j'aime bien les poissons biens cuits ( tu vas comprendre en lisant mes annotations)
patoche.ino (9.08 KB)
Salut dfgh
J'ai repris le prg supprimé le thermostat qui était un bonus pour moi mais pas absolument nécessaire.
J'ai toujours le problème de décalage des secondes ça fait trois jours complais (vacance) que je suis dessus je sature
#include "Arduino.h"
#include <LiquidCrystal.h>
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
#include <OneWire.h> // Inclusion de la librairie OneWire
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
//#define BROCHE_ONEWIRE 7 // Broche utilisée pour le bus 1-Wire
//la broche 7 est déjà utilisée par le LCD
#define BROCHE_ONEWIRE 10 // Broche utilisée pour le bus 1-Wire
OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds
float temp;
int sensorPin = 10;
int relais_1 = 9;
int relais_2 = 11;
int relais_3 = 12;
int time;
int val_up = 0;
int val_down = 0;
unsigned long last_time1 = 0;
unsigned long last_time2 = 0;
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
void setup() {
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin();
lcd.begin(16, 2);
//delay(10);
Serial.begin(9600);
pinMode(relais_1, OUTPUT);
pinMode(relais_2, OUTPUT);
pinMode(relais_3, OUTPUT);
digitalWrite(relais_1, 1);
digitalWrite(relais_2, 1);
digitalWrite(relais_3, 1);
lcd.print("Aquapatoche");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
if (! rtc.isrunning()) {
Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
// rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
else
{
Serial.println("RTC is running!");
DateTime now = rtc.now();
}
delay(2000);
lcd.clear();
delay(10);
}
void printDigits(int digits)
{
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if (digits < 10)
lcd.print('0');
lcd.print(digits);
}
void loop()
{ DateTime now = rtc.now();
val_up = (map (now.minute(), 0, 59, 0, 150));
val_down = (map (now.minute(), 0, 59, 150, 0));
time = ((now.hour() * 100) + now.minute());
//Recuperer la temperature du DS18B20**************************************************
if (getTemperature(&temp)) {
// Affiche la température
Serial.print("Temperature : ");
Serial.print(temp);
Serial.write(176); // caractère °
Serial.write('C');
Serial.println();
}
//****************Led**********************************************************************************
if ((now.hour() > 12) && (now.hour() < 21))
{
lcd.setCursor (0, 1);
digitalWrite(relais_1, LOW);
lcd.print("Rampe Led-on ");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_1, HIGH);
lcd.print("Rampe Led-off ");
delay(2000);
}
//****************Pompe Led****************************************************************************
if ((now.hour() > 10) && (now.hour() < 22))
{
lcd.setCursor (0, 1);
digitalWrite(relais_2, LOW);
lcd.print("Pompe Led-on ");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_2, HIGH);
lcd.print("Pompe Led-off ");
delay(2000);
}
//****************Led nuit****************************************************************************
if ((now.hour() > 20) && (now.hour() < 23))
{
lcd.setCursor (0, 1);
digitalWrite(relais_3, LOW);
lcd.print("Led nuit-on ");
delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_3, HIGH);
lcd.print("Led nuit-off ");
delay(2000);
}
//Affichage heure***************************************************************************************
if ( millis() >= (last_time1 + 1000))
{
lcd.setCursor(0, 0) ;
lcd.print(now.hour());
printDigits(now.minute());
printDigits(now.second());
last_time1 = millis();
}
//Affichage temperature*****************************************************************************
if ( millis() >= (last_time2 + 5000))
{
lcd.setCursor(8, 0);
lcd.print("T:");
lcd.print(temp);
lcd.print((char)223);
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}
// Fonction récupérant la température depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp) {
byte data[9], addr[8];
// data : Données lues depuis le scratchpad
// addr : adresse du module 1-Wire détecté
if (!ds.search(addr)) { // Recherche un module 1-Wire
ds.reset_search(); // Réinitialise la recherche de module
return false; // Retourne une erreur
}
if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
return false; // Si le message est corrompu on retourne une erreur
if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
return false; // Si ce n'est pas le cas on retourne une erreur
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0x44, 1); // On lance une prise de mesure de température
delay(800); // Et on attend la fin de la mesure
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0xBE); // On envoie une demande de lecture du scratchpad
for (byte i = 0; i < 9; i++) // On lit le scratchpad
data[i] = ds.read(); // Et on stock les octets reçus
// Calcul de la température en degré Celsius
*temp = ((data[1] << 8) | data[0]) * 0.0625;
// Pas d'erreur
return true;
}
Encore modifié mais toujours problème avec mes secondes.
#include "Arduino.h"
#include <LiquidCrystal.h>
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
#include <OneWire.h> // Inclusion de la librairie OneWire
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
//#define BROCHE_ONEWIRE 7 // Broche utilisée pour le bus 1-Wire
//la broche 7 est déjà utilisée par le LCD
#define BROCHE_ONEWIRE 10 // Broche utilisée pour le bus 1-Wire
OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds
float temp;
int sensorPin = 10;
int relais_1 = 9;
int relais_2 = 11;
int relais_3 = 12;
int time;
int val_up = 0;
int val_down = 0;
unsigned long last_time1 = 0;
unsigned long last_time2 = 0;
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
void setup() {
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin();
lcd.begin(16, 2);
//delay(10);
Serial.begin(9600);
// pinMode(chauffage, OUTPUT); // digital pin pour chauffage en sortie
pinMode(relais_1, OUTPUT);
pinMode(relais_2, OUTPUT);
pinMode(relais_3, OUTPUT);
digitalWrite(relais_1, 1);
digitalWrite(relais_2, 1);
digitalWrite(relais_3, 1);
lcd.print("Aquapatoche");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
if (! rtc.isrunning()) {
Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
// rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
else
{
Serial.println("RTC is running!");
DateTime now = rtc.now();
}
delay(2000);
lcd.clear();
delay(10);
}
void printDigits(int digits)
{
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if (digits < 10)
lcd.print('0');
lcd.print(digits);
}
void loop()
{ DateTime now = rtc.now();
val_up = (map (now.minute(), 0, 59, 0, 150));
val_down = (map (now.minute(), 0, 59, 150, 0));
time = ((now.hour() * 100) + now.minute());
//Recuperer la temperature du DS18B20**************************************************
if (getTemperature(&temp)) {
// Affiche la température
Serial.print("Temperature : ");
Serial.print(temp);
Serial.write(176); // caractère °
Serial.write('C');
Serial.println();
}
//****************Led**********************************************************************************
if ((now.hour() > 12) && (now.hour() < 21))
{
digitalWrite(relais_1, LOW);
lcd.setCursor (0, 1);
lcd.print("Led");
delay(15);
}
else
{
digitalWrite(relais_1, HIGH);
lcd.setCursor (0, 1);
lcd.print(" - ");
}
//****************Pompe Led****************************************************************************
if ((now.hour() > 10) && (now.hour() < 22))
{
digitalWrite(relais_2, LOW);
lcd.setCursor (5, 1);
lcd.print("Pompe");
delay(15);
}
else
{
digitalWrite(relais_2, HIGH);
lcd.setCursor (5, 1);
lcd.print(" - ");
}
//****************Led nuit****************************************************************************
if ((now.hour() > 20) && (now.hour() < 23))
{
digitalWrite(relais_3, LOW);
lcd.setCursor (12, 1);
lcd.print("Lune");
delay(15);
}
else
{
digitalWrite(relais_3, HIGH);
lcd.setCursor (12, 1);
lcd.print(" -");
}
//Affichage heure***************************************************************************************
if ( millis() >= (last_time1 + 1000))
{
lcd.setCursor(0, 0) ;
lcd.print(now.hour());
printDigits(now.minute());
printDigits(now.second());
last_time1 = millis();
}
//Affichage temperature*****************************************************************************
if ( millis() >= (last_time2 + 5000))
{
lcd.setCursor(8, 0);
lcd.print("T:");
lcd.print(temp);
lcd.print((char)223);
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}
// Fonction récupérant la température depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp) {
byte data[9], addr[8];
// data : Données lues depuis le scratchpad
// addr : adresse du module 1-Wire détecté
if (!ds.search(addr)) { // Recherche un module 1-Wire
ds.reset_search(); // Réinitialise la recherche de module
return false; // Retourne une erreur
}
if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
return false; // Si le message est corrompu on retourne une erreur
if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
return false; // Si ce n'est pas le cas on retourne une erreur
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0x44, 1); // On lance une prise de mesure de température
delay(800); // Et on attend la fin de la mesure
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0xBE); // On envoie une demande de lecture du scratchpad
for (byte i = 0; i < 9; i++) // On lit le scratchpad
data[i] = ds.read(); // Et on stock les octets reçus
// Calcul de la température en degré Celsius
*temp = ((data[1] << 8) | data[0]) * 0.0625;
// Pas d'erreur
return true;
}
ton decalage est normal
ta boucle Loop est faite de fonctions qui s'exécutent les unes après les autres
si mili est > que vieux mili +1000 tu affiches les secondes
puis tu allumes le chauffage et tu attends 2 secondes
puis tu allumes la lumiere et tu attends 2 secondes
lorsque ta boucle LOOP repasse sur l'affichage des secondes, il s'est passé 4 secondes
la fonction mili lis le timer et te donne les bonnes secondes
mais ton affichage des secondes ne se fait pas toutes les secondes
il faut changer ta boucle LOOP
exemple
LOOP si milli> vieux mili+1000 afficher les secondes
puis avec un switch effectuer chacune des fonctions .
ainsi ta LOOP se fera en moins d'une seconde et ton rafraichissement se fera dans les temps
te switch te permettra d'avoir une stabilité dans l'affichage tout en supprimant les delay(2000)
ce code en exemple
regarde le et reviens avec tes questions
#include "Arduino.h"
#include <LiquidCrystal.h>
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
#include <OneWire.h> // Inclusion de la librairie OneWire
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
#define BROCHE_ONEWIRE 10 //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds
float temp;
//LCDKeypad lcd;
int sensorPin = 1;
int chauffage = 2;
int relais_1 = 3;
int relais_2 = 11;
int relais_3 = 12;
int time;
int val_up = 0;
int val_down = 0;
int tour=0;
unsigned long last_time1 = 0;
unsigned long last_time2 = 0;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
//int backLight = 10;//µµµµµµµ retro eclairage à cabler en dur µµµµµµµµµ
void setup()
{
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
rtc.begin();
//analogWrite(backLight, 10); // à cabler en hard
lcd.begin(16, 2);
delay(10);
Serial.begin(57600);
//********************************************************************************
pinMode(chauffage, OUTPUT); // digital pin pour chauffage en sortie
pinMode(relais_1, OUTPUT);
pinMode(relais_2, OUTPUT);
pinMode(relais_3, OUTPUT);
digitalWrite(relais_1, 0);
digitalWrite(relais_2, 0);
digitalWrite(relais_3, 0);
lcd.print("MasterBalby 3.4");
lcd.setCursor(0, 1) ;
lcd.print("Gestion Aqua");
delay(2000);
lcd.clear();
if (! rtc.isrunning())
{/* // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
while (1)
{
lcd.setCursor (0, 0);
lcd.print(" pendule RTC HS");
delay(300);
lcd.setCursor (0, 1);
lcd.print(" pendule RTC HS");
delay(300);
lcd.setCursor (0, 0);
lcd.print(" ");
delay(300);
lcd.setCursor (0, 1);
lcd.print(" ");
delay(300);
//Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
*/
}
else
{
Serial.println("RTC is running!");
DateTime now = rtc.now();
}
}
void loop(){
if ( millis() >= (last_time1 + 1000)){traitement();}
}
void traitement()
{
last_time1=millis();
DateTime now = rtc.now();
val_up = (map (now.minute(), 0, 59, 0, 150));
val_down = (map (now.minute(), 0, 59, 150, 0));
time = ((now.hour() * 100) + now.minute());
//Affichage heure***********raffraichissement toutes les secondes******************************
lcd.setCursor(0, 0) ;
lcd.print(now.hour());
printDigits(now.minute());
// printDigits(now.second());
//affichage sur moniteur de la temperature***************************
if (getTemperature(&temp)) // Affiche la température
{
Serial.print("Temperature : ");
Serial.print(temp);
Serial.write(176); // caractère °
Serial.write('C');
Serial.println();
}
else
{/*
while (1)
{
lcd.setCursor (0, 0);
lcd.print("temperature HS");
delay(300);
lcd.setCursor (0, 1);
lcd.print("temperature HS");
delay(300);
lcd.setCursor (0, 0);
lcd.print(" ");
delay(300);
lcd.setCursor (0, 1);
lcd.print(" ");
delay(300);
}*/
}
//Chauffage******************************************************************************
//if((temp < 24) //si l'eau est à moins de 24°, on chauffe
if ((temp < 24) )
{
digitalWrite(chauffage, LOW);
}
else if (temp > 26) //si leau est a plus de 26°, on ne chauffe plus
{
digitalWrite(chauffage, HIGH);
}
switch (tour)
{
//***** plage horaire du fonctionnement de la rampe d'eclairage **
case 0:
tour++;
if ((now.hour() > 13) && (now.hour() < 21))
{
digitalWrite(relais_1, LOW);
lcd.setCursor (0, 1);lcd.print("Rampe Led-on");
// delay(2000);
}
else
{
digitalWrite(relais_1, HIGH);
lcd.setCursor (0, 1);lcd.print("Rampe Led-off ");
//delay(2000);
}
//**************** Led temoin de la plage horaire du fonctionnement de la pompe ***
break;
case 1:
tour++;
if ((now.hour() > 13) && (now.hour() < 21))
{
lcd.setCursor (0, 1);
digitalWrite(relais_2, LOW);
lcd.print("Pompe Led-on");
//delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_2, HIGH);
lcd.print("Pompe Led-off");
// delay(2000);
}
//****************Pompe filtre en marche de 13 à 21 h ***************************
break;
case 2:
tour++;
if ((now.hour() > 13) && (now.hour() < 21))
{
lcd.setCursor (0, 1);
digitalWrite(relais_3, LOW);
lcd.print("Pompe filtre-on");
//delay(2000);
}
else
{
lcd.setCursor (0, 1);
digitalWrite(relais_3, HIGH);
lcd.print("Pompe filtre-off");
//delay(2000);
}
//*******************Affichage chauffage allumé********************************************************
break;
case 3:
tour++;
lcd.setCursor(0, 1);
lcd.print(" ");
lcd.setCursor(0, 1);
if (digitalRead(chauffage) == LOW)
{
lcd.print("Chauffe-on ");
//delay(2000);
}
else
{
lcd.print("Chauffe-off ");
//delay(2000);
}
break;
//Affichage temperature****raffraichissement toutes les 5 secondes*****************************
break;
case 4:
tour=0;
//if ( millis() >= (last_time2 + 5000))
{
lcd.setCursor(9, 0);
lcd.print("T:");
lcd.print(temp);
lcd.print((char)223);
last_time2 = millis();
}
//Serial.print(hour()),Serial.print(":"),Serial.print(minute()),Serial.print(":"),Serial.print(second()),Serial.print(" "),Serial.pri
//Serial.print(temps_perso),Serial.println();
//Serial.print(time),Serial.println();
}// fin de boucle LOOP
}
void printDigits(int digits)
{
// utility function for digital clock display: prints preceding colon and leading 0
lcd.print(":");
if (digits < 10)
lcd.print('0');
lcd.print(digits);
}
// Fonction récupérant la température depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d'erreur
boolean getTemperature(float *temp)
{
byte data[9], addr[8];
// data : Données lues depuis le scratchpad
// addr : adresse du module 1-Wire détecté
if (!ds.search(addr))
{ // Recherche un module 1-Wire
ds.reset_search(); // Réinitialise la recherche de module
return false; // Retourne une erreur
}
if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
return false; // Si le message est corrompu on retourne une erreur
if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
return false; // Si ce n'est pas le cas on retourne une erreur
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0x44, 1); // On lance une prise de mesure de température
delay(800); // Et on attend la fin de la mesure
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On sélectionne le DS18B20
ds.write(0xBE); // On envoie une demande de lecture du scratchpad
for (byte i = 0; i < 9; i++) // On lit le scratchpad
data[i] = ds.read(); // Et on stock les octets reçus
// Calcul de la température en degré Celsius
*temp = ((data[1] << 8) | data[0]) * 0.0625;
// Pas d'erreur
return true;
}
Salut
J'ai compris le système de case mais comment est défini l’ordre de défilement c'est aléatoire et pas réguliè ?
toutes les secondes, tu met à jour
_le comptage du temps( pour scrutation toutes les secondes)
_la date et l'heure et tu l'affiches sur le LCD ( donc c'est bien régulier )
_tu regardes la température (si le système est ok, sinon tu affiches l'alarme(il faut libérer cette partie du code)) et tu chauffes si besoin.
puis
_si c'est la 1ère seconde d'un cycle de 5 secondes[/b] si c'est entre 13 et 21h: tu allumes ou pas les rampes de leds ( relais 1)
et tu l'affiches sur le LCD
_si c'est la 2ème seconde d'un cycle de 5 secondes[/b] si c'est entre 13 et 21h: tu allumes ou pas la pompe en marche" ( relais 2) et tu l'affiches sur le LCD
_si c'est la 3ème seconde d'un cycle de 5 secondes[/b] si c'est entre 13 et 21h: tu allumes ou pas la led "pompe filtre on" (relais 3)et tu l'affiches sur le LCD
_si c'est la 4ème seconde d'un cycle de 5 secondes[/b] tu écrit "chauf on ou chauf off
_si c'est la 5ème seconde d'un cycle de 5 secondes[/b] tu écrit la température
1er nota: ce prg fait probablement "presque ce que tu veux" mais c'est à toi de te l'approprier et de le modifier pour arriver à avoir le prg performant que tu veux et à être indépendant.
2eme nota: dans le prg, il y a des lignes qui ne servent pas ( val up, val down ...)
profites de ton étude pour faire du ménage.
3eme nota: j'ai respecté ton ébauche de prg, mais pourquoi ne mettre la pompe que de 13 à 21h?
si tu ne veux pas qu'elle tourne en permanence, 1h toutes les 2 h serait surement mieux pour les occupants.
bon courage, si tu as d'autres questions reviens vers nous