Go Down

Topic: Problemas con efectos de luces para belen (Read 2687 times) previous topic - next topic

noter

Bien. Comienza al menos poniendo los dos programas con los pines definitivos e intentaremos unificarlos (porque nos has despertado el espíritu navideño y eso :) ), a condición de que posteriormente nos muestres un vídeo con el resultado.

elpilas

#16
Dec 15, 2017, 08:28 pm Last Edit: Dec 16, 2017, 07:53 am by elpilas
Bueno pues los códigos son los mostrados con anterioridad:

El primero es el modificado por noter, es el encargado de los efectos de las estrellas y las fogatas.

Code: [Select]

const int estrellas1 = 2;    // led blanco
const int estrellas2 = 3;   // led blanco
const int llama1 = 5;    // led rojo
const int llama2 = 6;   // led naranja
const int llama3 = 7;   // led naranja
const int llama11 = 8;    // led rojo


void setup() {
    pinMode(estrellas1, OUTPUT);
    pinMode(estrellas2, OUTPUT);
    pinMode(llama1, OUTPUT);
    pinMode(llama2, OUTPUT);
    pinMode(llama3, OUTPUT);
    pinMode(llama11, OUTPUT);

}

void loop() {
  estrellas();
  llamas();
}

void estrellas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(estrellas1, random(5,200));
    analogWrite(estrellas2, random(50,255));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,200);
  }
}

void llamas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(llama1, random(10,220));
    analogWrite(llama2, random(30,255));
    analogWrite(llama3, random(10,255));
    analogWrite(llama11, random(20,240));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,50);
  }
}


El segundo es el encargado de realizar los ciclos día/noche.

Code: [Select]


int dia = 4;    // LED blanco cielo pin d04
int noche=9;   // LED azul cielo pin d09
int casa1=11;    // LED de casa arabe pin d11
int transicion=10;   //LED rojo atardecer
int casa2=12;    // LED de casa pequeña pin d12
int casa3=13;   // LED de casa grande pin d13


void setup()  {
  // nada
}

void loop()  {
  // hacerse de día:
  for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=1) {
    if  (fadeValue<255)
    {digitalWrite(transicion,HIGH);}
      else
    {digitalWrite(transicion,LOW);}
    analogWrite(noche,255-fadeValue);
    analogWrite(dia, fadeValue);
    delay(300);

    if (fadeValue<70)
      {digitalWrite (casa1,HIGH);}
      else
      {digitalWrite (casa1,LOW);}
     if (fadeValue<65)
      {digitalWrite (casa2,HIGH);}
      else
      {digitalWrite (casa2,LOW);}  
     if (fadeValue<40)
      {digitalWrite (casa3,HIGH);}
      else
      {digitalWrite (casa3,LOW);}
    
    delay(150);                        
  }
  delay (120000);
  // hacerse de noche:
  for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=1) {
    analogWrite(dia, fadeValue);
    if (fadeValue>0)
       {digitalWrite(transicion,HIGH);}
       else
       {digitalWrite(transicion,LOW);}
    analogWrite(noche,255-fadeValue);
    delay (300);

    analogWrite(noche,255-fadeValue);
    if (fadeValue<110)
      {digitalWrite (casa1,HIGH);}
      else
      {digitalWrite (casa1,LOW);}
     if (fadeValue<105)
      {digitalWrite (casa2,HIGH);}
      else
      {digitalWrite (casa2,LOW);}  
     if (fadeValue<80)
      {digitalWrite (casa3,HIGH);}
      else
      {digitalWrite (casa3,LOW);}
      
    delay(150);                            
  }
  delay (120000);
}


En cuanto al video no hay problema,nada mas tenga el montaje hecho lo subo.

Y si alguno se viene por sevilla lo mismo cae hasta un polvoroncito con su correspondiente copa de anís.

Muchas gracias

noter

No he podido probarlo, y me gustaría comentarlo un poco para que tenga utilidad; pero para que vayas masticando algo:
Code: [Select]

const int estrellas1 = 2;    // led blanco
const int estrellas2 = 3;   // led blanco
const int estrellas3 = 4;   // led blanco
const int llama1 = 5;    // led rojo
const int llama2 = 6;   // led naranja
const int llama3 = 7;   // led naranja
const int llama11 = 8;    // led rojo
const int llama12 = 9;   // led naranja
const int llama13 = 10;   // led naranja

void setup() {
    pinMode(estrellas1, OUTPUT);
    pinMode(estrellas2, OUTPUT);
    pinMode(estrellas3, OUTPUT);
    pinMode(llama1, OUTPUT);
    pinMode(llama2, OUTPUT);
    pinMode(llama3, OUTPUT);
    pinMode(llama11, OUTPUT);
    pinMode(llama12, OUTPUT);
    pinMode(llama13, OUTPUT);
}

void loop() {
  estrellas();
  llamas();
}

void estrellas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) > siguienteDestello) {
    analogWrite(estrellas1, random(5,200));
    analogWrite(estrellas2, random(50,255));
    analogWrite(estrellas3, random(10,150));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,200);
  }
}

void llamas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) > siguienteDestello) {
    analogWrite(llama1, random(10,220));
    analogWrite(llama2, random(30,255));
    analogWrite(llama3, random(10,255));
    analogWrite(llama11, random(20,240));
    analogWrite(llama12, random(15,250));
    analogWrite(llama13, random(40,150));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,50);
  }
}

Ya me comentarás si hace algo o no ;).

elpilas

#18
Dec 16, 2017, 11:34 am Last Edit: Dec 16, 2017, 11:39 am by elpilas
Buenos días, noter, este ultimo código que mandaste si funciona por si solo, de hecho es el que tu me modificaste anteriormente introduciendo en el "millis". El problema viene cuando lo unes al de ciclos día/noche ya que las cadencias del código de estrellas/llamas se relentizan perdiendo su parpadeo original.  Por eso tal y como me pediste, en mi anterior post puse los dos códigos separados, en primer lugar el que tu modificaste,  es decir, este ultimo que has mandado nuevamente  y en segundo lugar el de ciclos día/noche rectificando ambos para adaptarlo, en las salidas necesarias, a un arduino mega.

Gracias

IgnoranteAbsoluto

Entiendo que las estrellas y las fogatas han de estar "activas" mientras sea de noche. Y que las luces de las casas estén encendidas de noche y apagadas de día. Entiendo que en la transición de la noche al día han de ir apagándose las casas "escalonadamente". Y en la transición del día a la noche las casas se han de encender "escalonadamente".

Pero lo que no tengo claro es qué quieres que hagan las estrellas y las fogatas en las transiciones de noche a día y de día a noche. Así como para qué son las salidas dia, noche y transicion (tal vez las tengas sólo para depurar el programa o tal vez tienen un cometido que no he entendido).

¿Podrías aclararme más detalladamente qué es lo que quieres que haga todo en conjunto?

elpilas

#20
Dec 16, 2017, 03:25 pm Last Edit: Dec 16, 2017, 03:33 pm by elpilas
Buenos días, voy a intentar aclarar que hace el programa en su conjunto a ver si podéis echarme una manilla.
Al conectar la alimentación de arduino el programa arranca en transición noche/día, en el cual solo están activas las salidas día, noche y transición (en Faded todas ellas) simulando el amanecer. Una vez transcurridos 1' y 15" aproximadamente se termina esa transición quedándose activa solo la salida "día". Pasados 2' comienza la transición día/noche activándose nuevamente las otras dos salidas ( día, que ya estaba, transición y noche, que se hacen activas),  pasados nuevamente 1' y 15" se apagan las salidas transición y día quedándose activa solamente la salida noche. En este periodo de transición día/noche es cuando gradualmente se encienden las estrellas, fogatas y luces de las casas. Pasados de nuevo 2' el programa entra otra vez en transición noche /día finalizando así un ciclo completo. Las estrellas, fogatas y casas están encendidas en la parte del ciclo correspondiente a "noche" y en parte de las dos transiciones, noche/día y día/noche.
Las salidas, día, noche y transición son salidas activas que van a gobernar las tiras de leds de los colores correspondientes con un driver bc337 y un MOSFET irf 530/540.
Eso es lo que quiero que haga.
Uniendo los programas las cadencias de las estrellas y llamas varian dando lugar a un efecto irreal, muy alejado de como actúa el programa en solitario.

Muchas gracias por el interes

noter

#21
Dec 16, 2017, 06:31 pm Last Edit: Dec 16, 2017, 08:13 pm by noter
Perdona, porque me pilló que iba a salir justo y con las prisas adjunté el mismo código de la última vez, sin el amanecer/anochecer.
Este era el código que te quise poner:

Code: [Select]
const int estrellas1 = 2;    // led blanco
const int estrellas2 = 3;   // led blanco
const int dia = 4;    // LED blanco cielo pin d04
const int llama1 = 5;    // led rojo
const int llama2 = 6;   // led naranja
const int llama3 = 7;   // led naranja
const int llama11 = 8;    // led rojo
const int noche=9;   // LED azul cielo pin d09
const int transicion=10;   //LED rojo atardecer
const int casa1=11;    // LED de casa arabe pin d11
const int casa2=12;    // LED de casa pequeña pin d12
const int casa3=13;   // LED de casa grande pin d13

int fadeValue=0;

void setup() {
// iniciamos todos los analógicos apagados
for(int i=2; i<=10; i++) {
analogWrite(i, 0);
}

// Como vamos a iniciar amaneciendo, empezamos con las casas encendidas.
// Al ser también pines PWM, podríamos definir un brillo diferente para
// cada casa con analogWrite en lugar de digitalWrite

for(int i=10; i<=13; i++){
    pinMode(i, OUTPUT);
    digitalWrite(i, HIGH);
}
}

void loop() {
ciclodia();
estrellas();
llamas();
}

void ciclodia()  {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=450;
  enum {amaneciendo, dia, anocheciendo, noche} static estado=amaneciendo;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    ultimoDestello += siguienteDestello;
  switch (estado) {
      case amaneciendo:
        fadeValue++;
    analogWrite(noche,255-fadeValue);
    analogWrite(dia, fadeValue);
        if (fadeValue==70) {
        digitalWrite(casa1, LOW);
        }
        else if(fadeValue==65){
            digitalWrite(casa2, LOW);
        }
        else if(fadeValue==40){
            digitalWrite(casa3, LOW);
        }
        else if(fadeValue==255){
            digitalWrite(transicion, LOW);
            estado=dia;
            siguienteDestello = 120000;
        }
        break;
      case dia:
        estado = anocheciendo;
        siguienteDestello=450;
        digitalWrite(transicion, HIGH);
        break;
      case anocheciendo:
        fadeValue--;
    analogWrite(noche,255-fadeValue);
    analogWrite(dia, fadeValue);
        if (fadeValue==110) {
        digitalWrite(casa1, HIGH);
        }
        else if(fadeValue==105){
            digitalWrite(casa2, HIGH);
        }
        else if(fadeValue==80){
            digitalWrite(casa3, HIGH);
        }
        else if(fadeValue==0){
        digitalWrite(transicion, LOW);
            estado=noche;
            siguienteDestello = 120000;
        }
        break;
      case noche:
        estado = amaneciendo;
        siguienteDestello=450;
        digitalWrite(transicion, HIGH);
        break;
    }
  }
}

void estrellas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(estrellas1, random(5,200));
    analogWrite(estrellas2, random(50,255));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,200);
  }
}

void llamas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(llama1, random(10,220));
    analogWrite(llama2, random(30,255));
    analogWrite(llama3, random(10,255));
    analogWrite(llama11, random(20,240));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,50);
  }
}

Te vuelvo a decir lo mismo; que no está probado, así que seguramente tendrá cosas que corregir, pero será a buen seguro buen punto de partida.
Por ejemplo, las estrellas y las llamas están constantemente encendidas, así que habrá que decidir cómo se comportarán durante el amanecer/anochecer.
Ya me contarás.
Saludos.

elpilas

Buenas tardes,antes de nada volver a agradeceros la atención y ayuda que me estáis prestando.He montado el circuito al completo con todos sus leds para ver como se comporta el conjunto y os voy a relatar como se actua el código :

Al conectar la alimentación del arduino parpadea 2 veces la salida de la casa 3 y a continuación se activan las salidas: llamas 1,2,3 y 4;estrellas 1 y 2;casas 1,2 y 3;y transición.

Las salidas " llamas " y " estrellas " como bien apuntaba el amigo noter están siempre activas independientemente del punto en que se encuentre el código bien sea día o noche,desde que se conecta la alimentación de la placa no se desactivan nunca .

Por otra parte, las salidas día y noche no se activan nunca,están siempre apagadas.

Otra cosa curiosa es que " transición" entra y sale de forma brusca, es decir, no hay faded en esa salida.

Así que a investigar toca a ver hasta donde puedo llegar.

Gracias y un saludo

noter

De lo que comentas, casi todo era lo esperado, menos una cosa. Que "transición" entre y salga de forma brusca se explica porque, al igual que las casas, lo estamos tratando como pin de salida digital (y escribimos HIGH/LOW con digitalWrite). Por ello recomendaba en el comentario ponerlos también como analógicos, para poder definir distintos brillos para cada casa, aunque luego sean fijos y no "centelleantes".
Lo que me mosquea más es que las salidas día y noche estén siempre apagadas, pues estoy casi seguro de que se les está enviando valor analógico ascendente/descendente durante las transiciones.
Vamos a hacer una cosa. Vamos a asignar a "transición" el mismo valor que a "día" a ver si hace o no fade, y dirimir si es problema de soft o de hard.
¡Vale! Acabo de descubrir un desafortunado fallo. He llamadao igual al pin del led dia que a uno de los ciclos. Prueba ahora y me comentas el nuevo comportamiento. Está un poco acelerado el ciclo día/noche, para poder evaluarlo más rápido, pero eso sería fácilmente corregible.

Code: [Select]

const int estrellas1 = 2;    // led blanco
const int estrellas2 = 3;   // led blanco
const int dia = 4;    // LED blanco cielo pin d04
const int llama1 = 5;    // led rojo
const int llama2 = 6;   // led naranja
const int llama3 = 7;   // led naranja
const int llama11 = 8;    // led rojo
const int noche=9;   // LED azul cielo pin d09
const int transicion=10;   //LED rojo atardecer
const int casa1=11;    // LED de casa arabe pin d11
const int casa2=12;    // LED de casa pequeña pin d12
const int casa3=13;   // LED de casa grande pin d13

int fadeValue=0;

void setup() {
// iniciamos todos los analógicos apagados
for(int i=2; i<=9; i++) {
analogWrite(i, 0);
}

// Como vamos a iniciar amaneciendo, empezamos con las casas encendidas.
// Al ser también pines PWM, podríamos definir un brillo diferente para
// cada casa con analogWrite en lugar de analogWrite

for(int i=10; i<=13; i++){
    analogWrite(i, 255); // Analógicas también, pero encendidas al inicio.
}
}

void loop() {
ciclodia();
estrellas();
llamas();
}

void ciclodia()  {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=100;
  enum {amaneciendo, diurno, anocheciendo, nocturno} static estado=amaneciendo;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    ultimoDestello += siguienteDestello;
  switch (estado) {
      case amaneciendo:
        fadeValue++;
      analogWrite(noche,255-fadeValue);
      analogWrite(dia, fadeValue);
          analogWrite(transicion, fadeValue);
        if (fadeValue==70) {
        analogWrite(casa1, 0);
        }
        else if(fadeValue==65){
            analogWrite(casa2, 0);
        }
        else if(fadeValue==40){
            analogWrite(casa3, 0);
        }
        else if(fadeValue==255){
            //analogWrite(transicion, 0);
            estado=diurno;
            siguienteDestello = 12000;
        }
        break;
      case diurno:
        estado = anocheciendo;
        siguienteDestello=100;
        //analogWrite(transicion, 255);
        break;
      case anocheciendo:
        fadeValue--;
      analogWrite(noche,255-fadeValue);
      analogWrite(dia, fadeValue);
          analogWrite(transicion, fadeValue);
        if (fadeValue==110) {
        analogWrite(casa1, 255);
        }
        else if(fadeValue==105){
            analogWrite(casa2, 255);
        }
        else if(fadeValue==80){
            analogWrite(casa3, 255);
        }
        else if(fadeValue==0){
        //analogWrite(transicion, 0);
            estado=nocturno;
            siguienteDestello = 12000;
        }
        break;
      case nocturno:
        estado = amaneciendo;
        siguienteDestello=100;
        //analogWrite(transicion, 255);
        break;
    }
  }
}

void estrellas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(estrellas1, random(5,200));
    analogWrite(estrellas2, random(50,255));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,200);
  }
}

void llamas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(llama1, random(10,220));
    analogWrite(llama2, random(30,255));
    analogWrite(llama3, random(10,255));
    analogWrite(llama11, random(20,240));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,50);
  }
}

elpilas

#24
Dec 17, 2017, 06:15 pm Last Edit: Dec 17, 2017, 06:32 pm by elpilas
Buenas de nuevo,bueno te explico como se comporta ahora.

Al conectar la alimentación pasan a nivel alto las tres salidas,día,noche y transición.
Transcurrido un tiempo ,de manera gradual se apaga la salida noche quedándose activas las salidas transición y día. Sin llegar a apagarse estas dos ultimas salidas, vuelve a conectarse la salida noche estando otra vez las tres activas. Después de un tiempo comienzan a apagarse de forma gradual las salidas transición y día quedándose a nivel alto solo la salida noche y comenzando un nuevo ciclo.
En definitiva, mientras que están conectadas las salidas transición y día se enciende y apaga 2 veces la salida noche y la salida día en ningún momento esta activa por si sola.
Por un lado esta encendida solo la salida noche en una parte del ciclo y por otra están encendidas a la vez día y transición en otra parte del ciclo.
Los apagados y encendidos ahora mismo si se hacen de manera gradual en todas las salidas

noter

Pues hay algo que no me cuadra. Pongo nueva versión esencialmente igual, pero con unas constantes definidas arriba para cambiar fácilmente los parámetros de temporización. No he entendido mucho el cómo se está comportando actualmente en cada ciclo. Nada más conectar, debería iniciar amaneciendo, es decir, "noche" disminuyendo de 255 a 0 y "dia" creciendo de 0 a 255. Prueba a ver el código como está, y después comenta en el loop las llamadas a estrellas() y llamas() y deja sólo la llamada a ciclodia() y me dices cómo hacen las iluminaciones correspondientes. Actualmente "transición" debería comportarse como un espejo de "día".
Code: [Select]

const int DURACION_DIA=12000; // AUMENTAR PARA ALARGAR DURACIÓN DÍA
const int DURACION_NOCHE=12000; // AUMENTAR PARA ALARGAR DURACIÓN NOCHE
const int LAPSO_TRANSICION=50; // AUMENTAR PARA HACER EL AMANECER/ANOCHECER MÁS LENTO

const int estrellas1 = 2;    // led blanco
const int estrellas2 = 3;   // led blanco
const int dia = 4;    // LED blanco cielo pin d04
const int llama1 = 5;    // led rojo
const int llama2 = 6;   // led naranja
const int llama3 = 7;   // led naranja
const int llama11 = 8;    // led rojo
const int noche=9;   // LED azul cielo pin d09
const int transicion=10;   //LED rojo atardecer
const int casa1=11;    // LED de casa arabe pin d11
const int casa2=12;    // LED de casa pequeña pin d12
const int casa3=13;   // LED de casa grande pin d13

int fadeValue=0;

void setup() {
// iniciamos todos los analógicos apagados
for(int i=2; i<9; i++) {
analogWrite(i, 0);
}

// Como vamos a iniciar amaneciendo, empezamos con las casas encendidas.
// Al ser también pines PWM, podríamos definir un brillo diferente para
// cada casa con analogWrite en lugar de analogWrite

for(int i=9; i<=13; i++){
    analogWrite(i, 255); // Analógicas también, pero encendidas al inicio.
}
}

void loop() {
ciclodia();
estrellas();
llamas();
}

void ciclodia()  {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=LAPSO_TRANSICION;
  enum {amaneciendo, diurno, anocheciendo, nocturno} static estado=amaneciendo;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    ultimoDestello += siguienteDestello;
  switch (estado) {
      case amaneciendo:
        fadeValue++;
      analogWrite(noche,255-fadeValue);
      analogWrite(dia, fadeValue);
          analogWrite(transicion, fadeValue);
        if (fadeValue==70) {
        analogWrite(casa1, 0);
        }
        else if(fadeValue==65){
            analogWrite(casa2, 0);
        }
        else if(fadeValue==40){
            analogWrite(casa3, 0);
        }
        else if(fadeValue==255){
            //analogWrite(transicion, 0);
            estado=diurno;
            siguienteDestello = DURACION_DIA;
        }
        break;
      case diurno:
        estado = anocheciendo;
        siguienteDestello=LAPSO_TRANSICION;
        //analogWrite(transicion, 255);
        break;
      case anocheciendo:
        fadeValue--;
      analogWrite(noche,255-fadeValue);
      analogWrite(dia, fadeValue);
          analogWrite(transicion, fadeValue);
        if (fadeValue==110) {
        analogWrite(casa1, 255);
        }
        else if(fadeValue==105){
            analogWrite(casa2, 255);
        }
        else if(fadeValue==80){
            analogWrite(casa3, 255);
        }
        else if(fadeValue==0){
        //analogWrite(transicion, 0);
            estado=nocturno;
            siguienteDestello = DURACION_NOCHE;
        }
        break;
      case nocturno:
        estado = amaneciendo;
        siguienteDestello=LAPSO_TRANSICION;
        //analogWrite(transicion, 255);
        break;
    }
  }
}

void estrellas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(estrellas1, random(5,200));
    analogWrite(estrellas2, random(50,255));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,200);
  }
}

void llamas() {
  static unsigned long ultimoDestello=0;
  static unsigned long siguienteDestello=0;
  if ((millis()-ultimoDestello) >= siguienteDestello) {
    analogWrite(llama1, random(10,220));
    analogWrite(llama2, random(30,255));
    analogWrite(llama3, random(10,255));
    analogWrite(llama11, random(20,240));
    ultimoDestello+=siguienteDestello;
    siguienteDestello = random(1,50);
  }
}


Deberías ir pensando también cómo quieres que se comporten las hogueras y las estrellas de día, y durante el amanecer o anochecer.

elpilas

Se pueden subir videos directamente al hilo?

noter

No. Deberías subirlos a youtube y poner un vínculo.

elpilas

Vamos a ver si puedo explicarme que es lo que hace el codigo:

Comineza amaneciendo con " noche" activa e inmediatamente despues se activan "transicion y dia " de manera gradual. A demas se activan nada mas conectar la alimentacion las casas.

Cuando empiezan a encerder " transicion y dia" las casa comienzan a apagarse de manera gradual.

Pasado un tiempo "noche" se apaga quedandose activas "dia y transicion"

Transcurrido un tiempo "noche" comienza a encenderse otra vez sin que se hayan apagado "transicion y dia"(en este punto "transicion" tendria que haberse apagado hace un rato y haberse quedado solo "dia").
pasado un tiempo,"transicion y dia" se pagan quedandose solo "noche".

En esta parte del ciclo las casa comienzan a encenderse y permanecen encendidas hasta que llega el amanecer nuevamente.

Las llamas y las estrellas estan siempre encendidas,las he comentado y el ciclo dia / noche se comporta de la misma manera que si estuvieran activas.

En cuanto a cuando tendrian que activarse/desactivarse estrellas y fuego,pues el mismo intervalo que casas: anochecer/noche/amanecer.

Espero haberme explicado correctamente.

IgnoranteAbsoluto

Aquí tienen mi propuesta. Ya sé que va a ser un poco complicada de entender, pero no tengo tiempo de explicarla con detalle, sobre todo el uso de las clases y la herencia. Algo de las clases y máquinas de estado lo explico en unas respuestas del post alarma temporizada en un mismo led al presionar un botón.

He usado las clases y la herencia para definir tres tipos de objetos que heredan de ObjetoLED. Estrella Fogata y Casa. Cada una de las tres clases controla un tipo de elemento. Y todos los elementos son controlados por otra clase, DiaNoche, que se encarga de controlar el día, la noche, el anochecer y el atardecer. Para facilitar el control por parte de DiaNoche de todos los elementos, son todos tratados por igual como ObjetoLED mediante el paso de la referencia del array objetos[ ] que contiene referencia a todos ellos.

Se pueden definir y añadir al array objetos[] tantos elementos como se quiera (siempre que se tengan pines disponibles).

DiaNoche controla también los LED de "día", "noche" y "transición". Internamente controla "la luz del Sol" cuyo valor es 0 cuando es de noche y 255 cuando es de día. Obviamente en la transición del anochecer o el amanecer irá adquiriendo valores entre el 0 y el 255. Uno de los parámetros de cada objeto es luzSolApagado y es el valor que ha de tener "la luz del Sol" para saber en qué momento de las trancisiones se  han de apagar o de encender cada uno.

Las casas se encienden y se apagan, sin más, al anochecer y al amanecer. No "parpadean".

Las estrellas y las fogatas "parpadean" cuando están encendidas. El tiempo de encendido y la intensidad son aleatorios entre unos márgenes que se establecen individualmente para cada una de ellas. Recomiendo poner valores de tiempos pequeños para las fogatas y un poco más grandes para las estrellas.

Las fogatas se encienden y apagan "bruscamente", como las casas. Mientras que las estrellas se encienden y se apagan poco a poco según anochece o amanece.

Se puede configurar el tiempo que dura "el día" y el de "la noche" por separado, con lo que pueden ser diferentes (se supone que en invierno los días son más cortos). También se puede configurar el tiempo que dura el anochecer y el amanecer (estos comparten el valor, así que no pueden ser diferentes).

Espero que esto sirva. Siento no tener tiempo para explicarlo mejor.

Adjunto el código.

Go Up