Raspberry Pi - Projeto Termômetro Digital com Python

ÍNDICE DE CONTEÚDO [MOSTRAR]

Este post faz parte da série Raspberry PI com Python. Leia também os outros posts da série:

Raspberry PI - GPIO output com Python
Raspberry PI – GPIO input com Python
Raspberry PI - PWM com Python
Raspberry Pi - Display LCD com Python
Raspberry Pi - Projeto Termômetro Digital com Python - Teoria
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

1	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

1	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

1 2	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

1	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);

1	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

1 2	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 V_CC 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 V_CC 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()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

# 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 | Fontes

https://www.embarcados.com.br/

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

Olá Seja Bem vindo !

Total de Visualizações

Postagens Populares

Como alterar a extensão de vários arquivos

xampp : como instalar no Fedora

Abrir Programas automaticamente no Ubuntu

A Linguagem POTIGOL :)

PFSENSE : DMZ

Docker: Instalando no Ubuntu 18...

Documentação de Imagem do Docker do Oracle Database Server

Exportar saída de consulta para o Excel no Oracle SQL Developer

PFSENSE : desabilitar o pfsense

PHPMYADMIN: Como desinstalar phpmyadmin do Ubuntu

Automatizando execução do ETL no Pentaho

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

Instalação da Biblioteca do Módulo DHT-22

Comandos

Circuito

Esquema Elétrico

Montagem

Código

Descrição do Código

Conclusão

Postado por Luis O P Carvalho

Páginas

have fun

Pesquisar este blog

Marcadores

Tags

Olá Seja Bem vindo !

Total de Visualizações

Postagens Populares

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

Instalação da Biblioteca do Módulo DHT-22

Comandos

Circuito

Esquema Elétrico

Montagem

Código

Descrição do Código

Conclusão

Postado por Luis O P Carvalho

Social

Páginas

have fun

Pesquisar este blog

Marcadores

Tags