// Control iluminación temporizada.
/* Necesidad:
// Un interruptor crepuscular ya existente en la instalación activará una serie de lamparas de jardín tras el ocaso, las cuales serán desconectadas al alba por el interruptor crepuscular.
- Pero se desea que varias de esas lámparas se apaguen tras cumplirse un tiempo definido en macro de 4 horas y 30 minutos, en adelante "Periodo 1".
- Habrá un pulsador accesible de tipo timbre que tendrá las siguientes funciones:
- Si se pulsa durante el periodo 1, se apagarán las luces conectadas al circuito, no afectando al tiempo de las 4 horas y 30 minutos. Las luces entonces permanecen apagadas indefinidamente. (Función apagado voluntario).
- Si se vuelve a pulsar se volverán a encender esas luces. No afectando al tiempo contado de las 4 horas y 30 minutos, que tras cumplirse, las luces se apagarán automáticamente. (Función re-encendido tras apagado voluntario).
- Una vez que se han cumplido las 4 horas y media, las luces son apagadas automáticamente y el pulsador entonces pasa tener las siguientes funciones:
- Si se pulsa, las luces se volverán a encender, pero esta vez, el periodo pasa a ser de 1 hora, definido en otra macro, en adelante "Periodo 2". volviéndose a apagar automáticamente tras cumplirse el tiempo. Una vez apagadas, si volvemos a pulsar, volveríamos a encender durante otra hora.
- Si se vuelve a pulsar, después de un encendido voluntario, las luces se volverían a apagar.
Resumen: Como un temporizador de luces de escaleras pero tenemos dos periodos. Uno inicial de 4 horas y media tras el cual, todo se apagará si o si. Pero que durante el mismo podemos encender y apagar las veces que queramos a nuestro antojo.
Y tras el apagado, pasa lo mismo. Que podemos encender y apagar a nuestro antojo, pero el encendido nunca será superior a una hora.
Funcionamiento del circuito:
Se reciben 220V procedentes del crepuscular. Mediante una pequeña fuente de alimentación a 5V, el circuito es alimentado.
- Al quedar alimentado el circuito, lo primero que hará será activarse el relé que controla las lámparas que queremos controlar/temporizar.
- El relé quedará activado durante el periodo indicado en la macro "retardo_off_horas, y minutos"
- Transcurrido el tiempo, el relé se desconectará.
- Un pulsador permitirá como se ha indicado arriba, volver a activar el relé voluntariamente. En este caso, el tiempo que permanece el relé es diferente y está definido en la macro "press_retardo_off_horas y minutos".
- Como se ha indicado, durante el primer periodo, el pulsador permite encender y apagar a nuestro antojo sin que esos encendidos y apagados afecten al tiempo establecido.
- Tras cumplirse el primer periodo, el relé se desactiva y el pulsador permite volver a activarlo pero esta vez durante el segundo periodo.
*/
// CONFIGURACION
#define retardo_off_horas 4 // Tiempo en horas desde que se inicia la iluminación hasta que se apagará automáticamente.
#define retardo_off_minutos 30 // Minutos para lo mismo.
#define press_retardo_off_horas 1 // Tiempo en horas desde que se inicia la iluminación por pulsación despues del apagado inicial hasta apagarla (Función de re-encendido voluntario).
#define press_retardo_off_minutos 0 // Minutos para lo mismo.
// PIN del ATMEGA USADOS: (Placa Arduino Nano)
// PIN_A1 de la placa arduino ------ Como entrada, lectura pulsador en Pull up a vdd. -- PIN C1 en ATMEGA: Puerto C1
// PIN_A0 de la placa arduino-------- Como salida, excita el relé. --- PIN C0 en ATMEGA: Puerto C0
unsigned long _end = 0; // Cálculo de timeout deseado.
void setup() {
DDRC = 0b000001; // Puerto C0 como salida, y C1 como entrada.
}
void loop() {
_end = millis() + (retardo_off_horas * 3600000) + (retardo_off_minutos * 60000); // Determinamos el tiempo en ms que debe permanecer el relé activado inicialmente.
PORTC = (1<<PC0); // RELÉ ENCENDIDO El pin de PORTC tiene ahora un valor lógico 1.
while(millis() <= _end) { // Mantendremos encendido y monitorizaremos el tiempo esperando a que se cumpla.
if ((PINC & (1<<PC1)) == 0) { // Si pulsamos durante el tiempo de encendido
if ((PINC & (1<<PC0)) == 1) PORTC = (0<<PC0); // Apagamos relé si estaba encendido.
else PORTC = (1<<PC0); // O encendemos relé si estaba apagado.
delay(1);
while((PINC & (1<<PC1)) == 0); // Esperando a soltar el pulsador.
delay(1);
}
}
// Una vez concluido el primer tiempo:
PORTC = (0<<PC0); // Apagamos relé.
while(1) { // Monitoreamos el pulsador, por si alguien quiere realizar un re-encendido voluntario.
if ((PINC & (1<<PC1)) == 0) pulsa(); // Si se ha pulsado el pulsador vamos a la funcion pulsa(); desde la cual re-encenderemos y temporizaremos este re-encendido.
}
}
void pulsa() { // Si se quiere realizar un re-encendido voluntario....
PORTC = (1<<PC0); // Activamos relé.
delay(1);
while((PINC & (1<<PC1)) == 0); // Esperando a que se suelte el pulsador.
delay(1);
_end = millis() + (press_retardo_off_horas * 3600000) + (press_retardo_off_minutos * 60000); // Determinamos el tiempo en ms que debe permanecer el relé activado tras el re-encendido voluntario.
while(millis() <= _end) { // funcion apagado voluntario tras un reencendido también voluntario.
if ((PINC & (1<<PC1)) == 0) break;
}
PORTC = (0<<PC0); // Bien sea por que se ha cumplido el tiempo, o por que se haya vuelto a pulsar el pulsador, apagamos el relé
delay(1);
while((PINC & (1<<PC1)) == 0); // Esperando a soltar.
delay(1);
// Y regresamos al bucle infinito de función principal loop(). Ello permitirá volver a encender y apagar tantas veces como se pulse el pulsador.
}
