Allumage progressif Rampe aquarium + Température

Bonjour à tous,

voila ce qui m'amène.
Je viens de m'acheter un aquarium de 250 litres que je veux entièrement éclairer avec des Leds.
J'ai décidé d'utiliser des Leds 10mm 5 chips de 3.4V et 100mA.
Il y a 58 leds blanches et 18 leds blanches chaudes (je n'utilise pas de rouges ni de bleues car il n'y aura aucune plante dans le bac car ce sera un biotope malawi).
Les leds sont cablées par trois avec une résistance de 22 ohm.
L'alimentation est une alim de PC 12V.
En plus j'ai installé 12 leds 5mm bleues 3.4V 0.2mA pour faire un eclairage lunaire (leds non présentes sur les photos).
Pareil qu'avant : 3 leds bleues en série mais une resistance de 100 ohm.

QUelques photos du bricolage :
http://img8.imageshack.us/img8/9010/92733082.jpg
http://img801.imageshack.us/img801/4994/58109907.jpg
http://img219.imageshack.us/img219/3392/img20101008110622.jpg

Voila maintenant ce que je voudrais réaliser :

Je voudrais que toutes les leds blanches et blanches chaudes s'allument progressivement sur une durée de 1 heure à une heure donnée.
Puis plus tard allumage des leds bleues et extinction après de toutes les blanches.
Puis pour finir extinction des bleues.

Exemple :
16h00 : allumage progessif des blanches
17h00 : luminosité max
22h00 : allumage des leds bleues
22h15 : extinction progessive des blanches
22h45 : blanches éteintes
00h00 : extinction des bleues

Le top serait d'avoir un affichage affichant l'heure et de pouvoir à l'aide de boutons poussoir ou un clavier changer les différents réglages.
Pourquoi pas aussi une sonde de température avec affichage à coté de l'heure.

Pour commencer je voulais savoir si c'était réalisable et surtout quel kit je devais acheter pour mon projet.

Merci d'avance pour votre aide.
masterbalby

Hello

Pour le fading, 3 sorties PWM suffisent, une pour chaque couleur, avec un transistor en commutation (je doute que la carte supporte une telle quantité de leds). Un exemple de montage, a adapter a tes besoins

Coté prog : http://arduino.cc/en/Tutorial/Fading

Pour la gestion du temps, une horloge temps réel type DS1307

Et pour l'interface + boutons, tu as des shields tout fait, fans c'est assez facile a réaliser soit-même
Gestion LCD: Arduino Playground - LCD
Boutons: Arduino Playground - InterfacingWithHardware

Bon voila je viens d'acheter un Duemilanove ATmega328.
Pour le programme à ecrire faut il tout ecrire d'un coup (3 sorties PWM, clock, température) ou alors creer une fonction, puis les autres pour ensuite tout assembler ?

Si tu te limites aux leds et à l'horloge, le code est assez simple et tu peux tout faire en un bloc.
Par contre, si tu ajoutes un lcd (ou que tu voudras en ajouter un), il vaut mieux faire des fonctions. Surtout si tu veux en prime une gestion en menus et pleins de données à afficher à l'écran....

Le plus simple, a mon avis:

  • une fonction retournantl'heure (via l'horloge I2C )
  • une fonction de gestion des LEDs 3 arguments: les leds à sélectionner (bleus, blanches, chauffantes), le mode de transition (allumage, extinction), et le temps de transition.
  • une fonction retournant la température (par thermomètre I2C par ex, comme le bus est déjà exploité par l'horloge, autant en profiter)
  • une fonction pour gérer un petit écran lcd tout simple, et afficher des données ( la T° par ex)
  • la boucle loop() pour lier le tout

Pour les boutons, tout dépend ce que tu veux faire avec .
Si c'est pour faire un thermostat (modification des températures min et max d'utilisation des leds chauffantes), tu peux utiliser 2 potentiomètres, reliées a 2 entrées analogiques, et afficher sur l'ecran:
T° en cours / T° min / T° max

merci pour la réponse.

Je pensais utiliser 2 sorties PWR pour gérer mon éclairage et en utilisant des mosfets.

Ai-je bon ??

Hello

Je pense que tu devrais rajouter une diode à la sortie, pour éviter les "retours de flamme"
D'ailleurs, à propos d'éclairage à LEDs, un article plutot interessant (commutation de 110 LEDs rouges) :
http://www.sonelec-musique.com/electronique_realisations_eclairage_leds_006.html
Il utilise ici un transistor MOSFET IRFZ44. Ça devrait t'être utile, surtout l'étage de commande. Il faudra par contre recalculer les résistances ...

Voici mon calcul pour chaque branche de 3 leds
R=(tension_alim-3Resistancestensin_d'alimenation)/courant_d'utilisation
R=(12-3
3.4)/0.1
R=18 ohm

Alors pourquoi recalculer mes résistances ??

non, je parlais du montage de l'article que je présentais, qu'il aurait fallu adapter pour ton utilisation. Tes calculs sont correctes.

Est ce que ce type de mosfet pourrait faire l'affaire ??

Bonsoir,
je suis très intéresse par la création d'un programme de ce type avec allumage et extinction progressif de led blanches et bleu avec horloge.
Pour ce faire, je compte prendre un artmega 328. Cependant, je suis néophyte dans ce type de montage.
Quelqu'un aurait il réussi a faire fonctionner ce type système et aurait un schéma de montage électrique clair ainsi qu'un programme complet adapté à ce type de micro controller.
Merci d'avance pour vos réponses;)

tu vas devoir attendre un peu pour que je t'aide car je n'ai pas encore recu mon arduino commandé.

Que pensez vous d'un systeme ce type?

http://www.electronet24.com/Commandes_dclairage/Programmateurs/Programmateur_numrique_pour_tableau_modulaire_i45_317.htm

je n'ai toujours pas recu mon arduino mais je commence à faire mon programme.
J'ai une question au sujet du capteur de température LM35 au sujet de la formule pour transformer la tension de sortie en température.
J'ai trouvé deux méthodes sur deux sites différents qui ne sont pas identiques.

  1. (5,0 * tension_relevée * 100) / 1024
  2. ((tension_relevée * 5.0 / 1024) -0.5) * 100

Voila le problème est que je n'ai pas mon arduino pour faire mes tests.

alors je me reponds à moi même .
Il suffit de convertir la tension reçue en mV puis de diviser par 10.
Ex : tension reçue 0.222V
Température= (0.2221000)/10 ou plus simplement (0.222100)
Température=22.2°C

Me revoila
j'ai recu mon arduino duemilanove ainsi que mon lcd.
je peux enfin faire des essais
Je suis donc arrivé à afficher la température ainsi que l'heure et la date en utilisant un DS1307 et un LM35 pour la température.

Voila le code :

#include <LiquidCrystal.h>
#include <WProgram.h>
#include <Wire.h>
#include <DS1307.h>

int TempPin = 0; 
int rtc[7];
int minute;
int heure;
int jour;
int mois;
int calendrier;
int annee;
int seconde;
// Initialisation de la bibliothèque avec les numéros des broches de l interface
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

void setup() {
  Serial.begin(9600);
  lcd.begin (8, 2); 
  delay(10);
  //lcd.print("Temp:"); 
  RTC.stop();
  RTC.set(DS1307_SEC,1);        //set the seconds
  RTC.set(DS1307_MIN,34);     //set the minutes
  RTC.set(DS1307_HR,11);       //set the hours
  RTC.set(DS1307_DOW,6);       //set the day of the week
  RTC.set(DS1307_DATE,13);       //set the date
  RTC.set(DS1307_MTH,11);        //set the month
  RTC.set(DS1307_YR,10);         //set the year
  RTC.start();
}

void loop() { 

  RTC.get(rtc,true);
  for(int i=0; i<7; i++)
  {
    heure=rtc[2];  
    calendrier=rtc[3];
    jour=rtc[4];
    mois=rtc[5];
    annee=rtc[6];
    minute=rtc[1];
    seconde=rtc[0];
  }


  // TEMPERATURE  
  //getting the voltage reading from the temperature sensor
  int reading = analogRead(TempPin);  
  // converting that reading to voltage, for 3.3v arduino use 3.3
  float voltage = reading * 4.2 / 1024; 
  // print out the voltage
  Serial.print(voltage); 
  Serial.println(" volts");
  // now print out the temperature
  float temperature = voltage * 100 ;  
  Serial.print(temperature); 
  Serial.println(" degres");
  Serial.println(" ");
  lcd.clear();
  lcd.setCursor (0, 0); // mettre le curseur sur la colonne 0, la ligne 0
  lcd.print ("temp : "); // envoyer les données à l'ordinateur 
  lcd.setCursor (0, 1); // mettre le curseur sur la colonne 0, la ligne 1 
  lcd.print (temperature); // envoyer les données à l'ordinateur 
  lcd.print ((char) 223); // symbole de degré
  lcd.print ("C");
  delay(2000);   //waiting two second
  // TEMPERATURE

  //TIME
  lcd.clear();
  if (heure < 10)
  {
    lcd.print("0");
  } 
  lcd.print(RTC.get(DS1307_HR,true)); //read the hour and also update all the values by pushing in true
  lcd.print("H");
  if (minute < 10)
  {
    lcd.print("0");
  }
  lcd.print(RTC.get(DS1307_MIN,false));//read minutes without update (false)
  lcd.print(" ");
  if (jour <10)
  {
    lcd.print("0");
  }
  lcd.print(RTC.get(DS1307_DATE,false));//read date
  lcd.setCursor (0, 1); // mettre le curseur sur la colonne 0, la ligne 1 
  lcd.print("/");
  if (mois < 10)
  {
    lcd.print("0");
  } 
  lcd.print(RTC.get(DS1307_MTH,false));//read month
  lcd.print("/");
  lcd.print(RTC.get(DS1307_YR,false)); //read year 
  delay(2000);
  //TIME
}

Une petite vidéo du résultat

J'ai donc deux rampes. Une pour le jour et un eclairage lunaire.
Je voudrais arriver à allumer par exemple la rampe jour à 15h00 et la rampe lunaire à 21h00. Puis extinction de la rampe jour à 21h15 et de la rampe lunaire à 23h00.
Pour l'allumage il y a deux options : soit allumage et extinction progressifs ou allumage et extinction d'un coup.

C'est donc ici que je bloque.
Je sais allumer une rampe d'un coup ou progressivement mais je ne sais pas programmer cet allumage à une heure donnée.

Par avance je vous remercie pour votre aide.

y'a une lib pour le faire :slight_smile: TimeAlarms

Alors voila mon projet avance bien.
J'ai l'heure, le capteur de température enclenche ou non le chauffage du bac, j'allume et éteints à heures fixes mes deux rampes leds.

J'ai par contre un soucis
j'aimerais rajouter soit un interrupteur ou un bouton poussoir pour pouvoir allumer la rampe jour avant son allumage automatique.
Avec mon code si on allume manuellement une fois ça fonctionne.
On peut eteindre la rampe manuellement.
Par contre après quand la rampe s'allume automatiquement elle se met à clignoter toutes les secondes et l'allumage manuel n'est plus possible.

Voila mon code

#include <LiquidCrystal.h>
#include <WProgram.h>
#include <Wire.h>
#include <DS1307.h>

/*
Arduino Masterbalby Controller
 Analog Pin 4 = SDA pour ds1307
 Analog Pin 5 = SCL pour ds1307
 Analog Pin 0 = Température Sensor
 Digital Pin 15 = Relais chauffage
 Digital Pin 16 = Relais Day Light
 Digital Pin 17 = Relais Moon Light
 */

//LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int sensorPin = 0;
int chauffage = 15;
int day_light = 16;
int moon_light = 17;
int heater_on_temp = 19;  //allume chauffage à cette température
int heater_off_temp = 22; //éteint le chauffage à cette température
int lights_on_time = 1001;  //allume les day lights à cette heure (en temps_perso)
int lights_off_time = 1003; //éteint les day lights à cette heure (en temps_perso)
int moon_on_time = 1002;  //allume les  moon lights à cette heure (en temps_perso)
int moon_off_time = 1004;  //éteint les moon lights à cette heure (en temps_perso)
int minute;
int heure; 
int seconde;
int date;
int mois;
int annee; 
int temps_perso;
const int APPUI=0; // constante état du BP - appui sur niveau bas
//const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut
const int BP=6; //declaration constante de broche 
int ETAT_BP; // variable d'état du bouton poussoir


void setup() {
  Serial.begin(9600);
  RTC.stop();
  RTC.set(DS1307_SEC,00);        //réglage secondes
  RTC.set(DS1307_MIN,00);        //réglage minutes
  RTC.set(DS1307_HR,10);         //réglage heures (military)
  RTC.set(DS1307_DOW,2);         //réglage jour de la semaine
  RTC.set(DS1307_DATE,15);       //réglage date
  RTC.set(DS1307_MTH,11);         //réglage mois
  RTC.set(DS1307_YR,10);          //réglage année
  RTC.start();
  //lcd.begin(16, 2);
  pinMode(chauffage, OUTPUT);  // digital pin pour chauffage en sortie
  pinMode(day_light, OUTPUT);  // digital pin pour day light en sortie
  pinMode(moon_light, OUTPUT);  // digital pin pour moon light en sortie
  //lcd.print("MasterBalby 1.0");
  //lcd.print("Gestion Aqua");
  //delay(2000);
  pinMode(BP, INPUT); //met la broche en entree 
  digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée
}

void loop(){
  //Récupérer l'heure du DS1307**********************************************************************************************
  heure = RTC.get(DS1307_HR,true);  
  minute = 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) + minute;  //creation temps_perso
  //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.begin(0,0);
  Serial.print(temp); 
  Serial.println(" degres");  
  //Affichage heure******************************************************************************************
  Serial.print(RTC.get(DS1307_HR,true));
  Serial.print(":");
  Serial.print(RTC.get(DS1307_MIN,false));
  Serial.print(":");
  Serial.print(RTC.get(DS1307_SEC,false));
  delay(1000);
  //Controles des sorties ***************************************************************************************
  //****************Chauffage
  if(temp < heater_on_temp){     // allume le chauffage si la température relevée est inférieure à heater_on_temp 
    digitalWrite(chauffage, HIGH);
      }  
  if(temp > heater_off_temp){    // éteint le chauffage si la température relevée est supérieure à heater_on_temp 
    digitalWrite(chauffage, LOW);
  }
  //****************Day Lights**********************************************************************************
  if(lights_on_time > temps_perso ||  lights_off_time <= temps_perso)
//   if((ETAT_BP==APPUI) && lights_on_time > temps_perso ||  lights_off_time <= temps_perso)
  {
    digitalWrite(day_light, LOW);
    Serial.print(" -Jour OFF- ");
  }
  else
  {
    digitalWrite(day_light, HIGH);
    Serial.print(" -Jour ON- ");
  }
  //****************Moon Lights****************************************************************************
  if(moon_on_time > temps_perso  || moon_off_time <= temps_perso){
    digitalWrite(moon_light, LOW);
    Serial.print(" -Nuit OFF- ");
  }
  else{
    digitalWrite(moon_light, HIGH);
    Serial.print(" -Nuit ON- ");
  }
  //Affichage chauffage allumé********************************************************
  //lcd.begin(2,0);
   if(digitalRead(chauffage) == HIGH)
   {
   Serial.println(" -Chauffage ON- ");
   }
   else
   {
   Serial.println(" -Chauffage OFF- ");
   }
  //**********************Allumage manuel avec bouton poussoir rampe jour***************************
  ETAT_BP=digitalRead(BP);
   if (ETAT_BP==APPUI)
   { 
   digitalWrite(day_light,1); // allume la LED
   }
   else 
   {
   digitalWrite(day_light,0); // éteint la LED
   }
}

A votre bon coeur....

Problème résolu.
Il fallait remplacer

if((ETAT_BP==APPUI) && lights_on_time > temps_perso ||  lights_off_time <= temps_perso)

par

if((ETAT_BP==APPUI) && (lights_on_time > temps_perso ||  lights_off_time <= temps_perso))

il manquait deux parenthèses