
RESPOSTA DIRETA
A Merrii A31 vendida pela Lojamundi sai com o Debian 13 gravado na memória interna (NAND), sem cartão microSD. Ligue nela o sensor LM75 por quatro fios e ela vira um sensor de temperatura de rede: a cada 15 segundos, o Home Assistant, rodando em outro computador, lê a temperatura e, por uma tomada inteligente, liga ou desliga o ventilador ou o aquecedor. O ar-condicionado entra pela integração do próprio aparelho com o Home Assistant, não pela tomada.
Este é um projeto da nossa bancada, montado com dois produtos da loja: a placa Merrii A31 Hummingbird e o sensor de temperatura LM75. Abaixo estão a lista de materiais, a ligação dos fios, os comandos para ler o sensor no Debian, o serviço que entrega a temperatura na rede e a configuração do Home Assistant. É tudo o que rodou na nossa placa, com o que já foi testado e o que ainda não foi.

A Merrii A31 é uma placa de desenvolvimento com processador de quatro núcleos e 1 GB de memória. A unidade vendida pela Lojamundi sai com o Debian 13 (trixie), a versão estável atual do Debian, gravado na memória interna da placa, a NAND de 8 GB. Não precisa de cartão microSD: o sistema sobe direto da placa.
Isso pesa num projeto que fica ligado o dia inteiro. Em placas que nunca desligam, o cartão microSD costuma ser o ponto fraco. Aqui o sistema mora na memória interna, que no Linux trabalha em modo SLC (um bit por célula, o modo mais confiável da memória flash) e deixa cerca de 3,6 GB para sistema e dados.
Os programas vêm do repositório oficial do Debian para ARM de 32 bits (armhf). O kernel fica fixo na versão testada nesta placa, porque o driver da memória interna é feito para ela: trocar o kernel é um procedimento técnico, não uma atualização comum.
Nota: a Merrii trabalha quente. Parado, o processador fica perto de 65 °C com dissipador e entre 72 e 74 °C sem ele. Use um dissipador no processador e deixe a placa num lugar ventilado.
O LM75 é um termômetro digital: o próprio chip converte a temperatura em número e entrega pelo barramento I²C, sem ajuste analógico. Na loja, o módulo aparece como "Sensor de Temperatura Banana Pi", porque nasceu para encaixar nessa placa. Na Merrii, ele vai ligado por fios.
O J11 é a barra de 60 pinos (2 × 30) na face de baixo da Merrii. O passo dos pinos é de 2,0 mm, mais apertado que o padrão de 2,54 mm das placas de prototipagem; por isso o jumper precisa de fêmea de 2,0 mm. O sensor usa quatro pinos: alimentação, terra e os dois sinais do I²C.

Ligação do sensor LM75 no conector J11 da Merrii A31
| Função | Pino no J11 | No módulo |
|---|---|---|
| Alimentação 3 V | 59 | VCC |
| Dados (SDA) | 46 | SDA |
| Relógio (SCL) | 44 | SCL |
| Terra (GND) | 42 | GND |
| Alarme (OS) | — | deixe livre |
O pino 59 fica na fileira de dentro, na ponta mais longe do mini-USB. Os pinos 42, 44 e 46 são vizinhos, na fileira da borda. O pino 59 entrega a alimentação da lógica da placa, que medimos em cerca de 3,0 V: dentro da faixa do LM75, que funciona com 2,8 V ou mais.
No módulo, os cinco contatos seguem a ordem do Banana Pi, a placa para a qual ele foi feito: VCC, SDA, SCL, OS e GND, em sequência. Se o seu módulo não trouxer o nome dos contatos impresso, descubra de que ponta a sequência começa pelo próprio chip, com o multímetro (passo 1 do checklist abaixo).
Atenção: desligue a placa (sudo poweroff) e tire a fonte da tomada antes de mexer nos fios. Nunca use os pinos 1 e 2 do J11: eles têm 5 V e ficam colados em pinos de 3 V. Um esbarrão ali pode danificar a placa.
Não trance o fio do SDA com o do SCL nem deixe os dois lado a lado num cabo comprido: um sinal interfere no outro. A especificação do I²C (NXP UM10204, seção 7.5) pede, acima de 10 cm, a ordem SDA, VCC, GND e SCL numa fita, ou pares trançados em que cada sinal acompanha um fio de alimentação ou de terra. Na nossa bancada, quatro fios soltos e separados, de 40 a 50 cm, leram sem erro.

Deixe o sensor longe da placa. O processador da Merrii passa de 60 °C e esquentaria a leitura; com fios desse comprimento, o sensor mede o ar do ambiente, não o calor da placa.
merrii-a31.local. Se o seu computador não encontrar esse nome, procure o IP da placa na lista de aparelhos conectados do roteador.ssh USUARIO@merrii-a31.local.passwd.É a configuração de rede que já vem na placa: o systemd-networkd cuida da rede (é ele que pega o endereço do cabo), e o wpa_supplicant e o iw já vêm instalados. Na nossa bancada, a placa trabalhou só pelo Wi-Fi com os dois configurados do mesmo jeito. Antes de começar, confira que o serviço de rede está ativo: o comando abaixo deve responder active.
systemctl is-active systemd-networkdDepois, abra o arquivo da rede sem fio no editor:
sudo nano /etc/wpa_supplicant/wpa_supplicant-wlan0.confCole o bloco abaixo, trocando o nome e a senha pelos da sua rede (mantenha as aspas), e salve:
ctrl_interface=DIR=/run/wpa_supplicant GROUP=netdev
country=BR
network={
ssid="NOME-DA-SUA-REDE"
psk="SENHA-DA-SUA-REDE"
}Depois, proteja o arquivo (a senha fica nele), crie a configuração de rede do Wi-Fi e ligue o serviço:
sudo chmod 600 /etc/wpa_supplicant/wpa_supplicant-wlan0.conf
printf '[Match]\nName=wlan0\n\n[Network]\nDHCP=yes\n' | sudo tee /etc/systemd/network/25-wlan0.network
sudo systemctl enable --now wpa_supplicant@wlan0
sudo networkctl reloadConfira antes de tirar o cabo. O primeiro comando deve responder "Connected to", e o segundo, uma linha inet com o endereço que o roteador deu ao Wi-Fi:
sudo iw dev wlan0 link
ip -4 addr show wlan0Por fim, do computador, entre por SSH nesse endereço novo. Se entrar, tire o cabo: o Wi-Fi volta sozinho a cada reinício. A placa só enxerga redes de 2,4 GHz.
Com o sensor ligado e a placa acessível por SSH, registre o sensor no kernel. O Debian já traz o driver do LM75 e as ferramentas de I²C: não há pacote para instalar.
sudo modprobe lm75
echo lm75b 0x48 | sudo tee /sys/bus/i2c/devices/i2c-1/new_device
cat /sys/bus/i2c/devices/1-0048/hwmon/hwmon*/temp1_inputA resposta vem em milésimos de grau: 25375 significa 25,375 °C. Na nossa bancada, 180 leituras seguidas, uma por segundo, saíram sem nenhum erro. O registro feito à mão vale até o próximo reinício; o serviço da próxima seção refaz o registro a cada boot.
Nota: o barramento do J11 costuma aparecer como i2c-1. Se na sua placa o número for outro, o script da próxima seção encontra o barramento certo sozinho, pelo endereço da controladora.
O Home Assistant precisa buscar o número pela rede. Na nossa placa, isso ficou com um script em bash e três arquivos do systemd, sem nenhum pacote extra. A cada conexão na porta 8075, o systemd abre um processo curto que lê o sensor, responde e sai: nenhum programa fica parado ocupando memória.
{"temperatura_c":24.250,"sensor":"lm75b","endereco":"0x48"}Se o sensor não responder, a placa devolve o código 503 com "temperatura_c": null. É de propósito: o Home Assistant mostra o sensor como indisponível em vez de repetir um número velho.
#!/bin/bash
# merrii-lm75 — sensor de temperatura LM75 no TWI2 do J11 da Merrii A31 Hummingbird.
# Fica em /usr/local/sbin/merrii-lm75. Não usa pacote extra:
# só o driver lm75 do kernel Debian, que publica a leitura no hwmon.
#
# merrii-lm75 registrar registra o sensor no kernel (o merrii-lm75.service chama no boot).
# Sem sensor respondendo, desfaz o registro e sai com 0: o boot não falha.
# merrii-lm75 ler só o número, em °C (para scripts); sai com 1 sem leitura (sensor não
# registrado ou erro no I²C), nunca imprime um número inventado
# merrii-lm75 [estado] leitura legível: sensor e processador, para comparar
# merrii-lm75 remover tira o registro do kernel
# merrii-lm75 http responde UMA requisição HTTP no stdin/stdout. Quem chama é o
# merrii-lm75-http.socket (porta 8075, um processo curto por conexão), para o
# Home Assistant: GET / devolve {"temperatura_c":24.125,...}; sem leitura, 503 com
# "temperatura_c":null, para o HA mostrar "indisponível" e não o último valor.
#
# Configuração (opcional): /etc/default/merrii-lm75 com ENDERECO=0x48 e DRIVER=lm75|lm75a|lm75b.
# O nome do driver sai do próprio chip (marcação; resolução da leitura: 11 bits = LM75A/B, 9 = LM75),
# não da página do módulo.
# Para registrar de novo depois de mexer nos fios (com a placa desligada!): sudo systemctl restart merrii-lm75
set -u
export LC_ALL=C
ENDERECO=0x48
DRIVER=lm75b
[ -r /etc/default/merrii-lm75 ] && . /etc/default/merrii-lm75
# O TWI2 é a controladora 1c2b400 do A31; o número do i2c-N vem da ordem de registro e pode mudar.
barramento() {
local b
for b in /sys/bus/i2c/devices/i2c-*; do
case "$(readlink -f "$b/of_node" 2>/dev/null)" in
*/i2c@1c2b400) echo "${b##*i2c-}"; return 0 ;;
esac
done
return 1
}
dispositivo() { # /sys/bus/i2c/devices/<bus>-00<end>
printf '/sys/bus/i2c/devices/%d-%04x' "$1" "$((ENDERECO))"
}
ler_mili() { # temperatura do LM75 em milésimos de grau; falha (≠ 0) sem leitura
local B h m
B=$(barramento) || return 1
for h in "$(dispositivo "$B")"/hwmon/hwmon*/temp1_input; do
[ -r "$h" ] || continue
# erro de I²C: o cat falha (ex.: tempo esgotado) e não sai número: nunca devolve 0.000 inventado
m=$(cat "$h") || return 1
[[ $m =~ ^-?[0-9]+$ ]] || return 1
echo "$m"
return 0
done
return 1
}
registrar() {
local B D n
[ "$(id -u)" = 0 ] || { echo "merrii-lm75: registrar exige root (sudo)" >&2; return 1; }
B=$(barramento) || { echo "merrii-lm75: TWI2 (i2c@1c2b400) não encontrado" >&2; return 1; }
D=$(dispositivo "$B")
if [ -e "$D/driver" ]; then
echo "merrii-lm75: sensor já registrado em ${D##*/} ($(cat "$D/name"))"
return 0
fi
# sobra de um registro anterior sem driver (sensor ausente na hora): limpa antes
[ -e "$D" ] && echo "$ENDERECO" > "/sys/bus/i2c/devices/i2c-$B/delete_device"
modprobe lm75 || return 1
echo "$DRIVER $ENDERECO" > "/sys/bus/i2c/devices/i2c-$B/new_device" || return 1
for n in $(seq 30); do [ -e "$D/driver" ] && break; sleep 0.1; done
if [ -e "$D/driver" ]; then
n=$(ler_mili) && echo "merrii-lm75: sensor $DRIVER em i2c-$B $ENDERECO, $(awk -v m="$n" 'BEGIN{printf "%.3f", m/1000}') °C" \
|| echo "merrii-lm75: sensor $DRIVER registrado em i2c-$B $ENDERECO, ainda sem leitura"
else
# o chip não respondeu: o kernel deixa o dispositivo sem driver; desfaz para não sobrar lixo
echo "$ENDERECO" > "/sys/bus/i2c/devices/i2c-$B/delete_device"
echo "merrii-lm75: nenhum sensor respondeu em i2c-$B $ENDERECO; registro desfeito (confira os fios com a placa desligada e rode: sudo systemctl restart merrii-lm75)"
fi
return 0
}
remover() {
local B D
[ "$(id -u)" = 0 ] || { echo "merrii-lm75: remover exige root (sudo)" >&2; return 1; }
B=$(barramento) || return 0
D=$(dispositivo "$B")
[ -e "$D" ] && echo "$ENDERECO" > "/sys/bus/i2c/devices/i2c-$B/delete_device"
return 0
}
ler() {
local m
m=$(ler_mili) || { echo "merrii-lm75: sem leitura do sensor: não registrado ou erro no I²C (veja: systemctl status merrii-lm75 e sudo dmesg)" >&2; return 1; }
awk -v m="$m" 'BEGIN{printf "%.3f\n", m/1000}'
}
estado() {
local m z
if m=$(ler_mili); then
awk -v m="$m" -v d="$DRIVER" -v e="$ENDERECO" 'BEGIN{printf "Sensor LM75 (%s, %s): %.1f °C\n", d, e, m/1000}'
else
echo "Sensor LM75: sem leitura, não registrado ou erro no I²C (veja: systemctl status merrii-lm75 e sudo dmesg)"
fi
for z in /sys/class/thermal/thermal_zone*; do
[ "$(cat "$z/type" 2>/dev/null)" = cpu-thermal ] &&
awk '{printf "Processador A31: %.1f °C (mede o chip, não o ambiente)\n", $1/1000}' "$z/temp"
done
return 0
}
# Uma requisição por processo: o systemd (Accept=yes) entrega a conexão no stdin/stdout e fecha ao sair.
# Lê a linha do pedido e os cabeçalhos até a linha em branco, com prazo (cliente mudo não prende o
# processo), e só então responde: fechar com dados por ler faria o kernel mandar RST no lugar da resposta.
# Só texto ASCII no corpo, para o Content-Length em bytes bater com ${#corpo} (LC_ALL=C).
http() {
local linha cab metodo caminho m t s estado corpo
IFS= read -r -t 5 linha || return 0
linha=${linha%$'\r'}
while IFS= read -r -t 2 cab; do
cab=${cab%$'\r'}
[ -z "$cab" ] && break
done
metodo=${linha%% *}
caminho=${linha#* }
caminho=${caminho%% *}
if [ "$metodo" != GET ] && [ "$metodo" != HEAD ]; then
estado='405 Method Not Allowed'
corpo='{"erro":"use GET"}'
elif [ "$caminho" != / ] && [ "$caminho" != /temperatura ]; then
estado='404 Not Found'
corpo='{"erro":"use GET /"}'
elif m=$(ler_mili 2>/dev/null); then
s=
t=$m
[ "$t" -lt 0 ] && { s=-; t=$((-t)); }
estado='200 OK'
corpo=$(printf '{"temperatura_c":%s%d.%03d,"sensor":"%s","endereco":"%s"}' \
"$s" $((t / 1000)) $((t % 1000)) "$DRIVER" "$ENDERECO")
else
estado='503 Service Unavailable'
corpo=$(printf '{"temperatura_c":null,"sensor":"%s","endereco":"%s","erro":"sem leitura do sensor"}' \
"$DRIVER" "$ENDERECO")
fi
printf 'HTTP/1.0 %s\r\nContent-Type: application/json\r\nContent-Length: %d\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n' \
"$estado" "${#corpo}"
[ "$metodo" = HEAD ] || printf '%s' "$corpo"
return 0
}
case "${1:-estado}" in
registrar) registrar ;;
remover) remover ;;
ler) ler ;;
estado) estado ;;
http) http ;;
*) echo "uso: merrii-lm75 [estado|ler|registrar|remover|http]" >&2; exit 2 ;;
esac[Unit]
Description=Sensor de temperatura LM75 no J11 (TWI2) da Merrii A31
Documentation=file:/usr/local/sbin/merrii-lm75
# só existe na Merrii: a controladora do TWI2 do A31
ConditionPathExists=/sys/firmware/devicetree/base/soc/i2c@1c2b400
After=systemd-modules-load.service systemd-udevd.service
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/local/sbin/merrii-lm75 registrar
[Install]
WantedBy=multi-user.target# merrii-lm75: temperatura do LM75 por HTTP, para o Home Assistant.
# Cada conexão abre uma instância curta de merrii-lm75-http@.service, que responde e sai: não há processo
# parado esperando. Teste, de outra máquina da rede: curl http://IP-DA-MERRII:8075/
[Unit]
Description=Merrii LM75: temperatura por HTTP (porta 8075)
[Socket]
ListenStream=8075
Accept=yes
MaxConnections=8
MaxConnectionsPerSource=4
[Install]
WantedBy=sockets.target# merrii-lm75: uma resposta HTTP com a temperatura; chamada pelo merrii-lm75-http.socket.
# Usuário dinâmico sem privilégio: só lê o hwmon (/sys, legível por todos) e o /etc/default/merrii-lm75.
# LogLevelMax=notice: o Home Assistant pergunta a cada 15 s e a raiz é NAND com journal persistente; sem
# isto, cada pergunta grava duas linhas ("Started"/"Deactivated") no journal. SyslogLevel=warning faz o
# que o script escrever no stderr passar pelo filtro.
[Unit]
Description=Merrii LM75: resposta HTTP com a temperatura
CollectMode=inactive-or-failed
[Service]
ExecStart=/usr/local/sbin/merrii-lm75 http
StandardInput=socket
StandardOutput=socket
StandardError=journal
SyslogLevel=warning
LogLevelMax=notice
DynamicUser=yes
User=merrii-lm75-http
RuntimeMaxSec=20
PrivateDevices=yes
ProtectHome=yes
ProtectKernelModules=yes
ProtectControlGroups=yesPara instalar, crie os quatro arquivos numa pasta da placa (o editor nano já vem no Debian) e, dentro dela, rode:
sudo install -o root -g root -m 755 merrii-lm75 /usr/local/sbin/merrii-lm75
sudo install -o root -g root -m 644 merrii-lm75.service merrii-lm75-http.socket merrii-lm75-http@.service /etc/systemd/system/
printf 'ENDERECO=0x48\nDRIVER=lm75b\n' | sudo tee /etc/default/merrii-lm75
sudo systemctl daemon-reload
sudo systemctl enable merrii-lm75.service merrii-lm75-http.socket
sudo systemctl restart merrii-lm75.service merrii-lm75-http.socket
/usr/local/sbin/merrii-lm75 estadoO último comando mostra a temperatura do sensor e a do processador, para comparar. Depois, teste de outro computador da rede, trocando IP-DA-MERRII pelo endereço da placa:
curl http://IP-DA-MERRII:8075/Atenção: o serviço não tem senha e responde em todas as interfaces de rede. Use só na rede local e nunca abra a porta 8075 para a internet. Reserve no roteador um IP fixo para a placa, para o Home Assistant sempre encontrá-la.
O Home Assistant não roda mais em placas ARM de 32 bits como a Merrii: o projeto encerrou esse suporte em 2025. Ele fica num computador da rede (um PC, um mini PC ou uma placa de 64 bits), e a Merrii trabalha como o sensor dele.
Toda a configuração cabe num arquivo de pacote. No configuration.yaml, ative a pasta de pacotes:
homeassistant:
packages: !include_dir_named packagesE crie packages/merrii_a31.yaml, trocando IP-DA-MERRII pelo IP da placa e switch.sua_tomada pela entidade da sua tomada inteligente:
# packages/merrii_a31.yaml — Merrii A31 + sensor LM75 no Home Assistant
# Troque IP-DA-MERRII pelo IP fixo da placa e switch.sua_tomada pela sua tomada inteligente.
# Sem leitura do sensor, a placa responde 503 com "temperatura_c": null e o sensor abaixo
# fica "indisponível" (nunca repete o último valor). Placa desligada ou fora da rede: idem.
#
# MODO AQUECER: a tomada LIGA abaixo de alvo - 0,3 °C e DESLIGA acima de alvo + 0,3 °C.
# Para RESFRIAR com um ventilador: ac_mode: true e initial_hvac_mode: "cool".
# Ar-condicionado NÃO vai na tomada (o compressor não pode ser ligado e desligado assim):
# use a integração do próprio aparelho com o Home Assistant.
rest:
- resource: http://IP-DA-MERRII:8075/
scan_interval: 15 # segundos entre leituras
timeout: 10
sensor:
- name: "Merrii temperatura"
unique_id: merrii_a31_lm75_temperatura
value_template: "{{ value_json.temperatura_c }}"
# 503 ou resposta estranha = indisponível; nunca repete o último valor
availability: "{{ value_json is defined and value_json.temperatura_c is number }}"
device_class: temperature
state_class: measurement
unit_of_measurement: "°C"
climate:
- platform: generic_thermostat
name: "Merrii termostato"
unique_id: merrii_a31_termostato
heater: &merrii_tomada switch.sua_tomada # a SUA tomada inteligente (troque só aqui)
target_sensor: sensor.merrii_temperatura
initial_hvac_mode: "heat" # começa no modo aquecer a cada reinício do HA
target_temp: 26
min_temp: 15
max_temp: 35
cold_tolerance: 0.3 # o LM75 lê de 0,125 em 0,125 °C; 0,3 evita liga-desliga
hot_tolerance: 0.3
min_cycle_duration: "00:01:00" # a tomada fica pelo menos 1 min em cada estado
precision: 0.1
target_temp_step: 0.5
automation:
# O termostato do HA ignora o sensor "indisponível" e segue com a ÚLTIMA temperatura que viu:
# sem esta automação, uma tomada ligada continuaria ligada com a placa muda.
- id: merrii_a31_sem_leitura_desliga_tomada
alias: "Merrii: sem leitura há 2 min, desliga a tomada"
description: "Segurança do termostato da Merrii (packages/merrii_a31.yaml)."
mode: single
triggers:
- trigger: state
entity_id: sensor.merrii_temperatura
to: "unavailable"
for: "00:02:00"
actions:
- action: homeassistant.turn_off
target:
entity_id: *merrii_tomadaNota: para resfriar com um ventilador, acrescente ac_mode: true e troque initial_hvac_mode para "cool": a lógica se inverte. Para o alvo escolhido na tela sobreviver a um reinício do Home Assistant, apague as linhas target_temp e initial_hvac_mode. O intervalo de 15 segundos foi o do nosso teste; de 30 a 60 segundos, o Home Assistant grava menos no banco de dados.
Atenção: a trava de segurança cobre a placa caindo com o Home Assistant no ar. Se o próprio Home Assistant reiniciar com a placa fora da rede, a automação pode não disparar, e a tomada fica como estava. Com aquecedor, use um aparelho com termostato e proteção próprios: a automação é uma camada a mais, não a única.
Ainda não testamos o fim da corrente com aparelhos de verdade: no nosso teste, a tomada era simulada no Home Assistant. Os próximos passos da bancada são uma tomada inteligente real ligando e desligando pelo termostato e o modo resfriar com um ventilador.
Com um Debian completo na placa, o projeto abre outros caminhos. Os itens abaixo são possibilidades da placa e do sensor, ainda não testadas nesta montagem:
Não. A placa vendida pela Lojamundi sai com o Debian 13 gravado na memória interna (NAND), e o sistema sobe sem cartão.
Não. Desde 2025, o Home Assistant não tem mais instalação para placas ARM de 32 bits. Ele roda em outro computador da rede, e a Merrii entrega a temperatura para ele.
O chip lê em passos de 0,125 °C, e o fabricante indica ±2 °C de −25 a +100 °C. Para comandar um termostato, compare a leitura com um termômetro de referência. Se houver diferença, desconte no value_template do sensor, no packages/merrii_a31.yaml: por exemplo, "{{ value_json.temperatura_c - 0.5 }}" se o LM75 marcar 0,5 °C a mais.
Sim. A Merrii tem Wi-Fi de 2,4 GHz e, na nossa bancada, trabalhou só pelo rádio, sem cabo. Assim dá para levar o sensor ao ambiente que você quer medir. O primeiro acesso é pelo cabo; depois, a rede sem fio se configura pelo SSH, com o wpa_supplicant que já vem no Debian.
Dá. A placa responde a temperatura em JSON por HTTP, e qualquer sistema que leia um endereço da rede, como Node-RED, openHAB ou Zabbix, consegue usar o número.
Pode, mas não pelo cartão: com o Debian na memória interna, a placa ignora o microSD na hora de ligar. Para regravar, é preciso o modo FEL, com o cabo mini-USB ligado a um computador.
Quer montar o seu? A Merrii A31 e o sensor LM75 estão na loja. Dúvidas na montagem? Chame no WhatsApp (11) 2666-4242 ou pelo Fale Conosco. Para clientes Lojamundi, o suporte técnico é gratuito antes e depois da compra.
Ver a Merrii A31Fontes oficiais (consultadas em 14/11/2026): Home Assistant: sensor RESTful · Home Assistant: Generic Thermostat · Home Assistant: pacotes de configuração · Home Assistant: fim do suporte a sistemas de 32 bits (2025) · Debian 13 (trixie) · Kernel Linux: driver lm75
