Raspberry Pi - Projeto Termômetro Digital com Python - Prática

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:

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.

 

Módulo AM2302
Figura 1 - Módulo AM2302

 

Esquema Elétrico

 

Termômetro Digital com Python - Esquema Elétrico do Projeto Termômetro com Python
Figura 2 - Esquema Elétrico do Projeto Termômetro com Python

 

 

Montagem

 

Termômetro Digital com Python - Montagem no Protoboard do Projeto Termômetro com Python
Figura 3 - Montagem no Protoboard do Projeto Termômetro com Python

 

 

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+

 

Datasheet Sensor Am2302

 

Biblioteca DHT-22

 

Referência da Figura 2

 

Referência das Tabelas: Datasheet Sensor Am2302

Outros artigos da série

<< Raspberry Pi - Projeto Termômetro Digital com Python - TeoriaRaspberry Pi - Comunicação Serial (UART) entre a Raspberry Pi e Arduino em Python e Wiring >>
NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Roniere Rezende
Natural de Cachoeira de Minas, cidade localizada no extremo sul de Minas Gerais. Graduado em engenharia elétrica pela PUC MINAS campus Poços de Caldas e técnico de telecomunicações pela Escola Técnica de Eletrônica "Francisco Moreira da Costa" - ETE "FMC" em Santa Rita do Sapucaí-MG. Atualmente atua como Analista Programador na Nexcode System na cidade de São Caetano do Sul-SP. Possui conhecimentos em eletrônica analógica, digitais, e de potência, em sistemas de telecomunicações e radiofrequência, em sistemas embarcados e linguagem de programação como C / C ++, Python e Matlab. Pesquisa e estuda sobre microcontroladores 8 e 32 bits, Arduino, Raspberry, STM32 Nucleo, desenvolvimento de dispositivos eletrônicos, sistemas embarcados, software e hardware.

Deixe um comentário

avatar
 
  Notificações  
Notificar