Problème programme

Bonjour a tous!

Cela fait quelques temps que je survol le monde de l'arduino et j'avoue que je n'y comprend pas grand chose...
Après plusieurs essais, je me suis résigné à viser plus bas...

Je compte utiliser l'arduino à l'aide de relai afin d'en faire un "bête" programmateur afin de gérer allumage extinction de plusieurs éléments.
J'utilise donc un module RTC, un arduinno mega, et une carte 8 relais.
J'ai repris un programme en libre accès que j'ai légèrement modifié afin qu'il gère 8 relais, mais je bloque quand même...

Actuellement, ça ne fonctionne pas correctement, les différents éléments s'allument (selon l'heure prévu: si je lance le programme a 15h, tous les éléments qui doivent fonctionner à 15h sont allumés. Les autres non, bref, normal) lors du lancement du programme, mais ne s'allument pas par la suite (ça ne redémarre pas le lendemain par exemple), Ça s’éteint bien a l'heure prévue. Et l'un des éléments (bleus dans le code) fonctionne sans souci jusqu’à ce qu'il soit le seul allumé, dès lors il s'allume et s'éteint a intervalle irrégulier (de l'ordre des 5 à 15 secondes)

//**********************GESTION DES 8 RELAIS***************
//Date : Juin 2014
//*************************************************************
#include <LiquidCrystal.h>
#include <Wire.h>
#include <RTClib.h>
#define LCD_WIDTH 20
#define LCD_HEIGHT 4
char lcdbuf[LCD_WIDTH]; 
uint8_t DsHour ,DsMin ,DsSec;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
RTC_DS1307 rtc;	
int minute;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
int lastSeconde;
//Configuration des Pin du relai
int refuge = A0;
int bleus = A1;
int blancBleu = A2;
int blanc = A3;
int divers = A4;
int osmo = A5 ;
int pomposmo = A6 ;
int RAH= A7 ;
//Configuration des heures allumage/extinction (format HHMM )
int refuge_on_time = 1300; //allume refuge
int refuge_off_time = 2130; //éteint refuge
int bleus_on_time = 0730; //allume bleu 
int bleus_off_time = 2230; //éteint bleu
int blancBleu_on_time = 0830; //allume blanc bleu
int blancBleu_off_time = 2130; //éteint blanc bleu
int blanc_on_time = 0930; //allume blanc
int blanc_off_time = 2030; //éteint blanc
int divers_on_time = 0900; //allume divers
int divers_off_time = 2100; //éteint divers
int osmo_on_time = 1230; //allume module osmo 
int osmo_off_time = 1245; //éteint module osmo
int pomposmo_on_time = 1230; //allume pomposmo
int pomposmo_off_time = 1245; //éteint pomposmo
int RAH_on_time = 1200; //allume RAH
int RAH_off_time = 1215; //éteint RAH

void setup(void)
{
 Serial.begin(9600);
 pinMode(refuge, OUTPUT); // digital pin pour refuge
 pinMode(bleus, OUTPUT); // digital pin pour bleus
 pinMode(blancBleu, OUTPUT); // digital pin pour blanc bleu
 pinMode(blanc, OUTPUT); // digital pin pour blanc
pinMode(divers, OUTPUT); // digital pin pour divers
 pinMode(osmo, OUTPUT); // digital pin pour module osmo
 pinMode(pomposmo, OUTPUT); // digital pin pour pomposmo
 pinMode(RAH, OUTPUT); // digital pin pour RAH
 Wire.begin(); 
 rtc.begin();
 lcd.begin(LCD_WIDTH, LCD_HEIGHT,1); 
// 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(__DATE__, __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(); 
}
void GetTimeFromRTC()
{ DateTime now = rtc.now(); 
 DsHour = now.hour();
 DsMin = now.minute();
 DsSec = now.second();
 temps_perso = (DsHour * 100) + DsMin ;
}
void loop(void) 
{
// Leds refuge on/off k1
 if( (temps_perso >= refuge_on_time) && (temps_perso < refuge_off_time) ) 
{
 digitalWrite(refuge, HIGH);
 lcd.setCursor(0, 3);
 lcd.print("refuge");
 delay(15);
}
 else 
{
 digitalWrite(refuge, LOW); 
 lcd.setCursor(0, 3);
 lcd.print(" ");
}
// Leds bleus on/off k2
 if( (temps_perso >= bleus_on_time) && (temps_perso < bleus_off_time) ) 
{
 digitalWrite(bleus, HIGH);
 lcd.setCursor(6, 3);
 lcd.print("bleus");
 delay(15);
}
 else 
{
 digitalWrite(bleus, LOW); 
 lcd.setCursor(6, 3);
 lcd.print(" ");
}
// Leds blancBleu on/off k3
 if( (temps_perso >= blancBleu_on_time) && (temps_perso < blancBleu_off_time) ) 
{
 digitalWrite(blancBleu, HIGH);
 lcd.setCursor(11, 3);
 lcd.print("blancBleu");
 delay(15);
}
 else
{
 digitalWrite(blancBleu, LOW); 
 lcd.setCursor(11, 3);
 lcd.print(" ");
}
// Leds blanc on/off k1
 if( (temps_perso >= blanc_on_time) && (temps_perso < blanc_off_time) ) 
{
 digitalWrite(blanc, HIGH);
 lcd.setCursor(0, 3);
 lcd.print("blanc");
 delay(15);
}
 else 
{
 digitalWrite(blanc, LOW); 
 lcd.setCursor(0, 3);
 lcd.print(" ");
}
// Leds divers on/off k1
 if( (temps_perso >= divers_on_time) && (temps_perso < divers_off_time) ) 
{
 digitalWrite(divers, HIGH);
 lcd.setCursor(0, 3);
 lcd.print("divers");
 delay(15);
}
 else 
{
 digitalWrite(divers, LOW); 
 lcd.setCursor(0, 3);
 lcd.print(" ");
}
// osmo on/off k1
 if( (temps_perso >= osmo_on_time) && (temps_perso < osmo_off_time) ) 
{
 digitalWrite(osmo, HIGH);
 lcd.setCursor(0, 3);
 lcd.print("osmo");
 delay(15);
}
 else 
{
 digitalWrite(osmo, LOW); 
 lcd.setCursor(0, 3);
 lcd.print(" ");
}
// pomposmo on/off k1
 if( (temps_perso >= pomposmo_on_time) && (pomposmo < refuge_off_time) ) 
{
 digitalWrite(pomposmo, HIGH);
 lcd.setCursor(0, 3);
 lcd.print("pomposmo");
 delay(15);
}
 else 
{
 digitalWrite(pomposmo, LOW); 
 lcd.setCursor(0, 3);
 lcd.print(" ");
}

// RAH on/off k4
 if( (temps_perso >= RAH _on_time) && (RAH < blanc_off_time) ) 
{
 digitalWrite(RAH , HIGH);
 lcd.setCursor(16, 3);
 lcd.print("RAH");
 delay(15);
}
 else 
{
 digitalWrite(RAH, LOW); 
 lcd.setCursor(16, 3);
 lcd.print(" ");}

// Gestion de l'heure
 GetTimeFromRTC(); 
 Serial.print("Heure RTC : ");
 Serial.println(lcdbuf);
 delay(900);
// Gestion de l'affichage 
 lcd.clear();
 lcd.setCursor(1, 0) ;
 lcd.print("RedSeaReef Arduino");
 lcd.setCursor(6,1);
 sprintf(lcdbuf, "%.2d:%.2d:%.2d",DsHour,DsMin,DsSec);
 lcd.print(lcdbuf);
 lcd.setCursor(0, 2) ;
 lcd.print("Circuit en fonction:");
}
// Fin du programme

Bref, tout cela pour demander si quelqu'un avait le courage de relire le code et de me dire si oui ou non il est censé fonctionner (et s'allumer tous les jours),
A défaut, savoir si il existe d'autres programmes pour faire "programmateurs".

Al3an:
Bref, tout cela pour demander si quelqu'un avait le courage de relire le code et de me dire si oui ou non il est censé fonctionner

Ben non pas le courage (moi grosse feignasse) mais un conseil.

Place des Serial.print() dans ton code pour :

  1. vérifier que cela passe bien où tu veux --> cad que les conditions if quelque chose sont correctes.
  2. afficher les valeurs essentielles pour vérifier qu'elles sont cohérentes avec ce que tu attends

Applique les points 1 et 2 sur des petits bouts de programme : découpe et met au point. Le plus confortable c'est quand le code de la fonction à tester tient sur un seul écran.

Le code n'est pas censé être très complexe... C'est long surtout parce qu'il y a 8 relais, donc 8 copier/coller ...
Je vais tenter avec les serial.print.
Je l'avais déja fait sur d'autre codes effectivement c'est pratique!

Dans le setup je ferais un GetTimeFromRTC(); après le lcd.clear pour initialiser la variable temps_perso avant la première boucle du main (car tu n'apelles GetTimeFromRTC(); dans ton main qu'après les tests IF).

Dans l'initialisation des int, tu peux enlever les "0" non significatif par exemple 0730 => 730. Perso ça m'a fait des erreurs de compilation.

Dans tes tests tu as 1 minute de battement car il est par exemple 7h30 entre 7h30m00s et 7h30m59s donc cela pourrait poser un problème dans ton application?
De plus tes tests vont être valides pendant 1min (tu rentres dans tes boucles IF durant 1 min), donc ton programme risque de ralentir...

Tu peux enlever les delay(15); qui ne servent qu'à ralentir l’exécution du programme.

Je ferais un temps_perso exprimé avec les secondes pour les comparaisons et bien voir si tes tests IF fonctionnent en mettant un petit serial.print de debug.

:wink:

Tout d'abord, Merci des réponses apportées... Je n'y comprend pas grand chose...
Donc j'exécute les indications données...
Autant la partie câblage, j'aime beaucoup autant tout ce qui touche a la programmation c'est une vrai source de perte de patience...

John: Merci. Je ne comprend pas tout ce que tu m'as indiqué mais je vais tester.
Effectivement j'ai retiré les "0" non significatif, il y avait des erreurs de compilation...Ca m'a pris un temps fou avant de trouver...

Je viens de retirer les " delay(15); " je ne sais pas a quoi ça sert. Je fais confiance.
J'ai aussi mis le " GetTimeFromRTC(); après le lcd.clear " Pareil, j'ai pas tout compris... C'est pour que l'arduino récupère l'heure avant de commencer les programme c'est bien ça?

Pour :
"Dans tes tests tu as 1 minute de battement car il est par exemple 7h30 entre 7h30m00s et 7h30m59s donc cela pourrait poser un problème dans ton application?
De plus tes tests vont être valides pendant 1min (tu rentres dans tes boucles IF durant 1 min), donc ton programme risque de ralentir...

[...]

Je ferais un temps_perso exprimé avec les secondes pour les comparaisons et bien voir si tes tests IF fonctionnent en mettant un petit serial.print de debug."

Alors là... J'ai vraiment rien compris... Je n'ai fais que très peu de C, c'est du chinois pour moi!
Comment puis-je exprimer un temps_perso en secondes? C'est tout a fait possible que cela soit source de souci puisque je cherche a avoir une continuité.

C'est un programme que j'ai trouvé sur le net et que j'ai adapté pour qu'il gère 8 relais. Je l'ai "bidouillé" le moins possible, n'ayant pas les connaissances pour. Il est censé fonctionner avec un écran LCD, ce que je n'ai pas sur mon installation.

J'ai aussi remplacé les " lcd.print " par des " Serial.print"

Salut Al3an

En relisant ton programme je pense qu'il doit fonctionner.... j'ai juste un petit doute sur les broches sur lesquelles tu branches tes relais ... ce sont toutes des broches en Ax ... donc entrées analogiques .... alors que tu souchaites utiliser des sorties digitales (numérotées de 1 à xx) : Sur une UNO, si je fais int pin = A0; ... la valeur de pin est 14 (les 13 premieres sont digitales, les 6 suivantes analogiques A0 à A5) ... a vérifier si ce n'est pas fait

Si ton programme reste ainsi (juste une gestion des relais sur des plages horaires), tu n'as pas besoins d'une réactivité à la microseconde ... je laisserai le temps_perso en minutes comme tu l'as fait (de toute façon tu entres dans les boucles if tant que ton temps_perso est dans la plage horaire).

Dans le loop, je ferai :
la lecture de l'horloge en premier ...
puis les 8 tests ...
(puis une pause de 30 s optionnelle ... et sans doute inutile)

PS : delay(15) fait faire une pause de 15ms au programme ... peut être dans le programme d'origine pour ne pas commuter tous les relais quasi instantanément (gros appel de courant) ... tu peux les enlever ou pas ... ca ne changera pas grand chose

Ok.
J'avais suivi pour les entrée analogiques plutôt que digitales.
J'ai déjà tenter de changer de sorties mais ça n'a rien fait.
Je referai un test en les changeant au besoin (demain si ça fait toujours stroboscope chez moi...)
J'ai pu vérifier sur le net (avec la marge d'erreur qu'on lui connait!), il me semble d'ailleurs sur ce forum (mais je peux faire erreur, la mémoire, hein...) que ça n'était pas gênant.
On verra si cela ne fonctionne pas pour demain...

Pour le moment les tests que j'ai effectués semblent concluants, ça s'allume a l'heure désirée, mais je ne souhaite pas trop m'avancer, hier c'était pareil... On verra demain...

Pareil, j'inverserai horloge et test demain selon les résultats des tests de ce soir.
Les delay, sont déja enlevés. Sans conséquences...

Allez, tests ce soir et réponse ou re-questions, demain!

En tout cas merci a vous!

Tu utilises qu'elle carte ? Et sur quelles sortie as-tu branché tes relais ?

J'utilise une carte mega.
Les sorties utilisées sont les analogiques A0, A1, A2 jusque A7.

Il vaut mieux te mettre sur des sorties digitales D1 etc

Pour ton temps en seconde tu fais simplement:

void GetTimeFromRTC()
{ DateTime now = rtc.now(); 
 DsHour = now.hour();
 DsMin = now.minute();
 DsSec = now.second();
 temps_perso = (DsHour * 10000) + DsMin * 100 + DsSec ;
}

et temps perso sera en sec: par emple à 22h54m54s temps_perso vaudra 225454

Donc tu changes tes valeurs de référence:

//Configuration des heures allumage/extinction (format HHMM )
int refuge_on_time = 1300; //allume refuge

devient:

//Configuration des heures allumage/extinction (format HHMM )
int refuge_on_time = 130000; //allume refuge

etc...

Le délais de 15ms ne sert à rien (en plus 15ms c'est invisible pour l'humain) car tu ne commute et décommute pas sans arret donc enlève les. ça ne changera strictement rien.

"Dans tes tests tu as 1 minute de battement car il est par exemple 7h30 entre 7h30m00s et 7h30m59s donc cela pourrait poser un problème dans ton application?
De plus tes tests vont être valides pendant 1min (tu rentres dans tes boucles IF durant 1 min), donc ton programme risque de ralentir...

Pour ca je peux pas mieux t'expliquer: tu sais qu'il y a 60s dans une minute donc quand tu fais un test sur des minutes ce test sera vrai pendant 59 secondes (le temps entre la minute que tu test et la minute suivante).
Avec des serial.print dans ton programme tu t'en rendra compte rapidement...

:wink:

Bon les tests en situation réelle ne sont pas concluants...
Le relai 1 ne s'allume pas et le relai 2 ne s'éteint pas a l'heure dite (donc respectivement " refuge " et " bleus ".)
J'ai débrancher l'arduino et rebranché, le relai 2 (bleus) s'est éteint mais le relai 1 (refuge) ne s'est pas allumé pour autant.
Branchement en direct provisoire pour la nuit...

Ce matin, le relai 1 (refuge) a été rebranché mais ne s'est pas éteint a l'heure dite. Le relai 2 (bleu) ne s'est pas allumé.
J'ai relancé le programme et s'est rentré dans l'ordre...

J'avoue que je commence a me demander si ce ne serait pas un souci de faux contact ou de branchement...
Si je dois brancher mon ordi tous les matins, autant que je mette des interrupteurs... Pas au point mon truc...

Merci John, je vais tenter cela après avoir fait les recommandations de B83s.
Puis je referai des tests et vous redirais ce qu'il en est... En tout cas merci de l’investissement et de l'aide apporté a un grand néophyte dans mon genre...

@john_lenfr : vu comme il a programmé ses tests ... ils sont valables sur toute la plage de temps qu'il a programmée if (temps_perso >= mini && temps_perso < maxi) { //on.... } {//off} ... donc passer temps_perso en seconde ne changera rien du tout ... ca marchera très bien comme il fait actuellement.

Sur la carte mega ... tu peux utliser les voie digitales 22 à 49 ... elles n'ont pas d'autres fonctions (ni voies séries, ni SPI ...) qui risqueraient d'interférer par la suite.

Les plages actullement programmées sont bien, mais si un jour tu veux les changer, il faudra toujours que le début soit inférieur à la fin ... tu ne pourras par mettre en marche à 23:00 et eteindre à 05:00 sans changer le test correspondant
si début < fin alors le test devient if (temps > debut et temps < fin) {//on} {//off}
si début > fin alors le test devient if (temps > debut ou temps < fin) {//on} {//off}

une petite fonction serait bien utile pour eviter ces pièges

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);
}

//dans le loop .. tu n'as plus à te soucier des valeurs de debut et fin
if inplage(temps_perso, debutxx, finxxx) {
    //alumer
} {
   //eteindre
}

Vous allez très vite!
J'ai pas encore pris le temps de modifier tout cela...

Par contre, B83s, concernant l'heure de début supérieur a celle de fin, c'est le cas! Le relai 1 (refuge) s'allume plus tard qu'il ne s'éteint... Serait-ce possible que cela fasse "planté" complètement le programme? ou suffisamment pour qu'il cesse tout activité?

Car ce relai doit s'allumer a 22h30 alors que le relai bleu s'éteint a cette heure là et c'est justement a ce moment que ça bloque et qu'il ne se passe plus rien du tout... Bleu reste allumé, refuge reste éteint.

Et ça ne redémarre pas le lendemain a moins de relancer le programme...

Bon, je vais tenter ton astuce!

Bonjour,

je n'ai pas essayé mais je doute que ce code compile sans erreurs :

int bleus_on_time = 0730; //allume bleu 
int bleus_off_time = 2230; //éteint bleu
int blancBleu_on_time = 0830; //allume blanc bleu
int blancBleu_off_time = 2130; //éteint blanc bleu
int blanc_on_time = 0930; //allume blanc
int blanc_off_time = 2030; //éteint blanc
int divers_on_time = 0900; //allume divers

En C un nombre qui commence par zéro est considéré comme étant un nombre octal (ie exprimé en base 8 ). Ce qui signifie que 0730 = 0x1d8 = 472.
De plus, puisqu'on est en base 8, les seuls symboles autorisés sont 0..7, donc 0830, 0930 et 0900 sont invalides et doivent générer une erreur à la compilation.
Le zéro initial est peut-être agréable à l’œil, mais dans ce cas il modifie le comportement du programme et est donc à proscrire.

Aller, ça fait plusieurs fois qu'on me le dit, alors j'écoute quand même...
J'ai changer les sorties, je suis sur les 22 à 29 en digitale.

Haifger, oui effectivement c'est une correction que j'ai déja apportée... Mais tu as raison, je devrais remettre mon code, histoire de ne plus reprendre la version initiale...

H83s, J'ai pu insérer ceci:

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);
}

Par contre, lorsque je remplace les

if( (temps_perso >= blancBleu_on_time) && (temps_perso < blancBleu_off_time) ) 
{
// etc...

Par

 if inplage ( (temps_perso >= blancBleu_on_time) && (temps_perso < blancBleu_off_time) ) 

//etc...{

Cela ne fonctionne pas...

Je remet le code compet pour éviter les erreurs...:

//**********************GESTION DES 8 RELAIS***************
//Date : Juin 2014
//*************************************************************
#include <LiquidCrystal.h>
#include <Wire.h>
#include <RTClib.h>
#define LCD_WIDTH 20
#define LCD_HEIGHT 4
char lcdbuf[LCD_WIDTH]; 
uint8_t DsHour ,DsMin ,DsSec;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
RTC_DS1307 rtc;	
int minute;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
int lastSeconde;
//Configuration des Pin du relai
int refuge = 22;
int bleus = 23;
int blancBleu = 24;
int blanc = 25;
int divers = 26;
int osmolateur = 27 ;
int pompeOsmolateur = 28 ;
int agitMagnetique= 29 ;

/*
refuge on: 22h30 off: 7h30
bleus on: 7h30 off: 22h30
blancBleu on:8h30 off:21h30
blanc on:9h30 off:20h30
divers on: 9h off: 21h
osmolateur on: 21h off 21h30
pompeOsmolateur on: 21h00 off: 21h30
agitMagnetique on: 20h30 off: 20h45
*/

//Configuration des heures allumage/extinction (format HHMM )
int refuge_on_time = 2230; //allume refuge
int refuge_off_time = 730; //éteint refuge
int bleus_on_time = 730; //allume bleu 
int bleus_off_time = 2230; //éteint bleu
int blancBleu_on_time = 830; //allume blanc bleu
int blancBleu_off_time = 2130; //éteint blanc bleu
int blanc_on_time = 930; //allume blanc
int blanc_off_time = 2030; //éteint blanc
int divers_on_time = 900; //allume divers
int divers_off_time = 2100; //éteint divers
int osmolateur_on_time = 2100; //allume module osmolateur 
int osmolateur_off_time = 2130; //éteint module osmolateur
int pompeOsmolateur_on_time = 2100; //allume pompe osmolateur
int pompeOsmolateur_off_time = 2130; //éteint pompe osmolateur
int agitMagnetique_on_time = 2030; //allume agitateur magnétique
int agitMagnetique_off_time = 2045; //éteint agitateur magnétique

void setup(void)
{
 Serial.begin(9600);
 pinMode(refuge, OUTPUT); // digital pin pour refuge
 pinMode(bleus, OUTPUT); // digital pin pour bleus
 pinMode(blancBleu, OUTPUT); // digital pin pour blanc bleu
 pinMode(blanc, OUTPUT); // digital pin pour blanc
pinMode(divers, OUTPUT); // digital pin pour divers
 pinMode(osmolateur, OUTPUT); // digital pin pour module osmolateur
 pinMode(pompeOsmolateur, OUTPUT); // digital pin pour pompe osmolateur
 pinMode(agitMagnetique, OUTPUT); // digital pin pour agitateur magnétique
 Wire.begin(); 
 rtc.begin();
 lcd.begin(LCD_WIDTH, LCD_HEIGHT,1); 
// 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(__DATE__, __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 de l'heure
 GetTimeFromRTC(); 
 Serial.print("Heure RTC : ");
 Serial.println(lcdbuf);
 delay(900);

// Leds refuge on/off k1
 if ((temps_perso >= refuge_on_time) && (temps_perso < refuge_off_time) ) 
{
 digitalWrite(refuge, HIGH);
 lcd.setCursor(0, 3);
Serial.print("refugeON");
}
 else 
{
 digitalWrite(refuge, LOW); 
lcd.setCursor(0, 3);
Serial.print("refugeOFF ");
}
// Leds bleus on/off k2
 if( (temps_perso >= bleus_on_time) && (temps_perso < bleus_off_time) ) 
{
 digitalWrite(bleus, HIGH);
 lcd.setCursor(6, 3);
Serial.print("bleusON");
}
 else 
{
 digitalWrite(bleus, LOW); 
 lcd.setCursor(6, 3);
 Serial.print("bleusOFF");
}
// Leds blanc_bleu on/off k3
 if( (temps_perso >= blancBleu_on_time) && (temps_perso < blancBleu_off_time) ) 
{
 digitalWrite(blancBleu, HIGH);
 lcd.setCursor(11, 3);
 Serial.print("blancBleuON");
}
 else
{
 digitalWrite(blancBleu, LOW); 
 lcd.setCursor(11, 3);
 Serial.print("blancBleuOFF");
}
// Leds blanc on/off k4
 if( (temps_perso >= blanc_on_time) && (temps_perso < blanc_off_time) ) 
{
 digitalWrite(blanc , HIGH);
 lcd.setCursor(16, 3);
 Serial.print("blancON");
}
 else 
{
 digitalWrite(blanc, LOW); 
 lcd.setCursor(16, 3);
 Serial.print("blancOFF");}

// Leds divers on/off k1
 if( (temps_perso >= divers_on_time) && (temps_perso < divers_off_time) ) 
{
 digitalWrite(divers, HIGH);
 lcd.setCursor(0, 3);
 Serial.print("diversON");
}
 else 
{
 digitalWrite(divers, LOW); 
 lcd.setCursor(0, 3);
 Serial.print("diversOFF");
}
// osmolateur on/off k1
 if( (temps_perso >= osmolateur_on_time) && (temps_perso < osmolateur_off_time) ) 
{
 digitalWrite(osmolateur, HIGH);
 lcd.setCursor(0, 3);
 Serial.print("osmolateurON");
}
 else 
{
 digitalWrite(osmolateur, LOW); 
 lcd.setCursor(0, 3);
 Serial.print("osmolateurOFF");
}

// pompeOsmolateur on/off k1
 if( (temps_perso >= pompeOsmolateur_on_time) && (temps_perso < pompeOsmolateur_off_time) ) 
{
 digitalWrite(pompeOsmolateur, HIGH);
 lcd.setCursor(0, 3);
 Serial.print("pompeOsmolateurON");
}
 else 
{
 digitalWrite(pompeOsmolateur, LOW); 
 lcd.setCursor(0, 3);
 Serial.print("pompeOsmolateurOFF");
}
// agitMagnetique on/off k1
 if( (temps_perso >= agitMagnetique_on_time) && (temps_perso < agitMagnetique_off_time) ) 
{
 digitalWrite(agitMagnetique, HIGH);
 lcd.setCursor(0, 3);
 Serial.print("agitMagnetiqueON");
}
 else 
{
 digitalWrite(agitMagnetique, LOW); 
 lcd.setCursor(0, 3);
 Serial.print("agitMagnetiqueOFF");
}

// Gestion de l'affichage 
 lcd.clear();
 lcd.setCursor(1, 0) ;
 Serial.print("RedSeaReef Arduino");
 lcd.setCursor(6,1);
 sprintf(lcdbuf, "%.2d:%.2d:%.2d",DsHour,DsMin,DsSec);
 lcd.print(lcdbuf);
 lcd.setCursor(0, 2) ;
 Serial.print("Circuit en fonction:");
}
// Fin du programme

avec la fonction inplage, les tests sont sur le modèle suivant (tu passes en argument à la fonction l'heure actuelle, l'heure de mise en marche et l'heure d'arret) ...je te laisse modifier les 8 tests sur le modele suivant

// Leds refuge on/off k1
 if ( inplage(temps_perso,refuge_on_time,refuge_off_time) ) {
          digitalWrite(refuge, HIGH);
          lcd.setCursor(0, 3);
          Serial.print("refugeON");
}  else {
         digitalWrite(refuge, LOW); 
         lcd.setCursor(0, 3);
         Serial.print("refugeOFF ");
}

Le fait d'avoir un début > à la fin ne fait pas planter ton programme ... mais il ne marchera pas comme tu le souhaites :
par exemple si tu testes (temps > 2300 et temps < 700) .... tu verras que ca ne peut jamais être vrai ... d'où l'interêt de la fonction inplage qui gère cette situation et qui simplifie tes tests dans le loop

Bon...
Alors en fait le:

boolean inplage(int t, int debut, int fin) { 
//renvoie true si temps 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);
}

Je le met où?
Dans le void setup? Parceque si c'est le cas, il veut pas. J'ai le droit a :
"a function-definition is not allowed here before '{' token "

Si je le sors du void setup et que je le met au dessus du void loop, j'ai le droit à:
"too few arguments to function 'boolean inplage(int, int, int)' "

Le " t " c'est bien juste un " t " pas " temps_perso "?
Debut, fin et t, je dois les déclarer au début avec un

int debut;
int fin;
int t;

ou pas?
(j'ai tenté les 2 ça marche pas...)

voici le code entier :wink:
je n'ai pas de RTC pour tester mais le code compile ...

pour info : inplage est une fonction, on peut la mettre avant ou après le setup ou le loop peu importe, mais pas dedans,
int t, int debut et int fin sont des variables locales (dans la fonction inplage), elles sont déclarées sur la boolean inplage(int t, ....) et elles n'existent que dans la fonction inplage (su tu fais debut = 10 dans le loop tu auras une erreur à la compilation)
L'erreur "too few argument" c'est parce que tu appelais inplage avec pas assez d'arguments ... il faut lui passer 3 valeurs (ou 3 variables de type int) ... temps_perso, heure_mise_en_marche et heure_arret .... comme ci-dessous.

//**********************GESTION DES 8 RELAIS***************
//Date : Juin 2014
//*************************************************************
#include <LiquidCrystal.h>
#include <Wire.h>
#include <RTClib.h>
#define LCD_WIDTH 20
#define LCD_HEIGHT 4
char lcdbuf[LCD_WIDTH];
uint8_t DsHour , DsMin , DsSec;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
RTC_DS1307 rtc;
int minute;
int heure;
int seconde;
int date;
int mois;
int annee;
int temps_perso;
int lastSeconde;
//Configuration des Pin du relai
int refuge = 22;
int bleus = 23;
int blancBleu = 24;
int blanc = 25;
int divers = 26;
int osmolateur = 27 ;
int pompeOsmolateur = 28 ;
int agitMagnetique = 29 ;

/*
refuge on: 22h30 off: 7h30
bleus on: 7h30 off: 22h30
blancBleu on:8h30 off:21h30
blanc on:9h30 off:20h30
divers on: 9h off: 21h
osmolateur on: 21h off 21h30
pompeOsmolateur on: 21h00 off: 21h30
agitMagnetique on: 20h30 off: 20h45
*/

//Configuration des heures allumage/extinction (format HHMM )
int refuge_on_time = 2230; //allume refuge
int refuge_off_time = 730; //éteint refuge
int bleus_on_time = 730; //allume bleu
int bleus_off_time = 2230; //éteint bleu
int blancBleu_on_time = 830; //allume blanc bleu
int blancBleu_off_time = 2130; //éteint blanc bleu
int blanc_on_time = 930; //allume blanc
int blanc_off_time = 2030; //éteint blanc
int divers_on_time = 900; //allume divers
int divers_off_time = 2100; //éteint divers
int osmolateur_on_time = 2100; //allume module osmolateur
int osmolateur_off_time = 2130; //éteint module osmolateur
int pompeOsmolateur_on_time = 2100; //allume pompe osmolateur
int pompeOsmolateur_off_time = 2130; //éteint pompe osmolateur
int agitMagnetique_on_time = 2030; //allume agitateur magnétique
int agitMagnetique_off_time = 2045; //éteint agitateur magnétique

void setup(void) {
  Serial.begin(9600);
  pinMode(refuge, OUTPUT); // digital pin pour refuge
  pinMode(bleus, OUTPUT); // digital pin pour bleus
  pinMode(blancBleu, OUTPUT); // digital pin pour blanc bleu
  pinMode(blanc, OUTPUT); // digital pin pour blanc
  pinMode(divers, OUTPUT); // digital pin pour divers
  pinMode(osmolateur, OUTPUT); // digital pin pour module osmolateur
  pinMode(pompeOsmolateur, OUTPUT); // digital pin pour pompe osmolateur
  pinMode(agitMagnetique, OUTPUT); // digital pin pour agitateur magnétique
  Wire.begin();
  rtc.begin();
  lcd.begin(LCD_WIDTH, LCD_HEIGHT, 1);
  // 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(__DATE__, __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 de l'heure
  GetTimeFromRTC();
  Serial.print("Heure RTC : ");
  Serial.println(lcdbuf);
  delay(900);

  // Leds refuge on/off k1
  if (inplage(temps_perso, refuge_on_time, refuge_off_time) )   {
    digitalWrite(refuge, HIGH);
    lcd.setCursor(0, 3);
    Serial.print("refugeON");
  }   else   {
    digitalWrite(refuge, LOW);
    lcd.setCursor(0, 3);
    Serial.print("refugeOFF ");
  }
  // Leds bleus on/off k2
  if ( inplage(temps_perso, bleus_on_time, bleus_off_time) )   {
    digitalWrite(bleus, HIGH);
    lcd.setCursor(6, 3);
    Serial.print("bleusON  ");
  }  else  {
    digitalWrite(bleus, LOW);
    lcd.setCursor(6, 3);
    Serial.print("bleusOFF ");
  }
  // Leds blanc_bleu on/off k3
  if ( inplage(temps_perso, blancBleu_on_time, blancBleu_off_time) )   {
    digitalWrite(blancBleu, HIGH);
    lcd.setCursor(11, 3);
    Serial.print("blancBleuON  ");
  }   else  {
    digitalWrite(blancBleu, LOW);
    lcd.setCursor(11, 3);
    Serial.print("blancBleuOFF ");
  }
  // Leds blanc on/off k4
  if ( inplage(temps_perso, blanc_on_time, blanc_off_time) )   {
    digitalWrite(blanc , HIGH);
    lcd.setCursor(16, 3);
    Serial.print("blancON  ");
  }  else  {
    digitalWrite(blanc, LOW);
    lcd.setCursor(16, 3);
    Serial.print("blancOFF ");
  }

  // Leds divers on/off k1
  if ( inplage(temps_perso, divers_on_time, divers_off_time) )  {
    digitalWrite(divers, HIGH);
    lcd.setCursor(0, 3);
    Serial.print("diversON  ");
  }  else  {
    digitalWrite(divers, LOW);
    lcd.setCursor(0, 3);
    Serial.print("diversOFF ");
  } 

  // osmolateur on/off k1
  if ( inplage(temps_perso, osmolateur_on_time, osmolateur_off_time) )  {
    digitalWrite(osmolateur, HIGH);
    lcd.setCursor(0, 3);
    Serial.print("osmolateurON  ");
  }  else  {
    digitalWrite(osmolateur, LOW);
    lcd.setCursor(0, 3);
    Serial.print("osmolateurOFF ");
  }

  // pompeOsmolateur on/off k1
  if ( inplage(temps_perso, pompeOsmolateur_on_time, pompeOsmolateur_off_time) )  {
    digitalWrite(pompeOsmolateur, HIGH);
    lcd.setCursor(0, 3);
    Serial.print("pompeOsmolateurON  ");
  }  else  {
    digitalWrite(pompeOsmolateur, LOW);
    lcd.setCursor(0, 3);
    Serial.print("pompeOsmolateurOFF ");
  }
  // agitMagnetique on/off k1
  if ( inplage(temps_perso, agitMagnetique_on_time, agitMagnetique_off_time) )  {
    digitalWrite(agitMagnetique, HIGH);
    lcd.setCursor(0, 3);
    Serial.print("agitMagnetiqueON  ");
  }  else  {
    digitalWrite(agitMagnetique, LOW);
    lcd.setCursor(0, 3);
    Serial.print("agitMagnetiqueOFF ");
  }

  // Gestion de l'affichage
  lcd.clear();
  lcd.setCursor(1, 0) ;
  Serial.print("RedSeaReef Arduino");
  lcd.setCursor(6, 1);
  sprintf(lcdbuf, "%.2d:%.2d:%.2d", DsHour, DsMin, DsSec);
  lcd.print(lcdbuf);
  lcd.setCursor(0, 2) ;
  Serial.print("Circuit en fonction:");
}
// Fin du programme

Merci!

Décidément je crois que la programmation et moi on est pas copain...
En tout cas, c'est très sympa d'avoir refait le programme pour moi... Pour le coup j'arrive avec plein de questions et pas moyen de donner le moindre coup de pouce...
Je vous rassure, je le fait dans d'autres domaines...loin de toute programmation :wink:

Je viens de tenter le programme, ça compile et ça se lance.
Verdict ce soir et demain matin, au moment où habituellement ça plante et ne se relance pas...

de rien !

c'est chacun son truc !