RuiViana

Soares.ino

Sep 13th, 2020 (edited)
752
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // **********************************************************************
  2. // **
  3. // **  Sistema para Monitoramento de Pressao e Humidade com emissao
  4. // ** de Alarmes (visual, sonoro, e SMS), em um Arduino UNO.
  5.  
  6. // **********************************************************************
  7.  
  8.  
  9.  
  10.  
  11. //***********************************************************************
  12. //  Selecionar se a compilacao sera' para uma Simulacao, ou sera'
  13. //  para o Hardware "real".
  14. //
  15. // Opcoes:
  16. //  0 = versao para Hardware "real".
  17. //  1 = versao para Simulacao.
  18. //=======================================================================
  19.  
  20. #define opcao_Simulacao 0   // 0 = versao "real",  1 = versao para Simulacao.
  21.  
  22. //***********************************************************************
  23.  
  24.  
  25.  
  26.  
  27. //***********************************************************************
  28. //  Especificacao das Bibliotecas Padroes usadas neste Sistema:
  29. //=======================================================================
  30.  
  31. //#include <LiquidCrystal.h>  // Lib para o LCD padrao, tipo Colunas x Linhas.
  32.  
  33. #include <Wire.h> //INCLUSÃO DE BIBLIOTECA
  34. #include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA
  35. #include <virtuabotixRTC.h>                    //biblioteca para o RTC DS1302      
  36. #include <SD.h>
  37. #include <SPI.h>
  38.  
  39. File myFile;
  40.  
  41. int pinoSS = 53;
  42.  
  43. LiquidCrystal_I2C Display_LCD(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); //ENDEREÇO DO I2C E DEMAIS INFORMAÇÕES
  44.  
  45.  
  46. //***********************************************************************
  47.  
  48. // ========================================================================================================
  49. // --- Mapeamento de Hardware ---
  50. #define   clk   22
  51. #define   dat   23
  52. #define   rst   24
  53.  
  54.  
  55. // ========================================================================================================
  56.  
  57. // ========================================================================================================
  58. // --- Constantes Auxiliares ---
  59. #define   segL       00
  60. #define   minL       24
  61. #define   horL       20
  62. #define   d_semL     6
  63. #define   d_mesL   10
  64. #define   mesL       9
  65. #define   anoL     2020
  66.  
  67.  
  68. // ========================================================================================================
  69. // --- Declaração de Objetos ---
  70. virtuabotixRTC   myRTC(clk, dat, rst);         //declara objeto para o RTC
  71.  
  72.  
  73. // ========================================================================================================
  74. // --- Protótipo das Funções ---
  75. void DS1302();
  76. void week(int dayW);
  77.  
  78.  
  79.  
  80. //***********************************************************************
  81.  
  82. //***********************************************************************
  83. //  Especificacao e instanciamento do Display LCD utilizado neste
  84. //  Sistema:
  85. //=======================================================================
  86.  
  87. #define LCD_col   16   // numero de colunas do Display LCD.
  88.  
  89. #define LCD_lin  4    // numero de linhas do Display LCD.
  90.  
  91. //-----------------------------------------------------------------------
  92.  
  93.  
  94.  
  95.  
  96. //***********************************************************************
  97. //  Define o pino do Arduino usado para o acionamento do Buzzer.
  98. //=======================================================================
  99.  
  100. #define pino_BUZZER  25   // pino usado para controle do Buzzer.
  101.  
  102. //***********************************************************************
  103.  
  104.  
  105.  
  106.  
  107. //***********************************************************************
  108. //  Definicao do Nivel Logico ( HIGH ou LOW ) que aciona o Buzzer
  109. //  (ou o Driver dele) neste Sistema:
  110. //=======================================================================
  111.  
  112. #define BUZZER_ON   HIGH   // Nivel Logico que aciona o Buzzer.
  113.  
  114. //***********************************************************************
  115.  
  116.  
  117.  
  118.  
  119. //***********************************************************************
  120. //  Especificacao do tipo do Buzzer: "passivo" ou "ativo".
  121. //  Buzzer "ativo" e' aquele que quando se liga a alimentação aos
  122. //  terminais do mesmo, ele ja' emite som em uma frequencia fixa
  123. //  que nao pode ser alterada, embora ainda possa ser "modulada".
  124. //  Como a "modulação" pode produzir sons estranhos, ao se usar
  125. //  Buzzer "ativo", o ideal e' fazer sinalizacoes distintas apenas
  126. //  atraves da duracao da sinalizacao (duracao do som emitido).
  127. //  Ja' com o Buzzer "passivo", tem-se mais flexibilidade, e alem
  128. //  da duracao do som, e' possivel emitir-se diversas frequencias
  129. //  ("tons"), permitindo aos sons emitidos serem "mais agradaveis".
  130. //  Este Sistema trabalha com os dois tipos de Buzzer, bastando que
  131. //  seja selecionado a seguir, qual o tipo utilizado:
  132. //=======================================================================
  133.  
  134. #define tipo_BUZZER   0   // 0 = Buzzer "passivo",  1 = Buzzer "ativo".
  135.  
  136. //***********************************************************************
  137.  
  138.  
  139.  
  140.  
  141. //***********************************************************************
  142. //  Definicao das Diversos alarmes sonoros emitidos via Buzzer.
  143. //  Para cada alarme, devem ser especificados a frequencia do
  144. //  sinal sonoro (ou "tom"), o tempo de duracao de um "bip" emitido,
  145. //  e o ciclo de repeticao do "bip" emitido.
  146. //
  147. // Obs.:
  148. //  - a frequencia do sinal sonoro NAO tera' efeito se um Buzzer do
  149. //  tipo "ativo" tiver sido especificado (ver #define tipo_BUZZER).
  150. //
  151. //  - O ciclo do "bip" e' contado a partir da emissao do "bip", e
  152. //  deve ser maior que a duracao (o "tON") do proprio "bip". Porem,
  153. //  se a duracao do ciclo for setada menor ou igual a do "bip", isto
  154. //  resultara' em um som emitido continuamente.
  155. //=======================================================================
  156.  
  157. #define BUZZER_Pressao_freq_Hz  100   // frequencia do sinal sonoro, em [Hz].
  158.  
  159. #define BUZZER_Pressao_tON_ms   100   // duracao de um "bip" emitido, em mili-segundos.
  160.  
  161. #define BUZZER_Pressao_ciclo_ms  6000  // ciclo de repeticao do "bip", em mili-segundos.
  162.  
  163. //-----------------------------------------------------------------------
  164.  
  165.  
  166. //***********************************************************************
  167.  
  168.  
  169.  
  170.  
  171. //***********************************************************************
  172. //  Definicao da conexao dos LEDs aos pinos do Arduino:
  173. //=======================================================================
  174.  
  175. #define pino_LED_verde   30   // pino onde o "LED verde" esta' conectado.
  176.  
  177. #define pino_LED_vermelho  32  // pino onde o "LED vermelho" esta' conectado.
  178.  
  179. #define pino_LED_amarelo   34   // pino onde o "LED amarelo" esta' conectado.
  180.  
  181. //***********************************************************************
  182.  
  183.  
  184.  
  185.  
  186. //***********************************************************************
  187. //  Definicao do estado Logico ( HIGH ou LOW ) para ligar os LEDs
  188. //  neste Sistema:
  189. //=======================================================================
  190.  
  191. #define LED_ON   HIGH   // estado logico para ligar os LEDs neste Sistema.
  192.  
  193. //***********************************************************************
  194.  
  195.  
  196.  
  197.  
  198. //***********************************************************************
  199.  
  200. //***********************************************************************
  201. //  Definicao da conexao dos Sensores de Pressao aos pinos do
  202. //  Arduino:
  203. //=======================================================================
  204.  
  205. #define pino_PRESSAO_1   A0   // pino onde o Sensor de "Pressao 1" esta' conectado.
  206.  
  207. #define pino_PRESSAO_2   A1   // pino onde o Sensor de "Pressao 2" esta' conectado.
  208.  
  209. //***********************************************************************
  210.  
  211.  
  212.  
  213.  
  214. //***********************************************************************
  215. //  Define o "range" numerico absoluto da conversao AD neste
  216. //  Sistema, e o correspondente "range" absoluto em Volts.
  217. //  Especificar conforme o Hardware atual utilizado.
  218. //=======================================================================
  219.  
  220. #ifdef  __AVR__   // se e' um Arduino AVR convencional:
  221.  
  222. #define range_AD  1024   // "range" numerico absoluto da conversao AD.
  223.  
  224. #define range_AD_Volts  5  // "range" absoluto da conversao AD, em Volts.
  225.  
  226. //..................................................
  227.  
  228. #else   // se o Hardware nao foi especificado:
  229.  
  230. #error   Configuracao invalida para range_AD!   // sinaliza erro no Tempo de Compilacao.
  231.  
  232. #endif
  233.  
  234. //***********************************************************************
  235.  
  236.  
  237.  
  238.  
  239. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  240. //
  241. //  Rotinas para Gerenciamento da Sinalizacao via LEDs.
  242. //
  243. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  244.  
  245.  
  246.  
  247.  
  248. //***********************************************************************
  249. //  Definicao de uma Estrutura para Controle da Sinalizacao via
  250. //  LED neste Sistema:
  251. //=======================================================================
  252.  
  253. struct LED_control   // informacoes para controle da sinalizacao:
  254. {
  255.   byte pino;   // pino onde o LED esta' conectado.
  256.  
  257.   unsigned short tempo_ON_ms;  // duracao de uma piscada, em mili-segundos.
  258.  
  259.   unsigned long ciclo_ms;  // ciclo da piscada (ou intervalo entre piscadas), em mili-segundos.
  260.  
  261.   unsigned long duracao_ms;  // duracao da sinalizacao, em mili-segundos.
  262.  
  263.   byte status: 4; // indica o status atual do controle do LED.
  264.  
  265.   byte sign: 1; // indica se uma sinalizacao esta' sendo feita.
  266.  
  267.   byte logica_ON: 1; // indica o Nivel Logico que liga o LED no Hardware.
  268.  
  269.   unsigned long ref_ciclo;   // referencia de tempo para o ciclo da piscada.
  270.  
  271.   unsigned long ref_duracao;  // referencia de tempo para a duracao da sinalizacao.
  272. };
  273. //***********************************************************************
  274.  
  275.  
  276.  
  277.  
  278. //***********************************************************************
  279. //  Desliga o LED especificado via estrutura de controle.
  280. //  Isto e' feito apenas via Hardware e nao tem efeito na Maquina
  281. //  de Estados que Gerencia a sinalizacao logica.
  282. //
  283. // Parametros:
  284. //  LED_control_PTR = aponta a estrutura para controle do LED.
  285. //=======================================================================
  286.  
  287. void  desliga_LED ( struct LED_control* LED_control_PTR )
  288. {
  289.   digitalWrite( (*LED_control_PTR).pino, !(*LED_control_PTR).logica_ON );  // desliga o LED especificado.
  290. }
  291. //***********************************************************************
  292.  
  293.  
  294.  
  295.  
  296. //***********************************************************************
  297. //  Liga o LED especificado via estrutura de controle.
  298. //  Isto e' feito apenas via Hardware e nao tem efeito na Maquina
  299. //  de Estados que Gerencia a sinalizacao logica.
  300. //
  301. // Parametros:
  302. //  LED_control_PTR = aponta a estrutura para controle do LED.
  303. //=======================================================================
  304.  
  305. void  liga_LED ( struct LED_control* LED_control_PTR )
  306. {
  307.   digitalWrite( (*LED_control_PTR).pino, (*LED_control_PTR).logica_ON );  // liga o LED especificado.
  308. }
  309. //***********************************************************************
  310.  
  311.  
  312.  
  313.  
  314. //***********************************************************************
  315. //  Definicao dos Estados para a Maquina de Estados que controla
  316. //  a sinalizacao via LEDs neste Sistema:
  317. //=======================================================================
  318.  
  319. enum
  320. {
  321.   LED_estado_aguarda,  // estado para aguardar uma solicitacao de sinalizacao.
  322.  
  323.   LED_estado_iniciar,  // estado para iniciar uma sinalizacao solicitada.
  324.  
  325.   LED_estado_tON,   // estado para gerenciar o tempo minimo que o LED fica ligado.
  326.  
  327.   LED_estado_tOFF,  // estado para gerenciar o tempo minimo que o LED fica desligado.
  328.  
  329.   LED_estado_duracao,  // estado para gerenciar a duracao da sinalizacao.
  330. };
  331. //***********************************************************************
  332.  
  333.  
  334.  
  335.  
  336. //***********************************************************************
  337. //  Controla a sinalizacao do LED especificado via estrutura de
  338. //  controle.
  339. //  O Gerenciamento e' feito atraves de uma Maquina de Estados.
  340. //  O estado atual da Maquina de Estados, e' armazenado na propria
  341. //  estrutura de controle do LED especificado, resultando que cada
  342. //  LED tem sua propria Maquina de Estados.
  343. //  Parametros de temporizacao tambem estao contidos na estrutura
  344. //  de controle do LED. O mesmo se aplica para as informacoes que
  345. //  identificam o LED (pino, logica ON/OFF, etc).
  346. //
  347. // Parametros:
  348. //  LED_control_PTR = aponta a estrutura para controle do LED.
  349. //=======================================================================
  350.  
  351. void  Maquina_Controla_LED ( struct LED_control* LED_control_PTR )
  352. {
  353.   //--------------------------------------------------
  354.   byte status;
  355.   //--------------------------------------------------
  356.  
  357.   status = (*LED_control_PTR).status;  // obtem o estado atual da sinalizacao do LED especificado.
  358.  
  359.   //..................................................
  360.  
  361.   if ( status == LED_estado_aguarda )   // se esta' aguardando uma solicitacao de sinalizacao:
  362.   {
  363.     if ( (*LED_control_PTR).sign )   // se foi solicitado uma sinalizacao:
  364.     {
  365.       (*LED_control_PTR).ref_duracao = millis();  // obtem referencia de tempo para a duracao da sinalizacao.
  366.  
  367.       status = LED_estado_iniciar;   // vai iniciar a sinalizacao solicitada.
  368.     }
  369.   }
  370.  
  371.   //..................................................
  372.  
  373.   if ( status == LED_estado_iniciar )   // se esta' iniciando uma sinalizacao:
  374.   {
  375.     liga_LED( LED_control_PTR );   // liga o LED especificado.
  376.  
  377.     (*LED_control_PTR).ref_ciclo = millis();  // obtem referencia de tempo para o ciclo da piscada do LED.
  378.  
  379.     status = LED_estado_tON;   // vai gerenciar o "tempo ON" do LED.
  380.   }
  381.  
  382.   //..................................................
  383.  
  384.   if ( status == LED_estado_tON )   // se esta' gerenciando o "tempo ON" do LED:
  385.   {
  386.     if ( ( millis() - (*LED_control_PTR).ref_ciclo ) >= (*LED_control_PTR).tempo_ON_ms )  // se terminou o tempo "tempo ON":
  387.     {
  388.       desliga_LED( LED_control_PTR );  // desliga o LED especificado.
  389.  
  390.       status = LED_estado_tOFF;   // vai gerenciar o ciclo da piscada do LED.
  391.     }
  392.   }
  393.  
  394.   //..................................................
  395.  
  396.   if ( status == LED_estado_tOFF )   // se esta' gerenciando o ciclo da piscada do LED:
  397.   {
  398.     if ( ( millis() - (*LED_control_PTR).ref_ciclo ) >= (*LED_control_PTR).ciclo_ms )  // se terminou este ciclo:
  399.     {
  400.       status = LED_estado_duracao;   // vai gerenciar a duracao da sinalizacao solicitada.
  401.     }
  402.   }
  403.  
  404.   //..................................................
  405.  
  406.   if ( status == LED_estado_duracao )   // se esta' gerenciando a duracao da sinalizacao:
  407.   {
  408.     if ( ( millis() - (*LED_control_PTR).ref_duracao ) >= (*LED_control_PTR).duracao_ms )  // se terminou a sinalizacao atual:
  409.     {
  410.       (*LED_control_PTR).sign = false;   // indica que o LED esta' livre para sinalizacao.
  411.  
  412.       status = LED_estado_aguarda;  // vai aguardar uma nova solicitacao.
  413.     }
  414.     else   // se nao terminou a sinalizacao atual:
  415.     {
  416.       status = LED_estado_iniciar;   // reinicia o ciclo de sinalizacao via LED especificado.
  417.     }
  418.   }
  419.  
  420.   //..................................................
  421.  
  422.   (*LED_control_PTR).status = status;  // salva o estado atual da sinalizacao do LED especificado.
  423. }
  424. //***********************************************************************
  425.  
  426.  
  427.  
  428.  
  429. //***********************************************************************
  430. //  Finaliza a sinalizacao do LED especificado.
  431. //
  432. // Parametros:
  433. //  LED_control_PTR = aponta a estrutura para controle do LED.
  434. //=======================================================================
  435.  
  436. void  LED_control_reset ( struct LED_control* LED_control_PTR )
  437. {
  438.   desliga_LED( LED_control_PTR );  // desliga o LED especificado.
  439.  
  440.   (*LED_control_PTR).status = LED_estado_aguarda;  // reseta o estado de controle da sinalizacao.
  441.  
  442.   (*LED_control_PTR).sign = false;  // indica que o LED esta' livre para sinalizacao.
  443. }
  444. //***********************************************************************
  445.  
  446.  
  447.  
  448.  
  449. //***********************************************************************
  450. //  Requisita uma sinalizacao atraves do LED especificado.
  451. //
  452. // Parametros:
  453. //  LED_control_PTR = aponta a estrutura para controle do LED.
  454. //  tempo_ON_ms = tempo que o LED fica "ON" na piscada de sinalizacao, em mili-segundos.
  455. //  ciclo_ms = ciclo da piscada do LED (o intervalo entre piscadas), em mili-segundos.
  456. //  duracao_ms = duracao da sinalizacao, em mili-segundos.
  457. //=======================================================================
  458.  
  459. void  LED_control_set ( struct LED_control* LED_control_PTR, unsigned short tempo_ON_ms, unsigned long ciclo_ms, unsigned long duracao_ms )
  460. {
  461.   if ( !(*LED_control_PTR).sign )   // se o LED especificado esta' livre para sinalizacao:
  462.   {
  463.     (*LED_control_PTR).tempo_ON_ms = tempo_ON_ms;   // seta o tempo que o LED fica "ON" na piscada de sinalizacao.
  464.  
  465.     (*LED_control_PTR).ciclo_ms = ciclo_ms;  // seta o intervalo de tempo entre piscadas do LED.
  466.  
  467.     (*LED_control_PTR).duracao_ms = duracao_ms;  // seta a duracao da sinalizacao.
  468.  
  469.     (*LED_control_PTR).sign = true;   // indica que uma sinalizacao deve ser iniciada.
  470.   }
  471. }
  472. //***********************************************************************
  473.  
  474.  
  475.  
  476.  
  477. //***********************************************************************
  478. //  Configura e inicializa a estrutura de controle especificada
  479. //  para sinalizacao atraves do LED tambem especificado (o pino
  480. //  onde este LED esta' conectado e o respectivo Nivel Logico que
  481. //  liga o LED no Hardware).
  482. //
  483. // Parametros:
  484. //  LED_control_PTR = aponta a estrutura para controle do LED.
  485. //  pino = pino do Arduino onde esta' conectado o LED usado na sinalizacao.
  486. //  logica_ON = nivel logico (HIGH ou LOW), que liga o LED no Hardware.
  487. //=======================================================================
  488.  
  489. void  LED_control_config ( struct LED_control* LED_control_PTR, byte pino, bool logica_ON )
  490. {
  491.   pinMode( pino, OUTPUT );  // configura no Hardware, o pino de controle do LED.
  492.  
  493.   (*LED_control_PTR).pino = pino;   // registra o pino onde esta' conetado o LED.
  494.  
  495.   (*LED_control_PTR).logica_ON = logica_ON;  // registra o nivel logico que liga o LED.
  496.  
  497.   //..................................................
  498.  
  499.   LED_control_reset( LED_control_PTR );   // inicialmente, "desliga" a sinalizacao.
  500. }
  501. //***********************************************************************
  502.  
  503.  
  504.  
  505.  
  506. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  507. //
  508. //  Rotinas para Gerenciamento da Sinalizacao via Buzzer.
  509. //
  510. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  511.  
  512.  
  513.  
  514.  
  515. //***********************************************************************
  516. //  Definicao de Parametros para sinalizacao via Buzzer.
  517. //
  518. // Obs.:
  519. //  - a Frequencia do Buzzer so' e' utilizada se um Buzzer tipo
  520. //  "passivo" tiver sido especificado (ver #define tipo_BUZZER).
  521. //=======================================================================
  522.  
  523. unsigned int BUZZER_freq_Hz;   // Frequencia do sinal sonoro, em Hertz.
  524.  
  525. unsigned long BUZZER_tempo_ON_ms;  // duracao do acionamento "ON" do Buzzer, em mili-segundos.
  526.  
  527. unsigned long BUZZER_ciclo_ms;  // ciclo de acionamento do Buzzer, em mili-segundos.
  528.  
  529. //***********************************************************************
  530.  
  531.  
  532.  
  533.  
  534. //***********************************************************************
  535. //  Definicao de uma Flag para indicar quando esta' ativa uma
  536. //  sinalizacao via Buzzer:
  537. //=======================================================================
  538.  
  539. bool BUZZER_flag = false;  // indica se esta' ativa uma sinalizacao via Buzzer.
  540.  
  541. //***********************************************************************
  542.  
  543.  
  544.  
  545.  
  546. //***********************************************************************
  547. //  Desliga o Buzzer.
  548. //  Isto e' feito apenas via Hardware e nao tem efeito na Maquina
  549. //  de Estados que Gerencia a sinalizacao logica.
  550. //
  551. // Obs.:
  552. //  - a funcao "noTone" nesta rotina, so' tem efeito se um Buzzer do
  553. //  tipo "passivo" tiver sido especificado (ver #define tipo_BUZZER).
  554. //=======================================================================
  555.  
  556. void  desliga_BUZZER ()
  557. {
  558.   noTone( pino_BUZZER );   // desliga o sinal no pino do Buzzer.
  559.  
  560.   digitalWrite( pino_BUZZER, !BUZZER_ON );  // garante Buzzer desenergizado.
  561. }
  562. //***********************************************************************
  563.  
  564.  
  565.  
  566.  
  567. //***********************************************************************
  568. //  Aciona o Buzzer.
  569. //  Isto e' feito apenas via Hardware e nao tem efeito na Maquina
  570. //  de Estados que Gerencia a sinalizacao logica.
  571. //  O acionamento e' implementado conforme o tipo especificado para
  572. //  o Buzzer, ou seja, "passivo" ou "ativo".
  573. //=======================================================================
  574.  
  575. #if ( tipo_BUZZER == 0 )   // se o Buzzer e' do tipo "passivo":
  576.  
  577. #define aciona_BUZZER(pino,freq)   tone(pino,freq)   // aciona com a frequencia especificada.
  578.  
  579. //..................................................
  580.  
  581. #elif ( tipo_BUZZER == 1 )   // se o Buzzer e' do tipo "ativo":
  582.  
  583. #define aciona_BUZZER(pino,freq)   digitalWrite(pino,BUZZER_ON)   // entao apenas liga o Buzzer.
  584.  
  585. //..................................................
  586.  
  587. #else   // se o tipo do Buzzer e' invalido:
  588.  
  589. #error  Configuracao invalida para o Buzzer!   // indica o erro no tempo de compilacao.
  590.  
  591. #endif
  592.  
  593. //***********************************************************************
  594.  
  595.  
  596.  
  597.  
  598. //***********************************************************************
  599. //  Definicao dos Estados para a Maquina de Estados que controla
  600. //  a sinalizacao via Buzzer neste Sistema:
  601. //=======================================================================
  602.  
  603. enum
  604. {
  605.   BUZZER_estado_verificar,  // estado para verificar se deve fazer uma sinalizacao.
  606.  
  607.   BUZZER_estado_iniciar,  // estado para iniciar um ciclo de sinalizacao via Buzzer.
  608.  
  609.   BUZZER_estado_tON,   // estado para gerenciar o tempo minimo que o Buzzer fica acionado.
  610.  
  611.   BUZZER_estado_tOFF,  // estado para gerenciar o tempo minimo que o Buzzer fica desacionado.
  612. };
  613. //***********************************************************************
  614.  
  615.  
  616.  
  617.  
  618. //***********************************************************************
  619. //  Definicao de uma variavel para controle da Maquina de Estados
  620. //  que gerencia a sinalizado via Buzzer:
  621. //=======================================================================
  622.  
  623. byte estado_Buzzer = 0;   // estado atual da sinalizacao via Buzzer.
  624.  
  625. //***********************************************************************
  626.  
  627.  
  628.  
  629.  
  630. //***********************************************************************
  631. //  Controla a sinalizacao via Buzzer. O Gerenciamento e' feito
  632. //  atraves de uma Maquina de Estados.
  633. //=======================================================================
  634.  
  635. void  Maquina_Controla_BUZZER ()
  636. {
  637.   //--------------------------------------------------
  638.   static unsigned long ref_tempo_ms;
  639.   //--------------------------------------------------
  640.  
  641.   //..................................................
  642.  
  643.   if ( estado_Buzzer == BUZZER_estado_verificar )   // se esta' verificando se deve fazer uma sinalizacao:
  644.   {
  645.     if ( BUZZER_flag )   // se a sinalizacao via Buzzer esta' habilitada:
  646.     {
  647.       estado_Buzzer = BUZZER_estado_iniciar;   // vai iniciar um ciclo de acionamento do Buzzer.
  648.     }
  649.   }
  650.  
  651.   //..................................................
  652.  
  653.   if ( estado_Buzzer == BUZZER_estado_iniciar )   // se esta' iniciando um ciclo de acionamento do Buzzer:
  654.   {
  655.     aciona_BUZZER( pino_BUZZER, BUZZER_freq_Hz );  // aciona o Buzzer.
  656.  
  657.     ref_tempo_ms = millis();  // obtem referencia de tempo para o ciclo de acionamento do Buzzer.
  658.  
  659.     estado_Buzzer = BUZZER_estado_tON;   // vai gerenciar o tempo de acionamento do Buzzer.
  660.   }
  661.  
  662.   //..................................................
  663.  
  664.   if ( estado_Buzzer == BUZZER_estado_tON )   // se esta' aguardando o fim do tempo de acionamento do Buzzer:
  665.   {
  666.     if ( ( millis() - ref_tempo_ms ) >= BUZZER_tempo_ON_ms )  // se terminou o tempo de acionamento do Buzzer:
  667.     {
  668.       desliga_BUZZER();  // desliga o sinal no Buzzer.
  669.  
  670.       estado_Buzzer = BUZZER_estado_tOFF;   // vai aguardar o fim do ciclo de acionamento do Buzzer.
  671.     }
  672.   }
  673.   //..................................................
  674.  
  675.   if ( estado_Buzzer == BUZZER_estado_tOFF )   // se esta' aguardando o fim do ciclo de acionamento do Buzzer:
  676.   {
  677.     if ( ( millis() - ref_tempo_ms ) >= BUZZER_ciclo_ms )  // se terminou o ciclo de acionamento do Buzzer:
  678.     {
  679.       estado_Buzzer = BUZZER_estado_verificar;  // vai verificar se continua ou suspende a sinalizacao.
  680.     }
  681.   }
  682.   //..................................................
  683.  
  684. }
  685. //***********************************************************************
  686.  
  687.  
  688.  
  689.  
  690. //***********************************************************************
  691. //  Finaliza a sinalizacao atual via Buzzer.
  692. //=======================================================================
  693.  
  694. void  BUZZER_reset ()
  695. {
  696.   desliga_BUZZER();   // garante Buzzer desligado.
  697.  
  698.   estado_Buzzer = BUZZER_estado_verificar;  // reseta o estado de controle da sinalizacao.
  699.  
  700.   BUZZER_flag = false;   // indica que nao ha' sinalizacao neste momento.
  701. }
  702. //***********************************************************************
  703.  
  704.  
  705.  
  706.  
  707. //***********************************************************************
  708. //  Requisita uma sinalizacao via Buzzer, especificando qual a
  709. //  Frequencia do sinal sonoro, a duracao de um "bip" emitido, e
  710. //  ciclo de repeticao deste "bip".
  711. //
  712. // Parametros:
  713. //  freq_Hz = Frequencia do sinal sonoro, em Hertz.
  714. //  tempo_ON_ms = duracao de um "bip" emitido, em mili-segundos.
  715. //  ciclo_ms = ciclo de repeticao do "bip", em mili-segundos.
  716. //
  717. // Obs.:
  718. //  - a Frequencia do sinal sonoro so' tera' efeito se um Buzzer do
  719. //  tipo "passivo" tiver sido especificado (ver #define tipo_BUZZER).
  720. //=======================================================================
  721.  
  722. void  BUZZER_set ( unsigned int freq_Hz, unsigned long tempo_ON_ms, unsigned long ciclo_ms )
  723. {
  724.   if ( !BUZZER_flag )  // se nao ha' uma sinalizacao sendo feita:
  725.   {
  726.     BUZZER_freq_Hz = freq_Hz;  // seta a Frequencia do sinal do Buzzer, em [Hz].
  727.  
  728.     BUZZER_tempo_ON_ms = tempo_ON_ms;  // seta a duracao do "bip" emitido, em [ms].
  729.  
  730.     BUZZER_ciclo_ms = ciclo_ms;  // seta o ciclo de repeticao do "bip" emitido, em [ms].
  731.  
  732.     BUZZER_flag = true;   // habilita a sinalizacao via Buzzer.
  733.   }
  734. }
  735. //***********************************************************************
  736.  
  737.  
  738.  
  739.  
  740. //***********************************************************************
  741. //  Configura o Hardware e inicializa o controle para sinalizacao
  742. //  via Buzzer.
  743. //=======================================================================
  744.  
  745. void  BUZZER_init ()
  746. {
  747.   pinMode( pino_BUZZER, OUTPUT );  // configura o pino de controle do Buzzer.
  748.  
  749.   BUZZER_reset();   // inicialmente, "desliga" a sinalizacao.
  750. }
  751. //***********************************************************************
  752.  
  753.  
  754.  
  755.  
  756.  
  757. #include <SoftwareSerial.h>   // Lib para implementar uma Serial por Software.
  758.  
  759. //-----------------------------------------------------------------------
  760.  
  761.  
  762.  
  763.  
  764.  
  765.  
  766.  
  767.  
  768.  
  769.  
  770. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  771. //
  772. //  Rotinas para Gerenciamento da Medicao de Pressao no Sistema.
  773. //
  774. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  775.  
  776.  
  777.  
  778.  
  779. //***********************************************************************
  780. //  Definicao dos pontos para Mapeamento e calculo da Pressao.
  781. //  Os quatro valores a seguir, podem ser obtidos de quaisquer
  782. //  dois pontos de um Grafico Pressao x Voltagem do Sensor de
  783. //  Pressao, ou obtidos atraves da medicao direta desses pontos
  784. //  usando o Sensor na pratica.
  785. //  Este Sistema considera um comportamento linear para a curva
  786. //  Pressao x Voltagem resultante do Sensor de Pressao.
  787. //
  788. // Obs.:
  789. //  - a mesma unidade deve ser usada para as Pressoes de Referencia
  790. //  "A" e "B".
  791. //=======================================================================
  792.  
  793. #define Press_ref_A   0   // Pressao de Referencia "A", medida pelo Sensor, na unidade desejada.
  794.  
  795. #define Press_ref_A_volt  0.46  // tensao em Volts, correspondente 'a Pressao de Referencia "A".
  796.  
  797. //-----------------------------------------------------------------------
  798.  
  799. #define Press_ref_B   1  // Pressao de Referencia "B", medida pelo Sensor, na unidade desejada.
  800.  
  801. #define Press_ref_B_volt  0.76  // tensao em Volts, correspondente 'a Pressao de Referencia "B".
  802.  
  803. //***********************************************************************
  804.  
  805.  
  806.  
  807.  
  808. //***********************************************************************
  809. //  Definicao de Variaveis para armazenar os valores de Pressao
  810. //  medidos neste Sistema.
  811. //  As unidades e escalas, dependerao dos pontos usados para o
  812. //  Mapeamento e calculo da Pressao (as constantes "Press_ref_A" e
  813. //  "Press_ref_B").
  814. //=======================================================================
  815.  
  816. float PRESSAO_1;   // valor atual da "Pressao 1".
  817.  
  818. float PRESSAO_2;   // valor atual da "Pressao 2".
  819.  
  820. //***********************************************************************
  821.  
  822.  
  823.  
  824.  
  825. //***********************************************************************
  826. //  Coeficientes utilizados para Mapeamento e calculo dos valores
  827. //  de Pressao medidos neste Sistema.
  828. //  Este Sistema considera um comportamento linear para a curva
  829. //  Pressao x Voltagem resultante do Sensor de Pressao.
  830. //=======================================================================
  831.  
  832. float coef_ang_Pressao;  // Coeficiente Linear da curva da Pressao.
  833.  
  834. float ref_Pressao;  // ponto de referencia da curva da Pressao.
  835.  
  836. int sample_ref_Pressao;  // sample correspondente a "ref_Pressao".
  837.  
  838. //***********************************************************************
  839.  
  840.  
  841.  
  842.  
  843. //***********************************************************************
  844. //  Calcula os Coeficientes utilizados para Mapeamento e calculo
  845. //  dos valores de Pressao medidos neste Sistema.
  846. //  Isto e' feito a partir dos pontos fornecidos para Mapeamento
  847. //  e calculo da Pressao: ponto (Press_ref_A, Press_ref_A_volt) e
  848. //  o ponto (Press_ref_B, Press_ref_B_volt), alem do range da
  849. //  Conversao AD.
  850. //  Este Sistema considera um comportamento linear para a curva
  851. //  Pressao x Voltagem resultante do Sensor de Pressao.
  852. //=======================================================================
  853.  
  854. void  calc_Parametros_PRESSAO ()
  855. {
  856.   //--------------------------------------------------
  857.   float sample_min, sample_max;
  858.   float delta_S, delta_P;
  859.   //--------------------------------------------------
  860.  
  861.   sample_min = (float) range_AD * Press_ref_A_volt / range_AD_Volts;  // calcula o sample da "referencia A" de Pressao.
  862.  
  863.   sample_max = (float) range_AD * Press_ref_B_volt / range_AD_Volts;  // calcula o sample da "referencia B" de Pressao.
  864.  
  865.   delta_S = sample_max - sample_min;  // calcula o "delta" de sample para a Pressao.
  866.  
  867.   delta_P = (float) Press_ref_B - Press_ref_A;  // calcula o "delta" da Pressao.
  868.  
  869.   coef_ang_Pressao = delta_P / delta_S;  // calcula o Coef. Linear da curva PxV, para uso em calculos da Pressao.
  870.  
  871.   ref_Pressao = (float) Press_ref_A;  // seta a referencia de Pressao, para uso em calculos da Pressao.
  872.  
  873.   sample_ref_Pressao = sample_min;  // seta a referencia de samples de Presao, para uso em calculos da Pressao.
  874. }
  875. //***********************************************************************
  876.  
  877.  
  878.  
  879.  
  880. //***********************************************************************
  881. //  Calcula Pressao na escala e unidade deste Sistema, para o
  882. //  sample correspondente especificado.
  883. //  O calculo e' feito a partir da equacao linear da curva PxV,
  884. //  usando os Coeficientes desta curva (previamente calculados).
  885. //=======================================================================
  886.  
  887. float calc_PRESSAO ( int sample_AD )
  888. {
  889.   //--------------------------------------------------
  890.   float result;
  891.   int delta_sample;
  892.   //--------------------------------------------------
  893.  
  894.   delta_sample = sample_AD - sample_ref_Pressao;  // calcula o "delta" em relacao ao "sample_ref_Pressao".
  895.  
  896.   result = (float) delta_sample * coef_ang_Pressao + ref_Pressao;  // calcula a Pressao correspondente.
  897.  
  898.   return ( result );  // informa a Pressao na escala e unidade deste Sistema.
  899. }
  900. //***********************************************************************
  901.  
  902.  
  903.  
  904.  
  905. //***********************************************************************
  906. //  Obtem os valores atuais das Pressoes medidas neste Sistema.
  907. //  Para isto, o sample da Pressao e' obtido (conversao AD), e
  908. //  entao mapeado para a escala e unidade que sao utilizadas
  909. //  neste Sistema.
  910. //=======================================================================
  911.  
  912. void  obtem_PRESSAO ()
  913. {
  914.   //--------------------------------------------------
  915.   int sample_AD;
  916.   //--------------------------------------------------
  917.  
  918.   sample_AD = analogRead( pino_PRESSAO_1 );   // obtem sample da "Pressao 1".
  919.  
  920.   PRESSAO_1 = calc_PRESSAO( sample_AD );   // calcula "Pressao 1" na escala e unidade deste Sistema.
  921.  
  922.   //..................................................
  923.  
  924.   sample_AD = analogRead( pino_PRESSAO_2 );   // obtem sample da "Pressao 2".
  925.  
  926.   PRESSAO_2 = calc_PRESSAO( sample_AD );   // calcula "Pressao 2" na escala e unidade deste Sistema.
  927. }
  928. //***********************************************************************
  929.  
  930.  
  931.  
  932.  
  933. //***********************************************************************
  934. //  Definicao da Variavel para o intervalo de tempo, em unidades
  935. //  de mili-segundos, entre medicoes consecutivas de Pressao neste
  936. //  Sistema, assim determinando a Taxa de Amostragem da medicao.
  937. //=======================================================================
  938.  
  939. unsigned long intervalo_PRESSAO_ms;  // intervalo entre medicoes, em mili-segundos.
  940.  
  941. //***********************************************************************
  942.  
  943.  
  944.  
  945.  
  946. //***********************************************************************
  947. //  Atualiza os indices de Pressao do Sistema, conforme a taxa
  948. //  de amostragem determinada pelo intervalo entre medicoes.
  949. //  Na saida, a rotina informa se uma nova medicao esta' ou nao
  950. //  disponivel.
  951. //
  952. // saida:
  953. //  true = uma nova medicao esta' disponivel.
  954. //  false = uma nova medicao ainda nao esta' disponivel.
  955. //=======================================================================
  956.  
  957. bool  atualiza_PRESSAO ()
  958. {
  959.   //--------------------------------------------------
  960.   bool Ok = false;
  961.   static unsigned long ref_tempo_ms = 0;
  962.   //--------------------------------------------------
  963.  
  964.   if ( ( millis() - ref_tempo_ms ) >= intervalo_PRESSAO_ms )  // se e' o momento de nova medicao:
  965.   {
  966.     obtem_PRESSAO();   // obtem novos indices, conforme sensores.
  967.  
  968.     Ok = true;   // sinaliza que uma nova medicao esta' disponivel.
  969.  
  970.     ref_tempo_ms = millis();   // seta referencia de tempo para nova amostragem.
  971.   }
  972.  
  973.   return ( Ok );  // informa se ha' ou nao uma nova medicao disponivel.
  974. }
  975. //***********************************************************************
  976.  
  977.  
  978.  
  979.  
  980. //***********************************************************************
  981. //  Configura e inicializa a Medicao de Pressao no Sistema.
  982. //  A configuracao permite especificar o intervalo entre medicoes,
  983. //  assim determinando a Taxa de Amostragem para a medicao.
  984. //
  985. // Parametros:
  986. //  intervalo_ms = intervalo entre medicoes, em mili-segundos.
  987. //=======================================================================
  988.  
  989. void  Sensor_PRESSAO_init ( unsigned long intervalo_ms )
  990. {
  991.   pinMode( pino_PRESSAO_1, INPUT_PULLUP );  // configura o pino para o Sensor de "Pressao 1"
  992.  
  993.   pinMode( pino_PRESSAO_2, INPUT_PULLUP );  // configura o pino para o Sensor de "Pressao 2"
  994.  
  995.   intervalo_PRESSAO_ms = intervalo_ms;  // seta o intervalo entre medicoes.
  996.  
  997.   calc_Parametros_PRESSAO();  // inicializa Parametros para calculo da Pressao.
  998. }
  999. //***********************************************************************
  1000.  
  1001.  
  1002.  
  1003.  
  1004. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1005. //
  1006. //  Rotinas para Gerenciamento da exibicao no Display LCD.
  1007. //
  1008. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1009.  
  1010.  
  1011.  
  1012.  
  1013. //***********************************************************************
  1014. //  Definicao dos diversos tempos de exibicao de informacoes no
  1015. //  Display LCD neste Sistema:
  1016. //=======================================================================
  1017.  
  1018. #define tempo_Display_Pressao_ms   5000  // tempo em mili-segundos, para exibicao da Pressao.
  1019.  
  1020.  
  1021. //***********************************************************************
  1022.  
  1023.  
  1024.  
  1025.  
  1026.  
  1027.  
  1028.  
  1029.  
  1030. //***********************************************************************
  1031. //  Funcao para exibir os valores de Pressao no Display LCD.
  1032. //=======================================================================
  1033.  
  1034. void  Display_Pressao ()
  1035. {
  1036.   Display_LCD.setCursor( 0, 0 );   // exibe a informacao da "Pressao 1":
  1037.   Display_LCD.print( F("Pressao  = ") );
  1038.   Display_LCD.print( PRESSAO_1, 2 );
  1039.   Display_LCD.print( F(" bar") );
  1040.  
  1041.   Display_LCD.setCursor( 0, 1 );   // exibe a informacao da "Pressao 2":
  1042.   Display_LCD.print( F("Depressao= ") );
  1043.   Display_LCD.print( PRESSAO_2, 2 );
  1044.   Display_LCD.print( F(" bar") );
  1045. }
  1046. //***********************************************************************
  1047.  
  1048.  
  1049.  
  1050.  
  1051. //***********************************************************************
  1052. //  Atualiza a exibicao das informacoes no Display LCD.
  1053. //  Cada informacao e' exibida no tempo especificado para a mesma.
  1054. //  Quando um tempo de exibicao termina, a funcao seleciona a
  1055. //  proxima informacao a ser exibida.
  1056. //=======================================================================
  1057.  
  1058. void  atualiza_Display ()
  1059. {
  1060.   //--------------------------------------------------
  1061.   static byte select = 0;
  1062.   static unsigned long ref_tempo_ms = 0;
  1063.   //--------------------------------------------------
  1064.  
  1065.  
  1066.   if ( select == 0 )  // se esta' selecionada a exibicao da Pressao:
  1067.   {
  1068.     Display_Pressao();  // entao exibe no Display, a Pressao atual.
  1069.  
  1070.     if ( ( millis() - ref_tempo_ms ) >= tempo_Display_Pressao_ms )  // se terminou o tempo de exibicao:
  1071.     {
  1072.       select = 0;  // seleciona exibicao da proxima informacao.
  1073.  
  1074.       ref_tempo_ms = millis();  // reseta referencia de tempo para exibicao.
  1075.     }
  1076.   }
  1077. }
  1078. //***********************************************************************
  1079.  
  1080.  
  1081.  
  1082.  
  1083. //***********************************************************************
  1084. //  Definicao do intervalo de tempo para a atualizacao do Display
  1085. //  LCD neste Sistema.
  1086. //  Esta definicao determina a taxa de atualizacao do Display (ou
  1087. //  seja, tempos menores aumentam a taxa de atualizacao do Display).
  1088. //=======================================================================
  1089.  
  1090. #define intervalo_Display_ms  500   // intervalo de atualizacao do Display, em [ms].
  1091.  
  1092. //***********************************************************************
  1093.  
  1094.  
  1095.  
  1096.  
  1097. //***********************************************************************
  1098. //  Gerencia a atualizacao do display LCD, de acordo com a taxa
  1099. //  de atualizacao do mesmo.
  1100. //=======================================================================
  1101.  
  1102. void  Gerencia_Display ()
  1103. {
  1104.   //--------------------------------------------------
  1105.   static unsigned long ref_tempo_ms = 0;
  1106.   //--------------------------------------------------
  1107.  
  1108.   if ( ( millis() - ref_tempo_ms ) >= intervalo_Display_ms )  // se e' o momento de atualizar:
  1109.   {
  1110.     atualiza_Display();   // faz a atualizacao do Display.
  1111.  
  1112.     ref_tempo_ms = millis();  // seta referencia de tempo para a proxima atualizacao.
  1113.   }
  1114. }
  1115. //***********************************************************************
  1116.  
  1117.  
  1118.  
  1119.  
  1120. //***********************************************************************
  1121. //  Inicializa o controle do Display LCD.
  1122. //=======================================================================
  1123.  
  1124. void  Display_init ()
  1125. {
  1126.   Display_LCD.begin( LCD_col, LCD_lin );   // inicializa o Display LCD.
  1127.  
  1128.   Display_LCD.clear();   // inicialmente, "limpa" o Display.
  1129. }
  1130. //***********************************************************************
  1131.  
  1132.  
  1133.  
  1134.  
  1135. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1136. //
  1137. //  Configuracao dos LEDs usados em sinalizacoes neste Sistema.
  1138. //
  1139. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1140.  
  1141.  
  1142.  
  1143.  
  1144. //***********************************************************************
  1145. //  Definicao e instanciamento das estruturas de controle para
  1146. //  cada um dos LEDs usados em sinalizacoes neste Sistema:
  1147. //=======================================================================
  1148.  
  1149. struct LED_control  LED_verde_control;   // estrutura de controle para o "LED verde".
  1150.  
  1151. struct LED_control  LED_vermelho_control;  // estrutura de controle para o "LED vermelho".
  1152.  
  1153. struct LED_control  LED_amarelo_control;   // estrutura de controle para o "LED amarelo".
  1154.  
  1155. //***********************************************************************
  1156.  
  1157.  
  1158.  
  1159.  
  1160. //***********************************************************************
  1161. //  Funcao para configurar o controle de cada um dos LEDs usados
  1162. //  em sinalizacoes neste Sistema.
  1163. //  Para cada um dos LEDs, e' especificado a respectiva estrutura
  1164. //  de controle, o pino onde o LED esta' conectado, e o Nivel Lógico
  1165. //  que liga o LED no Hardware.
  1166. //=======================================================================
  1167.  
  1168. void  LED_control_init ()
  1169. {
  1170.   LED_control_config( &LED_verde_control, pino_LED_verde, LED_ON );  // configura sinalizacao via "LED verde".
  1171.  
  1172.   LED_control_config( &LED_vermelho_control, pino_LED_vermelho, LED_ON );  // configura sinalizacao via "LED vermelho".
  1173.  
  1174.   LED_control_config( &LED_amarelo_control, pino_LED_amarelo, LED_ON );  // configura sinalizacao via "LED amarelo".
  1175. }
  1176. //***********************************************************************
  1177.  
  1178.  
  1179.  
  1180.  
  1181. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1182. //
  1183. //  Gerenciamento das diversas sinalizacoes neste Sistema.
  1184. //
  1185. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1186.  
  1187.  
  1188.  
  1189.  
  1190. //***********************************************************************
  1191. //  Define identificadores unicos para cada uma das sinalizacoes
  1192. //  (ou alertas) neste Sistema.
  1193. //  Cada identificador (flag) deve obrigatoriamente corresponder
  1194. //  a um unico "bit" no "Registro de Alertas".
  1195. //  Como o "Registro de Alertas" corresponde a um unico byte,
  1196. //  entao os valores validos e disponiveis para serem usados como
  1197. //  flags identificadoras, sao em Hexadecimal: 0x01, 0x02, 0x04,
  1198. //  0x08, 0x10, 0x20, 0x40, e 0x80.
  1199. //=======================================================================
  1200.  
  1201.  
  1202. #define flag_alerta_Pressao_1  0x02  // flag identificadora para o alerta de "Pressao 1".
  1203.  
  1204. #define flag_alerta_Pressao_2  0x04  // flag identificadora para o alerta de "Pressao 2".
  1205.  
  1206. //***********************************************************************
  1207.  
  1208.  
  1209.  
  1210.  
  1211. //***********************************************************************
  1212. //  Definicao da Variavel usada como "Registro de Alertas" deste
  1213. //  Sistema.
  1214. //  Como a definicao atual usa um unico byte para o "Registro de
  1215. //  Alertas", entao um maximo de ate' 8 flags identificadoras sao
  1216. //  possiveis de serem usadas, ou seja, ate' 8 alertas distintos
  1217. //  podem existir neste Sistema.
  1218. //  Portanto, os valores validos e disponiveis para serem usados
  1219. //  como flags identificadoras, sao em Hexadecimal: 0x01, 0x02,
  1220. //  0x04, 0x08, 0x10, 0x20, 0x40, e 0x80.
  1221. //=======================================================================
  1222.  
  1223. byte Registro_Alertas = 0;  // "Registro de Alertas" deste Sistema.
  1224.  
  1225. //***********************************************************************
  1226.  
  1227.  
  1228.  
  1229.  
  1230.  
  1231. //***********************************************************************
  1232.  
  1233.  
  1234.  
  1235.  
  1236.  
  1237.  
  1238.  
  1239. //***********************************************************************
  1240. //  Requisita que seja "desligado" o alerta de "Pressao 1".
  1241. //  Para isto, a respectiva flag indentificadora do alerta, e'
  1242. //  resetada no "Registro de Alertas".
  1243. //=======================================================================
  1244.  
  1245. void  reseta_Alerta_Pressao_1 ()
  1246. {
  1247.   Registro_Alertas &= (byte) ~flag_alerta_Pressao_1;  // reseta a flag de "Pressao 1".
  1248. }
  1249. //***********************************************************************
  1250.  
  1251.  
  1252.  
  1253.  
  1254. //***********************************************************************
  1255. //  Requisita que seja "ligado" o alerta de "Pressao 1".
  1256. //  Para isto, a respectiva flag indentificadora do alerta, e'
  1257. //  setada no "Registro de Alertas".
  1258. //=======================================================================
  1259.  
  1260. void  seta_Alerta_Pressao_1 ()
  1261. {
  1262.   Registro_Alertas |= flag_alerta_Pressao_1;  // seta a flag de "Pressao 1".
  1263. }
  1264. //***********************************************************************
  1265.  
  1266.  
  1267.  
  1268.  
  1269. //***********************************************************************
  1270. //  Requisita que seja "desligado" o alerta de "Pressao 2".
  1271. //  Para isto, a respectiva flag indentificadora do alerta, e'
  1272. //  resetada no "Registro de Alertas".
  1273. //=======================================================================
  1274.  
  1275. void  reseta_Alerta_Pressao_2 ()
  1276. {
  1277.   Registro_Alertas &= (byte) ~flag_alerta_Pressao_2;  // reseta a flag de "Pressao 2".
  1278. }
  1279. //***********************************************************************
  1280.  
  1281.  
  1282.  
  1283.  
  1284. //***********************************************************************
  1285. //  Requisita que seja "ligado" o alerta de "Pressao 2".
  1286. //  Para isto, a respectiva flag indentificadora do alerta, e'
  1287. //  setada no "Registro de Alertas".
  1288. //=======================================================================
  1289.  
  1290. void  seta_Alerta_Pressao_2 ()
  1291. {
  1292.   Registro_Alertas |= flag_alerta_Pressao_2;  // seta a flag de "Pressao 2".
  1293. }
  1294. //***********************************************************************
  1295.  
  1296.  
  1297.  
  1298.  
  1299.  
  1300.  
  1301.  
  1302. //***********************************************************************
  1303. //  Gerencia o alerta de Pressao atraves do respectivo LED de
  1304. //  alerta, conforme o estado da flag indicadora do alerta no
  1305. //  "Registro de Alertas".
  1306. //=======================================================================
  1307.  
  1308. void  Gerencia_Alerta_LED_Pressao ()
  1309. {
  1310.   if ( ( Registro_Alertas & ( flag_alerta_Pressao_1 | flag_alerta_Pressao_2 ) ) != 0 )  // se esta' "ligado" um alerta de Pressao:
  1311.   {
  1312.     LED_control_set( &LED_vermelho_control, 50, 1000, -1 );  // ativa o "LED vermelho" ( LED_control*, tempo_ON_ms, intervalo_ms, duracao_ms ).
  1313.  
  1314.     Maquina_Controla_LED( &LED_vermelho_control );  // controla a sinalizacao atraves do "LED vermelho".
  1315.   }
  1316.   else   // se NAO esta' "ligado" um alerta de Pressao:
  1317.   {
  1318.     LED_control_reset( &LED_vermelho_control );  // desativa o "LED vermelho".
  1319.   }
  1320. }
  1321. //***********************************************************************
  1322.  
  1323.  
  1324.  
  1325.  
  1326. //***********************************************************************
  1327. //  Gerencia a sinalizacao atraves do "LED verde".
  1328. //  Este LED deve piscar a intervalos regulares, quando nao ha'
  1329. //  alertas ativos no Sistema (conforme indicado pelo conteudo do
  1330. //  "Registro de Alertas"). Havendo alertas, o "LED verde" deve
  1331. //  ficar desligado.
  1332. //=======================================================================
  1333.  
  1334. void  Gerencia_LED_verde ()
  1335. {
  1336.   if ( Registro_Alertas == 0 )  // se NAO ha' alerta no Sistema:
  1337.   {
  1338.     LED_control_set( &LED_verde_control, 50, 1000, -1 );  // ativa o "LED verde" ( LED_control*, tempo_ON_ms, intervalo_ms, duracao_ms ).
  1339.  
  1340.     Maquina_Controla_LED( &LED_verde_control );  // controla a sinalizacao atraves do "LED verde".
  1341.   }
  1342.   else   // se ha' algum alerta no Sistema:
  1343.   {
  1344.     LED_control_reset( &LED_verde_control );  // desativa o "LED verde".
  1345.   }
  1346. }
  1347. //***********************************************************************
  1348.  
  1349.  
  1350.  
  1351.  
  1352. //***********************************************************************
  1353. //  Gerencia a sinalizacao/alertas atraves do Buzzer.
  1354. //  Havendo alertas ativos no Sistema, o Buzzer e' acionado de
  1355. //  forma "personalizada" para cada tipo de alerta. Se nao ha'
  1356. //  alertas ativos, entao o Buzzer e' desligado. A existencia ou
  1357. //  nao de alertas ativos, e' indicado pelo conteudo do "Registro
  1358. //  de Alertas".
  1359. //  A sequencia de verificado do "Registro de Alertas", determina
  1360. //  a prioridade dos alertas via Buzzer. Assim, o primeiro alerta
  1361. //  verificado, e' o que possui maior prioridade.
  1362. //  Identificadores para cada alerta, impedem que um alerta ja'
  1363. //  sendo sinalizado via Buzzer, seja novamente reiniciado, o que
  1364. //  desligaria o Buzzer momentaneamente, interrompendo de forma
  1365. //  abrupta a sinalizacao atual.
  1366. //=======================================================================
  1367.  
  1368. void  Gerencia_Alerta_Buzzer ()
  1369. {
  1370.   //--------------------------------------------------
  1371.   static byte ID_alerta = 0;
  1372.   //--------------------------------------------------
  1373.  
  1374.   if ( ( Registro_Alertas & ( flag_alerta_Pressao_1 | flag_alerta_Pressao_2 ) ) != 0 )  // se ha' alerta de Pressao:
  1375.   {
  1376.     if ( ID_alerta != 1 )  // se o alerta de Pressao via Buzzer NAO esta' sendo executado:
  1377.     {
  1378.       BUZZER_reset();  // desliga qualquer alerta vigente via Buzzer.
  1379.  
  1380.       BUZZER_set( BUZZER_Pressao_freq_Hz, BUZZER_Pressao_tON_ms, BUZZER_Pressao_ciclo_ms );  // aciona o Buzzer ( freq_Hz, tempo_ON_ms, ciclo_ms ).
  1381.  
  1382.       ID_alerta = 1;  // registra que ha' um alerta de Pressao via Buzzer.
  1383.     }
  1384.   }
  1385.  
  1386.   else   // se NAO ha' alertas no Sistema:
  1387.   {
  1388.     if ( ID_alerta != 0 )  // se alertas via Buzzer ainda nao foram desligados:
  1389.     {
  1390.       BUZZER_reset();  // desliga qualquer alerta vigente via Buzzer.
  1391.  
  1392.       ID_alerta = 0;  // registra que NAO ha' alertas via Buzzer.
  1393.     }
  1394.   }
  1395.  
  1396.   //..................................................
  1397.  
  1398.   Maquina_Controla_BUZZER();   // gerencia a sinalizacao atraves do Buzzer.
  1399. }
  1400. //***********************************************************************
  1401.  
  1402.  
  1403.  
  1404.  
  1405.  
  1406.  
  1407.  
  1408.  
  1409. //***********************************************************************
  1410. //  Gerencia as diversas sinalizacoes/alertas existentes neste
  1411. //  Sistema.
  1412. //=======================================================================
  1413.  
  1414. void  Gerencia_Alertas ()
  1415. {
  1416.   Gerencia_LED_verde();  // gerencia a sinalizacao atraves do "LED verde".
  1417.  
  1418.   Gerencia_Alerta_LED_Pressao();  // gerencia alertas de Pressao atraves do respectivo LED de alerta.
  1419.  
  1420.  
  1421.   Gerencia_Alerta_Buzzer();   // gerencia alertas atraves do Buzzer.
  1422.  
  1423.  
  1424. }
  1425. //***********************************************************************
  1426.  
  1427.  
  1428.  
  1429.  
  1430. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1431. //
  1432. //    Gerencia o "Auto-Teste" deste Sistema.
  1433. //
  1434. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1435.  
  1436.  
  1437.  
  1438.  
  1439. //***********************************************************************
  1440. //  Define o tempo da duracao do "Auto-Teste" das sinalizacoes
  1441. //  deste Sistema:
  1442. //=======================================================================
  1443.  
  1444. #define duracao_Auto_Teste_ms   3000  // duracao do "Auto-Teste", em [ms].
  1445.  
  1446. //***********************************************************************
  1447.  
  1448.  
  1449.  
  1450.  
  1451. //***********************************************************************
  1452. //
  1453. //=======================================================================
  1454.  
  1455. void  Auto_Teste_sinalizacoes ()
  1456. {
  1457.   //--------------------------------------------------
  1458.   unsigned long ref_tempo_ms;
  1459.   //--------------------------------------------------
  1460.  
  1461.   Display_LCD.clear();   // informa via Display LCD, que esta' executando o "Auto-Teste".
  1462.   Display_LCD.setCursor( 2, 0 );
  1463.   Display_LCD.print( F("*SAFM MINERACAO*") );
  1464.   Display_LCD.setCursor( 6, 2 );
  1465.   Display_LCD.print( F("**821E  PC 07 **") );
  1466.   delay(3000);
  1467.   //..................................................
  1468.  
  1469.   LED_control_set( &LED_verde_control, 50, 250, -1 );  // ativa o "LED verde" ( LED_control*, tempo_ON_ms, intervalo_ms, duracao_ms ).
  1470.  
  1471.   LED_control_set( &LED_vermelho_control, 50, 250, -1 );  // ativa o "LED vermelho" ( LED_control*, tempo_ON_ms, intervalo_ms, duracao_ms ).
  1472.  
  1473.   LED_control_set( &LED_amarelo_control, 50, 250, -1 );  // ativa o "LED amarelo" ( LED_control*, tempo_ON_ms, intervalo_ms, duracao_ms ).
  1474.  
  1475.   BUZZER_reset();  // desliga qualquer alerta vigente via Buzzer.
  1476.  
  1477.   BUZZER_set( 100, 500, 1000 );  // aciona o Buzzer ( freq_Hz, tempo_ON_ms, ciclo_ms ).
  1478.  
  1479.  
  1480.   //..................................................
  1481.  
  1482.   ref_tempo_ms = millis();  // seta referencia de tempo para a duracao do "Auto-Teste".
  1483.  
  1484.   while ( ( millis() - ref_tempo_ms ) < duracao_Auto_Teste_ms )  // se nao acabou o "Auto-Teste":
  1485.   {
  1486.     Maquina_Controla_LED( &LED_verde_control );  // controla a sinalizacao atraves do "LED verde".
  1487.  
  1488.     Maquina_Controla_LED( &LED_vermelho_control );  // controla a sinalizacao atraves do "LED vermelho".
  1489.  
  1490.     Maquina_Controla_LED( &LED_amarelo_control );  // controla a sinalizacao atraves do "LED amarelo".
  1491.  
  1492.     Maquina_Controla_BUZZER();   // gerencia a sinalizacao atraves do Buzzer.
  1493.  
  1494.  
  1495.   }
  1496.  
  1497.   //..................................................
  1498.  
  1499.  
  1500.   BUZZER_reset();  // desliga sinalizacao via Buzzer.
  1501.  
  1502.   LED_control_reset( &LED_verde_control );  // desliga o "LED verde".
  1503.  
  1504.   LED_control_reset( &LED_vermelho_control );  // desliga o "LED vermelho".
  1505.  
  1506.   LED_control_reset( &LED_amarelo_control );  // desliga o "LED amarelo".
  1507.  
  1508.   //..................................................
  1509.  
  1510.   Display_LCD.clear();  // "limpa" o Display LCD.
  1511. }
  1512. //***********************************************************************
  1513.  
  1514.  
  1515.  
  1516.  
  1517. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1518. //
  1519. //  Inicializacao e Loop de Controle Principal do Sistema.
  1520. //
  1521. //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
  1522.  
  1523.  
  1524.  
  1525.  
  1526. //***********************************************************************
  1527. //  Inicializacao do Sistema.
  1528. //=======================================================================
  1529.  
  1530. void  setup ()
  1531. {
  1532.  
  1533.   Display_LCD.begin (16, 4); //SETA A QUANTIDADE DE COLUNAS(16) E O NÚMERO DE LINHAS(2) DO DISPLAY
  1534.   Display_LCD.setBacklight(HIGH); //LIGA O BACKLIGHT (LUZ DE FUNDO)
  1535.  
  1536.   Serial.begin(9600);   // inicializa a Serial padrao do Arduino.
  1537.  
  1538.   // myRTC.setDS1302Time(segL, minL, horL, d_semL, d_mesL, mesL, anoL);
  1539.  
  1540.   delay(500);   // tempo para eventual "startup" da Serial.
  1541.  
  1542.  
  1543.  
  1544.   pinMode(pinoSS, OUTPUT); // Declara pinoSS como saída
  1545.  
  1546.   // Open serial communications and wait for port to open:
  1547.   Serial.begin(9600);
  1548.   while (!Serial) {
  1549.     ; // wait for serial port to connect. Needed for native USB port only
  1550.   }
  1551.  
  1552.  
  1553.   Serial.print("Initializing SD card...");
  1554.  
  1555.   Serial.print("Initiali SD card");
  1556.  
  1557.  
  1558.   if (!SD.begin(4)) {
  1559.  
  1560.     Serial.println("initialization failed!");
  1561.  
  1562.     while (1);
  1563.   }
  1564.   Serial.println("initialization done.");
  1565.  
  1566.  
  1567.  
  1568.   // open the file. note that only one file can be open at a time,
  1569.   // so you have to close this one before opening another.
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.   //..................................................
  1577.  
  1578.   Sensor_PRESSAO_init( 100 );  // configura Medicoes de Pressao, a intervalos de 100 mili-segundos.
  1579.  
  1580.  
  1581.   //..................................................
  1582.  
  1583.   Display_init();  // inicializa o controle do Display LCD.
  1584.  
  1585.   LED_control_init();  // configura o controle dos LEDs usados nas sinalizacoes/alertas.
  1586.  
  1587.   BUZZER_init();  // configura o controle da sinalizacao/alerta via Buzzer.
  1588.  
  1589.   //..................................................
  1590.  
  1591.   Auto_Teste_sinalizacoes();  // executa o "Auto-Teste" das sinalizacoes do Sistema.
  1592.  
  1593.   //..................................................
  1594.  
  1595.  
  1596. }
  1597.  
  1598. // ========================================================================================================
  1599. // --- Desenvolvimento das Funções ---
  1600. void DS1302()
  1601. {
  1602.   myRTC.updateTime();         //faz leitura do DS1302
  1603.  
  1604.   // Imprime informações
  1605.   Serial.print(" -> ");
  1606.   week(myRTC.dayofweek);
  1607.   Serial.print(" | ");
  1608.   Serial.print(myRTC.dayofmonth);
  1609.   Serial.print("/");
  1610.   Serial.print(myRTC.month);
  1611.   Serial.print("/");
  1612.   Serial.print(myRTC.year);
  1613.   Serial.print(" | ");
  1614.   if (myRTC.hours < 10) Serial.print("0");
  1615.   Serial.print(myRTC.hours);
  1616.   Serial.print(":");
  1617.   if (myRTC.minutes < 10) Serial.print("0");
  1618.   Serial.print(myRTC.minutes);
  1619.   Serial.print(":");
  1620.   if (myRTC.seconds < 10) Serial.print("0");
  1621.   Serial.println(myRTC.seconds);
  1622.  
  1623.   Display_LCD.setCursor( 4, 4 );
  1624.  
  1625.   Display_LCD.print(myRTC.dayofmonth);
  1626.   Display_LCD.print("/");
  1627.   Display_LCD.print(myRTC.month);
  1628.   Display_LCD.print("/");
  1629.   Display_LCD.print(myRTC.year);
  1630.  
  1631.   Display_LCD.setCursor( 15, 4 );
  1632.  
  1633.   if (myRTC.hours < 10) Display_LCD.print("0");
  1634.   Display_LCD.print(myRTC.hours);
  1635.   Display_LCD.print(":");
  1636.   if (myRTC.minutes < 10) Display_LCD.print("0");
  1637.   Display_LCD.print(myRTC.minutes);
  1638.   Display_LCD.print(":");
  1639.   if (myRTC.seconds < 10) Display_LCD.print("0");
  1640.   Display_LCD.print(myRTC.seconds);
  1641.  
  1642.  
  1643.  
  1644. } //end DS1302
  1645.  
  1646.  
  1647. void week(int dayW)
  1648. {
  1649.  
  1650.   switch (dayW)
  1651.   {
  1652.     case 1: Serial.print("Dom"); break;
  1653.     case 2: Serial.print("Seg"); break;
  1654.     case 3: Serial.print("Ter"); break;
  1655.     case 4: Serial.print("Qua"); break;
  1656.     case 5: Serial.print("Qui"); break;
  1657.     case 6: Serial.print("Sex"); break;
  1658.     case 7: Serial.print("Sab"); break;
  1659.  
  1660.   } //end switch
  1661.  
  1662. } //end week
  1663.  
  1664.  
  1665.  
  1666.  
  1667. //***********************************************************************
  1668. //  Loop de Controle Principal do Sistema.
  1669. //=======================================================================
  1670. int tempoOld = 0;
  1671. int tempoAtual = 0;
  1672. bool grava = false;
  1673.  
  1674. void  loop ()
  1675. {
  1676.   {
  1677.  
  1678.     DS1302();
  1679.  
  1680.     atualiza_PRESSAO();   // atualiza a medicao de Pressao neste Sistema.
  1681.     myFile = SD.open("SIMED.txt", FILE_WRITE);
  1682.  
  1683.  
  1684.   }
  1685.  
  1686.   tempoAtual = myRTC.minutes;      // Captura minuto
  1687.   if( tempoAtual != tempoOld)      // Se e diferente significa passou 1 minuto
  1688.   {
  1689.     grava = true;                    // Habilitae gravar
  1690.     tempoOld = tempoAtual;          // Refaz o tempo
  1691.   }
  1692.  
  1693.   //--------------------------------------------------
  1694.  
  1695.   if ( PRESSAO_1 < 10 )  // se a "Pressao 1" esta' abaixo de 4.8 bar:
  1696.   {
  1697.     seta_Alerta_Pressao_1();  // requisita alertas para a "Pressao 1".
  1698.  
  1699.  
  1700.     Serial.print("BAIXA PRESSAO");
  1701.     Serial.print("  ");
  1702.     Serial.print(PRESSAO_1);
  1703.     Serial.print("  ");
  1704.     Serial.print("bar  ");
  1705.     Serial.print("  ");
  1706.     Serial.print(myRTC.hours);
  1707.     Serial.print(":");
  1708.     Serial.print(myRTC.minutes);
  1709.     Serial.print(":");
  1710.     Serial.print(myRTC.seconds);
  1711.     Serial.print("  ");
  1712.     Serial.print(myRTC.dayofmonth);
  1713.     Serial.print("/");
  1714.     Serial.print(myRTC.month);
  1715.     Serial.print("/");
  1716.     Serial.println(myRTC.year);
  1717.     Serial.println("done.");
  1718.  
  1719. if (grava == true)                 // Se esta habilitado gravar
  1720. {
  1721.     myFile.print("BAIXA   PRESSAO");
  1722.     myFile.print("  ");
  1723.     myFile.print(PRESSAO_1);
  1724.     myFile.print(" ");
  1725.     myFile.print("bar");
  1726.     myFile.print("  ");
  1727.     myFile.print(myRTC.hours);
  1728.     myFile.print(":");
  1729.     myFile.print(myRTC.minutes);
  1730.     myFile.print(":");
  1731.     myFile.print(myRTC.seconds);
  1732.     myFile.print("  ");
  1733.     myFile.print(myRTC.dayofmonth);
  1734.     myFile.print("/");
  1735.     myFile.print(myRTC.month);
  1736.     myFile.print("/");
  1737.     myFile.println(myRTC.year);
  1738.     myFile.println("   ");
  1739. }
  1740.   }
  1741.  
  1742.  
  1743.  
  1744.   else if ( PRESSAO_1 > 16 )  // se a "Pressao 1" esta' acima de 7 bar:
  1745.   {
  1746.     seta_Alerta_Pressao_1();  // requisita alertas para a "Pressao 1".
  1747.  
  1748.     Serial.print("ALTA PRESSAO");
  1749.     Serial.print("   ");
  1750.     Serial.print(PRESSAO_1);
  1751.     Serial.print("  ");
  1752.     Serial.print("bar  ");
  1753.     Serial.print("  ");
  1754.     Serial.print(myRTC.hours);
  1755.     Serial.print(":");
  1756.     Serial.print(myRTC.minutes);
  1757.     Serial.print(":");
  1758.     Serial.print(myRTC.seconds);
  1759.     Serial.print("  ");
  1760.     Serial.print(myRTC.dayofmonth);
  1761.     Serial.print("/");
  1762.     Serial.print(myRTC.month);
  1763.     Serial.print("/");
  1764.     Serial.println(myRTC.year);
  1765.     Serial.println("done.");
  1766.  
  1767. if (grava == true)                 // Se esta habilitado gravar
  1768. {
  1769.     myFile.print("ALTA    PRESSAO ");
  1770.     myFile.print(" ");
  1771.     myFile.print(PRESSAO_1);
  1772.     myFile.print(" ");
  1773.     myFile.print("bar");
  1774.     myFile.print("  ");
  1775.     myFile.print(myRTC.hours);
  1776.     myFile.print(":");
  1777.     myFile.print(myRTC.minutes);
  1778.     myFile.print(":");
  1779.     myFile.print(myRTC.seconds);
  1780.     myFile.print("  ");
  1781.     myFile.print(myRTC.dayofmonth);
  1782.     myFile.print("/");
  1783.     myFile.print(myRTC.month);
  1784.     myFile.print("/");
  1785.     myFile.println(myRTC.year);
  1786.     myFile.println("   ");
  1787.  
  1788. }
  1789.   }
  1790.  
  1791.  
  1792.   //..................................................
  1793.  
  1794.   if ( PRESSAO_2 < 10 )  // se a "Pressao 2" acima de -0.039 bar"
  1795.   {
  1796.     seta_Alerta_Pressao_2();  // requisita alertas para a "Pressao 2".
  1797.  
  1798.     Serial.print("ALTA DEPRESSAO");
  1799.     Serial.print("");
  1800.     Serial.print(PRESSAO_2);
  1801.     Serial.print("  ");
  1802.     Serial.print("bar  ");
  1803.     Serial.print("  ");
  1804.     Serial.print(myRTC.hours);
  1805.     Serial.print(":");
  1806.     Serial.print(myRTC.minutes);
  1807.     Serial.print(":");
  1808.     Serial.print(myRTC.seconds);
  1809.     Serial.print("  ");
  1810.     Serial.print(myRTC.dayofmonth);
  1811.     Serial.print("/");
  1812.     Serial.print(myRTC.month);
  1813.     Serial.print("/");
  1814.     Serial.println(myRTC.year);
  1815.     Serial.println("done.");
  1816.  
  1817. if (grava == true)                 // Se esta habilitado gravar
  1818. {
  1819.     myFile.print("ALTA  DEPRESSAO");
  1820.     myFile.print("  ");
  1821.     myFile.print(PRESSAO_2);
  1822.     myFile.print(" ");
  1823.     myFile.print("bar");
  1824.     myFile.print("  ");
  1825.     myFile.print(myRTC.hours);
  1826.     myFile.print(":");
  1827.     myFile.print(myRTC.minutes);
  1828.     myFile.print(":");
  1829.     myFile.print(myRTC.seconds);
  1830.     myFile.print("  ");
  1831.     myFile.print(myRTC.dayofmonth);
  1832.     myFile.print("/");
  1833.     myFile.print(myRTC.month);
  1834.     myFile.print("/");
  1835.     myFile.println(myRTC.year);
  1836.     myFile.println("   ");
  1837. }
  1838.  
  1839.   }
  1840.  
  1841.  
  1842.  
  1843.   else if ( PRESSAO_2 > 16 )  // se a "Pressao 1" esta' acima de -0.02 bar:
  1844.  
  1845.   {
  1846.     seta_Alerta_Pressao_2();  // requisita alertas para a "Pressao 1".
  1847.  
  1848.     Serial.print("BAIXA DEPRESSAO  ");
  1849.     Serial.print(PRESSAO_2);
  1850.     Serial.print("  ");
  1851.     Serial.print("bar  ");
  1852.     Serial.print("  ");
  1853.     Serial.print(myRTC.hours);
  1854.     Serial.print(":");
  1855.     Serial.print(myRTC.minutes);
  1856.     Serial.print(":");
  1857.     Serial.print(myRTC.seconds);
  1858.     Serial.print("  ");
  1859.     Serial.print(myRTC.dayofmonth);
  1860.     Serial.print("/");
  1861.     Serial.print(myRTC.month);
  1862.     Serial.print("/");
  1863.     Serial.println(myRTC.year);
  1864.     Serial.println("done.");
  1865.  
  1866.  
  1867. if (grava == true)                 // Se esta habilitado gravar
  1868. {
  1869.     myFile.print("BAIXA DEPRESSAO");
  1870.     myFile.print("  ");
  1871.     myFile.print(PRESSAO_2);
  1872.     myFile.print(" ");
  1873.     myFile.print("bar ");
  1874.     myFile.print(" ");
  1875.     myFile.print(myRTC.hours);
  1876.     myFile.print(":");
  1877.     myFile.print(myRTC.minutes);
  1878.     myFile.print(":");
  1879.     myFile.print(myRTC.seconds);
  1880.     myFile.print("  ");
  1881.     myFile.print(myRTC.dayofmonth);
  1882.     myFile.print("/");
  1883.     myFile.print(myRTC.month);
  1884.     myFile.print("/");
  1885.     myFile.println(myRTC.year);
  1886.     myFile.println("   ");
  1887.   }
  1888. }
  1889.  
  1890.  
  1891.  
  1892.  
  1893.   else  reseta_Alerta_Pressao_2();  // desativa alertas para a "Pressao 2".
  1894.   grava = false;                            // Desbilita gravacao
  1895.  
  1896.   //_____________________________________________________________________________
  1897.  
  1898.  
  1899.   myFile.close();
  1900.   Gerencia_Alertas();  // gerencia as diversas sinalizacoes/alertas deste Sistema.
  1901.  
  1902.   Gerencia_Display();  // gerencia a atualizacao do Display.
  1903. //  delay(1000);
  1904.   //_____________________________________________________________________________
  1905.  
  1906. }//end loop
  1907.  
  1908. //***********************************************************************
RAW Paste Data