Monitoramento de Ponto de Orvalho com Arduino

Introdução

Neste post iremos aprender a calcular o Ponto de Orvalho utilizando a temperatura e a umidade obtidas de um sensor DHT11, além de ser exibido em um display LCD o ponto de orvalho atual, mostrar a tendência da medida (se está subindo ou caindo) e mostrar a sensação no ser humano referente ao ponto de orvalho atual, tudo utilizando um Arduino NANO.

Imagem de Janne Andreassen (vonJanne) por Pixabay

Materiais Necessários para o Projeto Monitoramento de Ponto de Orvalho com Arduino

• 1x Arduino NANO
• 1x Display LCD 16×2 I2C azul
• 1x Módulo Sensor De Umidade e Temperatura DHT11
• 1x LED difuso Vermelho
• 1x LED difuso Verde
• 1x LED difuso Amarelo
• 3x Resistor 330Ω 1/4W
• 1x Protoboard
• Jumpers

O Ponto de Orvalho

Você já deve ter observado que quando deixamos uma garrafa com uma temperatura interna abaixo da temperatura ambiente, depois de um tempo, ela começa a “suar”? Este fenômeno é o Orvalho. Ele ocorre quando há uma condensação do vapor de água da atmosfera sobre uma superfície resfriada.

Imagem de Wolfgang Zimmel (werdepate) por Pixabay

Sabendo a temperatura e a umidade, podemos calcular a que temperatura irá ocorrer o orvalho. Esta medida é chamada de ponto de orvalho, ou Dew Point em inglês.

O ponto de orvalho é a temperatura à qual o ar deve ser resfriado para que ocorra a saturação do ar (orvalho). Saber o ponto de orvalho é muito importante para a indústria, pois evita a quebra de maquinários causada pelo acúmulo de água condensado pelo orvalho.

Para os seres humanos também é importante saber o ponto de orvalho, pois o mesmo indica o nível de desconforto térmico, já que o ponto de orvalho alto dificulta a evaporação do suor humano e consequentemente dificulta a termo-regulação corporal, ou se também o ponto de orvalho estiver muito baixo, pode causar o ressecamento do sistema respiratório.

Como calcular o Ponto de Orvalho

O Ponto de Orvalho pode ser calculado utilizando a seguinte fórmula, à qual é chamada de fórmula de Magnus:

Onde γ (T, UR) = resultado Intermediário,

T = temperatura atual,

UR = umidade relativa em %,

b = constante utilizada no cálculo,

c = constante utilizada no cálculo.

Tpo = temperatura do ponto de orvalho.

A constante b e a constante c variam dependendo da temperatura. Veja na tabela abaixo:

Por Exemplo, se temos uma temperatura de 27° Celsius e uma umidade de 70% UR, teremos um ponto de orvalho de 22,18°:

Ponto de Orvalho e a Sensação Humana

Como mencionado anteriormente, o corpo humano utiliza a evaporação do suor para termorregulação corporal.

Se a temperatura estiver alta e a umidade estiver alta (Ponto de Orvalho Alto) também o suor do corpo humano não irá evaporar, pois o ar estará saturado de vapor de água. Isto pode ser prejudicial para o corpo humano, o qual poderá elevar a temperatura e poderá até, em casos mais graves, haver morte por hipertermia.

O contrário também é prejudicial para o corpo humano, quando a umidade e a temperatura estiverem muito baixas (Ponto de Orvalho Baixo). Poderão ocorrer fissuras e irritação na pele e até o ressecamento do sistema respiratório.

Para um ambiente confortável é necessário que a temperatura esteja entre 20 e 24 ºC, a umidade esteja entre 20 e 60% e consequentemente deixando o valor do ponto de orvalho entre -4,5 e 15,5ºC.

Veja a tabela abaixo para mais detalhes:

Agora que já sabemos mais sobre o que é e a importância do Ponto de Orvalho, poderemos fazer a integração do cálculo e da visualização no Arduino.

Hardware do Projeto

Para o desenvolvimento do circuito eletrônico deste tutorial, siga o Diagrama abaixo:

O hardware é composto de um Arduino NANO, um display LCD 16×2 com comunicação I2C, que oferecerá ao usuário a exibição dos dados.

Recomendo que leia os seguintes artigos daqui da Eletrogate, para um aprofundamento no hardware:

• Display LCD;
• DHT11;
• Arduino Nano.

Software do Projeto

Para desenvolvermos o software para o Arduino, devemos fazer o download de uma biblioteca: a LiquidCrystal_I2C, que permitirá controlar o display I2C com funções extremamente semelhantes à biblioteca LiquidCrystal.

Para a instalação da biblioteca, siga os passos abaixo:

• No gerenciador de Bibliotecas da Arduino IDE, na barra de pesquisa digite: ‘LiquidCrystal_I2C’. Clique para instalar no resultado que aparecer primeiro, e que seja do autor Marco Schwartz.

Após instalada a biblioteca, cole o seguinte código na IDE Arduino:

/***************************************************
  Monitorador de Ponto de Orvalho com Arduino NANO
  Criado em 04 de Outubro de 2021 por Michel Galvão
 ****************************************************/

// Inclusão das Biblitecas
#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Configuração DHT11
#define DHTPIN 5
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

// Definição dos pinos
#define pinLEDVerde 2
#define pinLEDAmarelo 3
#define pinLEDVermelho 4

// Configuração Display LCD I2C
/* Para saber o endereço I2C do Display LCD, faça o upolad do código
    de exemplo i2c_scanner. Você pode acessar o código
    em: Arquivo -> Exemplos -> Wire ->  i2c_scanner. Faça o upload,
    já com o circuito previamente montado, e abra o Monitor Serial.
    Você verá a mensagem 'I2C device found at address 0x27!'
    indicando o endereço à que o Display LCD está endereçado.
*/
#define enderecoLCD 0x27
LiquidCrystal_I2C lcd(enderecoLCD, 16, 2);


// Endereçamento dos caracteres personalizados criados para o display LCD
#define Subindo 0
#define Descendo 1
#define Neutro 2

// Caractere 'Subindo'
byte _Subindo[] = {
  B00000,
  B00100,
  B01010,
  B10001,
  B00000,
  B00000,
  B00000,
  B00000
};

// Caractere 'Descendo'
byte _Descendo[] = {
  B00000,
  B00000,
  B00000,
  B00000,
  B10001,
  B01010,
  B00100,
  B00000
};

// Caractere 'Neutro'
byte _Neutro[] = {
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B00000,
  B00000,
  B00000
};

// Variáveis Globais
float temperature = 25.0;
float umidade = 70.0;
float pontoDeOrvalho;
float ultimaLeituraPontoDeOrvalho;
unsigned long time;
const int qtdIndices = 50; // Média Móvel de 50 índices
const int intervaloInicial = 7; // 7 segundos : intervalo para não atualizar a tendência inicialmente pr 7 segundos iniciais
bool autorizadoATestarTendencia = false;
const long intervaloDeTendencia = 3600; // Intervalo de 1 hora (3600 segundos) para controle de tendência


void setup() {
  /* setup()
       - Descrição
           É chamada quando um sketch inicia. Usa-se para inicializar variáveis, configurar o modo dos pinos(INPUT ou OUTPUT),
           inicializar bibliotecas, etc. Será executada apenas uma vez, após a placa ser alimentada ou acontecer um reset.
       - Referência
           https://www.arduino.cc/reference/pt/language/structure/sketch/setup/
  */

  // Configuração dos LED's como saída
  pinMode(pinLEDVerde, OUTPUT);
  pinMode(pinLEDAmarelo, OUTPUT);
  pinMode(pinLEDVermelho, OUTPUT);

  // Inicialização LCD
  lcd.init();
  lcd.clear();
  lcd.backlight();
  lcd.createChar(Subindo, _Subindo);
  lcd.createChar(Descendo, _Descendo);
  lcd.createChar(Neutro, _Neutro);

  // inicialização DHT
  dht.begin();

  // Splash screen LCD (Tela de abertura)
  lcd.setCursor(0, 0);
  lcd.print("--.--");
  lcd.write(223); // caractere ° (grau)
  lcd.print(" ");
  lcd.write(Neutro); // caractere personalizado de tendência neutra
  lcd.print("________");
  lcd.setCursor(0, 1);
  lcd.print("________________");
  delay(1000);

  lcd.clear();
}

void loop() {
  /* loop()
       - Descrição
           Função que repete-se consecutivamente enaqunto a placa estiver ligada, permitindo o seu programa 
           mudar e responder a essas mudanças. Usa-se para controlar ativamente uma placa Arduino.
       - Referência
           https://www.arduino.cc/reference/pt/language/structure/sketch/loop/
  */

  // Faz a tentativa de atualização das variáveis de temperatura e umidade
  atualizaDados();

  // Atribui à variável 'pontoDeOrvalho' o valor da média móvel calculada do valor de Ponto de Orvalho
  pontoDeOrvalho = pontoDeOrvalhoMedia(calculaPontoOrvalho(temperature, umidade));

  // millis() retorna o número de milissegundos passados desde que a placa Arduino começou a executar o programa atual;
  if (millis() >= intervaloInicial * 1000) { // Se o valor de millis() for maior que o tempo de intervaloInicial em milissegundos, ...
    autorizadoATestarTendencia = true; // atribui o valor true para a variável
  }

  String tendencia; // Cria variável local para armazenar a tendência atual do ponto de Orvalho
  if (autorizadoATestarTendencia) { // Se o valor da variável for true, ...
    /* Exibe ao usuário:
        - o ponto de Orvalho,
        - a tendência do valor do ponto de Orvalho( se está subindo, neutro ou descendo),
        - e a sensação do ponto de orvalho sobre o ser humano.
    */
    lcd.setCursor(0, 0);
    lcd.print(pontoDeOrvalho);
    lcd.write(223); // Imprime na tela LCD o caractere de endereço 223 (11011111) da memória do controlador do display LCD (HD44780)
    lcd.print(" ");
    tendencia = verificaTendencia(); // atribue a variável tendencia o valor retornado da função 'verificaTendencia()', o qual verifica a tendencia do valor do ponto de orvalho

    /* .indexOf()
        - Descrição
            Localiza um caractere ou String dentro de outra String.
        - Sintaxe
            minhaString.indexOf(string2)
        - Parâmetros
            -> minhaString: uma variável do tipo String
            -> string2: a string a ser procurada - char ou String
        - Retorna
            A posição da minhaString especificada dentro do objeto String, ou -1 se não for encontrada.
        - Referência
            https://www.arduino.cc/reference/pt/language/variables/data-types/string/functions/indexof/
    */
    if (tendencia.indexOf("Subindo") != -1) { // Se for encontrado a String "Subindo" dentro de tendencia, ...
      lcd.write(Subindo); // Imprime no display LCD o caractere personalizado correspondente
    } else if (tendencia.indexOf("Descendo") != -1) { // Se não, se for encontrado a String "Descendo" dentro de tendencia, ...
      lcd.write(Descendo); // Imprime no display LCD o caractere personalizado correspondente
    } else if (tendencia.indexOf("Neutro") != -1) { // Se não, se for encontrado a String "Neutro" dentro de tendencia, ...
      lcd.write(Neutro); // Imprime no display LCD o caractere personalizado correspondente
    }
    lcd.print(tendencia); //  Imprime no display LCD o conteúdo da String tendencia

    sensacaoHumanaPontoOrvalho(pontoDeOrvalho); // Executa a função responsável por exibir no display LCD a sensação do ponto de orvalho sobre o Ser Humano,
    //sendo necessário informar o pontoDeOrvalho como parâmetro para a função.
  } else { // se não, ...
    // Exibe ao usuário que o sistema está em carregamento
    lcd.setCursor(0, 0);
    lcd.print("Iniciando       ");
    lcd.setCursor(0, 1);
    lcd.print("Leitura Sensor  ");
    // Esquanto o sistema estiver em carregamento, atribui o valor de 'pontoDeOrvalho' para a variável 'ultimaLeituraPontoDeOrvalho'
    ultimaLeituraPontoDeOrvalho = pontoDeOrvalho; // atualiza o último valor da leitura do ponto de orvalho
  }

  controladorLEDS(); // chama a função responsável pelo controle dos LED's de indicação do nível do Ponto de Orvalho
}

float calculaPontoOrvalho(float temp, float umid) {
  /* calculaPontoOrvalho()
        - Descrição
            Função responsável para o cálculo do ponto de Orvalho.
        - Sintaxe
            calculaPontoOrvalho(float temp, float umid)
        - Parâmetros
            -> temp: temperatura em graus Celsius - float
            -> umid: umidade em % RH - float
        - Retorna
            O ponto de Orvalho em graus Celsius.
  */

  float calculo_pontoOrvalho; // variável local para retorno do valor calculado
  float b; // variáveis de constantes do cálculo do ponto de orvalho
  float c;
  if (temp >= 0 && temp <= 50.00) {
    // constantes utilizadas em material fornecido pela(o): Journal of Applied Meteorology and Climatology
    //  Buck, A. L. (1981), "New equations for computing vapor pressure and enhancement factor", J. Appl. Meteorol. 20: 1527–1532
    b = 17.368;
    c = 238.88;
  } else if (temp >= -40.00 && temp <= 0) {
    // constantes utilizadas em material fornecido pela(o): Journal of Applied Meteorology and Climatology
    //  Buck, A. L. (1981), "New equations for computing vapor pressure and enhancement factor", J. Appl. Meteorol. 20: 1527–1532
    b = 17.966;
    c = 247.15;
  } else {
    // constantes utilizadas em material fornecido pela(o): Sonntag (1990)
    // SHTxx Application Note Dew-point Calculation
    // http://irtfweb.ifa.hawaii.edu/~tcs3/tcs3/Misc/Dewpoint_Calculation_Humidity_Sensor_E.pdf
    b = 17.62;
    c = 243.12;
  }

  float funcao1 = (log(umid / 100) + (b * temp) / (c + temp)); // cálculo do Ponto de Orvalho parcial
  calculo_pontoOrvalho = (c * funcao1) / (b - funcao1); // cálculo do Ponto de Orvalho finalizado

  return calculo_pontoOrvalho; // retorna a chamada da função o ponto de orvalho calculado
}

void atualizaDados() {
  /* atualizaDados()
        - Descrição
            Função responsável para atualizar os dados do sensor DHT11.
        - Sintaxe
            atualizaDados()
        - Parâmetros
            NENHUM
        - Retorna
            SEM RETORNO
  */


  // método isnan() retorna true se a variável passada como parâmetro for um número inválido
  if (!isnan(dht.readTemperature())) { // Se a leitura de temperatura do DHT11 for um número válido, ...
    temperature = dht.readTemperature(); // atribue o valor da leitura de temperatura do sensor DHT11 para a variável global de armazenagem da temperatura
  }
  if (!isnan(dht.readHumidity())) { // Se a leitura de umidade do DHT11 for um número válido, ...
    umidade = 70.0; // atribue o valor da leitura de umidade do sensor DHT11 para a variável global de armazenagem da umidade
  }
}

String verificaTendencia() {
  /* verificaTendencia()
        - Descrição
            Função responsável para verificar qual a tendência que o ponto de orvalho atual está.
        - Sintaxe
            verificaTendencia()
        - Parâmetros
            NENHUM
        - Retorna
            -> "Descendo ": caso o valor do ponto de orvalho esteja caindo, ou
            -> "Subindo  ": caso o valor do ponto de orvalho esteja se elevando, ou
            -> "Neutro  ":  caso o valor do ponto de orvalho esteja fixo.
  */

  String retorno; // variável local para retornar para a chamada da função

  if (millis() - time > intervaloDeTendencia * 1000) { // Se millis() subtraido do tempo intermediário for maior do que o intervalo pré-definido em milissegundos, ...
    time = millis(); // atualiza a variável global que armazena o tempo intermediário
    ultimaLeituraPontoDeOrvalho = pontoDeOrvalho; // atualiza o último valor da leitura do ponto de orvalho
  }


  if (ultimaLeituraPontoDeOrvalho > pontoDeOrvalho) { // Se  o último valor da leitura do ponto de orvalho for maior que a leitura atual de ponto de orvalho, ...
    //valor está caindo
    retorno = "Descendo "; // atribui à variável 'retorno' o valor correspondente
  } else if (ultimaLeituraPontoDeOrvalho < pontoDeOrvalho) { // Se  o último valor da leitura do ponto de orvalho for menor que a leitura atual de ponto de orvalho, ...
    //valor está subindo
    retorno = "Subindo  "; // atribui à variável 'retorno' o valor correspondente
  }
  else if (ultimaLeituraPontoDeOrvalho == pontoDeOrvalho) { // Se  o último valor da leitura do ponto de orvalho for igual à leitura atual de ponto de orvalho, ...
    //valor está subindo
    retorno = "Neutro  "; // atribui à variável 'retorno' o valor correspondente
  }

  return retorno; // retorna o valor da variável 'retorno'
}

float pontoDeOrvalhoMedia(float medidaAtual) {
  /* pontoDeOrvalhoMedia()
      - Descrição
          Função responsável para calcular a média móvel do ponto de orvalho.
      - Sintaxe
          pontoDeOrvalhoMedia(float medidaAtual)
      - Parâmetros
          -> medidaAtual: valor do ponto de orvalho atual - float
      - Retorna
          A média móvel do ponto de orvalho calculada.

  */

  // O qualificador de variável static torna a variável persistida entre chamadas da função, preservando seu valor.
  // Mais sobre static: https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/static/
  static int numbers[qtdIndices]; // variável para armazenar os valores lidos do ponto de orvalho, tendo como quantidade de índices um valor definido pelo programador (qtdIndices)

  //desloca os elementos do vetor de média móvel
  for (int i = 0; i < qtdIndices; i++) { // estrutura de repetição que controla o deslocamento dos valores do pntOrvalho lido para o índice anterior
    numbers[i] = numbers[i + 1]; // faz o deslocamento dos valores do array com índice i + 1 para o índice i
  }
  numbers[qtdIndices] = medidaAtual; // atribui o valor 'medidaAtual' ao último índice do array numbers
  long indicesTotais = 0; // variável para armazenar a soma total dos valores do array numbers
  for (int i = 0; i < qtdIndices; i++) { // estrutura de repetição que controla a somatória de todos os valores dos índices do array numbers
    indicesTotais += numbers[i]; // faz a somatória
  }
  return indicesTotais / qtdIndices; // retorna a média calculada: todos valores somados (indicesTotais) / quantidade de medições (qtdIndices)

}

void controladorLEDS() {
  /* controladorLEDS()
       - Descrição
           Função responsável para o controle dos LED's de indicação do ponto de Orvalho.
       - Sintaxe
           controladorLEDS()
       - Parâmetros
           NENHUM
       - Retorna
           SEM RETORNO

  */

  if (pontoDeOrvalho > 24) { // se o pontoDeOrvalho for maior que 24, ...
    // liga LED VERMELHO e apaga os demais
    digitalWrite(pinLEDVermelho, HIGH);
    digitalWrite(pinLEDAmarelo, LOW);
    digitalWrite(pinLEDVerde, LOW);
  } else if ((pontoDeOrvalho > 21 && pontoDeOrvalho <= 24) || pontoDeOrvalho < 10) { // Se não, se o pontoDeOrvalho for maior que 21 E menor/igual que 24 OU menor que 10, ...
    // liga LED AMARELO e apaga os demais
    digitalWrite(pinLEDVermelho, LOW);
    digitalWrite(pinLEDAmarelo, HIGH);
    digitalWrite(pinLEDVerde, LOW);
  } else if (pontoDeOrvalho >= 10 && pontoDeOrvalho <= 18) { // Se não, se o pontoDeOrvalho for maior/igual que 10 E menor/igual que 18, ...
    // liga LED VERDE e apaga os demais
    digitalWrite(pinLEDVermelho, LOW);
    digitalWrite(pinLEDAmarelo, LOW);
    digitalWrite(pinLEDVerde, HIGH);
  }
}

void sensacaoHumanaPontoOrvalho(float ponto) {
  /* sensacaoHumanaPontoOrvalho()
        - Descrição
            Função responsável para exibição da sensação Humana sobre o ponto de orvalho no display LCD.
        - Sintaxe
            sensacaoHumanaPontoOrvalho(float ponto)
        - Parâmetros
            -> ponto: Ponto de Orvalho atual - float
        - Retorna
            SEM RETORNO

  */
  if (ponto > 29) { // se o ponto de orvalho for maior que 29, ...
    lcd.setCursor(0, 1);
    lcd.print("Opressao Severa ");
  } else if (ponto > 26) { // Se não, se o ponto de orvalho for maior que 26, ...
    lcd.setCursor(0, 1);
    lcd.print("Mort. alg. doenc");
  } else if (ponto > 24) { // Se não, se o ponto de orvalho for maior que 24, ...
    lcd.setCursor(0, 1);
    lcd.print("Ext. Desconfor. ");
  } else if (ponto > 21) { // Se não, se o ponto de orvalho for maior que 21, ...
    lcd.setCursor(0, 1);
    lcd.print("Desconfortavel  ");
  } else if (ponto > 18) { // Se não, se o ponto de orvalho for maior que 18, ...
    lcd.setCursor(0, 1);
    lcd.print("Desconf. maioria");
  } else if (ponto > 16) { // Se não, se o ponto de orvalho for maior que 16, ...
    lcd.setCursor(0, 1);
    lcd.print("OK para maioria ");
  } else if (ponto > 13) { // Se não, se o ponto de orvalho for maior que 13, ...
    lcd.setCursor(0, 1);
    lcd.print("Confortavel     ");
  } else if (ponto > 10) { // Se não, se o ponto de orvalho for maior que 10, ...
    lcd.setCursor(0, 1);
    lcd.print("Muito Confortave");
  } else if (ponto <= 10) { // Se não, se o ponto de orvalho for menor/igual que 10, ...
    lcd.setCursor(0, 1);
    lcd.print("Seco p/ alguns  ");
  }
}

No software, primeiro fazemos a inclusão das bibliotecas:

Em seguida, fazemos a configuração do sensor DHT, declarando o pino utilizado e o tipo de sensor DHT utilizado, e mapeamos os pinos dos LED’s utilizados.

Também criamos um objeto do tipo LiquidCrystal_I2C para gerenciamento das funções referentes ao display LCD. Passamos como parâmetros para a criação do objeto, o endereço I2C utilizado pelo display (sendo possível obtê-lo seguindo o comentário da imagem abaixo), a quantidade de colunas e a quantidade de linhas.

Logo após, definimos os endereços dos caracteres personalizados à serem criados para estarem na memória do display LCD.

Então, criamos um array mapeando o caractere personalizado à ser utilizado no display LCD. Este array pode ser criado manualmente ou no site Design a Custom Character for an LCD.

Logo após, criamos as variáveis globais, para armazenagem dos dados necessários.

Em void setup(), fazemos a configuração dos LED’s como saída, inicializamos o display LCD, juntamente com seus caracteres personalizados, e também inicializamos o sensor DHT11.

Em void loop(), chamamos a função responsável pela atualização de temperatura e de umidade. Esta função irá atualizar as variáveis globais referentes às mesmas. Também atribuímos o valor da média móvel do ponto de Orvalho calculado pela função calculaPontoOrvalho(). Logo em seguida, iremos controlar se os dados devem aparecer no display LCD ou não (inicialmente ao ligar o microcontrolador). Fazemos isso verificando se desde que foi ligada a placa arduino, se decorreu  7 segundos (intervaloInicial).

Em seguida, criamos uma variável local para armazenar a exibição da sensação humana sob o ponto de orvalho. Testamos se caso os dados devem aparecer no display LCD. Caso estejam autorizados à serem exibidos, imprimimos no display o valor de ponto de orvalho, um símbolo grau e atribuímos à variável ‘tendencia‘ o seu devido valor.

O índice 223, do símbolo grau,foi obtido pelos seguintes passos:

• 1. Escolhemos um caractere na seguinte tabela:

• 2. Pegamos o endereço da coluna e depois da linha

• No caso do símbolo escolhido anteriormente, ficaria: 11011111 , sendo primeiro colocado o número da coluna e em seguida o número da linha.
• Após obter o número do endereço binário do caractere, devemos convertê-lo para decimal. para isso acesse o site RapidTables e digite no campo Enter binary number (1) o 11011111. Em seguida clique em Convert (2) para realizar a conversão.

• Após a conversão irá se obter o resultado 223, o qual é o endereço do caractere na memória do display LCD.

• Para imprimir o caractere no display, deve-se utilizar o lcd.write(address) , onde address é o endereço do caractere.

Ainda dentro do if(autorizadoATestarTendencia), verificamos se a variável tendencia possui em seu valor "Subindo", "Descendo" ou "Neutro". Caso possua algum destes valores, imprimimos no display LCD o devido caractere personalizado de indicação de tendência. Em seguida, é imprimido a mensagem de tendência.

Depois chamamos a função sensacaoHumanaPontoOrvalho() responsável pela impressão da sensação humana sob o ponto de orvalho no display LCD.

Caso a condição if(autorizadoATestarTendencia) seja resultada false,  exibimos no display LCD a mensagem de espera de que está sendo feita a leitura do sensor pelo sistema. Esta condição só será false quando a placa arduino é ligada. Ainda dentro desta condição, atualizamos o valor da variável que armazena a última leitura do ponto de orvalho com o valor atual do mesmo.

Dentro do loop(), chamamos a função responsável pelo gerenciamento dos LED’s de indicação do nível do ponto de Orvalho.

A função calculaPontoOrvalho(), faz o cálculo do ponto de orvalho. Para efetuarmos o cálculo, devemos passar como parâmetro da função  valor de temperatura e da umidade. Primeiro criamos algumas variáveis para armazenamento do resultado do cálculo e das constantes do cálculo.

Em seguida, nesta função,  testamos de a que faixa de temperatura a mesma se encontra para podermos definir a constante b e c e, então, aumentarmos a precisão do cálculo de ponto de orvalho. No cálculo, em si, do ponto de orvalho, temos uma função matemática não habitual:

• log(): que calcula o logaritmo natural de um determinado número. Esta função recebe um argumento de entrada do tipo double que contém o número fornecido e retorna o log. natural desse número.

Ao final, após obtermos o resultado do cálculo, retornamos o resultado para a chamada da função.

A função atualizaDados(), é responsável pela atualização da temperatura e umidade com valores que sejam válidos.

A função verificaTendencia()retorna à chamada da função o valor referente da sensação humana sob o ponto de orvalho atual. Dentro da função, criamos uma variável local para armazenar o valor à ser retornado.

De tempos em tempos, devemos atualizar o valor da variável ultimaLeituraPontoDeOrvalho com o valor atual do ponto de orvalho. O tempo de intervalo entre as atualizações é definido pela variável intervaloDeTendencia, convertida de segundos para milissegundos.

Fazemos a testagem do valor da variável ultimaLeituraPontoDeOrvalho para verificar a posição em relação ao ponto de orvalho atual, e atribuímos à variável de retorno o valor adequado (Descendo, Subindo ou Neutro).

A função pontoDeOrvalhoMedia()retorna o valor da efetuação da média móvel do ponto de orvalho. Para efetuarmos a média móvel do ponto de orvalho, devemos criar um array de quantidade de índices conhecido para armazenar os valores lidos anteriormente do ponto de orvalho.

Em uma estrutura de repetição for, repassamos o valor da posição de índice variável i para a posição de índice anterior. Em seguida definimos o valor de posição do último índice do array com o valor atual do ponto de orvalho. Em seguida criamos uma variável para armazenar a soma total de todas as posições do array. Logo após fazemos a média, dividindo o valor da soma total pela quantidade de índices.

A função controladorLEDS(), é responsável pelo controle dos LED’s de indicação do nível de ponto de Orvalho. Dependendo da faixa à que se encontra o ponto de orvalho, determinado LED irá se acender.

A função sensacaoHumanaPontoOrvalho(), é responsável pela exibição no display LCD a sensação humana sob o ponto de orvalho, dependendo da faixa à que se encontra o ponto de orvalho atual.

Funcionamento Final

Veja o vídeo abaixo para ver o funcionamento final:

Conclusão

Com este exemplo de medição e monitoramento do ponto de orvalho, podemos utilizar os conceitos aqui aprendidos em outros projetos, como por exemplo a média móvel e o cálculo do ponto de orvalho.

Esperamos que o post tenha contribuído para seu aprendizado e, caso tenha ficado alguma dúvida, deixe nos comentários.

Até o próximo post!

Tenha a Metodologia Eletrogate na sua Escola! Conheça nosso Programa de Robótica Educacional.

Sobre o Autor

Michel Galvão Hobbysta em Sistemas Embarcados e IoT. Tem experiência em Automação Residencial e Agrícola.