Vamos aprender como ler e imprimir na tela um sensor de temperatura HDC1080 com microPython. Usaremos um Raspberry Pi RP2350 para essa tarefa, executando a versão mais recente do microPython.
Já vimos como começar com o RP2350 neste post, onde piscamos o LED integrado do Pi Pico 2 com o Thonny IDE. Vou explicar todo o processo do IDE novamente, só para ter certeza.
A ideia deste artigo é permitir que você leia a temperatura e a umidade do sensor HDC1080, via i2c e usando um Raspberry Pi Pico 2 RP2350. Escolhi o Thonny IDE como nosso software de programação porque ele é simples, leve e funcional o suficiente para o trabalho.
Hardware
A folha de dados do HDC1080 afirma que ele precisa de comunicação i2c para fornecer seus dados. Então, além de SDA e SCL, também precisamos de +3,3 V e GND, fornecidos pelo próprio Pi Pico 2. A tensão de alimentação para o próprio RP2350 vem via conexão USB C, que também traz dados para a placa. Veja na imagem abaixo o diagrama esquemático do experimento deste post.
A porta i2c do Raspberry Pi Pico 2 pode ser posicionada em uma variedade de pinos, como por exemplo i2c0 pode ir nos pinos 1-2, 4-5, 8-9, 16-17, e assim por diante. Os pinos “oficiais” e “originais” são 4 e 5, para serem compatíveis com o Arduino (que usa os pinos A4 e A5). Veja abaixo o diagrama completo de pinagem do Pi Pico 2.
Configurando a IDE Thonny
Acesse o site do Thonny IDE e baixe sua versão preferida (na verdade, a versão que se encaixa no seu sistema operacional). O meu é o Windows; siga as instruções na tela para instalá-lo (assim como qualquer outra instalação de software). Quando você abrir o IDE, haverá um menu na parte superior da tela, contendo “Arquivo”, “Editar”, “Exibir”, “Executar”, “Ferramentas” e “Ajuda”.
Vá em “Ferramentas > Opções…” e neste momento conecte sua placa Raspberry Pi Pico 2 ao computador por meio de um cabo USB. Vá para o submenu “Interpreter” e no menu suspenso selecione “Micropython (Raspberry Pi Pico)”. Em seguida, no menu suspenso “Porta ou WebRPL”, selecione a única (somente) porta COM que aparece. Clique em “OK” e observe a parte inferior da tela, ela deve ser parecida com a imagem abaixo.
Ela apresenta a versão do microPython, o nome da placa e “>>>” esperando você digitar algo. Isso significa que a placa foi reconhecida pelo Thonny IDE como executando microPython e está pronta para uso.
Código para o sensor HDC1080
O código para o nosso sensor HDC1080 não é meu, eu o encontrei no Github neste link. Você terá que criar dois arquivos “.py” para que este exemplo funcione, um é o código HDC1080 em “hdc1080.py”. O outro é o nosso arquivo principal contendo o uso da função e a impressão da tela (“main.py”). Ambos terão que ser salvos no próprio Pi, não no seu computador.
Primeiro copie o código abaixo:
# SPDX-FileCopyrightText: 2024 Mike Causer <https://github.com/mcauser>
# SPDX-License-Identifier: MIT
"""
MicroPython HDC1080 Temperature & Humidity Sensor
https://github.com/mcauser/micropython-hdc1080
"""
__version__ = "1.0.1"
from micropython import const
from time import sleep_ms
# registers
_TEMPERATURE = const(0x00)
_HUMIDITY = const(0x01)
_CONFIG = const(0x02)
_SERIAL_ID0 = const(0xFB)
_SERIAL_ID1 = const(0xFC)
_SERIAL_ID2 = const(0xFD)
_MANUFACTURER_ID = const(0xFE)
_DEVICE_ID = const(0xFF)
class HDC1080:
def __init__(self, i2c):
self._i2c = i2c
self._address = 0x40 # fixed I2C address
self._buf1 = bytearray(1)
self._buf2 = bytearray(2)
self._config = 0x10
def _read16(self, reg):
self._buf1[0] = reg
self._i2c.writeto(self._address, self._buf1)
sleep_ms(20)
self._i2c.readfrom_into(self._address, self._buf2)
return (self._buf2[0] << 8) | self._buf2[1]
def _write_config(self):
self._buf2[0] = _CONFIG
self._buf2[1] = self._config
self._i2c.writeto(self._address, self._buf2)
def _read_config(self):
# shift out the first 8 reserved bits
self._config = self._read16(_CONFIG) >> 8
def check(self):
if self._i2c.scan().count(self._address) == 0:
raise OSError(f"HDC1080 not found at I2C address {self._address:#x}")
return True
def config(
self, config=None, humid_res=None, temp_res=None, mode=None, heater=None
):
if config is not None:
self._config = config
self._write_config()
else:
self._read_config()
if humid_res is not None:
# 00 = 14-bit, 01 = 11-bit, 10 = 8-bit
if humid_res == 8:
self._config |= 2
self._config &= ~1
elif humid_res == 11:
self._config &= ~2
self._config |= 1
elif humid_res == 14:
self._config &= ~3
else:
raise ValueError("humid_res must be 8, 11 or 14")
if temp_res is not None:
# 0 = 14-bit, 1 = 11-bit
if temp_res == 11:
self._config |= 4
elif temp_res == 14:
self._config &= ~4
else:
raise ValueError("temp_res must be 11 or 14")
if mode is not None:
# mode 0 = temp or humid acquired
# mode 1 = temp and humid acquired in sequence, temp first
self._config &= ~16
self._config |= (mode & 1) << 4
if heater is not None:
self._config &= ~32
self._config |= (heater & 1) << 5
self._write_config()
def reset(self):
self._config = 128
self._write_config()
# sw reset bit self clears
self._read_config()
def battery_status(self):
# returns 0 if Vcc > 2.8V
# returns 1 if Vcc < 2.8V
self._read_config()
return (self._config >> 3) & 1
def temperature(self):
# temperature in celsius
return (self._read16(_TEMPERATURE) / 65536) * 165 - 40
def humidity(self):
# relative humidity percentage
return (self._read16(_HUMIDITY) / 65536) * 100
def serial_number(self):
# unique per device
return (
(self._read16(_SERIAL_ID0) << 24)
| (self._read16(_SERIAL_ID1) << 8)
| (self._read16(_SERIAL_ID2) >> 8)
)
def manufacturer_id(self):
# fixed 21577 == 0x5449 == b'\x54\x49' == b'TI'
return self._read16(_MANUFACTURER_ID)
def device_id(self):
# fixed 4176 == 0x1050 == b'\x10\x50' == b'\x10P'
return self._read16(_DEVICE_ID)Cole-o no Thonny IDE e vá em “File > Save As..”, depois escolha “Raspberry Pi Pico” no menu abaixo. Nomeie-o como “hdc1080.py”.
Vá em “Arquivo > Novo” e copie/cole o código abaixo, nosso código principal:
# SPDX-FileCopyrightText: 2024 Mike Causer <https://github.com/mcauser>
# SPDX-License-Identifier: MIT
"""
MicroPython HDC1080 Basic example
Prints the temperature and humidity every 500ms
"""
from machine import I2C
from hdc1080 import HDC1080
i2c = I2C(0)
hdc = HDC1080(i2c)
from time import sleep_ms
hdc.config(humid_res=14, temp_res=14, mode=0, heater=0)
if hdc.check():
print(f"Found HDC1080 with serial number {hdc.serial_number()}")
while True:
print(f"{hdc.temperature()} C, {hdc.humidity()} RH")
sleep_ms(1000)Então vá em “Arquivo > Salvar como”, escolha “Raspberry Pi Pico” e nomeie-o como “main.py”. Agora clique na seta verde no topo da tela (“Executar script atual”) ou pressione “F5”. Você começará a ver informações sendo impressas na parte inferior da tela, como na imagem abaixo.
Pra finalizar
Primeiro você verá o número de série da placa HDC1080, depois a temperatura em graus Celsius e a umidade em %RH serão exibidas na tela a cada 1000 ms (1 segundo). Uma coisa que notei é que toda vez que você remove a conexão da placa (USB) e a reconecta, você tem que fazer um pequeno processo.
Este processo envolve ir em “Ferramentas > Opções” e selecionar novamente a porta COM. Além disso, você tem que clicar na seta verde na parte superior da tela (executar código, “F5”) novamente todas as vezes. Acho que isso é parte do uso de uma tecnologia “mais nova” que é fácil de um lado e mais complexa do outro. Abaixo está um vídeo meu mostrando como este sensor funciona com o RP2350.
