Continuando o artigo anterior da série, trazemos agora a parte prática do projeto, apresentando a instalação da biblioteca do módulo DHT-22, a comunicação entre a Raspberry Pi e o módulo por meio de comando, o circuito/montagem realizado e o código.
Instalação da Biblioteca do Módulo DHT-22
No projeto do termômetro digital é utilizado o módulo AM2302, similar ao módulo DHT-22. Por este motivo é utilizada a biblioteca Python do Módulo DHT-11/22.
Para a instalação dessa biblioteca, deve-se primeiramente conectar a Raspberry Pi à internet. Em seguida, abre-se o LX Terminal e executa-se os comandos a seguir:
git clone https://github.com/adafruit/Adafruit_Python_DHT.git
Sem seguida, acesse a pasta Adafruit_Python_DHT com o comando:
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
cd Adafruit_Python_DHT
Deve-se atualizar o Raspbian e baixar o python-dev para que a biblioteca funcione corretamente. Execute os comandos abaixo:
sudo apt-get update sudo apt-get install build-essential python-dev
Agora é o momento de instalar a biblioteca, portanto execute o comando a seguir:
Sudo python setup.py install
Comandos
Os comandos Python utilizados para realizar a comunicação entre a Raspberry Pi e o módulo AM2302 fazem parte da biblioteca Adafruit_Python_DHT-22 e devemos usar o comando import para poder utilizar esses comandos nos nossos códigos. Como utilizar o comando import é demonstrado na seção “Código”.
A função para se realizar a leitura dos dados de temperatura e umidade é mostrada abaixo. Maiores informações podem ser obtidas na referência da biblioteca.
umid, temp = Adafruit_DHT.read_retry(sensor, pino_sensor);
As duas próximas declarações definem qual o modelo de sensor irá ser usado no código.
sensor = Adafruit_DHT.DHT11 sensor = Adafruit_DHT.DHT22
Para um melhor entendimento dos comandos referentes ao display de LCD, recomendo a leitura do artigo publicado sobre este assunto, aqui.
Circuito
A montagem do circuito do termômetro digital é similar ao mostrado no artigo anterior sobre o display de LCD, agora é acrescentado o módulo AM2302. A pinagem desse módulo pode ser vista na Figura 1. Para esta montagem, o módulo é alimentado por uma tensão de 3,3V para se evitar que a tensão no barramento de dados supere a máxima tensão suportada pelas portas GPIO da Raspberry Pi e, por consequência, as danifique. Um resistores de pull-up é colocado entre o VCC e o barramento de dados do módulo AM2302 para mantê-lo em nível lógico alto quando não estiver sendo utilizado o barramento. Para se evitar ruídos e interferências na medição do módulo 2302, é colocado um capacitor cerâmico de 100 nF mais próximo possível dos terminais de VCC e GND do módulo AM2302. Os dois botões presentes na montagem são utilizados para que se possa visualizar a máxima e a mínima temperatura registrada durante o período de medição que são pressionados.
Esquema Elétrico
Montagem
Código
O código em linguagem Python descrito abaixo faz com que os dados de temperatura e umidade relativa do ar obtidos do módulo AM2302 sejam interpretados pela Raspberry Pi e esta mostre as informações na tela do display de LCD. O código também faz o registro de máxima e mínima temperaturas obtidas durante o intervalo de medição, apresentando o instante que o evento ocorreu.
Aconselho para um bom entendimento deste código em Python dar uma recapitulada nos artigos anteriores desta série. Então vamos lá.
# Carrega as bibliotecas
from datetime import datetime
import Adafruit_CharLCD as LCD
import RPi.GPIO as GPIO
import Adafruit_DHT
import time
# Define o tipo de sensor
# sensor = Adafruit_DHT.DHT11
sensor = Adafruit_DHT.DHT22
# Pinos LCD x Raspberry (GPIO)
lcd_rs = 18
lcd_en = 23
lcd_d4 = 12
lcd_d5 = 16
lcd_d6 = 20
lcd_d7 = 21
lcd_backlight = 4
# Pino de entrada de dados do DHT-22
DHT_IN = 14
KEY_MAX = 4
KEY_MIN = 17
# Desabilita os Warnings
GPIO.setwarnings(False)
# Configura o modo de utilização das portas definidas pelas GPIOs
GPIO.setmode(GPIO.BCM)
# Define o pino conectado ao push-button
GPIO.setup(DHT_IN, GPIO.IN)
GPIO.setup(KEY_MAX, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(KEY_MIN, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
# Define número de colunas e linhas do LCD
lcd_colunas = 16
lcd_linhas = 2
# Define variables of maximum and minimum temperature
max_temp = 0
min_temp = 100
# Inicializa o LCD nos pinos configurados acima
lcd = LCD.Adafruit_CharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7, lcd_colunas, lcd_linhas,
lcd_backlight)
while True:
#Variáveis que recebem os valores de data e hora
tdy = datetime.today()
now = datetime.now()
time.sleep(0.1)
#Variáveis que recebem os valores de umidade e temperatura
umid, temp = Adafruit_DHT.read_retry(sensor, DHT_IN);
#Testa de os dados são válidos. Se sim, executa o código
if umid is not None and temp is not None:
#Configura os dados de temperatura no LCD
lcd.clear()
lcd.set_cursor(0,0)
lcd.message('Temp:')
temp_s = str(temp)
lcd.set_cursor(9,0)
lcd.message(temp_s.ljust(5)[:5])
lcd.set_cursor(15,0)
lcd.message('C')
#Configura os dados de umidade no LCD
lcd.set_cursor(0,1)
lcd.message('Humid:')
umid_s = str(umid)
lcd.set_cursor(9,1)
lcd.message(umid_s.ljust(5)[:5])
lcd.set_cursor(15,1)
lcd.message('%')
# Salva os dados do maior valor de temperatura
if temp > max_temp:
max_temp = temp
year_max = str((datetime.now().year)-2000)
month_max = str(datetime.now().month)
day_max = str(datetime.now().day)
hour_max = str(datetime.now().hour)
minute_max = str(datetime.now().minute)
# Salva os dados do menor valor de temperatura
if temp < min_temp:
min_temp = temp
year_min = str((datetime.now().year)- 2000)
month_min = str(datetime.now().month)
day_min = str(datetime.now().day)
hour_min = str(datetime.now().hour)
minute_min = str(datetime.now().minute)
# Acessa os dados salvos da temperatura máxima aperta um botão
if GPIO.input(KEY_MAX) == GPIO.HIGH:
flag = False
while True:
if GPIO.input(KEY_MAX) == GPIO.LOW:
flag = True
lcd.clear()
max_temp_s = str(max_temp)
lcd.set_cursor(0,0)
lcd.message('Max_temp:')
lcd.set_cursor(9,0)
lcd.message(max_temp_s.ljust(5)[:5])
lcd.set_cursor(15,0)
lcd.message('C')
# Define a posição dos dados do dia que ocorreu o evento
# o máximo valor na tela
if int(day_max) < 10:
lcd.set_cursor(0,1)
lcd.message('0')
lcd.set_cursor(1,1)
lcd.message(day_max)
else:
lcd.set_cursor(0,1)
lcd.message(day_max)
lcd.set_cursor(2,1)
lcd.message('/')
# Define a posição dos dados do mês que ocorreu o evento
# o máximo valor na tela
if int(month_max) < 10:
lcd.set_cursor(3,1)
lcd.message('0')
lcd.set_cursor(4,1)
lcd.message(day_max)
else:
lcd.set_cursor(3,1)
lcd.message(month_max)
# Configura a posição do ano e hora do valor máximo no display de LCD
lcd.set_cursor(5,1)
lcd.message('/')
lcd.set_cursor(6,1)
lcd.message(year_max)
lcd.set_cursor(11,1)
lcd.message(hour_max)
lcd.set_cursor(13,1)
lcd.message(':')
# Define a posição na tela dos dados do minuto que ocorreu o evento
if minute_max < 10:
lcd.set_cursor(14,1)
lcd.message('0')
lcd.set_cursor(15,1)
lcd.message(minute_max)
else:
lcd.set_cursor(14,1)
lcd.message(minute_max)
# Sai do loop infinito de temperatura máxima
if ((GPIO.input(KEY_MAX) == GPIO.HIGH) and flag == True) == True:
break
time.sleep(0.5)
# Acessa os dados salvos da temperatura mínima aperta um botão
if GPIO.input(KEY_MIN) == GPIO.HIGH:
flag = False
while True:
if GPIO.input(KEY_MIN) == GPIO.LOW:
flag = True
lcd.clear()
min_temp_s = str(min_temp)
lcd.set_cursor(0,0)
lcd.message('Min_temp:')
lcd.set_cursor(9,0)
lcd.message(min_temp_s.ljust(5)[:5])
lcd.set_cursor(15,0)
lcd.message('C')
# Define a posição dos dados do dia que que ocorreu o evento
# o mínimo valor na tela
if int(day_min) < 10:
lcd.set_cursor(0,1)
lcd.message('0')
lcd.set_cursor(1,1)
lcd.message(day_min)
else:
lcd.set_cursor(0,1)
lcd.message(day_min)
lcd.set_cursor(2,1)
lcd.message('/')
# Define a posição dos dados do mês que aconteceu
# o mínimo valor na tela
if int(month_min) < 10:
lcd.set_cursor(3,1)
lcd.message('0')
lcd.set_cursor(4,1)
lcd.message(day_min)
else:
lcd.set_cursor(3,1)
lcd.message(month_min)
# Configura a posiçõa do ano e hora do valor mínimo do display LCD
lcd.set_cursor(5,1)
lcd.message('/')
lcd.set_cursor(6,1)
lcd.message(year_min)
lcd.set_cursor(11,1)
lcd.message(hour_min)
lcd.set_cursor(13,1)
lcd.message(':')
# Define a posição dos dados do minuto que aconteceu
# o máximo valor na tela
if minute_min < 10:
lcd.set_cursor(14,1)
lcd.message('0')
lcd.set_cursor(15,1)
lcd.message(minute_min)
else:
lcd.set_cursor(14,1)
lcd.message(minute_min)
# Sai do loop infinito de temperatura mínima
if ((GPIO.input(KEY_MIN) == GPIO.HIGH) and flag == True) == True:
break
time.sleep(0.5)
# Caso os dados não sejam válidos,
# é apresentado na tela do LCD um notificação de erro de leitura dos dados
else:
lcd.clear()
lcd.set_cursor(1,0)
lcd.message('Reading Failed')
gpio.cleanup()
exit()
Descrição do Código
Entre as linhas 2 e 6 são declaradas as bibliotecas das funções que serão usadas no código.
Na linha 10 é definido qual modelo de sensor que iremos utilizar, no caso usar o modelo DHT-22.
Entre as linhas 13 a 19 é definida a pinagem do display de LCD.
Nas linhas 22, 23 e 24 são definidas as variáveis que definem quais são os GPIOs que serão utilizados como entrada de dados.
Na linha 27 são desabilitados os avisos de warnings.
Na linha 30 é configurado o modo de utilização das portas definidas pelo número dos GPIOs.
Nas linhas 33, 34 e 35 é configurada a pinagem dos GPIOs que receberam os dados.
Nas linhas 38 e 39 define-se que o display de LCD utilizado será 16 colunas e 2 linhas.
Na linha 42 define-se um valor inicial para a variável que será utilizada para armazenar o valor de temperatura máxima e na linha 43 define-se um valor inicial para a variável que será utilizada para armazenar o valor de temperatura mínima.
Nas linhas 46, 47 e 48 é declarado o objeto “lcd” a partir da função que define quais GPIOs irão ser utilizados para manipular o display de LCD.
Na linha 50 é onde o loop infinito principal deste código fonte é definido.
Nas linhas 52 e 53 as variáveis “tdy” e “now” recebem a informação de tempo, respectivamente dia e hora.
Na linha 56 as variáveis “umid” e “temp” recebem, respectivamente, as informações de umidade e temperatura geradas pelo módulo AM2302.
Na linha 59 é testado se os dados gerados pelo módulo AM2302 são válidos. Sendo válidos, o código é executado. Caso contrário, é gerada uma mensagem de erro presente entre as linhas 229 e 232.
Entre as linhas 61 e 68 é configurada a forma de apresentação dos dados de temperatura e entre as linhas 71 e 77 é configurada a forma de apresentação dos dados de umidade no display de LCD.
Entre as linhas 80 e 95 são realizados os registros de máxima e mínima temperatura que são realizados durante o período de medição.
Entre as linhas 98 e 160 são acessados os dados referentes à maior temperatura registrada durante o intervalo de medição, e se realiza a manipulação desses dados para sua apresentação no display de LCD. Os dados são de hora, dia, mês e ano que este evento ocorreu. Para se mostrar esses dados, quando se é pressionado o botão que dá acesso a estas informações, se entra num loop infinito que só é interrompido pressionando o botão novamente, fazendo que se retorne a tela inicial.
Entre as linhas 163 e 226 são acessados os dados de menor temperatura registrada durante o intervalo de medição. A manipulação dos dados é realizada de forma similar ao que é realizado para temperatura máxima.
Conclusão
Com o desenvolvimento do projeto do termômetro digital, pode-se adquirir conhecimento teórico e prático sobre o módulo sensor de temperatura e umidade, no caso o modelo AM2302. Também foi apresentado como instalar e utilizar as funções da biblioteca Python para o módulo DHT-11/22, que nos permite conseguir manipular os dados obtidos.
Com essas informações em mãos, pode-se observar que é simples utilizar o módulo AM2303 ou DHT-22 para outras aplicações onde se há a necessidade de analisar as informações de temperatura e umidade relativa ar e realizar algumas atuações a partir desses dados.
O leitor agora é capaz de desenvolver os seus próprios projetos utilizando o módulo DHT-22 (composto de um sensor de temperatura e outro de umidade) e similares.
Referências
Como ligar o sensor de temperatura DHT22 ao Raspberry Pi B+
Referência das Tabelas: Datasheet Sensor Am2302
O pino é o TX Gpio 14? Para receber o sensor?