Início / Projetos Arduino / Projetos Squids / Básico / Projeto 44 - Sensor de temperatura e umidade DHT11 com alarme RGB

---

Projeto 44 - Sensor de temperatura e umidade DHT11 com alarme RGB

Angelo Luis Ferreira | 09/10/2018 Acessos: 8.869

Objetivo

Neste projeto vamos criar um circuito onde utilizamos um sensor de temperatura e umidade DHT11 e um Led RGB como alarme. De acordo com as temperaturas lidas no sensor obteremos as cores do led RGB que irão variar entre vermelho, verde e azul. Também neste projeto poderemos visualizar os valores de temperatura e umidade em um display LCD e no monitor serial do IDE do Arduino.

Sensor DHT11 - O DHT11 é um sensor básico de baixo custo utilizado para a medição de temperatura e umidade do ar ambiente através de um termistor e um sensor capacitivo. Existem várias versões diferentes do DHT11 com a mesma aparência e número de pinos. Portanto é importante verificar o data sheet do componente para obter suas características principais. No nosso projeto as características estão descritas na tabela de componentes.

Led RGB - O LED RGB nada mais é que três Leds em um só, ele é formado por um vermelho (R de red), um verde (G de green) e um azul (B de blue). Associando as cores dos três Leds é possível se obter várias possibilidades de cores.

Aplicação

Para fins didáticos e projetos onde é necessária a medição de temperatura e/ou umidade do ambiente.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Display LCD	Display LCD 16X2 com pinos soldados	1		LCD que utilize o controlador HD44780 (veja na descrição ou datasheet do componente) O display poderá ser de qualquer cor (fundo verde, azul ou vermelho)
Potenciômetro	Potenciômetro 1OK	1		O valor do potenciômetro aumenta quando giramos o eixo do componente na direção do polo negativo para o polo positivo. Obs.: Se não possuir potenciômetro de 10KΩ você poderá utilizar um de outro valor, de 1kΩ até 100kΩ.
Push Button	Push button 6X6X5mm
Sensor de Temperatura e Umidade DHT11	Sensor de Temperatura DHT11	1		Características do DHT11 utilizado neste exemplo: Tensão de alimentação: 3,3V a 5,5V Umidade relativa: 20% a 95% (precisão de 5%) Temperatura: 0 a 50 ºC (precisão de 2%) Intervalo entre medições: mínimo 2s Corrente de utilização: 2,5mA datasheet
Led RGB	Led RGB 5mm	1		Você poderá utilizar um LED RGB ânodo ou cátodo (difuso ou de alto brilho) Você poderá substituir o Led RGB por 3 Leds 5mm comuns, sendo 1 vermelho, 1 verde e um azul (difuso ou de alto brilho)
Resistor	Resistor	3		1 Resistor 150Ω (vermelho) 2 Resistores 100Ω (azul e verde) Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

Atenção

1. Neste projeto vamos utilizar um display LCD 16x2 com controlador HD44780, que se adapta aos mais diversos projetos com vários modelos de placas e microcontroladores. Este display possui 16 colunas por 2 linhas com backlight (luz de fundo) verde, azul ou vermelha e tem 16 pinos para a conexão. Atenção: Utilize um display LCD com os pinos soldados.

2. Preste muita atenção na montagem do dsiplay LCD. Observe que utilizamos os 6 primeiros pinos do LCD, pulamos os 4 próximos e então utilizamos mais 6 pinos. Veja a tabela abaixo:

3. Observe que nesse projeto o potenciômetro foi montado como um divisor de tensão, onde utilizamos os 3 terminais do componente:

Obs.: Ao girar o eixo do potenciômetro, o valor da tensão deverá aumentar do negativo para o positivo, ou seja, se a tensão do circuito for 5V, o potenciômetro irá variar de 0 a 5V.

3.1. No nosso exemplo, girando-se o eixo do potenciômetro no sentido horário, aumentamos a tensão na entrada do pino 3 do display e diminuímos o contraste dos caracteres com o back light (luz de fundo) até que não é mais possível visualizá-los. Fazendo o contrário, ou seja, diminuindo a tensão até o zero, teremos um contraste máximo entre os caracteres e a luz de fundo.

4. Monte o botão (push button) sem o resistor, pois através da programação vamos habilitar o resistor pull-up interno do Arduino. Desta forma, quando o botão estiver pressionado, o Arduino retornará "LOW" ou "0". Para saber mais sobre circuitos com push button leia: Como usar push button com Arduino (programação).

5. Lembre-se que existem 2 tipos de LED RGB, o ânodo comum e o cátodo comum. Observe que para cada uma das cores existe um terminal, e além disso o quarto terminal (maior) deverá ser conectado ao polo positivo (ânodo comum) e ao polo negativo (cátodo comum).

5.1. Leia também: Led RGB anodo comum ou o Led RGB catodo comum? Como identificar e usar com Arduino (circuito e programação).

5.2. Veja na imagem abaixo como posicionamos o nosso LED RGB cátodo comum (conectado ao polo negativo GND) no protoboard.

6. Para determinar os valores dos resistores para o seu LED RGB, utilize os dados do fabricante (datasheet). No nosso projeto, utilizamos um LED RGB tipo ânodo comum com as seguintes características:

6.1. A partir destes dados calculamos o valor dos resistores (ou determine através da tabela prática: Tabela prática de utilização de leds 3mm e 5m). Para calcular o valor dos resistores leia: Como calcular o resistor adequado para o led ou utilize o aplicativo: Calculador de Led.

6.2. Após os cálculos determinamos os seguintes resistores: 2 resistores de 100Ω (terminais cor verde e azul) e 1 resistor de 150Ω (terminal cor vermelho).

Obs: Se você não tiver os dados do fabricante, utilize como referência os valores dos resistores que mostramos acima, tanto para o LED alto brilho como para o LED difuso. Se não tiver os resistores com os valores exatos ao determinado, utilize resistores com valores mais altos. No nosso exemplo utilizamos 2 resistores de 100Ω (terminais cor verde e azul) e 1 resistor de 150Ω (terminal cor vermelho).

7. Cuidado para não ligar o sensor de temperatura invertido. Ele deve ficar com a face reta virada para frente e conectado da seguinte forma:

7.1. Veja como deve ser a montagem no Arduino:

7.2. Neste projeto é importante que você deixe o sensor DHT11 distante dos demais componentes. Isto porque vamos colocar o sensor em local com muita umidade.  Veja portanto como deverá ficar a montagem do sensor:

8. A montagem do nosso projeto foi realizada em um protoboard com linhas de alimentação não contínuas, onde acrescentamos jampers para a ligação. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

Incluindo bibliotecas no IDE do Arduino

Neste projeto vamos mostrar como adicionar uma biblioteca no IDE do Arduino. Uma das grandes vantagens das placas Arduino é a diversidade de bibliotecas disponíveis que podem ser utilizadas em seus programas. Estas bibliotecas podem ser criadas para a linguagem "C" ou especificamente para o Arduino, reduzindo drasticamente o tempo gasto com programação.

Download dos arquivos da biblioteca do sensor DHT11

Para trabalharmos de forma mais fácil com o sensor DHT, podemos baixar a biblioteca DHTlib que foi desenvolvida para os sensores DHT11, DHT22, DHT33 e DHT44:

 DOWNLOAD - DHTlib.zip

Para saber detalhes desta biblioteca clique aqui.

Se você ainda não instalou estas bibliotecas, siga o nosso tutorial: Como incluir uma biblioteca no IDE do Arduino.

Ligando o display LCD

1. Para visualizar o display funcionando, digite o código abaixo no ambiente de desenvolvimento IDE do Arduino. Faça a verificação e o upload:

/*******************************************************************************
*
*          Testando o Display LC 16 X 2
*            http://squids.com.br/arduino
*
*******************************************************************************/
//Carrega a biblioteca LiquidCrystal
#include <LiquidCrystal.h>

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
//Define LCD 16 colunas por 2 linhas
lcd.begin(16, 2);

//Posiciona o cursor na coluna 0, linha 0;
lcd.setCursor(0,0);
//Envia o texto entre aspas para o LCD
lcd.print("Ola, meu nome e:");

//Posiciona o cursor na coluna 1, linha 1;
lcd.setCursor(1,1);
//Envia o texto entre aspas para o LCD
lcd.print("Squids Arduino");
}

void loop() {

} 

2. Se o display acender e mostrar os caracteres como na figura abaixo, a ligação está correta.

ATENÇÃO: Se o display acender e não mostrar os caracteres provavelmente é em função do contraste. Gire o eixo do potenciômetro no sentido anti-horário para aumentar o contraste. Se mesmo assim o display não mostrar os caracteres, corrija a montagem do circuito e/ou o código.

Comandos do display LCD para a biblioteca LiquidCrystal

No projeto vamos utilizar alguns comandos de controle do display LCD através da biblioteca LiquidCrystal que já vem embutida na IDE do Arduino. Para conhecer todos os comandos desta biblioteca, acesse o link: Comandos display LCD para biblioteca LiquidCrystal e LiquidCrystal Library (Arduino Reference).

Obs.: Para acessarmos uma biblioteca embutida na IDE do Arduino, assim como, para acessarmos um biblioteca local através de um header file, utilizaremos a diretiva #include.

Código do Projeto (Sketch)

1) Faça o dowload e abra o arquivo projeto44.ino no IDE do Arduino: DOWNLOAD - projeto44.ino

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*  Projeto 44 - Sensor de temperatura e umidade DHT11 com indicador de led RGB
*                   http://squids.com.br/arduino
*
*******************************************************************************/
#include <dht.h>  // Inclui a biblioteca no seu código
#include <LiquidCrystal.h>  //Carrega a biblioteca LiquidCrystal nativa na IDE

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
dht DHT; // Cria um objeto da classe dht

uint32_t timer = 0; // declara a variável timer

const int RED = 10; // Led RGB vermelho
const int GREEN = 9; // Led RGB verde
const int BLUE = 7; // Led RGB azul

const int pinButton = 8; // Pino do push button

int estado = 1;
int estado_anterior = 1;
int x = 1;

 
void setup() {
  Serial.begin(9600); // Inicializa serial com taxa de transmissão de 9600 bauds
  lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas
  lcd.clear(); // limpa a tela do display

  DHT.read11(A1); // chama método de leitura da classe dht (leitura inicial)

  pinMode(RED, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(BLUE, OUTPUT);

  pinMode(pinButton, INPUT_PULLUP);
}
 
void loop() {  
  // Executa 1 vez a cada 2 segundos (tempo de resposta do DHT 11)
  if(millis() - timer>= 2000)  {
    
    DHT.read11(A1); // chama método de leitura da classe dht,
                    // com o pino de transmissão de dados ligado no pino A1
 
    // Exibe na serial o valor de umidade
    Serial.print("Umidade = ");
    Serial.print(DHT.humidity);
    Serial.print(" %  ");
 
    // Exibe na serial o valor da temperatura
    Serial.print("Temperatura = ");
    Serial.print(DHT.temperature); 
    Serial.println(" Celsius  ");

    // Chama a função RGb()
    rgb();
    
    timer = millis(); // Atualiza a referência
  }

    // Chama a função print()
    print(x);

    // le o estado pushbutton: ligado (HIGH) ou desligado (LOW)
    estado = digitalRead(pinButton);

    // verifica se o botão (pushbutton) está pressionado
    if ((estado) && (!estado_anterior)) { // Se estado for HIGH e estado_anterio LOW
        // inverte valor da variável x
        x = !x;
        delay(10);
    }
    estado_anterior = estado;
}

void print(int x) {
if (x==1) {
    // Exibe no display LCD o valor da temperatura
    lcd.setCursor(0,0); // Define o cursor na posição de início
    lcd.print("Temp. = ");
    lcd.print(DHT.temperature);
    lcd.write(B11011111); // Imprime o símbolo de grau
    lcd.print("C");    
} else if (x==0) {        
    // Exibe no display LCD o valor da humidade
    lcd.setCursor(0,0); // Define o cursor na posição de início
    lcd.print("Umid. = ");
    lcd.print(DHT.humidity);
    lcd.print("% ");
    }
}

void rgb() {
    if( DHT.temperature < 15) {
        digitalWrite(BLUE, HIGH);
        digitalWrite(RED, LOW);
        digitalWrite(GREEN, LOW);
        Serial.println("COR: AZUL    "); // Escreve texto ” COR:AZUL” na serial
        // Exibe no display LCD o o nome da cor
        lcd.setCursor(5,1); // Define o cursor na posição de início
        lcd.print("AZUL    ");
    }
    else if( DHT.temperature >= 15 && DHT.temperature < 25 )
    {
        digitalWrite(BLUE, LOW);
        digitalWrite(RED, LOW);
        digitalWrite(GREEN, HIGH);
        Serial.println("COR: VERDE"); // Escreve texto ” COR:VERDE” na serial
        // Exibe no display LCD o o nome da cor
        lcd.setCursor(5,1); // Define o cursor na posição de início
        lcd.print("VERDE    ");
    }
    else if( DHT.temperature >= 25)
    {
        digitalWrite(BLUE, LOW);
        digitalWrite(RED, HIGH);
        digitalWrite(GREEN, LOW);
        Serial.println("COR: VERMELHA"); // Escreve texto ” COR:VERMELHA” na serial
        // Exibe no display LCD o o nome da cor
        lcd.setCursor(5,1); // Define o cursor na posição de início
        lcd.print("VERMELHO");
    }
}

Obs.: As temperaturas de controle (25ºC e 15ºC) poderão ser alteradas da forma que você desejar.

Vídeo

Como o projeto deve funcionar

1. Ao executar o programa, a temperatura atual em Celsius é exibida na tela do display LCD.

2. Dependendo da temperatura, a cor do led irá se alterar para vermelho (temperatura >= 25 ºC), verde(temperatura entre 15 e 25ºC) ou azul (temperatura < 15º).

3. Ao apertar o botão (push button), a umidade relativa será exibida na tela do display no lugar da temperatura.

4. Para visualizar a leitura das temperaturas e umidade relativa registradas, clique no ícone monitor serial, como mostra a figura abaixo:

Explicando o código do projeto

1. Primeiro definimos e declaramos as bibliotecas, constantes e variáveis globais do projeto.

1.1. Através do comando #include incluímos as bibliotecas dht.h e LiquidCrystal.h para serem compiladas junto ao sketch (não utilize ponto e vírgula no final de uma diretiva #include).

1.1.1. A diretiva #include é utilizada para incluir bibliotecas externas em um sketch. Isso dá ao programador acesso a um grande grupo de bibliotecas C padrão (grupos de funções pré definidas) e também bibliotecas específicas para o Arduino.

1.1.2. Como já mencionamos anteriormente, o arquivo da biblioteca dht.h deve ser inserido no IDE do Arduino. Se tiver dúvidas leia o artigo Como incluir uma biblioteca no IDE do Arduino.

1.1.3. A biblioteca LiquidCrystal.h já vem incluída no IDE do Arduino e contém todos os comandos e recursos para controlar um display LCD.

1.2.  Através da instrução LiquidCrystal lcd(12, 11, 5, 4, 3, 2); a biblioteca do LCD faz com que o programa do Arduino saiba que ao dar o comando LiquidCrystal lcd iremos utilizar um display, e faremos a comunicação utilizando os seguintes pinos do Arduino: 12, 11, 5, 4, 3, conforme mostra a tabela abaixo:

1.3. O comando dht DHT instancia o objeto definido pela classe dht inserida na biblioteca dht.h. Isto faz com que possamos utilizar todos os métodos (funções) da biblioteca para uso no programa.

1.4. Observe que utilizamos variáveis e constantes tipo int e uint32_t. Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:

1.5. Definimos a variável tipo uint32_t para receber o valor zero.

1.6. Depois definimos as constantes RED, GREEN e BLUE para receber os valores 10, 9 e 7 respectivamente. Estes valores significam definem os pinos de conexão do led RGB com as saídas digitais do Arduino.

1.7. Definimos a constante pinButton tipo int que recebe o valor 8. Isto significa que o pino do push button deverá estar conectado ao pino digital 8 do Arduino.

1.8. Finalmente definimos as variáveis tipo estado = 1, estado_anterior = 1 e x = 1.

2. Através da estrutura void setup(), definimos:

2.1. A função Serial.begin() serve para dizer ao Arduino que será coletado dados para o computador a partir da porta serial e o cabo USB. O número entre os parênteses significa qual é a taxa de dados que a placa vai se comunicar com o computador. Utilizaremos a taxa padrão de 9600bps (bits-per-second).

2.2. Através da instrução lcd.begin(16,2); a biblioteca do LCD informa ao Arduino que será utilizado um display com 16 colunas e 2 linhas.

2.3. O comando lcd.clear() limpa a tela do display LCD. Veja na tabela Biblioteca LiquidCrystal - Comandos display LCD e conheça os principais métodos para o display LCD.

2.4.  A expressão DHT.read11(A1); executa o método DHT.read11() da biblioteca dht.h permitindo realizar as leituras do sensor DHT11 que deverá estar conectado no pino analógico A1 do Arduino. Para saber detalhes desta biblioteca clique aqui.

2.4.1. A diretiva DHT.temperatura, que faz parte do método DHT.read(), permite a exibição no Monitor Serial do valor da Temperatura em Celsius.

3.2.3. Da mesma forma, a diretiva DHT.humidity que também faz parte do método DHT.read() permite a exibição no Monitor Serial do valor da Umidade Relativa do ar em porcentagem.

2.5. Define-se as constantes RED, GREEN e BLUE como saídas do controlador Arduino (OUTPUT) conectados aos pinos 10, 9 e 7 respectivamente.

2.6. A função pinMode() define a porta digital referente à variável pinButton, conexão do push button (botão), configurada como INPUT_PULLUP.

2.1.1. INPUT_PULLUP habilita o resistor pull-up interno do Arduino, eliminando a necessidade de colocarmos um resistor de 10K ligado ao VCC (5V).

Obs.: Os resistores pull-up e pull-down garantem um nível lógico estável quando, por exemplo, uma tecla não está pressionada. Geralmente utiliza-se um resistor de 10KΩ para esse propósito. A seguir é exibida a ligação desses resistores no circuito para leitura de tecla do botão:

 3. Através da estrutura void loop() , definimos:

3.1.  A expressão condicional if(millis() - timer >=2000) determina que os comandos inseridos nela sejam executados a cada 2 segundos (2.000ms) , sendo que:

3.1.1. A função millis() retorna o número de milissegundos passados desde que a placa Arduino começou a executar o programa atual. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra zero), após aproximadamente 50 dias.

3.1.2. A variável timer  tipo uint32_t, recebe inicialmente o valor zero.

3.1.3. Quando a diferença entre a função millis() e zero (valor inicial de timer) for maior que 2.000, a expressão condicional será verdadeira e todos comandos inerentes a ela serão executados. Isto significa que o programa roda durante 2 segundos sem executar os comandos definidos pela expressão if(millis() - timer >= 1000;  fazendo com que estes comandos somente sejam executados a cada 2 segundos.

Obs.: É importante salientar que a utilização da função millis() como condicional é diferente de utilizamos a função pause() que paralisa totalmente o programa por um determinado período. Leia mais: função millis() e Como usar temporizadores no Arduino.

 3.2. Caso a expressão condicional if(millis() - timer >= 2000) seja atendida, os seguintes comandos são realizados:

3.2.1. A expressão DHT.read11(A1); executa o método DHT.read11() da biblioteca dht.h permitindo realizar as leituras do sensor DHT11 que está conectado no pino analógico A1 do Arduino.

3.2.2. É exibido no Monitor Serial o o valor da Umidade Relativa do ar em porcentagem, através da diretiva DHT.humidity, que também faz parte do método DHT.read(). Para saber detalhes desta biblioteca clique aqui.

3.2.3. Da mesma forma é exibido o valor da Temperatura em Celsius, através da diretiva DHT.temperatura, que faz parte do método DHT.read(). Para saber detalhes desta biblioteca clique aqui.

3.2.4. Em seguida, é chamada a função rgb() que irá definir acender o led RGB na cor correspondente ao valor lido no sensor de temperatura. Também exibe nome da cor no display LCD.

3.2.5. Finalmente, a expressão timer = millis(); faz com que a variável timer receba agora o novo valor de millis() após 2000ms, reiniciando a contagem para a próxima exibição dos valores que atualizará as leituras do sensor de temperatura DHT11.

3.3. Continuando o loop, temos ainda:

3.3.1. É chamada a função print(x) que envia o valor de x inicialmente definido como 1. Esta função criada no programa (linha 80) exibirá no display LCD os valores da temperatura ou da umidade lidos no sensor.

3.3.3.2. Inicialmente o valor de x = 1.

3.3.2. Atribui-se o valor do sinal digital lido no botão (push button) à variável "estado", que pode ser HIGH (1) OU LOW (0).

3.3.3. Através da estrutura condicional if ((estado) && (!estado_anterior)) {} verifica se o botão está pressionado. Se sim, inverte o valor da variável "x", sendo:

Obs.: Este procedimento foi utilizada para acionar um botão como um interruptor. Veja o tutorial: Projeto 04b - Push Button como interruptor - liga e desliga (método alternativo ao Projeto 04a)

3.3.3.1. Se valor digital lido no botão (estado) for 1 (true) e o valor de estado_anterior for 0 (false), a condição verificada é verdadeira e são executadas as instruções que seguem:

3.3.3.1.1. Através do operador lógico NOT (!), o valor da variável "x" será invertido. Para saber mais sobre operadores lógicos leia - Referência Arduino.

3.3.3.1.2. Através do comando delay(10) fazemos uma pausa de 10 milissegundos. Isto é feito para reduzirmos a flutuação no sinal digital pelo efeito "bouncing" que ocorre em chaves mecânicas. Leia mais sobre "boucing"  no link: https://www.filipeflop.com/blog/debounce-o-que-e-e-como-resolver-via-software/

3.3.3.2. Caso contrário, a variável estado-anterior recebe o valor da variável estado, forçando que o botão seja acionado novamente para exibir o valor da umidade relativa, através da função print(x).

 4. Através da estrutura void print(int x) definimos:

 4.1. A função print() recebe a variável x que pode ser 0 (zero) ou um (1).

Desafios

Com base neste projeto, resolva o seguinte desafio: Desafio 27

Comentários