Lampara Led efecto Amanecer/Anochecer (Acualizacion)

Hola que tal amigos soy nuevo en el mundo de Arduino y la verdad quede muy fascinado con muchas cosas que se puede lograr con esa pequeña plaquita, nada mas que no tengo nada de conocimientos sobre circuitos y mucho menos en programación de arduino.
Tengo un proyecto en proceso sobre una lampara para un acuario y tengo en mente poder regular la intensidad de los led por PWM para darle un efecto de Amanecer/Anochecer con ayuda de un Reloj en tiempo real. Son 6 Series de led cada serie o linea es de un color diferente y pretendo que cada color encienda a cierto horario y se apaguen a cierta hora.
Tengo un Arduino Uno y un Reloj DS3231.

Este es mi humilde código con el que comencé a trabajar aun no esta del todo terminado pero tengo esa duda si seria la mejor manera de hacer el efecto que quiero lograr o hay alguna otra manera que sea mas funcional.

#include "RTClib.h"
#include <Wire.h>
RTC_DS3231 RTC;

int i = 0;
int Bco65 = 3;
int Bco35 = 5;
int Azul = 6;
int Rojo = 9;
int Verde = 10;
int Rosa = 11;

void setup(){
  RTC.begin();
  Wire.begin();
  RTC.adjust(DateTime(__DATE__, __TIME__)); //Se carga dos veces la segunda vez esta linea como comentarios
  Serial.begin(9600);
  delay(1000);
  
  pinMode(Bco65, OUTPUT);
  pinMode(Bco35, OUTPUT);
  pinMode(Azul, OUTPUT);
  pinMode(Rojo, OUTPUT);
  pinMode(Verde, OUTPUT);
  pinMode(Rosa, OUTPUT);
}

void loop(){
  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(' ');
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.print(now.second(), DEC);
  Serial.println();
  delay(500);

  if(now.hour() ==7 && now.minute() ==50){
    for(i = 0; i <= 55; i++){
      analogWrite(Azul, i);
      delay(50);
      }
  } 
  delay(500);
  if(now.hour() ==8 && now.minute() ==20){
    for(i = 55; i <= 235; i++){
      analogWrite(Azul, i);
      delay(45);
      }
  }
  delay(500);
  if(now.hour() ==9 && now.minute() ==30){
    for(i = 0; i <= 95; i++){
      analogWrite(Rojo, i);
      analogWrite(Verde, i);
      delay(30);
      }
  }
  delay(500);
  if(now.hour() ==10 && now.minute() ==45){
    for(i = 0; i <= 95; i++){
      analogWrite(Bco65, i);
      delay(45);
      }
  }
  else if(now.hour() ==10 && now.minute() ==50){
    for(i = 235; i >= 115; i--){
      analogWrite(Azul, i);
      delay(45);
      }
  }
  delay(500);
  if(now.hour() ==11 && now.minute() ==30){
    for(i = 0; i <= 125; i++){
      analogWrite(Bco35, i);
      delay(45);
      }
  }
}

Nota: Sobre la función "for" que lleva dentro de los corchetes en if(xxx) y de else if(xxx) lo que quisiera que la luz de los led vaya encendiendo de poco a poco a cierto punto y que no se enciendan de golpe.

Bueno me parece que aquí hay muy poca ayuda pero quien se molesta en hacer algo por alguien mas, pero como lo dice el titulo "Solucionado" :smiley: :stuck_out_tongue_closed_eyes:

Hasta ahora con ese código creo podrá trabajar bien mi lampara nada mas espero permanezca este post para los que tengan una idea de proyecto parecida al mio. Mi proyecto era hacer una lampara para un acuario y que tuviera un efecto de amanecer y anochecer simulando dicho efecto con arduino y con un reloj DS3231, hasta ahora este código es funcional para mi pero creo que se puede mejorar aun mas pero espero les sirva a los que visiten la pagina como inicio para comenzar.

Entonces empecemos aquí dejo mi código, mis esquemas y la lista de materiales que utilice

#include "Wire.h"
#include "RTClib.h"
RTC_DS3231 RTC;
float TempC;




/////////////////---Asignar Pines---/////////////////
int Rojo = 3;
int Azul = 5;
int Rosa = 6;
int Verde = 9;
int Bco35 = 10;
int Bco65 = 11;
int Sensor_LM35 = 0;
int FanIzq = 2;
int FanDcho = 4;
int FanCtro = 7;
/////////////////---Estados de Led---/////////////////
int edo_Rojo = 0;
int edo_Azul = 0;
int edo_Rosa = 0;
int edo_Verde = 0;
int edo_Bco35 = 0;
int edo_Bco65 = 0;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  RTC.begin();
  RTC.adjust(DateTime(__DATE__, __TIME__));          //Se carga 2 veces pero la segunda vez con "//"
  delay(500);

  //////////////---Salidas y Entradas---/////////////
  pinMode(Rojo, OUTPUT);
  pinMode(Azul, OUTPUT);
  pinMode(Rosa, OUTPUT);
  pinMode(Verde, OUTPUT);
  pinMode(Bco35, OUTPUT);
  pinMode(Bco65, OUTPUT);
  pinMode(FanIzq, OUTPUT);
  pinMode(FanDcho, OUTPUT);
  pinMode(FanCtro, OUTPUT);
}



void loop() {
  ///////////////////---Horario---///////////////////
  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(" ");
  Serial.print(now.hour(), DEC);
  Serial.print(":");
  Serial.print(now.minute(), DEC);
  Serial.print(":");
  Serial.print(now.second(), DEC);
  Serial.print("      ");

  //////////////////---Temperatura---//////////////////
  TempC = analogRead(Sensor_LM35);
  TempC = 5.0 * TempC * 10.0 / 1024.0;
  Serial.print("Temp_Circuito: ");
  Serial.print(TempC);
  Serial.println(" °C");

  /////////////---Sistema de Ventilacion---/////////////
  if (TempC >= 16)
    digitalWrite(FanIzq, HIGH);
  else
    digitalWrite(FanIzq, LOW);
  if (TempC >= 12)
    digitalWrite(FanCtro, HIGH);
  else
    digitalWrite(FanCtro, LOW);
  if (TempC >= 16)
    digitalWrite(FanDcho, HIGH);
  else
    digitalWrite(FanDcho, LOW);

  ////////////////---Sistema de Luces---///////////////
  if (now.hour() == 7 && now.minute() == 50) {
    if (edo_Azul != 255) {
      analogWrite(Azul, edo_Azul);
      edo_Azul++;
      delay(120);
    }
  }
  if (now.hour() == 8 && now.minute() == 25) {
    if ((edo_Rojo != 50) & (edo_Rosa != 25)) {
      analogWrite(Rojo, edo_Rojo);
      analogWrite(Rosa, edo_Rosa);
      edo_Rojo++;
      edo_Rosa++;
      delay(60);
    }
  }
  if (now.hour() == 9 && now.minute() == 0) {
    if ((edo_Azul != 155) & (edo_Verde != 30) & (edo_Bco35 != 25)) {
      analogWrite(Azul, edo_Azul);
      analogWrite(Verde, edo_Verde);
      analogWrite(Bco35, edo_Bco35);
      edo_Azul--;
      edo_Verde++;
      edo_Bco35++;
      delay(50);
    }
  }
  if (now.hour() == 9 && now.minute() == 30) {
    if ((edo_Rojo != 80) & (edo_Verde != 80) & (edo_Rosa != 50) & (edo_Bco65 != 30) & (edo_Bco35 != 55)) {
      analogWrite(Rojo, edo_Rojo);
      analogWrite(Verde, edo_Verde);
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      edo_Rojo++;
      edo_Verde++;
      edo_Rosa++;
      edo_Bco65++;
      edo_Bco35++;
      delay(70);
    }
  }
  if (now.hour() == 12 && now.minute() == 20) {
    if ((edo_Rojo != 120) & (edo_Verde != 120) & (edo_Rosa != 80) & (edo_Bco65 != 70) & (edo_Bco35 != 70)) {
      analogWrite(Rojo, edo_Rojo);
      analogWrite(Verde, edo_Verde);
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      edo_Rojo++;
      edo_Verde++;
      edo_Rosa++;
      edo_Bco65++;
      edo_Bco35++;
      delay(50);
    }
  }
  if (now.hour() == 15 && now.minute() == 0) {
    if (edo_Rojo != 155) {
      analogWrite(Rojo, edo_Rojo);
      edo_Rojo++;
      delay(45);
    }
  }
  if (now.hour() == 18 && now.minute() == 50) {
    if ((edo_Rosa != 25) & (edo_Verde != 55) & (edo_Bco65 != 40) & (edo_Bco35 != 40)) {
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Verde, edo_Verde);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      edo_Rosa--;
      edo_Verde--;
      edo_Bco65--;
      edo_Bco35--;
      delay(45);
    }
  }
  if (now.hour() == 19 && now.minute() == 40) {
    if (edo_Azul != 255) {
      analogWrite(Azul, edo_Azul);
      edo_Azul++;
      delay(45);
    }
  }
  if (now.hour() == 20 && now.minute() == 0) {
    if ((edo_Verde != 0) & (edo_Rosa != 0) & (edo_Bco65 != 0) & (edo_Bco35 != 0) & (edo_Rojo != 0)) {
      analogWrite(Verde, edo_Verde);
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      analogWrite(Rojo, edo_Rojo);
      edo_Verde--;
      edo_Rosa--;
      edo_Bco65--;
      edo_Bco35--;
      edo_Rojo--;
      delay(110);
    }
  }
  if (now.hour() == 20 && now.minute() == 1) {
    digitalWrite(Rojo, LOW);
    digitalWrite(Verde, LOW);
    digitalWrite(Rosa, LOW);
    digitalWrite(Bco65, LOW);
    digitalWrite(Bco35, LOW);
  }
  if (now.hour() == 22 && now.minute() == 30) {
    if (edo_Azul != 0) {
      analogWrite(Azul, edo_Azul);
      edo_Azul--;
      delay(120);
    }
  }
  if (now.hour() == 22 && now.minute() == 31) {
    digitalWrite(Azul, LOW);
  }
  ////////////////---Fin de la Programacion---///////////////
}

Nota: en archivo LampLed_Esquema no viene la conexión del Transistor 2N22222 pero deje otra imagen como ejemplo al igual que el sensor de temperatura LM35.


LucesPrueba.ino (5.03 KB)

LampLed_Esquema.zip (1.04 MB)

Bueno me parece que aquí hay muy poca ayuda pero quien se molesta en hacer algo por alguien mas, pero como lo dice el titulo "Solucionado"

Hay cientos de mensages por semana y nadie tiene obligación de responder los msgs sin respuesta. Simplemente pasa!
A veces ocurre que un tema no se responde porque los que rspondemos con habitualidad reconocemos que el tema se trató y que tu con una simple búsqueda indicada en las normas del foro como paso 1 a seguir simplemente seguirás.

Hay muchos ejemplos de rutinas Amanecer/Anochecer de Lamparas LED .
De hecho en la sección Proyectos @AlbertoG1 tiene un proyecto de Acuario de 500 Litros con el mismo tema.
Y hay muchos mas ejemplos en Hardware.

En los ultimos dos meses creo haber leído y respondido en 2 o 3 temas similares.

De modo que la poca ayuda que mencionas se debe a que esta respondido y hubo tal vez poca búsqueda de tu parte. Esto no lo digo para polemizar contigo.

Te recuerdo que siempre debes buscar.
Solo con leer no mas de 3 o 4 paginas por sección encuentras lo que te digo.

Simplemente tu pregunta se me pasó por alto, pero no soy responsable por no responderte.

Si lo se, esta mas que claro lo que digo al menos me llevo esa satisfaccion de que pude realizar mi proyecto por mi cuenta pero en fin, por esa razon trato de dejar mis notas y proyecto aunque esta a prueba espero le pueda servir a alguien mas para algun comienzo o idea de por donde empezar.

Saludos.....

Una pequeña mejora quitando el sensor LM35 lo tengo muy mal configurado o al menos a mi no me funciono así que use el DS3231 para obtener la temperatura y activar los ventiladores reportar cualquier fallo o error por favor

#include "Wire.h"
#include "RTClib.h"
//Horario//
RTC_DS3231 RTC;
String daysOfTheWeek[7] = {"Dom", "Lun", "Mar", "Mie", "Jue", "Vie", "Sab"};
String monthsNames[12] = {"Ene", "Feb", "Mar", "Abr", "May", "Jun", "Jul", "Ago", "Sep", "Oct", "Nov", "Dic"};
//Temperatura//
#define DS3231_I2C_ADDRESS 0x68


/////////////////---Asignar Pines---/////////////////
int Rojo = 3;
int Azul = 5;
int Rosa = 6;
int Verde = 9;
int Bco35 = 10;
int Bco65 = 11;
int FanIzq = 2;
int FanDcho = 4;
int FanCtro = 7;
/////////////////---Estados de Led---/////////////////
int edo_Rojo = 0;
int edo_Azul = 0;
int edo_Rosa = 0;
int edo_Verde = 0;
int edo_Bco35 = 0;
int edo_Bco65 = 0;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  RTC.begin();
  //RTC.adjust(DateTime(__DATE__, __TIME__));
  delay(500);

  //////////////---Salidas y Entradas---/////////////
  pinMode(Rojo, OUTPUT);
  pinMode(Azul, OUTPUT);
  pinMode(Rosa, OUTPUT);
  pinMode(Verde, OUTPUT);
  pinMode(Bco35, OUTPUT);
  pinMode(Bco65, OUTPUT);
  pinMode(FanIzq, OUTPUT);
  pinMode(FanDcho, OUTPUT);
  pinMode(FanCtro, OUTPUT);
}


void printDate(DateTime date) {
  Serial.print(date.day(), DEC);
  Serial.print('/');
  Serial.print(date.month(), DEC);
  Serial.print('/');
  Serial.print(date.year(), DEC);
  Serial.print(" (");
  Serial.print(daysOfTheWeek[date.dayOfTheWeek()]);
  Serial.print(") ");
  Serial.print(date.hour(), DEC);
  Serial.print(':');
  Serial.print(date.minute(), DEC);
  Serial.print(':');
  Serial.print(date.second(), DEC);
  Serial.println();
}


void loop() {
  ///////////////////---Horario---///////////////////
  DateTime now = RTC.now();
  printDate(now);

  //////////////////---Temperatura---//////////////////
  byte buffer[2];

  // Leemos los registros de temperatura
  Wire.beginTransmission(DS3231_I2C_ADDRESS);
  Wire.write(0x11); // La direccion de los registros de temperatura
  Wire.endTransmission();

  // Leemos 2 registros que son los unicos de temperatura
  Wire.requestFrom(DS3231_I2C_ADDRESS, 2);

  // Leemos de a un byte a la vez
  buffer[0] = Wire.read();
  buffer[1] = Wire.read();

  // Mostramos la temperatura con DS3231 por el Monitor Serial
  if (buffer[0] < 0xFF) {  // Para evitar una falsa lectura que usualmente viene en 0xFF = -127C lo que es imposible
    Serial.println(String("Temperatura: ") + buffer[0] + "." + (buffer[1] / 64 * 25) + "°C");
  }

  /////////////---Sistema de Ventilacion---/////////////
  if (buffer[0] >= 35)
    digitalWrite(FanIzq, HIGH);
  else
    digitalWrite(FanIzq, LOW);
  if (buffer[0] >= 33)
    digitalWrite(FanCtro, HIGH);
  else
    digitalWrite(FanCtro, LOW);
  if (buffer[0] >= 35)
    digitalWrite(FanDcho, HIGH);
  else
    digitalWrite(FanDcho, LOW);

  ////////////////---Sistema de Luces---///////////////
  if (now.hour() == 7 && now.minute() == 50) {
    if (edo_Azul != 255) {
      analogWrite(Azul, edo_Azul);
      edo_Azul++;
      delay(120);
    }
  }
  if (now.hour() == 8 && now.minute() == 25) {
    if ((edo_Rojo != 50) & (edo_Rosa != 25)) {
      analogWrite(Rojo, edo_Rojo);
      analogWrite(Rosa, edo_Rosa);
      edo_Rojo++;
      edo_Rosa++;
      delay(120);
    }
  }
  if (now.hour() == 9 && now.minute() == 0) {
    if ((edo_Azul != 155) & (edo_Verde != 30) & (edo_Bco35 != 25)) {
      analogWrite(Azul, edo_Azul);
      analogWrite(Verde, edo_Verde);
      analogWrite(Bco35, edo_Bco35);
      edo_Azul--;
      edo_Verde++;
      edo_Bco35++;
      delay(120);
    }
  }
  if (now.hour() == 9 && now.minute() == 30) {
    if ((edo_Rojo != 80) & (edo_Verde != 80) & (edo_Rosa != 50) & (edo_Bco65 != 30) & (edo_Bco35 != 55)) {
      analogWrite(Rojo, edo_Rojo);
      analogWrite(Verde, edo_Verde);
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      edo_Rojo++;
      edo_Verde++;
      edo_Rosa++;
      edo_Bco65++;
      edo_Bco35++;
      delay(120);
    }
  }
  if (now.hour() == 12 && now.minute() == 20) {
    if ((edo_Rojo != 120) & (edo_Verde != 120) & (edo_Rosa != 80) & (edo_Bco65 != 70) & (edo_Bco35 != 70)) {
      analogWrite(Rojo, edo_Rojo);
      analogWrite(Verde, edo_Verde);
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      edo_Rojo++;
      edo_Verde++;
      edo_Rosa++;
      edo_Bco65++;
      edo_Bco35++;
      delay(120);
    }
  }
  if (now.hour() == 15 && now.minute() == 0) {
    if (edo_Rojo != 155) {
      analogWrite(Rojo, edo_Rojo);
      edo_Rojo++;
      delay(120);
    }
  }
  if (now.hour() == 18 && now.minute() == 50) {
    if ((edo_Rosa != 25) & (edo_Verde != 55) & (edo_Bco65 != 40) & (edo_Bco35 != 40)) {
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Verde, edo_Verde);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      edo_Rosa--;
      edo_Verde--;
      edo_Bco65--;
      edo_Bco35--;
      delay(120);
    }
  }
  if (now.hour() == 19 && now.minute() == 40) {
    if (edo_Azul != 255) {
      analogWrite(Azul, edo_Azul);
      edo_Azul++;
      delay(120);
    }
  }
  if (now.hour() == 20 && now.minute() == 0) {
    if ((edo_Verde != 0) & (edo_Rosa != 0) & (edo_Bco65 != 0) & (edo_Bco35 != 0) & (edo_Rojo != 0)) {
      analogWrite(Verde, edo_Verde);
      analogWrite(Rosa, edo_Rosa);
      analogWrite(Bco65, edo_Bco65);
      analogWrite(Bco35, edo_Bco35);
      analogWrite(Rojo, edo_Rojo);
      edo_Verde--;
      edo_Rosa--;
      edo_Bco65--;
      edo_Bco35--;
      edo_Rojo--;
      delay(120);
    }
  }
  if (now.hour() == 20 && now.minute() == 1) {
    digitalWrite(Rojo, LOW);
    digitalWrite(Verde, LOW);
    digitalWrite(Rosa, LOW);
    digitalWrite(Bco65, LOW);
    digitalWrite(Bco35, LOW);
  }
  if (now.hour() == 22 && now.minute() == 30) {
    if (edo_Azul != 0) {
      analogWrite(Azul, edo_Azul);
      edo_Azul--;
      delay(120);
    }
  }
  if (now.hour() == 22 && now.minute() == 31) {
    digitalWrite(Azul, LOW);
  }
  ////////////////---Fin de la Programacion---///////////////
}

Código con algunos cambios para mantener la luz si se va la energía

Tengo en mente integrar una lcd Oled y poner un modulo Bluetooth para controlar la intensidad desde el móvil

Notas: subí de nuevo el código porque había subido otro sin los cambios guardados que tenia hasta el momento, este código es el que uso si hubiera modificaciones las subiré

LamparaLed.ino (12.5 KB)

En mi opinión una lámpara de acuario debería tener un display, un encoder rotativo con pulsador, y el RTC.
NO se entiende porque usas los seis canales pwm. Si es un acuario plantado, el verde no es utilizado por las plantas. El rosa tampoco tiene sentido. Los utilizados son el azul y el rojo, pero falta el blanco para cuando tu quieras mirar el acuario, por lo tanto con tres canales estaría mas que bien, repartiendo el total de la potencia 33% de Rojo, 33% de azul, y 33% de blanco cálido y blanco frío.

Yo dividiría el día en minutos, o sea de 00 a 1440 (60 minutos por 24 horas) creando una variable en la función que muestra la hora en el display como esta: MinActual = now.hour()*60+now.minute();
Por ejemplo MinActual 555 equivale a 9 hs y 15 minutos.

Podrías definir dos periodos de iluminación por ejemplo byte sun_pwm[3]; y byte moon_pwm[3]. El tres es para almacenar el nivel de 0 a 255 de los tres canales de luces led's. Esto guardarlo en le eeprom, así como también la información a que minuto amanece y cuando termina el atardecer. Lo mismo con la salida y puesta de la luna, donde pones a funcionar solo el azul y un poco de blanco a baja intensidad.

Si bien para ti el código te funciona no es muy práctico. Debes hacer un menú para ajustar la fecha y hora y los niveles de iluminación sin tener que usar una computadora cada vez que quieras cambiar algo.

Al Bluetooth no le encuentro sentido. No es algo que debas ajustar a diario. Mejor sería integrar un termostato para aprovechar el arduino y controlar también la temperatura con un sensor Ds18b20 y para saber y bajar la temperatura de tu lampara puedes usar el propio sensor de temperatura del RTC

con Tlamp = rtc.getTemperature();

Saludos amigo.

Hola a tod@s, intento adaptar este código a mi proyecto, pero no consigo que los valores de las variables que controlan las salidas PWM me funcionen bien.
En el primer caso donde comienza a las 8:00, el valor de la variable de rojo, no sube mas de 10, y en el segundo caso, a las 8:01 los valores de rojo y blanco se pasan del valor asignado que en este caso es 70 y no paran de subir.
He intentado crear una condición para que si supera el valor deseado, iguale y fuerce el valor a este, por ejemplo,

if (ciclo_rojo>70)

{

ciclo_rojo==70;

}

Pero aun asi, tambien se pasa de este valor.

¿Podeis ayudarme a encontrar mi error?

//Date 07/08/2018
//Reloj con RTC DS3231 y display I2C

#include <Wire.h>
#include "RTClib.h"
RTC_DS3231 rtc;
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd( 0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE ); //0x3F direccion I2C display, resto pines de funcinamiento del display(no variarlo) no tiene que ver con arduino, POSITIVE back light


const int out_blanco=3;  //Nombra out_blanco para pin 3
const int out_azul=6;
const int out_rojo=5;
int ciclo_blanco=0; // ciclo de trabajo WFM salida led
int ciclo_azul=0;
int ciclo_rojo=0;
int teclado = A0; // Pin A0 entreda teclado pulsadores
int key=0;


//byte amanecer=0;
//byte zenit=0;
//byte atardecer=0;
//byte ocaso=0;

int a=0;






void setup()
   {
   Serial.begin(9600);  
   delay(3000); // wait for console opening



    if (! rtc.begin()) //No se porque, pero es necesario para pasar la hora a Arduino por el puerto serie
  {
    //Serial.println("Couldn't find RTC");
    while (1);
  }
   
    //USAR UNO DE ESTOS DOS COMANDOS PARA PONER EN HORA EL RTC. LUEGO COMPILAR DE NUEVO ANULANDO LA LINEA
   //rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); //Ajusta la hora a la del PC en el momento de compilar
    rtc.adjust(DateTime(2014, 1, 21, 7, 59, 55)); // Ajusta la hora a la indicada (año, mes, dia, hora, minuto, segundo)

    analogWrite(out_blanco,LOW);  
    pinMode (out_blanco, OUTPUT);  // configura out_blanco "pin3" como salida
    analogWrite(out_azul,LOW);  
    pinMode (out_azul, OUTPUT);  // configura out_azul "pin9" como salida
    analogWrite(out_rojo,LOW);  
    pinMode (out_rojo, OUTPUT);  // configura out_rojo "pin5" como salida
    
    Serial.begin(9600);
    Wire.begin();
    lcd.begin (16,2);    // Inicializar el display con 16 caraceres 2 lineas
    
   }
   
void loop()
{
 lcd.clear();  
 lcd.home (); 
  
key=analogRead(teclado); //////////////////////////////////////////////////////////LEO LOS SWITCH DEL TECLADO
if ((key>900) && (key<1024)) lcd.print("arriba");
if ((key>700) && (key<900)) lcd.print("abajo");
if ((key>550) && (key<700)) lcd.print("derecha");
if ((key>400) && (key<550)) lcd.print("izquierda");
if ((key>200) && (key<400)) lcd.print("centro");
   
    DateTime now = rtc.now(); 
//    lcd.print(now.year(), DEC);
//    lcd.print('/');
//    if (now.month()<=9) lcd.print('0'); // Si es valor < a 9 pongo un cero para que los caracteres sean siemopre de dos digitos 00:00:00
//    lcd.print(now.month(), DEC);
//    lcd.print('/');
//    if (now.day()<=9) lcd.print('0');
//    lcd.print(now.day(), DEC);

lcd.print("R:");
lcd.print(ciclo_rojo);
lcd.print(" W:");
lcd.print(ciclo_blanco);
lcd.print(" B:");
lcd.print(ciclo_azul);



    
    lcd.setCursor ( 0, 1 ); 
    if (now.hour()<=9) lcd.print('0');
    lcd.print(now.hour(), DEC);
    lcd.print(':');
    if (now.minute()<=9) lcd.print('0');
    lcd.print(now.minute(), DEC);
    lcd.print(':');
    if (now.second()<=9) lcd.print('0');
    lcd.print(now.second(), DEC);

   
    
if(now.hour()==8) //Si son las 8
  {      
      if ((ciclo_rojo != 20) & (ciclo_blanco != 10)) 
        {
          analogWrite(out_rojo,ciclo_rojo);
          analogWrite(out_blanco,ciclo_blanco);
         // analogWrite(out_azul,ciclo_azul);
          ciclo_rojo++;
          ciclo_blanco++;
          //ciclo_azul++;
          delay(150);
        }
  
}

if((now.hour()==8) & (now.minute()==1)) 
  {      
      if ((ciclo_rojo != 25) & (ciclo_blanco != 35)& (ciclo_azul != 45)) 
        {
          analogWrite(out_rojo,ciclo_rojo);
          analogWrite(out_blanco,ciclo_blanco);
          analogWrite(out_azul,ciclo_azul);
          ciclo_rojo++;
          ciclo_blanco++;
          ciclo_azul++;
          delay(150);
        }
  }
  
delay(50);
}

Observa que la condición if((now.hour()==8) & (now.minute()==1)) se da durante un minuto al día pero la condición if(now.hour()==8) se da durante toda una hora, incluso durante el primer minuto.

A mi entender, el código esta mal planteado si lo que se pretende hacer es una buena lámpara para acuario con efecto amanecer y anochecer.

Primero de debe definir una variable con byte sun_pwm[3] si quieres solo un ciclo de iluminación y moon_pwm[3] si quieres un ciclo de luna.

El el setup recuperas el valor PWM desde la eeprom de la siguiente forma

  for(byte addr=0;addr<3;addr++)   { sun_pwm[addr] = EEPROM.read(addr);  }  // Niveles PWM modo Sol  Byte 0 a 2
  int x=0;
  for(byte addr=3;addr<6;addr++)  { moon_pwm[x] = EEPROM.read(addr);  x++; } // Niveles PWM modo Luna  Byte 3 a 5

De esta forma tendrás desde el byte 0 a 5 de la eeprom los valores para sun_pwm[0]; sun_pwm[1]; sun_pwm[2]; moon_pwm[0]; moon_pwm[1] y moon_pwm[2];

Cuando haces el menú fijas los niveles y lo guardas en la eeprom.

Con respecto al reloj RTC lo mejor es tener una función como esta y llamarla cada cierta cantidad de segundos o cada minuto desde el loop pero antes debes crear la variable global int MinActual que contendrá un valor desde 0 a 1440 que es el resultado de 60 minutos por 24 horas. De esta forma cada minuto del día tiene un valor.

void ImprimeHora() {
  DateTime now = rtc.now();
/*

Aquí lo que quieras imprimir en pantalla

*/
   MinActual = now.hour()*60+now.minute();
   
}

De esta forma puede hacer una condición if (MinActual >= MSolHoraInicio && MinActual <= MSolHoraFin) { }
para saber que estas dentro del periodo de iluminación Sol y if (MinActual > MLunaHoraInicio && MinActual < MLunaHoraFin){ } para cuando estas en el periodo de Luna.

Si solo quieres practicar con esto creo que ya tienes material para comenzar, pero si necesitas una lámpara de acuario te paso el código entero que esta para un arduino uno o nano, un RTC DS3231, un encoder rotatorio, una pantalla 20x4 con adaptador I2C, un sensor Ds18b20 y maneja 4 canales de led's.

Saludos

Gracias Daniel, voy a ir trabajando con los comentarios que haces, a ver si soy capaz de darle forma.

Saludos

Hola Daniel_Arg si tengo pensado poner una pantalla lcd y unos botones pero por ahora nada mas juego para ver si podia armar mi lampara y sobre todo que funcionara nada mas que me limita mi poco conocimiento en programacion, soy novato de hecho soy contador publico que juega a programar unos leds

El tema de la memoria eeprom me agradaba la opcion pero cuando vi lo que tenia que hacer para programar usandola se me complicó aun mas por eso decidi hacerlo de esa manera uso 6 tipos de luz para hacer combinaciones al inicio de del periodo de luz y al final pero en el punto medio es el que mi plantado lo aprovecha
Actualmente uso leds Azules, Rojos, Rosas, Verdes, Blancos 6500k y Blancos 35000k. Los leds Verdes y Rosas los utilizo para complimentar un poco el espectro de luz y los Blancos 35000k para darle un poco de claridad a ciclo intermedio ya que los importantes son los Azules, Rojos y Blancos 6500k

Tambien uso unos ventiladores para regular la temperatura de la lampara utilizando el sensor del RTC el modulo Bluetooth es para usarlo a control manual desde mi celular y enviar los datos de la intensidad de los leds, temperatura y mas adelante integrar sondas de calidad de agua y temperatura para visualizar tambien en mi cel por medio de Blynk y claro en la lcd de la lamapara

En este post vamos a hacer un diseño de una lámpara de acuario.
Tal vez si sigues el proyecto con un protoboard puedas entender el código y al final hacerle tus propias modificaciones.

Hola ea7ln
Cuando fijas a una hora que deberá encender los leds y este mismo tendrá un efecto por desvanecimiento utilizando esta función

if((now.hour()==8) & (now.minute()==1))

Esta función yo la utilizaba pero es muy exacta si quisieras que el desvanecimiento dura mas de un minuto en alcázar su valor al finalizar el minuto se quedaría a medias por eso mejor utilice esta otra forma por rango de horas así alcanza su valor dentro de ese rango

if (now.hour() >= 8 && now.hour() < 9)

Otra cosa en esta parte de tu código te recomiendo usarlo por separado cada valor de cada led y el aumento porque eso origina que si el valor de rojo=20 y blanco=10 arduino tomara el valor de 20 para los 2 colores o haga que se vayan subiendo hasta alcanzar el máximo valor de 255 y se reinicie

if(now.hour()==8) //Si son las 8
  {      
      if ((ciclo_rojo != 20) & (ciclo_blanco != 10)) 
        {
          analogWrite(out_rojo,ciclo_rojo);
          analogWrite(out_blanco,ciclo_blanco);
         // analogWrite(out_azul,ciclo_azul);
          ciclo_rojo++;
          ciclo_blanco++;
          //ciclo_azul++;
          delay(150);
        }
  
}

En mi ultimo código yo utilizaba mejor de esta forma por separado asignar el valor a cada color y tiene un valor mas exacto de la intensidad de cada color y usando la función milis le doy el tiempo para incrementar o disminuir la intensidad y también cree una variable para cada estado de color para esa variable pasarla por el Serial.print(); y saber cuanto es su valor en el que se encuentra

  if (now.hour() >= 10 && now.hour() < 11) {
    unsigned long actual4 = millis();
    if (actual4 - previo4 >= espera4) {
      previo4 = actual4;
      if (edoAzul != 200) {
        analogWrite(ledAzul, edoAzul);
        edoAzul++;
      }
      if (edoBco35 != 70) {
        analogWrite(ledBco35, edoBco35);
        edoBco35++;
      }
      if (edoVerde != 70) {
        analogWrite(ledVerde, edoVerde);
        edoVerde++;
      }
      if (edoRosa != 20) {
        analogWrite(ledRosa, edoRosa);
        edoRosa++;
      }
      espera4 = 8000;
    }
  }

Hola edgarll182, con los comentarios que me hicisteis y con algunos días de trabajo, he terminado el proyecto y ya está funcionado. Bueno, realmente terminado nunca estará porque ya se me ocurren cosas para mejorarlo e implementar funciones.
El mismo dispositivo controla la iluminación, y la temperatura de forma independiente de dos acuarios.
La iluminaciín es unica para los dos.
Lo adjunto por si a alguien le interesa y o quiere mejorarlo.

Automata_acuario_ver1.1.ino (20.9 KB)

Que bueno que pudistes terminar tu proyecto me da gusto

Saludos amigo

Buenas, se use el hilo lleva ya mucho tiempo parado. Quiero realizar este proyecto en mi acuario, pero no veo como se conecta el LCD al Arduino, podrías poner el esquema. Gracias

Este hilo se completó en Proyectos, y lo llevó adelante @ea7ln y @Daniel_Arg y luego este forero se molestó y borró sus respuestas. Pero @ea7ln completó la tarea.
No revivas hilos viejos con mas de 120 dias.
Te respondo para que busques por ahi, pero de nuevo, si el hilo esta con mas de 120 dias, no lo revivas. Le pregutnas por privado y si no responde, creas un hilo nuevo.

Hola buenos días una disculpa pedro68 e pasado a otro nuevo proyecto muy similar controlado con un Esp32 y controlado con la plataforma de Blynk, nada mas que aun estoy trabajando en el pero si tengo en mente subirlo mas adelante aquí como proyecto

--Algunas de las cosas que no pienso usar es la pantalla LCD o si por alguna razón integro una, seria la pantalla Oled 128*64 para una bomba dosificadora pero seria opcional
--Integrar un sensor de pH
--Sensor de temperatura del Acuario (Para controlar On/Off del Calentador)
--Sensor de Nivel de Agua con Sensor Ultrasonico
--Modulo de 4 Reles para controlar bomba de agua para subida, calentador, Válvula Solenoide (Integrare 4 Botones para On/Off de Forma manual, aunque esto también se puede hacer por medio de Blynk).
--Lampara con efecto Amanecer/Anochecer
--Soporte Blynk (Ajuste de Hora para On/Off de Lampara, Ajuste de porcentaje para Luz Dimeable, Ajuste temperatura para On/Off de calentador y Monitoreo de temperatura de Lampara, Acuario y pH)

Ya a futuro intentare implementar una bomba dosificadora para abonar al acuario y entre otras cosas, nada mas que tengo un inconveniente que en la parte donde vivo no puedo conseguir los materiales que necesito y tengo que encargarlo por internet y me demora el tiempo de llegada de cada material, aunque ya tengo mucho avance me faltan pocas piezas para terminar pero cuando lo tenga asiendo pruebas subo mis esquemas y códigos

Veo que no hay caso... les pongo que no revivian hilos viejos y comiencen un hilo nuevo pero siguen comantando éste!!
Hilo cerrado.