projet aquarium sur Mega 2560 R3

Bonjour à tous .
Je souhaiterais un peu d’aide pour mon projet , je suis débutant sur le codage et l’électronique .
J’ai parcouru pas mal de post , mais ça bloque toujours .
Actuellement mon lcd 16 x2 ne m’affiche que le chiffre 1 sur la première ligne , première case !
le lcd et la ds1307 sont en I2C . Il se peut aussi que se soit un problème de montage électronique !

Voici mon code :

//**********************GESTION 16 RELAIS**********************
//Date : Janvier 2016
//*************************************************************
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "RTClib.h"
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
#define shield_8_relayPin_1;
#define shield_8_relayPin_2;

char lcdbuf[LCD_WIDTH];
uint8_t DsHour , DsMin , DsSec;
LiquidCrystal_I2C lcd(0x27,16,2);// verifier les pins
RTC_DS1307 rtc;
int minute;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
int lastSeconde;

//Configuration des Pins
const int k1 = 22;
const int k2 = 23;
const int k3 = 24;
const int k4 = 25;
const int k5 = 26;
const int k6 = 27;
const int k7 = 28;
const int k8 = 29;//pompe_de_remonte
const int k9 = 30;
const int k10 = 31;
const int k11 = 32;
const int k12 = 33;
const int k13 = 34;
const int k14 = 35;
const int k15 = 36;
const int k16 = 37;//pompe_evaporation

//configuration des pin de rails led
int bleus_rouges = k1;// relais k1
int jaune_1 = k2;// relais k2 
int jaune_2 = k3;// relais k3
int jaune_3 = k4;// relais k4 
int jaune_4 = k5;// relais k5 
int blanc_bleu_1 = k6;// relais k6
int blanc_bleu_2 = k7;// relais k7
int blanc_bleu_3 = k9;// relais k9
int blanc_bleu_4 = k10;// relais k10
int blanc_bleu_5 = k11;// relais k11
int blanc_bleu_6 = k12;// relais k12
int blanc_bleu_7 = k13;// relais K13 
int blanc_bleu_8 = k14;// relais k14
int blanc_bleu_9 = k15;// relais k15

/*
bleus_rouges on:8h00 off:22h00
jaune_1 on:8h05 off:21h55
jaune_2 on:8h10 off:21h50
jaune_3 on:8h15 off:21h45
jaune_4 on:8h20 off:21h40
blanc_bleu_1 on:8h25 off 21h35
blanc_bleu_2 on:8h30 off:21h30
blanc_bleu_3 on:8h35 off:21h25       ligne 100
blanc_bleu_4 on:8h40 off:21h20
blanc_bleu_5 on:8h45 off:21h15
blanc_bleu-6 on:8h50 off:21h10
blanc_bleu_7 on:8h55 off:21h05
blanc_bleu_8 on:9h00 off:21h00
blanc_bleu_9 on:9h05 off:20h55

*/
//Configuration des heures allumage/extinction (format HHMM) 
int bleus_rouges_on_time = 800; //allume bleus_rouges
int bleus_rouges_off_time = 2200; //éteint bleus_rouges
int jaune_1_on_time = 805; //allume  jaune_1
int jaune_1_off_time = 2155; //éteint  jaune_1
int jaune_2_on_time = 810; //allume  jaune_2
int jaune_2_off_time = 2150; //éteint jaune_2
int jaune_3_on_time = 815; //allume jaune_3
int jaune_3_off_time = 2145; //éteint jaune_3
int jaune_4_on_time = 820; //allume jaune_4
int jaune_4_off_time = 2140; //éteint jaune_4
int blanc_bleu_1_on_time = 825; //allume blanc_bleu_1
int blanc_bleu_1_off_time = 2135; //éteint blanc_bleu_1
int blanc_bleu_2_on_time = 830; //allume  blanc_bleu_2
int blanc_bleu_2_off_time = 2130; //éteint  blanc_bleu_2
int blanc_bleu_3_on_time = 835; //allume blanc_bleu_3
int blanc_bleu_3_off_time = 2025; //éteint blanc_bleu_3
int blanc_bleu_4_on_time = 840; //allume blanc_bleu_4 
int blanc_bleu_4_off_time = 2120; //éteint blanc_bleu_4
int blanc_bleu_5_on_time = 845; //allume blanc_bleu_5
int blanc_bleu_5_off_time = 2115; //éteint blanc_bleu_5
int blanc_bleu_6_on_time = 850; //allume blanc_bleu_6
int blanc_bleu_6_off_time = 2110; //éteint blanc_bleu_6
int blanc_bleu_7_on_time = 855; //allume blanc bleu_7
int blanc_bleu_7_off_time = 2105; //éteint blanc bleu_7
int blanc_bleu_8_on_time = 900; //allume blanc bleu_8
int blanc_bleu_8_off_time = 2100; //éteint blanc bleu_8
int blanc_bleu_9_on_time = 905; //allume blanc bleu_9
int blanc_bleu_9_off_time = 2055; //éteint blanc bleu_9

//Configuration des niveaux d eau
int analogPin_0 = A0; //connect water sensor to analog interface 0 
int val_0 = 0; //define the initial value of variable ‘val_0’ as 0
int data_0 = 0; //define the initial value of variable ‘data_0’ as 0
int analogPin_1 = A1; //connect water sensor to analog interface 0 
int val_1 = 0; //define the initial value of variable ‘val_1’ as 0
int data_1 = 0; //define the initial value of variable ‘data_1’ as 0  

void setup(void) {
  Serial.begin(9600);
  pinMode(k8, OUTPUT);// digital pin pour  pompe_de_remontee
  pinMode(k16, OUTPUT);// digital pin pour pompe_evaporation
  pinMode(bleus_rouges, OUTPUT); // digital pin pour bleus et rouges
  pinMode(jaune_1, OUTPUT);// digital pin pour jaune_1
  pinMode(jaune_2, OUTPUT);// digital pin pour jaune_2
  pinMode(jaune_3, OUTPUT);// digital pin pour jaune_3
  pinMode(jaune_4, OUTPUT);// digital pin pour jaune_4
  pinMode(blanc_bleu_1, OUTPUT);// digital pin pour blanc_bleu_1
  pinMode(blanc_bleu_2, OUTPUT);// digital pin pour blanc_bleu_2
  pinMode(blanc_bleu_3, OUTPUT);// digital pin pour blanc_bleu_3
  pinMode(blanc_bleu_4, OUTPUT);// digital pin pour blanc_bleu_4 
  pinMode(blanc_bleu_5, OUTPUT);// digital pin pour blanc_bleu_5
  pinMode(blanc_bleu_6, OUTPUT);// digital pin pour blanc_bleu_6       ligne 150
  pinMode(blanc_bleu_7, OUTPUT);// digital pin pour blanc_bleu_7
  pinMode(blanc_bleu_8, OUTPUT);// digital pin pour blanc_bleu_8
  pinMode(blanc_bleu_9, OUTPUT);// digital pin pour blanc_bleu_9  
  Serial.begin(57600);
#ifdef AVR
  Wire.begin();
#else
  Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino
#endif
  rtc.begin();
  lcd.begin(16,2);
  lcd.backlight();
  // Section de mise à l'heure automatique basée sur l'heure de compilation
  // pour une mise à jour de l'heure, ajouter 2 slashs de commentaire devant if, Serial et }
  if (! rtc.isrunning()) {
    Serial.println("Module RTC non initialise!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  // une fois la mise à l'heure faite, retirer les 2 slashs devant if, Serial et }, recompiler et renvoyer le prog.
  // Fin de la section de mise à l'heure automatique
  lcd.clear();
  GetTimeFromRTC();
}
void GetTimeFromRTC() {
  DateTime now = rtc.now();
  DsHour = now.hour();
  DsMin = now.minute();
  DsSec = now.second();
  temps_perso = (DsHour * 100) + DsMin ;
}
boolean inplage(int t, int debut, int fin) {
  //renvoie true si temp est dans la plage horraire de debut à fin
  if (debut < fin)  return (t >= debut && t < fin);
  //sinon debut est > fin par ex marche de 23:00 à 05:00
  return (t >= debut || t < fin);
}

!

Merci .

Voici la suite du code :

void setup(void) {
  Serial.begin(9600);
  pinMode(k8, OUTPUT);// digital pin pour  pompe_de_remontee
  pinMode(k16, OUTPUT);// digital pin pour pompe_evaporation
  pinMode(bleus_rouges, OUTPUT); // digital pin pour bleus et rouges
  pinMode(jaune_1, OUTPUT);// digital pin pour jaune_1
  pinMode(jaune_2, OUTPUT);// digital pin pour jaune_2
  pinMode(jaune_3, OUTPUT);// digital pin pour jaune_3
  pinMode(jaune_4, OUTPUT);// digital pin pour jaune_4
  pinMode(blanc_bleu_1, OUTPUT);// digital pin pour blanc_bleu_1
  pinMode(blanc_bleu_2, OUTPUT);// digital pin pour blanc_bleu_2
  pinMode(blanc_bleu_3, OUTPUT);// digital pin pour blanc_bleu_3
  pinMode(blanc_bleu_4, OUTPUT);// digital pin pour blanc_bleu_4 
  pinMode(blanc_bleu_5, OUTPUT);// digital pin pour blanc_bleu_5
  pinMode(blanc_bleu_6, OUTPUT);// digital pin pour blanc_bleu_6       ligne 150
  pinMode(blanc_bleu_7, OUTPUT);// digital pin pour blanc_bleu_7
  pinMode(blanc_bleu_8, OUTPUT);// digital pin pour blanc_bleu_8
  pinMode(blanc_bleu_9, OUTPUT);// digital pin pour blanc_bleu_9  
  Serial.begin(57600);
#ifdef AVR
  Wire.begin();
#else
  Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino
#endif
  rtc.begin();
  lcd.begin(16,2);
  lcd.backlight();
  // Section de mise à l'heure automatique basée sur l'heure de compilation
  // pour une mise à jour de l'heure, ajouter 2 slashs de commentaire devant if, Serial et }
  if (! rtc.isrunning()) {
    Serial.println("Module RTC non initialise!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  // une fois la mise à l'heure faite, retirer les 2 slashs devant if, Serial et }, recompiler et renvoyer le prog.
  // Fin de la section de mise à l'heure automatique
  lcd.clear();
  GetTimeFromRTC();
}
void GetTimeFromRTC() {
  DateTime now = rtc.now();
  DsHour = now.hour();
  DsMin = now.minute();
  DsSec = now.second();
  temps_perso = (DsHour * 100) + DsMin ;
}
boolean inplage(int t, int debut, int fin) {
  //renvoie true si temp est dans la plage horraire de debut à fin
  if (debut < fin)  return (t >= debut && t < fin);
  //sinon debut est > fin par ex marche de 23:00 à 05:00
  return (t >= debut || t < fin);
}
void loop(void) {
  // gestion contacts _water_sensors
  {
  val_0 = analogRead(analogPin_0); //read and assign analog value to variable ’val’
  if(val_0<700){ //decide whether variable ‘val_0’ is under 700 digitalWrite(k8,HIGH); //turn on k8 when variable ‘val_0’ is over 700
  }
  else{
  digitalWrite(k8,LOW); //turn off  k8 when variable ‘val’ is over 700
  }
  data_0 = val_0; //variable ’val_0’ assigns value to variable ‘data_0’
  Serial.println(data_0); //print variable ‘data_0’ by Serial.print
   {
  val_1 = analogRead(analogPin_1); //read and assign analog value to variable ’val_1’
  if(val_1>700){ //decide whether variable ‘val_1’ is over 700 digitalWrite(k16,HIGH); //turn on k16 when variable ‘val_1’ is over 700
  }
  else{
  digitalWrite(k16,LOW); //turn off k16 when variable ‘val_1’ is under 700
  }
  data_1 = val_1; //variable ’va_l’ assigns value to variable ‘data_1’
  Serial.println(data_1); //print variable ‘data’ by Serial.print
  delay(100);
}

  // Gestion de l'affichage
  lcd.clear();
  lcd.setCursor(0, 0);
  sprintf(lcdbuf, "%.2d:%.2d:%.2d", DsHour, DsMin, DsSec);
  lcd.print(lcdbuf);

  // Gestion de l'heure                             ligne 200
  GetTimeFromRTC();
  Serial.print("Heure RTC : ");
  Serial.println(lcdbuf);
  delay(1000);
  // Leds bleus_rouges on/off k1
  if ( inplage(temps_perso, bleus_rouges_on_time, bleus_rouges_off_time) )  {
    digitalWrite(bleus_rouges, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("bleus_rouges ON  ");
  }  else  {
    digitalWrite(bleus_rouges, LOW);
    lcd.setCursor(1, 1);
    Serial.print("bleus_rouges OFF ");
  }
  // Leds jaune_1 on/off k2
  if ( inplage(temps_perso, jaune_1_on_time, jaune_1_off_time) )  {
    digitalWrite(jaune_1, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("jaune_1 ON  ");
  }  else  {
    digitalWrite(jaune_1, LOW);
    lcd.setCursor(1, 1);
    Serial.print("jaune_1 OFF ");
  }
  // Leds jaune_2 on/off k3
  if ( inplage(temps_perso, jaune_2_on_time, jaune_2_off_time) )  {
    digitalWrite( jaune_2, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("jaune_2 ON  ");
  }  else  {
    digitalWrite(jaune_2, LOW);
    lcd.setCursor(1, 1);
    Serial.print("jaune_2 OFF ");
  }
  // Leds jaune_3 on/off k4
  if ( inplage(temps_perso, jaune_3_on_time, jaune_3_off_time) )  {
    digitalWrite(jaune_3, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("jaune_3 ON  ");
  }  else  {
    digitalWrite(jaune_3, LOW);
    lcd.setCursor(1, 1);
    Serial.print("jaune_3 OFF ");
  } 
  // Leds jaune_4 on/off k5
  if ( inplage(temps_perso, jaune_3_on_time, jaune_3_off_time) )  {
    digitalWrite(jaune_3, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("jaune_3 ON  ");
  }  else  {
    digitalWrite(jaune_3, LOW);
    lcd.setCursor(1, 1);
    Serial.print("jaune_3 OFF ");
  } 
   // blanc_bleu_1 on/off k6
  if ( inplage(temps_perso, blanc_bleu_1_on_time, blanc_bleu_1_off_time) )  {
    digitalWrite(blanc_bleu_1, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_1 ON  ");
  }  else  {          
    digitalWrite(blanc_bleu_1, LOW);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_1 OFF ");
  }
  // blanc_bleu_2 on/off k7
  if ( inplage(temps_perso, blanc_bleu_2_on_time, blanc_bleu_2_off_time) )  {
    digitalWrite(blanc_bleu_2, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_2 ON  ");
  }  else  {
    digitalWrite(blanc_bleu_2, LOW);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_2 OFF ");
  }
  // Leds blanc_bleu_3 on/off k9
  if ( inplage(temps_perso, blanc_bleu_3_on_time, blanc_bleu_3_off_time) )   {
    digitalWrite(blanc_bleu_3, HIGH);
    lcd.setCursor(1, 1);
    Serial.print(" blanc_bleu_3 ON");
   }  else  {
    digitalWrite(blanc_bleu_3, LOW);
    lcd.setCursor(1, 1);
    Serial.print(" blanc_bleu_3 OFF ");
  }
  // Leds blanc_bleu_4 on/off k10
  if ( inplage(temps_perso, blanc_bleu_4_on_time, blanc_bleu_4_off_time) )   {
    digitalWrite(blanc_bleu_4, HIGH);
    lcd.setCursor(1, 1);
    Serial.print(" blanc_bleu_4 ON  ");
  }  else  {
    digitalWrite(blanc_bleu_4, LOW);
    lcd.setCursor(1, 1);
    Serial.print(" blanc_bleu_4 OFF ");
  }
  // Leds blanc_bleu_5 on/off k11
  if ( inplage(temps_perso, blanc_bleu_5_on_time, blanc_bleu_5_off_time) )   {
    digitalWrite(blanc_bleu_5, HIGH);
    lcd.setCursor(1, 1);
    Serial.print(" blanc_bleu_5 ON  ");
  }   else  {
    digitalWrite(blanc_bleu_5, LOW);
    lcd.setCursor(1, 1);
    Serial.print(" blanc_bleu_5 OFF ");
  }
  // Leds blanc_bleu_6 on/off k12
  if( inplage(temps_perso, blanc_bleu_6_on_time, blanc_bleu_6_off_time) )  {
    digitalWrite( blanc_bleu_6 , HIGH);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_6 ON  ");
  }  else  {                                      // ligne 300
    digitalWrite(blanc_bleu_6, LOW);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_6 OFF ");
  }
  // Leds blanc_bleu_7 on/off k13
  if ( inplage(temps_perso, blanc_bleu_7_on_time, blanc_bleu_7_off_time) )  {
    digitalWrite(blanc_bleu_7, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_7 ON  ");
   }  else  {
    digitalWrite(blanc_bleu_7, LOW);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_7 OFF ");
  } 
   // blanc_bleu_8 on/off k14
   if ( inplage(temps_perso, blanc_bleu_8_on_time, blanc_bleu_8_off_time) )  {
    digitalWrite(blanc_bleu_8, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_8 ON  ");
    }  else  {
    digitalWrite(blanc_bleu_8, LOW);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_8 OFF ");
   }
   // blanc_bleu_9 on/off k15
   if ( inplage(temps_perso, blanc_bleu_9_on_time, blanc_bleu_9_off_time) )  {
    digitalWrite(blanc_bleu_9, HIGH);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_9 ON  ");
    }  else  { 
    digitalWrite(blanc_bleu_9, LOW);
    lcd.setCursor(1, 1);
    Serial.print("blanc_bleu_9 OFF ");  
  }
 }
}
// Fin du programme

Cela fait 3 mois et demi que je suis dessus , enfin pas tout le temps non plus ,
je bricole l’aquarium en même temps .
Merci , et bonne soirée .

hello
j’ai commencé à regarder ton code.
j’ai fait qq modif de code et de commentaires
maintenant, il doit t’afficher l’heure au moniteur et pendant 1 seconde sur le lcd

j’ai tronqué la fin pour facilité de post
voyons déjà le résultat

edit: pour la suite du code, tu confond serial.print et lcd.print

//**********************GESTION 16 RELAIS**********************
//Date : Janvier 2016
//*************************************************************
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "RTClib.h"
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
#define shield_8_relayPin_1;
#define shield_8_relayPin_2;

char lcdbuf[LCD_WIDTH];
uint8_t DsHour , DsMin , DsSec;
LiquidCrystal_I2C lcd(0x27, 16, 2); // verifier les pins
RTC_DS1307 rtc;
int minute;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
int lastSeconde;

//Configuration des Pins
const int k1 = 22;
const int k2 = 23;
const int k3 = 24;
const int k4 = 25;
const int k5 = 26;
const int k6 = 27;
const int k7 = 28;
const int pompe_remontee = 29;//pompe_de_remonte
const int k9 = 30;
const int k10 = 31;
const int k11 = 32;
const int k12 = 33;
const int k13 = 34;
const int k14 = 35;
const int k15 = 36;
const int pompe_evaporation = 37;//pompe_evaporation

//configuration des pin de rails led
int bleus_rouges = k1;// relais k1
int jaune_1 = k2;// relais k2
int jaune_2 = k3;// relais k3
int jaune_3 = k4;// relais k4
int jaune_4 = k5;// relais k5
int blanc_bleu_1 = k6;// relais k6
int blanc_bleu_2 = k7;// relais k7
int blanc_bleu_3 = k9;// relais k9
int blanc_bleu_4 = k10;// relais k10
int blanc_bleu_5 = k11;// relais k11
int blanc_bleu_6 = k12;// relais k12
int blanc_bleu_7 = k13;// relais K13
int blanc_bleu_8 = k14;// relais k14
int blanc_bleu_9 = k15;// relais k15


//Configuration des heures allumage/extinction (format HHMM)
int bleus_rouges_on_time = 800; //allume bleus_rouges
int bleus_rouges_off_time = 2200; //éteint bleus_rouges
int jaune_1_on_time = 805; //allume  jaune_1
int jaune_1_off_time = 2155; //éteint  jaune_1
int jaune_2_on_time = 810; //allume  jaune_2
int jaune_2_off_time = 2150; //éteint jaune_2
int jaune_3_on_time = 815; //allume jaune_3
int jaune_3_off_time = 2145; //éteint jaune_3
int jaune_4_on_time = 820; //allume jaune_4
int jaune_4_off_time = 2140; //éteint jaune_4
int blanc_bleu_1_on_time = 825; //allume blanc_bleu_1
int blanc_bleu_1_off_time = 2135; //éteint blanc_bleu_1
int blanc_bleu_2_on_time = 830; //allume  blanc_bleu_2
int blanc_bleu_2_off_time = 2130; //éteint  blanc_bleu_2
int blanc_bleu_3_on_time = 835; //allume blanc_bleu_3
int blanc_bleu_3_off_time = 2025; //éteint blanc_bleu_3
int blanc_bleu_4_on_time = 840; //allume blanc_bleu_4
int blanc_bleu_4_off_time = 2120; //éteint blanc_bleu_4
int blanc_bleu_5_on_time = 845; //allume blanc_bleu_5
int blanc_bleu_5_off_time = 2115; //éteint blanc_bleu_5
int blanc_bleu_6_on_time = 850; //allume blanc_bleu_6
int blanc_bleu_6_off_time = 2110; //éteint blanc_bleu_6
int blanc_bleu_7_on_time = 855; //allume blanc bleu_7
int blanc_bleu_7_off_time = 2105; //éteint blanc bleu_7
int blanc_bleu_8_on_time = 900; //allume blanc bleu_8
int blanc_bleu_8_off_time = 2100; //éteint blanc bleu_8
int blanc_bleu_9_on_time = 905; //allume blanc bleu_9
int blanc_bleu_9_off_time = 2055; //éteint blanc bleu_9

//Configuration des niveaux d eau
int analogPin_0 = A0; //connect water sensor to analog interface 0
int val_0 = 0; //define the initial value of variable 'val_0' as 0
int data_0 = 0; //define the initial value of variable 'data_0' as 0
int analogPin_1 = A1; //connect water sensor to analog interface 0
int val_1 = 0; //define the initial value of variable 'val_1' as 0
int data_1 = 0; //define the initial value of variable 'data_1' as 0



void setup(void) {
  Serial.begin(9600);//*******************il faut choisr 9600 ou*******************************
  pinMode(pompe_remontee, OUTPUT);// digital pin pour  pompe_de_remontee
  pinMode(pompe_evaporation, OUTPUT);// digital pin pour pompe_evaporation
  pinMode(bleus_rouges, OUTPUT); // digital pin pour bleus et rouges
  pinMode(jaune_1, OUTPUT);// digital pin pour jaune_1
  pinMode(jaune_2, OUTPUT);// digital pin pour jaune_2
  pinMode(jaune_3, OUTPUT);// digital pin pour jaune_3
  pinMode(jaune_4, OUTPUT);// digital pin pour jaune_4
  pinMode(blanc_bleu_1, OUTPUT);// digital pin pour blanc_bleu_1
  pinMode(blanc_bleu_2, OUTPUT);// digital pin pour blanc_bleu_2
  pinMode(blanc_bleu_3, OUTPUT);// digital pin pour blanc_bleu_3
  pinMode(blanc_bleu_4, OUTPUT);// digital pin pour blanc_bleu_4
  pinMode(blanc_bleu_5, OUTPUT);// digital pin pour blanc_bleu_5
  pinMode(blanc_bleu_6, OUTPUT);// digital pin pour blanc_bleu_6       ligne 150
  pinMode(blanc_bleu_7, OUTPUT);// digital pin pour blanc_bleu_7
  pinMode(blanc_bleu_8, OUTPUT);// digital pin pour blanc_bleu_8
  pinMode(blanc_bleu_9, OUTPUT);// digital pin pour blanc_bleu_9
  Serial.begin(57600);//*******************il faut choisr 57600*******************************
#ifdef AVR
  Wire.begin();
#else
  Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino
#endif
  rtc.begin();
  lcd.begin();
  lcd.backlight();
  // Section de mise à l'heure automatique basée sur l'heure de compilation
  // pour une mise à jour de l'heure, ajouter 2 slashs de commentaire devant if, Serial et }
  if (! rtc.isrunning())
  {
    Serial.println("Module RTC non initialise!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  else
  {
    Serial.println("Module RTC initialise!");
  }
  // une fois la mise à l'heure faite, retirer les 2 slashs devant if, Serial et }, recompiler et renvoyer le prog.
  // Fin de la section de mise à l'heure automatique
  //lcd.clear();//l'initialisation par lcd.begin a déjà fait un clear
  GetTimeFromRTC();
}
void GetTimeFromRTC() {
  DateTime now = rtc.now();
  DsHour = now.hour();
  DsMin = now.minute();
  DsSec = now.second();
  temps_perso = (DsHour * 100) + DsMin ;
}
boolean inplage(int t, int debut, int fin)
{
  //renvoie true si temp est dans la plage horraire de debut à fin
  if (debut < fin)  return (t >= debut && t < fin);
  //sinon debut est > fin par ex marche de 23:00 à 05:00
  return (t >= debut || t < fin);
}
void loop(void)
{   //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ_gestion niveau d'eau_µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
    val_0 = analogRead(analogPin_0); 
    if (val_0 < 700)                       //si niveau trop bas
    {
     digitalWrite(pompe_remontee,HIGH);    //mettre la pompe de remontée en marche
    }
    else                                   //sinon, si niveau ok
    {
      digitalWrite(pompe_remontee, LOW);   //stopper la pompe de remontée
    }
    data_0 = val_0;                        //mémorisation de la valeur du niveau d'eau
    Serial.println(data_0);                //affichage sur moniteur et non sur LCD
    
    //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ_gestion evaporation de l'eau_µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
    val_1 = analogRead(analogPin_1); 
    if (val_1 > 700)                        //si retour évaporation >700
    { 
     digitalWrite(pompe_evaporation,HIGH);  //mettre la pompe d'évaporation en marche
    }
    else                                    //sinon, si niveau ok
    {
     digitalWrite(pompe_evaporation, LOW);  //stopper la pompe d'évaporation
    }
      data_1 = val_1;                       //mémorisation de la valeur d'évaporation
      Serial.println(data_1);               //affichage sur moniteur et non sur LCD
      delay(100);                           //tempo 100 millisecondes
    
    //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ_Gestion de l'affichage_de l'heure_µµµµµµµµµµµµµµµµµµµµµµµµµµµµ
    GetTimeFromRTC();
    lcd.clear();
    lcd.print(DsHour);lcd.print(":");lcd.print(DsMin);lcd.print(":");lcd.print(DsSec);                           
    sprintf(lcdbuf, "%.2d:%.2d:%.2d", DsHour, DsMin, DsSec);
    Serial.print("Heure RTC : ");
    Serial.println(lcdbuf);
    delay(1000);                               //tempo 1 seconde
    
    // Leds bleus_rouges on/off k1
    if ( inplage(temps_perso, bleus_rouges_on_time, bleus_rouges_off_time) ) //  est_il entre 8h et 22 h ?
    {
      digitalWrite(bleus_rouges, HIGH);
      lcd.setCursor(1, 1);
      lcd.print("bleus_rouges ON  ");
    }  else  {
      digitalWrite(bleus_rouges, LOW);
      lcd.setCursor(1, 1);
       lcd.print("bleus_rouges OFF ");
    }}

Bonsoir , merci " dfgh " pour votre aide .
J'ai fait les modifications suivant vos corrections du code .
Voici ce que ça donne :
affichage moniteur date et heure ok
affichage LCD I2C (pour 22H48mn30sec) = 2:4:3 (fixe en 1ere ligne 1ere case)
(pour bleus_rouges_on/off) = b (clignotant sur ligne du bas en 2eme case)

//**********************GCESTION 16 RELAIS**********************
//Date : Janvier 2016
//*************************************************************
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "RTClib.h"
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
#define shield_8_relayPin_1;
#define shield_8_relayPin_2;

char lcdbuf[LCD_WIDTH];
uint8_t DsHour, DsMin, DsSec;

LiquidCrystal_I2C lcd(0x27,16,2);// verifier les pins
RTC_DS1307 rtc;
int minute;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
int lastSeconde;

//Configuration des Pins
const int k1 = 22;
const int k2 = 23;
const int k3 = 24;
const int k4 = 25;
const int k5 = 26;
const int k6 = 27;
const int k7 = 28;
const int pompe_remontee = 29;// k8
const int k9 = 30;
const int k10 = 31;
const int k11 = 32;
const int k12 = 33;
const int k13 = 34;
const int k14 = 35;
const int k15 = 36;
const int pompe_evaporation = 37;// k16

//configuration des pin de rails led
int bleus_rouges = k1;// relais k1
int jaune_1 = k2;// relais k2 
int jaune_2 = k3;// relais k3
int jaune_3 = k4;// relais k4 
int jaune_4 = k5;// relais k5 
int blanc_bleu_1 = k6;// relais k6
int blanc_bleu_2 = k7;// relais k7
int blanc_bleu_3 = k9;// relais k9
int blanc_bleu_4 = k10;// relais k10
int blanc_bleu_5 = k11;// relais k11
int blanc_bleu_6 = k12;// relais k12
int blanc_bleu_7 = k13;// relais K13 
int blanc_bleu_8 = k14;// relais k14
int blanc_bleu_9 = k15;// relais k15


//Configuration des heures allumage/extinction (format HHMM) 
int bleus_rouges_on_time = 800; //allume bleus_rouges
int bleus_rouges_off_time = 2200; //éteint bleus_rouges
int jaune_1_on_time = 805; //allume  jaune_1
int jaune_1_off_time = 2155; //éteint  jaune_1
 //...   ...   ... suppression de ligne de code pour gain de place sur le post
int blanc_bleu_9_on_time = 905; //allume blanc bleu_9
int blanc_bleu_9_off_time = 2055; //éteint blanc bleu_9

//Configuration des niveaux d eau
int analogPin_0 = A0; //connect water sensor to analog interface 0 
int val_0 = 0; //define the initial value of variable ‘val_0’ as 0
int data_0 = 0; //define the initial value of variable ‘data_0’ as 0
int analogPin_1 = A1; //connect water sensor to analog interface 0 
int val_1 = 0; //define the initial value of variable ‘val_1’ as 0
int data_1 = 0; //define the initial value of variable ‘data_1’ as 0  

void setup(void) {
  Serial.begin(57600);
  pinMode(pompe_remontee, OUTPUT);// digital pin pour  pompe_de_remontee
  pinMode(pompe_evaporation, OUTPUT);// digital pin pour pompe_evaporation
  pinMode(bleus_rouges, OUTPUT); // digital pin pour bleus et rouges
  pinMode(jaune_1, OUTPUT);// digital pin pour jaune_1
    //...   ...   ... suppression de ligne de code pour gain de place sur le post
  pinMode(blanc_bleu_9, OUTPUT);// digital pin pour blanc_bleu_9  
 
#ifdef AVR
  Wire.begin();
#else
  Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino
#endif
  rtc.begin();
  lcd.begin(0x27, 16, 2);
  lcd.backlight();
  // Section de mise à l'heure automatique basée sur l'heure de compilation
  // pour une mise à jour de l'heure, ajouter 2 slashs de commentaire devant if, Serial et }
  if (! rtc.isrunning()){
    Serial.println("Module RTC non initialise!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  } else
  {
    Serial.println("Module RTC initialise!");
  }
  // une fois la mise à l'heure faite, retirer les 2 slashs devant if, Serial et }, recompiler et renvoyer le prog.
  // Fin de la section de mise à l'heure automatique
  GetTimeFromRTC();
}
void GetTimeFromRTC() {
  DateTime now = rtc.now();
  DsHour = now.hour();
  DsMin = now.minute();
  DsSec = now.second();
  temps_perso = (DsHour * 100) + DsMin ;
}
boolean inplage(int t, int debut, int fin) {
  //renvoie true si temp est dans la plage horraire de debut à fin
  if (debut < fin)  return (t >= debut && t < fin);
  //sinon debut est > fin par ex marche de 8:00 à 22:00
  return (t >= debut || t < fin);
}
void loop(void) {
  //************************* gestion niveau d'eau ********************************
  
  val_0 = analogRead(analogPin_0); 
  if(val_0<700)                                   // si niveau d'eau du filtre trop bas
  {  
    digitalWrite(pompe_remontee,HIGH);     //  arrêter la pompe de remontée (contact fermé au repos sur k8)
  }
   else                                           // sinon, si niveau ok
   {
  digitalWrite(pompe_remontee,LOW);        // mettre la pompe de remontée en route
  }
  data_0 = val_0;                                 // mémorisation de la valeur du niveau d'eau
  Serial.println(data_0);                         // affichage sur moniteur et non sur LCD
  
  //************************* gestion évaporation d'eau ****************************
  
  val_1 = analogRead(analogPin_1); 
  if(val_1>700)                                    // si niveau d'eau du bac trop bas
  { 
    digitalWrite(pompe_evaporation,HIGH);  // mettre la pompe d'évaporation en route  (contact ouvert  au repos sur k16)
  }
  else                                            // sinon , si niveau du bac ok
  {
  digitalWrite(pompe_evaporation,LOW);     // arreter la pompe d'evaporation
  }
  data_1 = val_1;                                // mémorisation de la valeur d'evaporation
  Serial.println(data_1);                        // affichage sur moniteur et non sur LCD
  delay(100);                                    // tempo 100 millisecondes

  //***************************** Gestion de l'affichage de l'heure ***********************************
  
  GetTimeFromRTC();
  lcd.clear();
   DateTime now = rtc.now();
   Serial.print(now.year(), DEC);Serial.print('/');
   Serial.print(now.month(), DEC); Serial.print('/');
   Serial.print(now.day(), DEC);Serial.print(" (");

  
  lcd.print(DsHour);lcd.print(":");lcd.print(DsMin);lcd.print(":");lcd.print(DsSec);
  sprintf(lcdbuf, "%.2d:%.2d:%.2d", DsHour, DsMin, DsSec);
  Serial.print("Heure RTC : ");
  Serial.println(lcdbuf);
  delay(1000);                        // tempo 1 seconde
  lcd.print(lcdbuf);

  // Leds bleus_rouges on/off k1
  if ( inplage(temps_perso, bleus_rouges_on_time, bleus_rouges_off_time))  
  {
    digitalWrite(bleus_rouges, HIGH);
    lcd.setCursor(1, 1);
    lcd.print("bleus_rouges ON  ");
  }  else  {
    digitalWrite(bleus_rouges, LOW);
    lcd.setCursor(1, 1);
    lcd.print("bleus_rouges OFF ");
  }
  // Leds jaune_1 on/off k2
  if ( inplage(temps_perso, jaune_1_on_time, jaune_1_off_time)) 
  {
    digitalWrite(jaune_1, HIGH);
    lcd.setCursor(1, 1);
    lcd.print("jaune_1 ON  ");
  }  else  {
    digitalWrite(jaune_1, LOW);
    lcd.setCursor(1, 1);
    lcd.print("jaune_1 OFF ");
  }

Là je fait de nouvelles recherches pour essayer de comprendre et améliorer le code ,
j'ai déja essayé d'autre modification pour le lcd.print, mais ça fait des conflit avec uint8_t ou encore avec char lcdbuf .J'ai ajouté la date sur le moniteur ça écrit cela : 2016/1/9 (Heure RTC : 23:23:35

J'aurais aussi plusieurs questions à poser ultérieurement (pour faire une usine à gaz ! )
Donc je retourne à mes recherches ^^. Encore merci pour votre aide .
Bonne soirée à tous !

hello
je ne comprends pas pourquoi ton afficheur ne prend que les dizaines de tes chiffres

voici un code qui fonctionne chez moi, mais
je n’ai pas de 2560. j’ai un UNO ( ce n’est pas cela qui gène. ( juste moi pour les initialisations des pattounes du micro))
je n’ai pas d’afficheur 16x2 en i2C, seulement un LCD 16x2 installé en données de 4 bits.

ton prg est énormément raccourci (par des boucles), mais pour le faire, j’ai modifié les initialisation de tes sorties.

en résumé, tu dois remettre en conformité ton cablage selon les initialisations du prg.
et lire les commentaires en fin de ligne.

//**********************GESTION 16 RELAIS**********************
//Date : Janvier 2016
//*************************************************************
#include <Arduino.h>
#include <Wire.h>
//#include <LiquidCrystal_I2C.h>
#include <LiquidCrystal.h>
#include "RTClib.h"
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
#define shield_8_relayPin_1;
#define shield_8_relayPin_2;
static LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
char lcdbuf[LCD_WIDTH];
uint8_t hr , mn , sc;
//LiquidCrystal_I2C lcd(0x27, 16, 2); // verifier les pins
RTC_DS1307 rtc;
//µµµµµµµµµµµµµµµµµµµµµµµµ_les déclarations des variables_µµµµµµµµµµµµµµµµµ
int vccrtc = A3;           //pour alim ds1307
int gndrtc = A2;           //pour alim ds1307
int temps_perso;           //heure courante sur 3 chiffres
int bleus_rouges = 22;     // relais k1
int jaune_1 = 23;          // relais k2
int jaune_2 = 24;          // relais k3
int jaune_3 = 25;          // relais k4
int jaune_4 = 26;          // relais k5
int blanc_bleu_1 = 27;     // relais k6
int blanc_bleu_2 = 28;     // relais k7
int blanc_bleu_3 = 29;     // relais k8
int blanc_bleu_4 = 30;     // relais k9
int blanc_bleu_5 = 31;     // relais k10
int blanc_bleu_6 = 32;     // relais k11
int blanc_bleu_7 = 33;     // relais K12
int blanc_bleu_8 = 34;     // relais k13
int blanc_bleu_9 = 35;     // relais k14
int blanc_bleu_10 = 36;    // relais k15
int pompe_remontee = 37;   // pompe_de_remonte
int pompe_evaporation = 38;// pompe_evaporation

const int lever_soleil = 800;//c'est ici qu'il faut modifier le début de l'éclairage
const int coucher_soleil = 2200;//c'est ici qu'il faut modifier la fin de l'éclairage

//µµµµµµµµµµµµµµµµµµ_Configuration pour le niveau de l'eau et l'évaporation_µµµµµµµµµµµµµµµµµµ
int analogPin_0 = A0;     //connect water sensor to analog interface 0
int val_0 = 0;            //define the initial value of variable 'val_0' as 0
int data_0 = 0;           //define the initial value of variable 'data_0' as 0
int analogPin_1 = A1;     //connect water sensor to analog interface 0
int val_1 = 0;            //define the initial value of variable 'val_1' as 0
int data_1 = 0;           //define the initial value of variable 'data_1' as 0



void setup(void)
{
  pinMode(vccrtc, OUTPUT);     // alim vcc rtc
  pinMode(gndrtc, OUTPUT);     // alim gnd rtc.
  digitalWrite(vccrtc, HIGH);
  digitalWrite(gndrtc, LOW);
  Serial.begin(9600);//*******************il faut choisr 9600 ou*******************************

  for (int f = 22; f < 39; f++)
  {
    pinMode(f, OUTPUT);
  }

#ifdef AVR
  Wire.begin();
#else
  Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino
#endif
  rtc.begin();
  // lcd.begin();
  lcd.begin(16, 2);
  //lcd.backlight();

  if (! rtc.isrunning())
  {
    Serial.println("Module RTC non initialise!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  else
  {
    Serial.println("Module RTC initialise!");
  }
  GetTimeFromRTC();
}
void GetTimeFromRTC()
{
  DateTime now = rtc.now();
  hr = now.hour();
  mn = now.minute();
  sc = now.second();
  temps_perso = (hr * 100) + mn ;
}

void loop(void)
{
  gestion_niveau_eau();
  gestion_evaporation();
  gestion_eclairage();
}

void gestion_niveau_eau()
{ //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ_gestion niveau d'eau_µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
  val_0 = analogRead(analogPin_0);
  if (val_0 < 700)                       //si niveau trop bas
  {
    digitalWrite(pompe_remontee, HIGH);   //mettre la pompe de remontée en marche
  }
  else                                   //sinon, si niveau ok
  {
    digitalWrite(pompe_remontee, LOW);   //stopper la pompe de remontée
  }
  data_0 = val_0;                        //mémorisation de la valeur du niveau d'eau
  Serial.print("niveau       :  "); Serial.println(data_0); //affichage sur moniteur et non sur LCD
}

void gestion_evaporation()
{ //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ_gestion evaporation de l'eau_µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
  val_1 = analogRead(analogPin_1);
  if (val_1 > 700)                        //si retour évaporation >700
  {
    digitalWrite(pompe_evaporation, HIGH); //mettre la pompe d'évaporation en marche
  }
  else                                    //sinon, si niveau ok
  {
    digitalWrite(pompe_evaporation, LOW);  //stopper la pompe d'évaporation
  }
  data_1 = val_1;                       //mémorisation de la valeur d'évaporation
  Serial.print("evaporation  :  "); Serial.println(data_1); //affichage sur moniteur
}

void affichage_heure()
{
  //µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ_Gestion de l'affichage_de l'heure_µµµµµµµµµµµµµµµµµµµµµµµµµµµµ
  Serial.println(" "); delay (500);
  GetTimeFromRTC();
  lcd.clear();
  lcd.print(hr); lcd.print(":"); lcd.print(mn); lcd.print(":"); lcd.print(sc);
  sprintf(lcdbuf, "%.2d:%.2d:%.2d", hr, mn, sc);
  Serial.print("Heure RTC    : ");
  Serial.print(lcdbuf); Serial.flush();
  Serial.print("   temps_perso : "); Serial.println(temps_perso);
}

void gestion_eclairage()
{ //µµµµµµµµµ_Gestion de l'éclairage_avec heure lever  et heure coucher du soleil µµµµµµµµµµµµµ
  for (int f = 1; f < 16; f++)
  {
    affichage_heure();
    //temps_perso=840;//ligne pour test de la boucle for
    if  ((temps_perso > lever_soleil) & (temps_perso < (coucher_soleil)))
    {
      if ((temps_perso > (lever_soleil + (f * 5))) & (temps_perso < (coucher_soleil - (f * 5))))
      {
        lcd.setCursor(0, 1);
        lcd.print("rampe " ); lcd.print(f); lcd.print(" ON" );
        digitalWrite(f + 21, HIGH);
        Serial.print("lampes "); Serial.print(f); Serial.println(" ON");
      }
      else
      {
        lcd.setCursor(0, 1);
        lcd.print("rampe " ); lcd.print(f); lcd.print(" OFF" );
        digitalWrite(f + 21, LOW);
        Serial.print("lampes "); Serial.print(f); Serial.println(" OFF");
      }
    } Serial.flush();
  }
}

Bonjour , et encore merci " dfgh " pour votre aide .
Je fait les modifications suivant votre nouveau code .
Pour les problèmes d'affichage , je crois que ça vient des résistances de tirage (pull-up), je n'en ai pas mis (je pensais que celles intégrées à la méga seraient suffisantes pour le I2C) , apparemment ça n'est pas le cas donc je vais commander ce qu'il faut (par contre je ne sais pas si se sont des 1/4 , 1/2 ou 1 watt en 4,7 kilo ohms).

Bonjour,

P=UI ou P=U²/R

P=5x5/4700=0.005W

Donc tu vois que la 1/4W suffit largement, mais si tu n'en a pas tu peux prendre 1/2W ou même 1W

Bonjour ,et merci kamill pour votre réponse rapide .