// ********************************************************************** // ** // ** Sistema para Controle Automatico de Luzes em um Corredor, via // ** sensores de passagem e sensor de noite/dia. // ** // ** questao do topico: // ** http://labdegaragem.com/forum/topics/sensor-com-fita-de-led // ** // ********************************************************************** //*********************************************************************** // Definicoes das temporizacoes relacionadas ao intervalo de // tempo entre acendimentos sequenciais das Lampadas, e do tempo // final que ficam ligadas antes de apagarem. Os tempos estao // especificados em segundos. //======================================================================= #define Intervalo_LAMP 3 // intervalo da sequencia de acendimentos, em segundos. #define tempo_FINAL 10 // tempo de acendimento final, em segundos. //*********************************************************************** //*********************************************************************** // Definicoes de Hardware para controle das Lampadas do Sistema: //======================================================================= #define pino_LAMP_1 12 // pino para controle ON/OFF da Lampada 1. #define pino_LAMP_2 11 // pino para controle ON/OFF da Lampada 2. #define pino_LAMP_3 10 // pino para controle ON/OFF da Lampada 3. #define pino_LAMP_4 5 // pino para controle ON/OFF da Lampada 4. #define pino_LAMP_5 4 // pino para controle ON/OFF da Lampada 5. #define pino_LAMP_6 3 // pino para controle ON/OFF da Lampada 6. //----------------------------------------------------------------------- #define LAMP_ON HIGH // estado logico que liga uma Lampada neste Sistema. #define LAMP_OFF !LAMP_ON // estado logico que desliga uma Lampada neste Sistema. //*********************************************************************** //*********************************************************************** // Definicoes de Hardware para leitura do estado dos Sensores // de Passagem neste Sistema: //======================================================================= #define pino_Sensor_1 8 // pino para leitura do estado do Sensor de Passagem 1. #define pino_Sensor_2 9 // pino para leitura do estado do Sensor de Passagem 2. //----------------------------------------------------------------------- #define PASS_ON HIGH // estado logico quando um sensor de passagem e' acionado. //*********************************************************************** //*********************************************************************** // Definicoes de Hardware para leitura do estado do Sensor que // indica quando e' noite neste Sistema: //======================================================================= #define pino_Noite 7 // pino para leitura do estado do "Sensor de noite". //----------------------------------------------------------------------- #define Noite_ON HIGH // estado logico quando o sensor indica que e' noite. #define Dia_ON !Noite_ON // estado logico quando o sensor indica que e' dia. //*********************************************************************** //*********************************************************************** // Definicoes de Hardware para controle do LED "Alive": //======================================================================= #define pino_LED_Alive 6 // pino para controle ON/OFF do LED "Alive" //----------------------------------------------------------------------- #define LED_ON HIGH // estado logico que liga um LED neste Sistema. #define LED_OFF !LED_ON // estado logico que desliga um LED neste Sistema. //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Definicoes para Controle da Maquina de Estados do Sistema. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Definicao dos estados da Maquina de Estados deste Sistema: //======================================================================= enum // estados deste Sistema: { estado_Inativo, // estado quando e' dia, com Lampadas desligadas. estado_Ativo, // estado que permite iniciar controle das Lampadas. estado_LAMP_1, // estado onde apenas a Lampada 1 esta' ligada. estado_LAMP_1_2, // estado onde as Lampadas 1 e 2 estao ligadas. estado_LAMP_2_3, // estado onde as Lampadas 1 e 2 estao ligadas. estado_LAMP_3_4, // estado onde as Lampadas 1 e 2 estao ligadas. estado_LAMP_4_5, // estado onde as Lampadas 1 e 2 estao ligadas. estado_LAMP_6, // estado onde apenas a Lampada 3 esta' ligada. estado_LAMP_6_5, // estado onde as Lampadas 3 e 2 estao ligadas. estado_LAMP_5_4, // estado onde as Lampadas 3 e 2 estao ligadas. estado_LAMP_4_3, // estado onde as Lampadas 3 e 2 estao ligadas. estado_LAMP_3_2, // estado onde as Lampadas 3 e 2 estao ligadas. estado_LAMP_1_2_3_4_5_6, // estado onde todas as Lampadas estao ligadas. estado_Mais_Tempo, // estado para reiniciar contagem de tempo final. }; //*********************************************************************** //*********************************************************************** // Definicao da Variavel para Controle da Maquina de Estados: //======================================================================= byte ESTADO_MAQ = estado_Inativo; // seta o estado inicial. //*********************************************************************** //*********************************************************************** // Definicao dos Eventos sinalizados neste Sistema: //======================================================================= enum // eventos sinalizados neste Sistema: { evento_nenhum, // indica que nao ha' evento. evento_Dia, // evento para sinalizar que entrou no periodo "dia". evento_Noite, // evento para sinalizar que entrou no periodo "noite". evento_PASS_1, // evento para sinalizar acionamento do Sensor de Passagem 1. evento_PASS_2, // evento para sinalizar acionamento do Sensor de Passagem 2. evento_Fim_CRONO, // evento para sinalizar que "zerou" a Cronometragem. }; //*********************************************************************** //*********************************************************************** // Definicao da Variavel para Sinalizar Eventos dos Sensores de // Passagem 1 e 2: //======================================================================= byte evento_S1 = evento_nenhum; // inicialmente, indica "nenhum evento". byte evento_S2 = evento_nenhum; // inicialmente, indica "nenhum evento". //*********************************************************************** //*********************************************************************** // Definicao da Variavel para Sinalizar Eventos Dia/Noite: //======================================================================= byte evento_Dia_Noite = evento_nenhum; // inicialmente, indica "nenhum evento". //*********************************************************************** //*********************************************************************** // Definicao da Variavel para Sinalizar Eventos do Cronometro: //======================================================================= byte evento_CRONO = evento_nenhum; // inicialmente, indica "nenhum evento". //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Rotinas para Controle ON/OFF das Lampadas. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Desliga a Lampada 1. //======================================================================= void desliga_LAMP_1 () { digitalWrite( pino_LAMP_1, LAMP_OFF ); // desliga a Lampada 1. } //*********************************************************************** //*********************************************************************** // Liga a Lampada 1. //======================================================================= void liga_LAMP_1 () { digitalWrite( pino_LAMP_1, LAMP_ON ); // liga a Lampada 1. } //*********************************************************************** //*********************************************************************** // Desliga a Lampada 2. //======================================================================= void desliga_LAMP_2 () { digitalWrite( pino_LAMP_2, LAMP_OFF ); // desliga a Lampada 2. } //*********************************************************************** //*********************************************************************** // Liga a Lampada 2. //======================================================================= void liga_LAMP_2 () { digitalWrite( pino_LAMP_2, LAMP_ON ); // liga a Lampada 2. } //*********************************************************************** //*********************************************************************** // Desliga a Lampada 3. //======================================================================= void desliga_LAMP_3 () { digitalWrite( pino_LAMP_3, LAMP_OFF ); // desliga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Liga a Lampada 3. //======================================================================= void liga_LAMP_3 () { digitalWrite( pino_LAMP_3, LAMP_ON ); // liga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Desliga a Lampada 4. //======================================================================= void desliga_LAMP_4 () { digitalWrite( pino_LAMP_4, LAMP_OFF ); // desliga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Liga a Lampada 4. //======================================================================= void liga_LAMP_4 () { digitalWrite( pino_LAMP_4, LAMP_ON ); // liga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Desliga a Lampada 5. //======================================================================= void desliga_LAMP_5 () { digitalWrite( pino_LAMP_5, LAMP_OFF ); // desliga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Liga a Lampada 5. //======================================================================= void liga_LAMP_5 () { digitalWrite( pino_LAMP_5, LAMP_ON ); // liga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Desliga a Lampada 6. //======================================================================= void desliga_LAMP_6 () { digitalWrite( pino_LAMP_6, LAMP_OFF ); // desliga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Liga a Lampada 6. //======================================================================= void liga_LAMP_6 () { digitalWrite( pino_LAMP_6, LAMP_ON ); // liga a Lampada 3. } //*********************************************************************** //*********************************************************************** // Desliga todas as Lampadas controladas pelo Sistema. //======================================================================= void desliga_Lampadas () { desliga_LAMP_1(); // desliga Lampada 1. desliga_LAMP_2(); // desliga Lampada 2. desliga_LAMP_3(); // desliga Lampada 3. desliga_LAMP_4(); // desliga Lampada 1. desliga_LAMP_5(); // desliga Lampada 2. desliga_LAMP_6(); // desliga Lampada 3. } //*********************************************************************** //*********************************************************************** // Liga todas as Lampadas controladas pelo Sistema. //======================================================================= void liga_Lampadas () { liga_LAMP_1(); // liga Lampada 1. liga_LAMP_2(); // liga Lampada 2. liga_LAMP_3(); // liga Lampada 3. liga_LAMP_4(); // liga Lampada 1. liga_LAMP_5(); // liga Lampada 2. liga_LAMP_6(); // liga Lampada 3. } //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Rotinas para leitura/tratamento dos Sensores de Passagem. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Definicao do periodo de tempo, em segundos, para o efeito de // "debouncing" dos Sensores de Passagem. // Quando um acionamento e' detectado num Sensor, sera' ignorado // qualquer outro acionamento deste Sensor, dentro do periodo do // "debouncing". Apos esse periodo, voltam a serem detectados os // acionamentos do respectivo Sensor. //======================================================================= #define Sens_PASS_deb (unsigned long) 2 // tempo do "debouncing", em segundos. //*********************************************************************** //*********************************************************************** // Faz a leitura e tratamento do Sensor de Passagem 1. // A rotina usa um tempo de "debouncing", para ignorar acionamentos // que sejam consecutivos em intervalos de tempo muito estreitos. // Como resultado, se duas ou mais pessoas passam seguidamente pelo // Sensor num intervalo de tempo pequeno, e' considerado apenas um // unico acionamento. //======================================================================= void verifica_Sensor_1 () { //-------------------------------------------------- static bool status = false; bool new_status; static bool debouncing = false; static unsigned long ref_Tempo = 0; //-------------------------------------------------- if ( !debouncing ) // se nao esta' no periodo de "debouncing": { new_status = ( digitalRead( pino_Sensor_1 ) == PASS_ON ); // le estado atual do Sensor. if ( ( new_status != status ) && new_status ) // se o Sensor foi disparado: { evento_S1 = evento_PASS_1; // sinaliza o respectivo Evento. ref_Tempo = millis(); // seta referencia de tempo para o "debouncing". debouncing = true; // indica que deve ser feito o "debouncing". } status = new_status; // atualiza o registro do estado do Sensor. } else if ( ( millis() - ref_Tempo ) >= ( 1000 * Sens_PASS_deb ) ) // se terminou o "debouncing": { status = ( digitalRead( pino_Sensor_1 ) == PASS_ON ); // atualiza o registro do estado do Sensor. debouncing = false; // indica que terminou o "debouncing". } } //*********************************************************************** //*********************************************************************** // Faz a leitura e tratamento do Sensor de Passagem 2. // A rotina usa um tempo de "debouncing", para ignorar acionamentos // que sejam consecutivos em intervalos de tempo muito estreitos. // Como resultado, se duas ou mais pessoas passam seguidamente pelo // Sensor num intervalo de tempo pequeno, e' considerado apenas um // unico acionamento. //======================================================================= void verifica_Sensor_2 () { //-------------------------------------------------- static bool status = false; bool new_status; static bool debouncing = false; static unsigned long ref_Tempo = 0; //-------------------------------------------------- if ( !debouncing ) // se nao esta' no periodo de "debouncing": { new_status = ( digitalRead( pino_Sensor_2 ) == PASS_ON ); // le estado atual do Sensor. if ( ( new_status != status ) && new_status ) // se o Sensor foi disparado: { evento_S2 = evento_PASS_2; // sinaliza o respectivo Evento. ref_Tempo = millis(); // seta referencia de tempo para o "debouncing". debouncing = true; // indica que deve ser feito o "debouncing". } status = new_status; // atualiza o registro do estado do Sensor. } else if ( ( millis() - ref_Tempo ) >= ( 1000 * Sens_PASS_deb ) ) // se terminou o "debouncing": { status = ( digitalRead( pino_Sensor_2 ) == PASS_ON ); // atualiza o registro do estado do Sensor. debouncing = false; // indica que terminou o "debouncing". } } //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Rotinas para leitura/tratamento do Sensor Dia/Noite. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Definicao do periodo de tempo, em segundos, para o efeito de // "debouncing" do Sensor Dia/Noite. // Este periodo de tempo e' usado para confirmacao de que ocorreu // uma alteracao efetiva do estado do Sensor Dia/Noite. // Ver rotinas a seguir, para mais detalhes sobre o mecanismo. //======================================================================= #define Dia_Noite_deb (unsigned long) 10 // tempo do "debouncing", em segundos. //*********************************************************************** //*********************************************************************** // Definicao dos estados da Maquina de Estados que gerencia a // sinalizacao dos Eventos Dia e Noite: //======================================================================= enum // estados da Maquina Dia/Noite: { estado_Dia, // estado indicando que e' dia. estado_Noite, // estado indicando que e' noite. estado_confirmar_Dia, // estado para confirmar passagem noite --> dia. estado_confirmar_Noite, // estado para confirmar passagem dia --> noite. }; //*********************************************************************** //*********************************************************************** // Definicao da Variavel para Controle da Maquina Dia/Noite: //======================================================================= byte ESTADO_Dia_Noite = estado_Dia; // seta o estado inicial. //*********************************************************************** //*********************************************************************** // Maquina de Estados para sinalizar os Eventos Dia e Noite. // A Maquina implementa um "debouncing" para as alteracoes no // estado indicado pelo Sensor Dia/Noite. Quando e' detectada uma // nova indicacao no Sensor (seja dia ou noite), a Maquina entao // aguarda um periodo de tempo para o "debouncing". Apos este tempo, // a Maquina le novamente o Sensor, para confirmar se o novo estado // foi mantido. Dessa forma, oscilacoes normalmente existentes nas // indicacoes deste tipo de sensor, podem ser ignoradas. //======================================================================= void Maquina_Dia_Noite () { //-------------------------------------------------- static unsigned long ref_Tempo; //-------------------------------------------------- if ( ESTADO_Dia_Noite == estado_Dia ) // se esta' no estado "Dia": { if ( digitalRead( pino_Noite ) == Noite_ON ) // se o Sensor indica "Noite": { ref_Tempo = millis(); // seta referencia de tempo para o "debouncing". ESTADO_Dia_Noite = estado_confirmar_Noite; // vai para o estado "confirmar Noite". } } //.................................................. if ( ESTADO_Dia_Noite == estado_Noite ) // se esta' no estado "Noite": { if ( digitalRead( pino_Noite ) == Dia_ON ) // se o Sensor indica "Dia": { ref_Tempo = millis(); // seta referencia de tempo para o "debouncing". ESTADO_Dia_Noite = estado_confirmar_Dia; // vai para o estado "confirmar Dia". } } //.................................................. if ( ESTADO_Dia_Noite == estado_confirmar_Noite ) // se esta' no estado "confirmar Noite": { if ( ( millis() - ref_Tempo ) >= ( 1000 * Dia_Noite_deb ) ) // se e' o momento de confirmar: { if ( digitalRead( pino_Noite ) == Noite_ON ) // se o Sensor ainda indica "Noite": { evento_Dia_Noite = evento_Noite; // sinaliza Evento "Noite". ESTADO_Dia_Noite = estado_Noite; // vai para o estado "Noite". } else ESTADO_Dia_Noite = estado_Dia; // volta para o estado "Dia". } } //.................................................. if ( ESTADO_Dia_Noite == estado_confirmar_Dia ) // se esta' no estado "confirmar Dia": { if ( ( millis() - ref_Tempo ) >= ( 1000 * Dia_Noite_deb ) ) // se e' o momento de confirmar: { if ( digitalRead( pino_Noite ) == Dia_ON ) // se o Sensor ainda indica "Dia": { evento_Dia_Noite = evento_Dia; // sinaliza Evento "Dia". ESTADO_Dia_Noite = estado_Dia; // vai para o estado "Dia". } else ESTADO_Dia_Noite = estado_Noite; // volta para o estado "Noite". } } //.................................................. } //*********************************************************************** //*********************************************************************** // Emulacao da funcao "verifica_Dia_Noite", atraves da Maquina // de Estados Dia/Noite: //======================================================================= #define verifica_Dia_Noite() Maquina_Dia_Noite() // emula funcao. //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Gerenciamento do Cronometro para temporizacoes no Sistema. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Definicao das Variaveis para implementacao do Cronometro: //======================================================================= unsigned long periodo_CRONO = 0; // periodo de tempo cronometrado. unsigned long ref_CRONO = 0; // referencia de tempo do Cronometro. //*********************************************************************** //*********************************************************************** // Seta periodo de tempo e inicia a cronometragem. //======================================================================= void inicia_CRONO ( unsigned long tempo ) { periodo_CRONO = tempo; // seta o periodo de tempo da cronometragem. ref_CRONO = millis(); // reseta a referencia de tempo do Cronometro. evento_CRONO = evento_nenhum; // reseta indicador de eventos. } //*********************************************************************** //*********************************************************************** // Verifica se expirou o tempo de cronometragem. Se expirou, // entao e' sinalizado o Evento correspondente. //======================================================================= void atualiza_CRONO () { if ( ( millis() - ref_CRONO ) >= periodo_CRONO ) // se expirou o tempo: { evento_CRONO = evento_Fim_CRONO; // sinaliza o evento "Fim_CRONO". } } //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Funcoes para controle do LED "Alive". // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Variavel para armazenar o periodo do LED "Alive", em unidades // de mili-segundos. //======================================================================= unsigned int periodo_Alive = 3000; // periodo do "Alive", em [ms]. //*********************************************************************** //*********************************************************************** // Desliga o LED "Alive". //======================================================================= void desliga_LED_Alive () { digitalWrite( pino_LED_Alive, LED_OFF ); // desliga o LED. } //*********************************************************************** //*********************************************************************** // Liga o LED "Alive". //======================================================================= void liga_LED_Alive () { digitalWrite( pino_LED_Alive, LED_ON ); // liga o LED. } //*********************************************************************** //*********************************************************************** // Atualiza o estado fisico do LED "Alive". //======================================================================= void atualiza_LED_Alive () { //-------------------------------------------------- static unsigned long ref_Tempo = 0; unsigned long Tempo; static unsigned int counter = 0; //-------------------------------------------------- if ( periodo_Alive < 200 ) periodo_Alive = 200; // garante periodo coerente. Tempo = millis(); // obtem tempo atual. if ( ( Tempo - ref_Tempo ) >= 100 ) // se e' o momento da cadencia do "Alive": { if ( counter < 200 ) // se esta' no periodo de ligar o LED: { liga_LED_Alive(); // entao, liga o LED. } else desliga_LED_Alive(); // senao, desliga o LED. counter = counter + 100; // incrementa contador da cadencia do "Alive". if ( counter >= periodo_Alive ) counter = 0; // recicla no periodo do "Alive". ref_Tempo = Tempo; // nova referencia de tempo. } } //*********************************************************************** //*********************************************************************** // Seta o periodo do "Alive" para indicar "Dia". //======================================================================= void seta_Alive_Dia () { periodo_Alive = 3000; // seta periodo de 3 segundos do "Alive". } //*********************************************************************** //*********************************************************************** // Seta o periodo do "Alive" para indicar "Noite". //======================================================================= void seta_Alive_Noite () { periodo_Alive = 1000; // seta periodo de 1 segundo do "Alive". } //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Funcoes auxiliares do Sistema. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Exibe via Porta Serial padrao, os Parametros de Temporizacao // atuais deste Sistema. //======================================================================= void exibe_Parametros () { Serial.print( F("intervalo da sequencia = ") ); // informa intervalo da sequencia de acendimentos. Serial.print( Intervalo_LAMP ); Serial.println( F(" segundos") ); Serial.println(); Serial.print( F("tempo final de acendimento = ") ); // informa o tempo de acendimento final. Serial.print( tempo_FINAL ); Serial.println( F(" segundos") ); Serial.println(); Serial.print( F("debouncing dos Sensores = ") ); // informa o tempo de "debouncing" dos Sensores de Passagem. Serial.print( Sens_PASS_deb ); Serial.println( F(" segundos") ); Serial.println(); Serial.print( F("debouncing para Dia/Noite = ") ); // informa o tempo de "debouncing" para Dia/Noite. Serial.print( Dia_Noite_deb ); Serial.println( F(" segundos") ); Serial.println(); } //*********************************************************************** //*********************************************************************** // Faz atualizacao de todos os Sensores do Sistema. //======================================================================= void verifica_Sensores () { verifica_Dia_Noite(); // atualiza status do Sensor Dia/Noite. verifica_Sensor_1(); // atualiza status do Sensor de Passagem 1. verifica_Sensor_2(); // atualiza status do Sensor de Passagem 2. } //*********************************************************************** //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ // // Inicializacao e Loop de Controle do Sistema. // //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ //*********************************************************************** // Inicializa este Sistema. //======================================================================= void setup () { pinMode( pino_LAMP_1, OUTPUT ); // configura pinos de controle das Lampadas. pinMode( pino_LAMP_2, OUTPUT ); pinMode( pino_LAMP_3, OUTPUT ); pinMode( pino_LAMP_4, OUTPUT ); // configura pinos de controle das Lampadas. pinMode( pino_LAMP_5, OUTPUT ); pinMode( pino_LAMP_6, OUTPUT ); desliga_Lampadas(); // inicialmente, mantem Lampadas desligadas. //.................................................. pinMode( pino_Sensor_1, INPUT ); // configura pinos dos Sensores de Passagem. pinMode( pino_Sensor_2, INPUT ); //.................................................. pinMode( pino_Noite, INPUT ); // configura pino do Sensor Dia/Noite. //.................................................. pinMode( pino_LED_Alive, OUTPUT ); // configura pino de controle do LED "Alive". desliga_LED_Alive(); // inicialmente, mantem desligado o LED "Alive". //.................................................. Serial.begin(9600); // inicializa Serial Padrao do Arduino. delay(100); // eventual tempo de startup da serial. //.................................................. Serial.println(); Serial.println( F("iniciando o Sistema...") ); // exibe mensagem inicial. Serial.println(); exibe_Parametros(); // exibe os Parametros de Temporizacao do Sistema. Serial.println( F("pronto!") ); // avisa que o Sistema esta' pronto. Serial.println(); } //*********************************************************************** //*********************************************************************** // Loop principal deste Sistema: executa a Maquina de Estados // principal que controla este Sistema. //======================================================================= void loop () { verifica_Sensores(); // atualiza o status de todos os Sensores do Sistema. atualiza_LED_Alive(); // atualiza o estado do LED "Alive". //.................................................. if ( ESTADO_MAQ == estado_Inativo ) // se esta' no estado "Inativo": { desliga_Lampadas(); // mantem Lampadas desligadas. seta_Alive_Dia(); // seta o LED "Alive" para indicar "dia". if ( evento_Dia_Noite == evento_Noite ) // se ocorreu evento "Noite": { evento_Dia_Noite = evento_nenhum; // reseta indicador de evento. Serial.println( F("iniciou a Noite!") ); // avisa via Serial padrao. Serial.println(); evento_S1 = evento_nenhum; // descarta eventuais eventos dos sensores. evento_S2 = evento_nenhum; ESTADO_MAQ = estado_Ativo; // vai para o estado "Ativo". } } //.................................................. if ( ESTADO_MAQ == estado_Ativo ) // se esta' no estado "Ativo": { desliga_Lampadas(); // mantem Lampadas desligadas. seta_Alive_Noite(); // seta o LED "Alive" para indicar "noite". if ( evento_Dia_Noite == evento_Dia ) // se ocorreu evento "Dia": { evento_Dia_Noite = evento_nenhum; // reseta indicador de evento. Serial.println( F("iniciou o Dia!") ); // avisa via Serial padrao. Serial.println(); ESTADO_MAQ = estado_Inativo; // vai para o estado "Inativo". } else if ( evento_S1 == evento_PASS_1 ) // se ocorreu evento "PASS_1": { evento_S1 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 1!") ); // avisa via Serial padrao. Serial.println( F("liga Lampada 1!") ); Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_1; // vai para o estado "LAMP_1". } else if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga Lampada 6!") ); Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_6; // vai para o estado "LAMP_6". } } //.................................................. if ( ESTADO_MAQ == estado_LAMP_1 ) // se esta' no estado "LAMP_1": { liga_LAMP_1(); // liga a Lampada 1. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 2!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_1_2; // vai para o estado "LAMP_1_2". } } if ( ESTADO_MAQ == estado_LAMP_1_2 ) // se esta' no estado "LAMP_1_2": { liga_LAMP_2(); // liga a Lampada 2. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 3!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_2_3; // vai para o estado "LAMP_2_3". } } //.................................................. if ( ESTADO_MAQ == estado_LAMP_2_3 ) // se esta' no estado "LAMP_2_3": { liga_LAMP_3(); // liga a Lampada 3. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 4!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_3_4; // vai para o estado "LAMP_3_4". } } if ( ESTADO_MAQ == estado_LAMP_3_4 ) // se esta' no estado "LAMP_3_4": { liga_LAMP_4(); // liga a Lampada 4. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 5!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_4_5; // vai para o estado "LAMP_4_5". } } if ( ESTADO_MAQ == estado_LAMP_4_5 ) // se esta' no estado "LAMP_4_5": { liga_LAMP_5(); // liga a Lampada 5. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 6!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } } //.................................................. if ( ESTADO_MAQ == estado_LAMP_6 ) // se esta' no estado "LAMP_6": { liga_LAMP_6(); // liga a Lampada 6. atualiza_CRONO(); if ( evento_S1 == evento_PASS_1 ) // se ocorreu evento "PASS_1": { evento_S1 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 1!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 5!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_6_5; // vai para o estado "LAMP_6_5". } } //.................................................. if ( ESTADO_MAQ == estado_LAMP_6_5 ) // se esta' no estado "LAMP_6_5": { liga_LAMP_5(); // liga a Lampada 5. atualiza_CRONO(); if ( evento_S1 == evento_PASS_1 ) // se ocorreu evento "PASS_1": { evento_S1 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 1!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 4!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_5_4; // vai para o estado "LAMP_5_4". } } if ( ESTADO_MAQ == estado_LAMP_5_4 ) // se esta' no estado "LAMP_5_4": { liga_LAMP_4(); // liga a Lampada 4. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 3!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_4_3; // vai para o estado "LAMP_4_3". } } if ( ESTADO_MAQ == estado_LAMP_4_3 ) // se esta' no estado "LAMP_4_3": { liga_LAMP_3(); // liga a Lampada 3. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 2!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_3_2; // vai para o estado "LAMP_3_2". } } if ( ESTADO_MAQ == estado_LAMP_3_2 ) // se esta' no estado "LAMP_3_2": { liga_LAMP_2(); // liga a Lampada 2. atualiza_CRONO(); if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println( F("liga todas as Lampadas!") ); Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // inicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("liga Lampada 1!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*Intervalo_LAMP ); // inicia cronometragem para proxima Lampada. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } } //.................................................. if ( ESTADO_MAQ == estado_LAMP_1_2_3_4_5_6 ) // se esta' no estado "LAMP_1_2_3_4_5_6": { liga_Lampadas(); // liga todas as Lampadas. atualiza_CRONO(); if ( evento_S1 == evento_PASS_1 ) // se ocorreu evento "PASS_1": { evento_S1 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 1!") ); // avisa via Serial padrao. Serial.println(); ESTADO_MAQ = estado_Mais_Tempo; // vai para o estado "Mais Tempo". } else if ( evento_S2 == evento_PASS_2 ) // se ocorreu evento "PASS_2": { evento_S2 = evento_nenhum; // reseta indicador de evento. Serial.println( F("detectou Sensor 2!") ); // avisa via Serial padrao. Serial.println(); ESTADO_MAQ = estado_Mais_Tempo; // vai para o estado "Mais Tempo". } else if ( evento_CRONO == evento_Fim_CRONO ) { Serial.println( F("terminou tempo final!") ); // avisa via Serial padrao. Serial.println( F("desliga todas as Lampadas!") ); Serial.println(); ESTADO_MAQ = estado_Ativo; // vai para o estado "Ativo". } } //.................................................. if ( ESTADO_MAQ == estado_Mais_Tempo ) // se esta' no estado "Mais Tempo": { Serial.println( F("tempo adicional ligado!") ); // avisa via Serial padrao. Serial.println(); inicia_CRONO( 1000*tempo_FINAL ); // reinicia cronometragem do tempo final. ESTADO_MAQ = estado_LAMP_1_2_3_4_5_6; // vai para o estado "LAMP_1_2_3_4_5_6". } //.................................................. } //***********************************************************************