/* *********************************************************************** * ***********************CONTROL DE BELEN******************************** * *********************************************************************** Código para controlar las distintas partes de un Belén: Iluminación, tanto general como puntual (casas, luna, estrellas, escenas...), el movimiento de escenas por motores, el sonido (ambiente y fondo musical o narración), manejado todo por un microcontrolador Arduino MEGA */ /************************ALIMENTACION DEL SISTEMA************************* Fuentes de alimentación: Iluminación 12v 16.5A Sonido, ventilador y relés 5v 3A Arduino Mega 7.5v 2.25A * *****Conectadas todas las GND entre si***** */ /* * *****CONTROL GENERAL DE LOS MOTORES DE LAS ESCENAS CON MOVIMIENTO***** Controla por medio de un relé que los motores de las escenas con movimiento solo reciban corriente eléctrica desde cierto momento de la fase amanecer hasta cierto momento de la fase atardecer, en función de los valores que se envían a las tiras led. Modulo relé conectado a 5v y GND y la señal al pin 35. El circuito se conecta al pin NO del relé * *********CONTROL DE PARADAS DE MOTOR UTILIZANDO MICRORRUPTORES********* Detiene el movimiento de una figura por el espacio del Belén. Cuando en su desplazamiento acciona uno de los microrruptores, un relé desconecta la corriente al motor hasta que pasa el tiempo espedificado, poniendose de nuevo en marcha hasta el siguiente microrruptor. Motor de 10 rpm a 220v, conectado a pines NC del relé. Los microrruptores se conectan en paralelo con resistencia pull-down de 4K7 al pin 34 El módulo relé se conecta a 5v y GND y la señal al pin 32 El motor se conecta al pin NC del relé * **********************MOTORES OTRAS ESCENAS************************** Para cada una de las escenas con motor, además del control dependiendo de la iluminación (apagado atardecer, encendido amanecer), se plantean otros controles que realizaran paradas y arranques de los motores, por los tiempos establecidos, mientras el control general esté enviando señal. En total se preparan cuatro circuitos, con los pines 22, 23, 24 y 25, a los que se conectan los pines de señal de los relés. Se especifican tiempos de parada y arranque para cada circuito en función de la escena: Zapatero, Alfarero, Almazara y Gallinero. Hay que ajustar a las necesidades exactas. Los motores se conectan a los pines NC del relé * ****************CONTROL DE LAS FASES DE ILUMINACIÓN ****************** Genera los colores que se determinen para cada una de las cuatro fases de la iluminación: Día, atardecer, noche y amanecer, con cambio progresivo de las tonalidades. Hay que cargar la composición de colores de cada una de las fases. Recalcula automáticamente los tiempos de transición de los colores para adaptarse al tiempo definido para las fases. Preparado para tira led RGB y tiras monocromas de 12v blanca y amarilla (estas últimas en un mismo circuito). Separa circuitos de horizonte (menor potencia por coeficiente de ajuste) y parte superior. La señal se envía a las tiras led mediante transistores TIP 120 y resistencias de 220 Oh (pins 13, 12, 11, 10, 9, 8, 7 Y 6) que soportan 60w cada uno. * ********************CONTROL LUNA Y ESTRELLAS************************** Al final de la fase atardecer inicia el encendido progresivo de la luna y las estrellas (estas últimas con parpadeo), alcanzando su máximo nivel en la fase anochecer, que mantienen hasta empezar a decrecer en el alba para apagarse al amanecer. Pins 5 (estrellas) y 4 (luna). La señal se envía mediante transistores TIP 120 y resistencias de 220 Oh *******************APARICION Y DESAPARICION DEL ÁNGEL***************** Al final de la fase atardecer inicia el encendido progresivo de la lUZ de la aparición del ángel, alcanzando su máximo nivel en la fase anochecer, que mantiene hasta empezar a decrecer en el alba para apagarse al amanecer. Conectado al pin 3. La señal se envía mediante transistor TIP 120 y resistencia de 220 Ohm *****************************CONTROL SOL**************************** Una led dicroica regulable, en color amarillo, hace las veces de iluminación solar. Siendo puntual, puede producir sombras en función de la luz general, dando mayor realismo a la escena. Durante la fase día está a toda su potencia, bajando durante el atardecer y anochecer hasta apagarse, para volver a incrementar su potencia durante el amanecer. Conectado al pin 2. La señal se envía mediante transistor TIP 120 y resistencia de 220 Ohm * ********************CONTROL ANTROCHAS Y CASAS************************* En los momentos indicados se encienden y apagan tres circuitos para antorchas y luces de interior de casas permitiendo hacer encendidos y apagados independientes por cada parte del Belén Pins 40, 41 Y 42 Se puede ampliar instalando más hadware y añadiendo software * ***************************SONIDO************************************* Con un DFPlayer Mini se reproducen sonidos de fondo (ambiente) a lo largo de las fases (un archivo de sonido por cada fase). Conectado a pins 46 y 47 (este con resistencia 1K en serie), 5v y GND La señal de salida se pasa por un amplificador PAM8406 para llegar a los altavoces ================================= Con otro DFPlayer Mini se reproduce música o narraciones durante el funcionamiento del belén. Conectado a pins 48 y 49 (este con resistencia 1K en serie), 5v y GND. Su funcionamiento se activa en void setup() haciendo un bucle contínuo con el total de los archivos de sonido grabados (en principio son villancicos). La señal de salida se pasa por un amplificador PAM8406 para llegar a los altavoces ******************VENTILADOR PARA DISIPAR CALOR TRANSISTORES******************** Un ventilador se encarga de ayudar a disipar el calor de los transistores en los circuitos con mucha carga. Llevan también disipadores de aluminio. Se activa por las lecturas de un sensor de temperatura y humedad DHT11, arrancando cuando detecta la temperatura marcada. Comprueba la lectura del sensor según el tiempo indicado (tpoVent). Detector DHT11 Conectado a pin 28 con resistencia pull-up de 330 Ohm Transistor TIP120 conectado a pin 29 con resistencia 220 Ohm Ventilador 5 v Conectando GND a la salida del transistor * *****************Codigos recopilados en 2019************************** * ************************por Iñaki Pascual****************************** * *********************************************************************** */ //******************************************************************** //=========================DATOS A CUMPLIMENTAR=========================== //*******COLORES DE LAS FASES********** //Variables con la composición del color para cada uno de los cuatro momentos,y circuitos de //estrellas, luna, ángel y sol //DIA int irAma = 255; int igAma = 255; int ibAma = 255; int iwAma = 255; //ATARDECER int irAta = 255; int igAta = 60; int ibAta = 40; int iwAta = 50; //NOCHE int irAno = 45; int igAno = 30; int ibAno = 190; int iwAno = 0; //AMACECER int irAlb = 135; int igAlb = 250; int ibAlb = 135; int iwAlb = 40; //===================== //Señal que se envía a los siguientes circuitos en cada fase //ESTRELLAS int isAta = 10; int isAno = 255; int isAlb = 10; int isAma = 0; //LUNA int imAta = 50; int imAno = 255; int imAlb = 20; int imAma = 0; //ÁNGEL int iaAta = 50; int iaAno = 255; int iaAlb = 20; int iaAma = 0; //SOL int ilAta = 80; int ilAno = 0; int ilAlb = 0; int ilAma = 255; //ANTORCHAS Y CASAS //Momentos de encendido y apagado de antorchas y casas en fases de anochecer y alba, //en base al valor que va tomando el circuito de color rojo de la tira led RGB int irA1On = 225; int irA2On = 200; int irA3On = 215; int irA1Off = 220; int irA2Off = 235; int irA3Off = 225; //Tiempo total de demora en los incrementos/decrementos intensidad color int tpoVar = 25; //Tiempo en segundos que tardan cada una de las transiciones de color //Tiempo de demora en las fases día y noche long tpoMdia = 70000; //Duración del día long tpoMnoc = 50000; //Duración de la noche const float coef = 0.6; //Coeficiente que se aplica a la intensidad de luz de horizonte //MICRORUPTORES long parada = 5000; //Tiempo de cada parada por microrruptor int tvalM = 10; //Tiempo entre lecturas estado microrruptores para rebotes //MOTORES GENERALES //Momento de parada de motores en fase atardecer en base al valor del circuito verde de la tira led RGB int igMStop = 73; //Momento de arranque de motores en fase alba int igMPlay = 242; //OTROS MOTORES //Tiempos en marcha (on) y parados (of) long tpoM1On = 15000; long tpoM1Of = 5000; long tpoM2On = 30000; long tpoM2Of = 10000; long tpoM3On = 40000; long tpoM3Of = 20000; long tpoM4On = 10000; long tpoM4Of = 5000; long tpoM5On = 45000; long tpoM5Of = 15000; //SONIDO //Volumen reproducción (entre 0 y 30) int volAM = 20; int volMU = 20; //===================================================================================== //**************************RESTO DE CONFIGURACION************************************* //===================================================================================== //VENTILADOR Y SENSOR TEMPERATURA Y HUMEDAD #include //Incluye libreria sensor const int pin = 28; //Define pin sensor const int vent = 29; //Define pin ventilador DHT11 dht11(pin); //Asigna pin a DHT11 float minimo = 26.00; //Temperatura a la que arranca ventilador unsigned long lecAnt = 0; //Momento anterior inicio tiempos unsigned long lecAct = 0; //Momento actual tiempos long tpoVent = 30000; //Demora entre lecturas sensor int tension; //Tensión que se envía: 0=apagado; 1=encendido int err; //Variable error float temp, hum; //Variables temperatura y humedad //************************************************************************ //ILUMINACION GENERAL - CICLO DIA Y NOCHE //Estados del sistema, que harán que fluyan las fases una tras otra byte estado = 0; //0= día; 1= atardecer; 2= anochecer, 3=noche; 4=alba; 5=amanecer //Define los pins const int RSU = 13; //Iluminación superior const int GSU = 12; const int BSU = 11; const int WSU = 10; const int RHO = 9; //Iluminaciópn horizonte const int GHO = 8; const int BHO = 7; const int WHO = 6; //Crea variable de intensidad colores y les doy el valor inicial = día (Ama) int ir = irAma; int ig = igAma; int ib = ibAma; int iw = iwAma; //Crea variables para almacenar momento inicio unsigned long inir = 0; unsigned long inig = 0; unsigned long inib = 0; unsigned long iniw = 0; unsigned long iniT = 0; //y final unsigned long finr; unsigned long fing; unsigned long finb; unsigned long finw; //******TIEMPOS****** //Cálculo de los tiempos de variacion de tono en las transiciones de fases para que se completen en el tiempo establecido (tpoVar) int tpoCata = tpoVar * 1000 / max(max(max(irAma, irAta) - min(irAma, irAta), max(igAma, igAta) - min(igAma, igAta)), max(max(ibAma, ibAta) - min(ibAma, ibAta), max(iwAma, iwAta) - min(iwAma, iwAta))); int tpoCano = tpoVar * 1000 / max(max(max(irAta, irAno) - min(irAta, irAno), max(igAta, igAno) - min(igAta, igAno)), max(max(ibAta, ibAno) - min(ibAta, ibAno), max(iwAta, iwAno) - min(iwAta, iwAno))); int tpoCalb = tpoVar * 1000 / max(max(max(irAno, irAlb) - min(irAno, irAlb), max(igAno, igAlb) - min(igAno, igAlb)), max(max(ibAno, ibAlb) - min(ibAno, ibAlb), max(iwAno, iwAlb) - min(iwAno, iwAlb))); int tpoCama = tpoVar * 1000 / max(max(max(irAlb, irAma) - min(irAlb, irAma), max(igAlb, igAma) - min(igAlb, igAma)), max(max(ibAlb, ibAma) - min(ibAlb, ibAma), max(iwAlb, iwAma) - min(iwAlb, iwAma))); //***************************************************** // ILUMINACION ESTRELLAS (igual que iluminación general) const int STAR = 5; int is = isAma; unsigned long inis = 0; unsigned long fins; int tpoSCano = tpoVar * 1000 / (max(isAta, isAno) - min(isAta, isAno)); int tpoSCalb = tpoVar * 1000 / (max(isAno, isAlb) - min(isAno, isAlb)); //***************************************************** //LUNA (igual que iluminación general) const int MOON = 4; int im = imAma; unsigned long inim = 0; unsigned long finm; int tpoMCano = tpoVar * 1000 / (max(imAta, imAno) - min(imAta, imAno)); int tpoMCalb = tpoVar * 1000 / (max(imAno, imAlb) - min(imAno, imAlb)); //****************************************************** //ÁNGEL (igual que iluminación general) const int ANG = 3; int ia = iaAma; unsigned long inia = 0; unsigned long fina; int tpoACano = tpoVar * 1000 / (max(iaAta, iaAno) - min(iaAta, iaAno)); int tpoACalb = tpoVar * 1000 / (max(iaAno, iaAlb) - min(iaAno, iaAlb)); //******************************************************* //SOL (igual que iluminación general) const int SOL = 2; int il = ilAma; unsigned long inil = 0; unsigned long finl; int tpoLCama = tpoVar * 1000 / ilAma; int tpoLCata = tpoVar * 1000 / (max(ilAma, ilAta) - min(ilAma, ilAta)); int tpoLCano = tpoLCama; //******************************************************** //ILUMINACION ANTORCHAS Y CASAS. Define pins const int ANT1 = 40; const int ANT2 = 41; const int ANT3 = 42; //***************************************************** //MOTOR MICRORRUPTORES. Define pins, estados y variables const int releM = 32; //Define los pins const int micror = 34; byte stRel = 0; //Estados del relé: 0=desactivado; 1=activado rebotes; 2=activado: 3=desactivado con microrruptores activados; 4=desactivado rebotes byte stMicr = 0; //Estados microrruptores: 0=circuito abierto; 1=circuito cerrado int valM1; //Almacena valor lectura primera para rebotes int valM2; //Almacena valor lectura segunda para rebotes unsigned long iniPar; //Almacena momento de inicio de la parada unsigned long iniVal; //Almacena momento primera lectura para rebotes //***************************************************** //MOTORES GENERALES. Define pin y estados const int releG = 35; //Define pin relé general byte stMoGr = 0; //Estado motores: 1=en marcha; 0=parados //***************************************************** //OTROS MOTORES //Pines relés motores const int MOTO1 = 22; const int MOTO2 = 23; const int MOTO3 = 24; const int MOTO4 = 25; const int MOTO5 = 26; //y estados byte stMOT1 = 1; // 1=Funcionando; 0=Parado byte stMOT2 = 1; byte stMOT3 = 1; byte stMOT4 = 1; byte stMOT5 = 1; unsigned long tpoM1ini = 0; //Momento inicio unsigned long tpoM2ini = 0; unsigned long tpoM3ini = 0; unsigned long tpoM4ini = 0; unsigned long tpoM5ini = 0; unsigned long tpoM1fin = 0; //Momento final unsigned long tpoM2fin = 0; unsigned long tpoM3fin = 0; unsigned long tpoM4fin = 0; unsigned long tpoM5fin = 0; //***************************************************** //SONIDO. Librerias necesarias #include "SoftwareSerial.h" #include "DFRobotDFPlayerMini.h" //Estados reproductor sonido ambiente byte stDFP = 0; //Estado reproductor ambiente 0=reposo; 1=repr 1; 2=repr 2; 3=repr 3; 4=repr 4 SoftwareSerial mySoftwareSerialAM(46, 47); // Pines conexión reproductor ambiente DFRobotDFPlayerMini myDFPlayerAM; SoftwareSerial mySoftwareSerialMU(48, 49); // Pines conexión reproductor música DFRobotDFPlayerMini myDFPlayerMU; //====================================================================== void setup() { Serial.begin(9600); //***************************************************** //VENTILADOR Y SENSOR TEMPERATURA Y HUMEDAD pinMode(vent, OUTPUT); //Define pin ventilador como salida digitalWrite(vent, tension); //Manda valor inicial a ventilador //ILUMINACION: impresión de los valores de velocidad en las transiciones de fases, luna, estrellas y ángel Serial.println("Valores velocidad transiciones:"); Serial.print("tiempo gral atardecer "); Serial.println(tpoCata); Serial.print("tiempo gral anochecer "); Serial.println(tpoCano); Serial.print("tiempo gral alba "); Serial.println(tpoCalb); Serial.print("tiempo gral amanecer "); Serial.println(tpoCama); Serial.print("tiempo luna anochecer "); Serial.println(tpoMCano); Serial.print("tiempo luna alba "); Serial.println(tpoMCalb); Serial.print("tiempo estrellas anochecer "); Serial.println(tpoSCano); Serial.print("tiempo estrellas alba "); Serial.println(tpoSCalb); Serial.print("tiempo ángel anochecer "); Serial.println(tpoACano); Serial.print("tiempo ángel alba "); Serial.println(tpoACalb); Serial.print("tiempo sol amanecer "); Serial.println(tpoLCama); Serial.print("tiempo sol atardecer "); Serial.println(tpoLCata); Serial.print("tiempo sol anochecer "); Serial.println(tpoLCano); //***************************************************** //Define pins como salida pinMode(RSU, OUTPUT); pinMode(GSU, OUTPUT); pinMode(BSU, OUTPUT); pinMode(WSU, OUTPUT); pinMode(RHO, OUTPUT); pinMode(GHO, OUTPUT); pinMode(BHO, OUTPUT); pinMode(WHO, OUTPUT); pinMode(MOON, OUTPUT); pinMode(STAR, OUTPUT); pinMode(SOL, OUTPUT); pinMode(ANT1, OUTPUT); pinMode(ANT2, OUTPUT); pinMode(ANT3, OUTPUT); //y hace prueba de encendidos Serial.println("Probando circuitos iluminación"); analogWrite(RSU, 255); delay(250); analogWrite(RSU, 0); analogWrite(GSU, 255); delay(250); analogWrite(GSU, 0); analogWrite(BSU, 255); delay(250); analogWrite(BSU, 0); analogWrite(WSU, 255); delay(250); analogWrite(WSU, 0); analogWrite(RHO, 255); delay(250); analogWrite(RHO, 0); analogWrite(GHO, 255); delay(250); analogWrite(GHO, 0); analogWrite(BHO, 255); delay(250); analogWrite(BHO, 0); analogWrite(WHO, 255); delay(250); analogWrite(WHO, 0); analogWrite(MOON, 255); delay(250); analogWrite(MOON, 0); analogWrite(STAR, 255); delay(250); analogWrite(STAR, 0); analogWrite(ANG, 255); delay(250); analogWrite(ANG, 0); analogWrite(SOL, 255); delay(250); analogWrite(SOL, 0); digitalWrite(ANT1, HIGH); delay(250); digitalWrite(ANT1, LOW); digitalWrite(ANT2, HIGH); delay(250); digitalWrite(ANT2, LOW); digitalWrite(ANT3, HIGH); delay(250); digitalWrite(ANT3, LOW); //****************************************************** //MOTOR MICRORRUPTORES (define pin y envío valor) pinMode(releM, OUTPUT); pinMode(micror, INPUT); digitalWrite(releM, HIGH); //****************************************************** //MOTORES GENERALES (define pin y envío valor)) pinMode(releG, OUTPUT); digitalWrite(releG, HIGH); //Manda valor HIGH=desconectado (conectado a salida NO) //***************************************************** //OTROS MOTORES (define pines y envío valores) pinMode(MOTO1, OUTPUT); //Define como salida pinMode(MOTO2, OUTPUT); pinMode(MOTO3, OUTPUT); pinMode(MOTO4, OUTPUT); pinMode(MOTO5, OUTPUT); digitalWrite(MOTO1, HIGH); //Manda valor HIGH=conectado digitalWrite(MOTO2, HIGH); digitalWrite(MOTO3, HIGH); digitalWrite(MOTO4, HIGH); digitalWrite(MOTO5, HIGH); //****************************************************** //SONIDO. Inicia y comprueba funcionamiento reproductores de sonido mySoftwareSerialAM.begin(9600); mySoftwareSerialMU.begin(9600); delay(10000); if (!myDFPlayerAM.begin(mySoftwareSerialAM)) { Serial.println(F("10 seg para arrancar ambiente")); delay(10000); } else { Serial.println(F("DFPlayer Mini Ambiente dispuesto.")); } myDFPlayerAM.volume(volAM); //Volumen reproducción archivos de sonido Ambiente //---- if (!myDFPlayerMU.begin(mySoftwareSerialMU)) { Serial.println(F("10 seg para arrancar música")); delay(10000); } else { Serial.println(F("DFPlayer Mini Música dispuesto.")); } myDFPlayerMU.volume(volMU); //Volumen reproducción archivos de música //Pone en marcha la música de ambiente en bucle myDFPlayerMU.enableLoopAll(); //****************************************************** Serial.println("Comienza el ciclo de fases"); //Manda a iluminación el estado inicial analogWrite(RSU, ir); analogWrite(GSU, ig); analogWrite(BSU, ib); analogWrite(WSU, iw); analogWrite(RHO, ir * coef); analogWrite(GHO, ig * coef); analogWrite(BHO, ib * coef); analogWrite(WHO, iw * coef); analogWrite(MOON, im); analogWrite(STAR, is); analogWrite(ANG, ia); analogWrite(SOL, il); digitalWrite(ANT1, LOW); digitalWrite(ANT2, LOW); digitalWrite(ANT3, LOW); //MANDA ARRANCAR MOTORES digitalWrite(releG, LOW); stMoGr = 1; Serial.println("es de día"); iniT = millis(); } //=========================================================== //FASE ATARDECER - variación entre color día y color atardecer void atardecer() { //CAMBIO ROJO if (irAma > irAta) //Si hay que reducir la tonalidad { if (ir > irAta) //Mientras la intensidad sea mayor que la determinada { finr = millis(); //guarda el momento if (finr - inir >= tpoCata) //cuando pasa el tiempo especificado { inir = finr; ir--; //reduce la intensidad analogWrite(RSU, ir); //envía el dato a la tira led superior analogWrite(RHO, ir * coef); //envía el dato ajustado a la tira led horizonte } } } if (irAma < irAta) //Si hay que aumentar la tonalidad { if (ir < irAta) { finr = millis(); if (finr - inir >= tpoCata) { inir = finr; ir++; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } //CAMBIO VERDE if (igAma > igAta) { if (ig > igAta) { fing = millis(); if (fing - inig >= tpoCata) { inig = fing; ig--; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } if (igAma < igAta) { if (ig < igAta) { fing = millis(); if (fing - inig >= tpoCata) { inig = fing; ig++; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } //CAMBIO AZUL if (ibAma > ibAta) { if (ib > ibAta) { finb = millis(); if (finb - inib >= tpoCata) { inib = finb; ib--; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } if (ibAma < ibAta) { if (ib < ibAta) { finb = millis(); if (finb - inib >= tpoCata) { inib = finb; ib++; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } //CAMBIO BLANCO Y AMARILLO if (iwAma > iwAta) { if (iw > iwAta) { finw = millis(); if (finw - iniw >= tpoCata) { iniw = finw; iw--; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (iwAma < iwAta) { if (iw < iwAta) { finw = millis(); if (finw - iniw >= tpoCata) { iniw = finw; iw++; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (ir == irAta && ig == igAta && ib == ibAta && iw == iwAta && im == imAta && is == isAta && il == ilAta) //Cuando se alcanzan los valores de color { iniT = millis(); estado = 2; Serial.println("empieza a anochecer"); } } //============================================================== //FASE ANOCHECER - variación entre color atardecer y color noche void anochecer() { //CAMBIO ROJO if (irAta > irAno) { if (ir > irAno) { finr = millis(); if (finr - inir >= tpoCano) { inir = finr; ir--; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } if (irAta < irAno) { if (ir < irAno) { finr = millis(); if (finr - inir >= tpoCano) { inir = finr; ir++; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } //CAMBIO VERDE if (igAta > igAno) { if (ig > igAno) { fing = millis(); if (fing - inig >= tpoCano) { inig = fing; ig--; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } if (igAta < igAno) { if (ig < igAno) { fing = millis(); if (fing - inig >= tpoCano) { inig = fing; ig++; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } //CAMBIO AZUL if (ibAta > ibAno) { if (ib > ibAno) { finb = millis(); if (finb - inib >= tpoCano) { inib = finb; ib--; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } if (ibAta < ibAno) { if (ib < ibAno) { finb = millis(); if (finb - inib >= tpoCano) { inib = finb; ib++; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } //CAMBIO BLANCO Y AMARILLO if (iwAta > iwAno) { if (iw > iwAno) { finw = millis(); if (finw - iniw >= tpoCano) { iniw = finw; iw--; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (iwAta < iwAno) { if (iw < iwAno) { finw = millis(); if (finw - iniw >= tpoCano) { iniw = finw; iw++; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (ir == irAno && ig == igAno && ib == ibAno && iw == iwAno && im == imAno && is == isAno && il == ilAno) { iniT = millis(); estado = 3; Serial.println("es de noche"); } } //=============================================================== //FASE NOCHE - mantenimiento del color noche durante el tiempo especificado void noche() { if (millis() - iniT >= tpoMnoc && estado == 3) { estado = 4; Serial.println("empieza el alba"); } } //====================================================== //FASE ALBA - variación entre color noche y color amanecer void alba() { //CAMBIO ROJO if (irAno > irAlb) { if (ir > irAlb) { finr = millis(); if (finr - inir >= tpoCalb) { inir = finr; ir--; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } if (irAno < irAlb) { if (ir < irAlb) { finr = millis(); if (finr - inir >= tpoCalb) { inir = finr; ir++; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } //CAMBIO VERDE if (igAno > igAlb) { if (ig > igAlb) { fing = millis(); if (fing - inig >= tpoCalb) { inig = fing; ig--; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } if (igAno < igAlb) { if (ig < igAlb) { fing = millis(); if (fing - inig >= tpoCalb) { inig = fing; ig++; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } //CAMBIO AZUL if (ibAno > ibAlb) { if (ib > ibAlb) { finb = millis(); if (finb - inib >= tpoCalb) { inib = finb; ib--; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } if (ibAno < ibAlb) { if (ib < ibAlb) { finb = millis(); if (finb - inib >= tpoCalb) { inib = finb; ib++; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } //CAMBIO BLANCO Y AMARILLO if (iwAno > iwAlb) { if (iw > iwAlb) { finw = millis(); if (finw - iniw >= tpoCalb) { iniw = finw; iw--; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (iwAno < iwAlb) { if (ig >= igAlb - iwAlb && estado == 4) { if (iw < iwAlb) { finw = millis(); if (finw - iniw >= tpoCalb) { iniw = finw; iw++; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } } if (ir == irAlb && ig == igAlb && ib == ibAlb && iw == iwAlb && im == imAlb && is == isAlb && il == ilAlb) { iniT = millis(); estado = 5; Serial.println("empieza a amanecer"); } } //============================================================ //FASE AMANECER - variación entre color amanecer y color día void amanecer() { //CAMBIO ROJO if (irAlb > irAma) { if (ir > irAma) { finr = millis(); if (finr - inir >= tpoCama) { inir = finr; ir--; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } if (irAlb < irAma) { if (ir < irAma) { finr = millis(); if (finr - inir >= tpoCama) { inir = finr; ir++; analogWrite(RSU, ir); analogWrite(RHO, ir * coef); } } } //CAMBIO VERDE if (igAlb > igAma) { if (ig > igAma) { fing = millis(); if (fing - inig >= tpoCama) { inig = fing; ig--; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } if (igAlb < igAma) { if (ig < igAma) { fing = millis(); if (fing - inig >= tpoCama) { inig = fing; ig++; analogWrite(GSU, ig); analogWrite(GHO, ig * coef); } } } //CAMBIO AZUL if (ibAlb > ibAma) { if (ib > ibAma) { finb = millis(); if (finb - inib >= tpoCama) { inib = finb; ib--; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } if (ibAlb < ibAma) { if (ib < ibAma) { finb = millis(); if (finb - inib >= tpoCama) { inib = finb; ib++; analogWrite(BSU, ib); analogWrite(BHO, ib * coef); } } } //CAMBIO BLANCO Y AMARILLO if (iwAlb > iwAma) { if (iw > iwAma) { finw = millis(); if (finw - iniw >= tpoCama) { iniw = finw; iw--; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (iwAlb < iwAma) { if (iw < iwAma) { finw = millis(); if (finw - iniw >= tpoCama) { iniw = finw; iw++; analogWrite(WSU, iw); analogWrite(WHO, iw * coef); } } } if (ir == irAma && ig == igAma && ib == ibAma && iw == iwAma && im == imAma && is == isAma && il == ilAma) { estado = 0; iniT = millis(); Serial.println("es de día"); } } //============================================================== //FASE DIA - mantenimiento del color día durante el tiempo especificado void dia() { if (millis() - iniT >= tpoMdia && estado == 0) { estado = 1; Serial.println("empieza a atardecer"); } } //============================================================ void loop() { //CÓDIGO CONTROL VENTILADOR DISIPADOR DE CALOR************* lecAct = millis(); if (lecAct > (lecAnt + tpoVent)) //Cuando pasa tiempo indicado { lecAnt = millis(); if ((err = dht11.read(hum, temp)) == 0) //Si error=0 (temp y hum con lectura) { Serial.print("Temperatura: "); //Imprime temperatura y humedad leidas por sensor Serial.print(temp); Serial.print(" Humedad: "); Serial.print(hum); Serial.println(); if (temp >= minimo) //Si la temperatura leida es mayor o igual que el mínimo { tension = 1; //tensión HIGH } else { tension = 0; //tensión LOW } digitalWrite(vent, tension); //Envia la tensión a ventildor Serial.print("Tensión "); //Imprime la tensión enviada Serial.println(tension); } else //Si no hay lecturas { Serial.println(); //Imprime error Serial.print("Error Num :"); Serial.print(err); Serial.println(); } } //CODIGO PARA SONIDO AMBIENTE********************* if (estado == 0 && (stDFP == 0 || stDFP == 4)) { Serial.println("Pista ambiente 1"); myDFPlayerAM.play(1); stDFP = 1; } if (estado == 1 && stDFP == 1) { Serial.println("Pista ambiente 2"); myDFPlayerAM.play(2); stDFP = 2; } if (estado == 3 && stDFP == 2) { Serial.println("Pista ambiente 3"); myDFPlayerAM.play(3); stDFP = 3; } if (estado == 4 && stDFP == 3) { Serial.println("Pista ambiente 4"); myDFPlayerAM.play(4); stDFP = 4; } //CODIGO PARADA Y ARRANQUE TODOS LOS MOTORES (CONECTADO SALIDA NO)********** if (ig == igMStop && estado == 1 && stMoGr == 1) //En el momento indicado se paran los motores { digitalWrite(releG, HIGH); stMoGr = 0; Serial.println("se apagan todos los motores"); } if (ig == igMPlay && estado == 4 && stMoGr == 0) //En el momento indicado arrancan los motores { digitalWrite(releG, LOW); stMoGr = 1; Serial.println("se encienden todos los motores"); } //CODIGO OTROS MOTORES //MOTOR 1 ************ZAPATERO************** if (stMoGr == 1 && stMOT1 == 0) //Si se cumple condicion { tpoM1fin = millis(); //Guarda momento if (tpoM1fin >= (tpoM1ini + tpoM1On)) //Cuando pasa el tiempo establecido { tpoM1ini = millis(); //Guarda momento digitalWrite(MOTO1, LOW); //Para motor 1 stMOT1 = 1; //Cambia situación motor } } if (stMoGr == 1 && stMOT1 == 1) //Si se cumple la condicion { tpoM1fin = millis(); //Guarda momento if (tpoM1fin >= (tpoM1ini + tpoM1Of)) //Cuando pasa el tiempo establecido { tpoM1ini = millis(); //Guarda momento digitalWrite(MOTO1, HIGH); //Arranca motor 1 stMOT1 = 0; //Cambia situación motor } } //MOTOR 2 *****************ALFARERO************** if (stMoGr == 1 && stMOT2 == 0) { tpoM2fin = millis(); if (tpoM2fin >= (tpoM2ini + tpoM2On)) { tpoM2ini = millis(); digitalWrite(MOTO2, LOW); stMOT2 = 1; } } if (stMoGr == 1 && stMOT2 == 1) { tpoM2fin = millis(); if (tpoM2fin >= (tpoM2ini + tpoM2Of)) { tpoM2ini = millis(); digitalWrite(MOTO2, HIGH); stMOT2 = 0; } } //MOTOR 3 *******************ALMAZARA*************** if (stMoGr == 1 && stMOT3 == 0) { tpoM3fin = millis(); if (tpoM3fin >= (tpoM3ini + tpoM3On)) { tpoM3ini = millis(); digitalWrite(MOTO3, LOW); stMOT3 = 1; } } if (stMoGr == 1 && stMOT3 == 1) { tpoM3fin = millis(); if (tpoM3fin >= (tpoM3ini + tpoM3Of)) { tpoM3ini = millis(); digitalWrite(MOTO3, HIGH); stMOT3 = 0; } } //MOTOR 4 ********************GALLINERO***************** if (stMoGr == 1 && stMOT4 == 0) { tpoM4fin = millis(); if (tpoM4fin >= (tpoM4ini + tpoM4On)) { tpoM4ini = millis(); digitalWrite(MOTO4, LOW); stMOT4 = 1; } } if (stMoGr == 1 && stMOT4 == 1) { tpoM4fin = millis(); if (tpoM4fin >= (tpoM4ini + tpoM4Of)) { tpoM4ini = millis(); digitalWrite(MOTO4, HIGH); stMOT4 = 0; } } //MOTOR 5 ************************POZO***************** if (stMoGr == 1 && stMOT5 == 0) { tpoM5fin = millis(); if (tpoM5fin >= (tpoM5ini + tpoM5On)) { tpoM5ini = millis(); digitalWrite(MOTO5, LOW); stMOT5 = 1; } } if (stMoGr == 1 && stMOT5 == 1) { tpoM5fin = millis(); if (tpoM5fin >= (tpoM5ini + tpoM5Of)) { tpoM5ini = millis(); digitalWrite(MOTO5, HIGH); stMOT5 = 0; } } if (stMoGr == 0) { digitalWrite(MOTO1, HIGH); stMOT1=1; digitalWrite(MOTO2, HIGH); stMOT2=1; digitalWrite(MOTO3, HIGH); stMOT3=1; digitalWrite(MOTO4, HIGH); stMOT4=1; digitalWrite(MOTO5, HIGH); stMOT5=1; } //CODIGO MOTOR MICRORRUPTORES********************** if (digitalRead(micror) == HIGH && stRel == 0) //si algún microrruptor ha cerrado el circuito, estando el relé 0=desactivado, { valM1 = digitalRead(micror); //guarda una primera lectura de microrruptores if (valM1 == 1 && stRel == 0) //si el valor leido es 1=HIGH { iniVal = millis(); //guarda momento de primera lectura stRel = 1; //cambia estado rele 1=activado rebotes } } if (digitalRead(micror) == HIGH && stRel == 1) //si algún microrruptor mantiene cerrado el circuito y estado rele 1=activado rebotes { if (millis() - iniVal >= tvalM) //una vez que pase el tiempo especificado { valM2 = digitalRead(micror); //guarda una segunda lectura de microrruptores if ( valM1 == valM2) //si las dos lecturas son iguales, { if (valM1 != stMicr) //diferentes al estado microrruptor { iniPar = millis(); //guarda momento inicio de la parada stRel = 2; //cambia estado rele a 2=activado stMicr = 1; //cambia estado microrruptores a 1=activado digitalWrite(releM, LOW); //manda a relé LOW=activado (el motor se para) } } } } if (millis() - iniPar >= parada && stRel == 2) //transcurrido el tiempo de parada especificado { stRel = 3; //cambia estado relé a 3=desactivado con microrruptores activados digitalWrite(releM, HIGH); //manda a relé HIGH=desactivado (el motor arranca) } if (digitalRead(micror) == LOW && stRel == 3) //cuando se liberan los microrruptores por el arranque del motor { valM1 = digitalRead(micror); //guarda primera lectura de microrruptores if (valM1 == 0 && stRel == 3) //si la lectura es 0=LOW { iniVal = millis(); //guarda momento lectura stRel = 4; //cambia estado rele 4=desactivado rebotes } } if (digitalRead(micror) == LOW && stRel == 4) //cuando estan liberados los microrruptores y estado rele 4=desactivado rebotes { if (millis() - iniVal >= tvalM && stRel == 4) //cuando pase el tiempo especificado { valM2 = digitalRead(micror); //guarda segunda lectura de microrruptores if ( valM1 == valM2) //cuando las dos lecturas sean iguales, { if (valM1 != stMicr) //si el valor leido es diferente al estado de microrruptor { stMicr = 0; //cambia estado microrruptores a 0=desactivado stRel = 0; //cambia estado relé a 0=desactivado } } } } //CODIGO PARA ANTORCHAS Y CASAS******************* //Encendido if (ir == irA1On && estado == 2) { digitalWrite(ANT1, HIGH); } if (ir == irA2On && estado == 2) { digitalWrite(ANT2, HIGH); } if (ir == irA3On && estado == 2) { digitalWrite(ANT3, HIGH); } //Apagado if (ir == irA1Off && estado == 5) { digitalWrite(ANT1, LOW); } if (ir == irA2Off && estado == 5) { digitalWrite(ANT2, LOW); } if (ir == irA3Off && estado == 5) { digitalWrite(ANT3, LOW); } //CODIGO PARA ILUMINACION GENERAL***************** switch (estado) { case 0: dia(); break; case 1: atardecer(); break; case 2: anochecer(); break; case 3: noche(); break; case 4: alba(); break; case 5: amanecer(); break; } //CÓDIGO PARA SOL***************** //Apagado //Fase atardecer if (estado == 1) { if (il > ilAta) { finl = millis(); if (finl - inil >= tpoLCata) { inil = finl; il--; analogWrite(SOL, il); } } } //Fase anochecer if (estado == 2) { if (il > ilAno) { finl = millis(); if (finl - inil >= tpoLCano) { inil = finl; il--; analogWrite(SOL, il); } } } //Encendido //Fase amanecer if (estado == 5) { if (il < ilAma) { finl = millis(); if (finl - inil >= tpoLCama) { inil = finl; il++; analogWrite(SOL, il); } } } //CODIGO PARA LUNA******************** //Encendido //Fase atardecer if (estado == 1 && ig <= igAta + (imAta * tpoMCano / tpoCata)) { if (im < imAta) { finm = millis(); if (finm - inim >= tpoMCano) { inim = finm; im++; analogWrite(MOON, im); } } } //Fase anochecer if (estado == 2) { if (im < imAno) { finm = millis(); if (finm - inim >= tpoMCano) { inim = finm; im++; analogWrite(MOON, im); } } } //Apagado //Fase alba if (estado == 4) { if (im > imAlb) { finm = millis(); if (finm - inim >= tpoMCalb) { inim = finm; im--; analogWrite(MOON, im); } } } //Fase amanecer if (estado == 5) { if (im > imAma) { finm = millis(); if (finm - inim >= tpoMCalb) { inim = finm; im--; analogWrite(MOON, im); } } } //CODIGO PARA ÁNGEL*********************** //Encendido //Fase atardecer if (estado == 1 && ig <= igAta + (iaAta * tpoACano / tpoCata)) { if (ia < iaAta) { fina = millis(); if (fina - inia >= tpoACano) { inia = fina; ia++; analogWrite(ANG, ia); } } } //Fase anochecer if (estado == 2) { if (ia < iaAno) { fina = millis(); if (fina - inia >= tpoACano) { inia = fina; ia++; analogWrite(ANG, ia); } } } //Apagado //Fase alba if (estado == 4) { if (ia > iaAlb) { fina = millis(); if (fina - inia >= tpoACalb) { inia = fina; ia--; analogWrite(ANG, ia); } } } //Fase amanecer if (estado == 5) { if (ia > iaAma) { fina = millis(); if (fina - inia >= tpoACalb) { inia = fina; ia--; analogWrite(ANG, ia); } } } //CODIGO PARA ESTRELLAS******************* //Encendido //Fase atardecer if (estado == 1 && ig <= igAta + (isAta * tpoSCano / tpoCata)) { if (is < isAta) { fins = millis(); if (fins - inis >= tpoSCano) { inis = fins; is++; analogWrite(STAR, random(is / 2, is)); //Intensidad aleatoria para parpadeo } } } //Fase anochecer if (estado == 2) { if (is < isAno) { fins = millis(); if (fins - inis >= tpoSCano) { inis = fins; is++; analogWrite(STAR, random(is / 2, is)); } } } //Mantenimiento parpadeo en fase noche if (estado == 3) { static unsigned long ultDest = 0; static unsigned long sigDest = 0; if ((millis() - ultDest) >= sigDest) { analogWrite(STAR, random(is / 2, is)); ultDest += sigDest; sigDest = random(1, 200); } } //Apagado //Fase alba if (estado == 4) { if (is > isAlb) { fins = millis(); if (fins - inis >= tpoSCalb) { inis = fins; is--; analogWrite(STAR, random(is / 2, is)); } } } //Fase amanecer if (estado == 5) { if (is > isAma) { fins = millis(); if (fins - inis >= tpoSCalb) { inis = fins; is--; analogWrite(STAR, random(is / 2, is)); } } } }