divisor

Sensor de temperatura com Linux para o Home Assistant

Sensor-Temperatura-Linux-Home-Assistant-blog_image_banner

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.

Como funciona

Diagrama do caminho da temperatura, de cima para baixo: o sensor LM75 mede a temperatura do ambiente e liga por 4 fios (I²C) à placa Merrii A31, com Debian 13 na memória interna; a placa manda a leitura a cada 15 s, pela rede ou Wi-Fi, ao Home Assistant, em outro computador da rede; o Home Assistant liga e desliga a tomada inteligente, que comanda o ventilador ou o aquecedor.
A placa mede, o Home Assistant decide e a tomada inteligente liga ou desliga o aparelho.
  • •O LM75 mede a temperatura do ambiente e conversa com a placa pelo barramento I²C: dois fios de sinal e dois de alimentação.
  • •A Merrii A31 lê o sensor no Debian e responde a temperatura pela rede, com cabo ou Wi-Fi.
  • •O Home Assistant, num computador da casa ou da empresa, consulta a placa a cada 15 segundos e usa o número num termostato.
  • •O termostato liga e desliga uma tomada inteligente, e nela vai o ventilador ou o aquecedor. O ar-condicionado entra por outro caminho, explicado logo abaixo.

Que aparelho ligar na tomada inteligente

  • •Funciona pela tomada: o aparelho que volta a ligar sozinho quando a energia volta, como um ventilador ou um aquecedor de chave mecânica (o botão fica na posição ligado). Aparelho de botão eletrônico ou de controle remoto costuma voltar desligado, e aí a tomada não adianta.
  • •A tomada precisa aguentar o aparelho: confira a corrente máxima impressa na tomada inteligente (10 A, por exemplo) e a potência do aparelho. Um aquecedor de 1.500 W puxa cerca de 12 A em 127 V e 7 A em 220 V.
  • •Ar-condicionado não vai na tomada: o compressor precisa de alguns minutos parado entre um ciclo e outro, e o aparelho de controle remoto não volta a ligar sozinho. O caminho é a integração do próprio ar com o Home Assistant (muitos modelos com Wi-Fi têm), com a temperatura da Merrii numa automação. Esse caminho ainda não testamos.

A placa: Merrii A31 com Debian 13 na memória interna

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.

Processador
Allwinner A31, 4 núcleos ARM Cortex-A7 (32 bits)
Memória
1 GB DDR3
Armazenamento
8 GB NAND, com cerca de 3,6 GB úteis no Linux
Sistema
Debian 13 (trixie), com o kernel 6.12 do próprio Debian
Rede
Gigabit Ethernet e Wi-Fi 2,4 GHz
Expansão
Conector J11 de 60 pinos, com passo de 2,0 mm
Funciona no Debian
Rede gigabit, Wi-Fi 2,4 GHz (cliente), I²C do J11 (onde entra o LM75) e console no HDMI (texto, 1080p)
Sem suporte no Debian
Bluetooth, aceleração gráfica (GPU), saída VGA, entrada CVBS, câmera (CSI), SPI e UART do J11, troca de resolução e áudio pelo HDMI; o infravermelho só recebe
Idioma
Português do Brasil, teclado ABNT2 e fuso de São Paulo
Alimentação
12 V DC (fonte recomendada: 12 V, 3 A)

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.

Ver a Merrii A31 na loja →

O sensor: LM75 da NXP

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.

Chip
NXP LM75, no endereço I²C 0x48
Resolução
0,125 °C (11 bits)
Faixa
−55 a +125 °C
Precisão
±2 °C de −25 a +100 °C; ±3 °C de −55 a +125 °C (dados do fabricante)
Alimentação
2,8 a 5,5 V
Extra
Saída de alarme (OS), que muda de estado sozinha num limite programado

Ver o sensor LM75 na loja →

Lista de materiais

  • ✓Placa Merrii A31, com o Debian 13 na memória interna
  • ✓Sensor de temperatura LM75
  • ✓4 jumpers com fêmea de 2,0 mm na ponta da placa e macho de 2,54 mm na ponta do sensor
  • ✓Fonte de 12 V DC (recomendada: 3 A) e um dissipador para o processador
  • ✓Um cabo de rede, para o primeiro acesso
  • ✓Um computador na rede com o Home Assistant (PC, mini PC ou placa de 64 bits)
  • ✓Uma tomada inteligente que o Home Assistant controle, com corrente para o seu aparelho
  • ✓Um multímetro, para conferir a ligação antes de energizar

Como ligar o sensor no J11

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.

Diagrama da face de baixo da Merrii A31 com o conector J11, passo de 2,0 mm: o pino 59 (3 V) vai ao VCC do módulo LM75, o 46 ao SDA, o 44 ao SCL e o 42 ao GND; o contato OS do módulo fica livre. Os pinos 1 e 2 têm 5 V e não devem ser usados.
Ligação do LM75 no J11, na face de baixo da Merrii: pinos 59 (3 V), 46 (SDA), 44 (SCL) e 42 (GND).

Ligação do sensor LM75 no conector J11 da Merrii A31

FunçãoPino no J11No módulo
Alimentação 3 V59VCC
Dados (SDA)46SDA
Relógio (SCL)44SCL
Terra (GND)42GND
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.

Fios: o detalhe que faz o I²C funcionar

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.

Dois quadros. Errado: um par de fios com o SDA trançado no SCL. Certo: uma fita de quatro vias na ordem SDA, VCC, GND e SCL, com os dois sinais separados pela alimentação e pelo terra.
SDA e SCL nunca juntos: separe os dois sinais com a alimentação e o terra.

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.

Checklist antes de energizar (com multímetro)
  1. Identifique os contatos do módulo pelo chip, com o multímetro em continuidade: o contato que apita com a perna 8 do chip é o VCC, a perna 4 é o GND, a 1 é o SDA, a 2 é o SCL e a 3 é o OS. A perna 1 fica junto da marca (a bolinha) do chip; essa numeração é a da folha de dados da NXP.
  2. Com a placa desligada e fora da tomada, meça continuidade entre o pino 42 e os pinos 29 ou 30 (marcados "29 30" na serigrafia, ambos terra): deve apitar.
  3. Ainda sem energia, confira que os pinos 44 e 46 não apitam com o terra nem entre si, e que o pino 1 não apita com o 3: 5 V e 3 V são separados.
  4. Encaixe um jumper no pino 59 e outro no 42, prenda as pontas soltas separadas com fita isolante e só então ligue a fonte. Meça nas pontas soltas: cerca de 3,0 V. Perto de 5 V significa jumper no pino errado; desligue e refaça.
  5. Desligue, conecte o módulo (VCC, SDA, SCL e GND) e ligue de novo. Encoste o dedo no chip do sensor por 30 segundos: se ele esquentar, tire a fonte na hora e reveja a ligação.

Primeiro acesso: rede e SSH

  1. Ligue a Merrii no roteador pelo cabo de rede e depois na fonte de 12 V. O primeiro acesso é pelo cabo; o Wi-Fi se configura depois.
  2. A placa pega o endereço pelo DHCP do roteador e se apresenta na rede com o nome merrii-a31.local. Se o seu computador não encontrar esse nome, procure o IP da placa na lista de aparelhos conectados do roteador.
  3. O usuário e a senha iniciais vêm num cartão dentro da caixa da placa. Do computador, entre por SSH trocando USUARIO pelo usuário do cartão: ssh USUARIO@merrii-a31.local.
  4. Troque a senha logo no primeiro acesso, com o comando passwd.
  5. Para usar o Wi-Fi (só 2,4 GHz), configure a rede sem fio por esse mesmo SSH, com o passo a passo logo abaixo. Com o Wi-Fi funcionando, o cabo pode sair.
Passo a passo do Wi-Fi

É 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.

Conferir o serviço de rede
systemctl is-active systemd-networkd

Depois, abra o arquivo da rede sem fio no editor:

Criar o arquivo da rede
sudo nano /etc/wpa_supplicant/wpa_supplicant-wlan0.conf

Cole o bloco abaixo, trocando o nome e a senha pelos da sua rede (mantenha as aspas), e salve:

/etc/wpa_supplicant/wpa_supplicant-wlan0.conf
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:

Ligar o Wi-Fi da Merrii
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 reload

Confira 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:

Conferir o Wi-Fi
sudo iw dev wlan0 link
ip -4 addr show wlan0

Por 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.

Primeira leitura no Debian

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.

Registrar o LM75 e ler a temperatura
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_input

A 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.

A temperatura na rede: o serviço que conversa com o Home Assistant

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.

Resposta da placa a um GET na porta 8075
{"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.

O script /usr/local/sbin/merrii-lm75
merrii-lm75
#!/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
Os três arquivos do systemd
merrii-lm75.service — registra o sensor a cada boot
[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-http.socket — escuta a porta 8075
# 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-http@.service — responde uma conexão
# 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=yes

Para instalar, crie os quatro arquivos numa pasta da placa (o editor nano já vem no Debian) e, dentro dela, rode:

Instalar o serviço na Merrii
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 estado

O ú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:

Teste em outro computador da rede
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.

No Home Assistant: sensor, termostato e trava de segurança

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:

configuration.yaml
homeassistant:
packages: !include_dir_named packages

E 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
# 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_tomada
  • •Sensor (rest): busca a temperatura a cada 15 segundos. Se a resposta não trouxer um número, o sensor fica indisponível.
  • •Termostato (generic_thermostat): no modo aquecer, liga a tomada abaixo do alvo menos 0,3 °C e desliga acima do alvo mais 0,3 °C. A tomada fica pelo menos 1 minuto em cada estado.
  • •Trava de segurança (automação): se o sensor ficar 2 minutos indisponível, desliga a tomada. Ela existe porque o termostato do Home Assistant segue com a última temperatura que viu quando o sensor some.

Nota: 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.

O que testamos na bancada

  • ✓Leitura do LM75: 180 leituras seguidas, uma por segundo, sem erro, com resolução de 0,125 °C.
  • ✓Reinício da placa: o sensor e o serviço voltam sozinhos, sem intervenção.
  • ✓Home Assistant: o sensor recebe a temperatura da placa a cada 15 segundos.
  • ✓Sensor sem leitura: o Home Assistant mostra "indisponível", sem repetir o último valor.
  • ✓Placa fora da rede: a trava de segurança disparou em 2 minutos exatos.
  • ✓Wi-Fi: a placa trabalhou só pelo Wi-Fi de 2,4 GHz, sem o cabo de rede.

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.

Ideias para ir além

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:

  • •Ventilador para resfriar: o mesmo termostato, no modo resfriar.
  • •Ar-condicionado: pela integração Wi-Fi do próprio aparelho com o Home Assistant, com a temperatura da Merrii numa automação.
  • •Sala de servidores, rack ou CPD: uma automação do Home Assistant avisa quando a temperatura passa do limite.
  • •Outros sistemas: a resposta é JSON por HTTP, que Node-RED, openHAB, Zabbix ou um script qualquer conseguem ler.
  • •Na própria placa: um script do systemd ou do cron reage à temperatura, guarda um histórico ou dispara um aviso.
  • •Alarme por hardware: a saída OS do LM75 muda de estado sozinha num limite programado (de fábrica, 80 °C), mesmo sem software.

Perguntas frequentes

A Merrii A31 precisa de cartão microSD?

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.

O Home Assistant roda na própria Merrii?

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.

Qual é a precisão do LM75?

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.

A placa funciona pelo Wi-Fi?

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á para usar outro programa no lugar do Home Assistant?

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.

Posso trocar o sistema da placa depois?

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 A31

Fontes 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

Acesso VIP Gratuito

Faça parte do Grupo VIP da Lojamundi no WhatsApp

Junte-se a profissionais e empresas que já recebem ofertas exclusivas, cupons secretos e promoções em primeira mão de equipamentos de telefonia, rede e segurança.

Descontos Exclusivos

Preços especiais e condições de pagamento liberadas apenas para membros do grupo.

Ofertas Relâmpago

Acesso antecipado a queimas de estoque, lançamentos e promoções com tempo limitado.

Conteúdo Selecionado

Sem spam. O grupo é silencioso e focado em enviar apenas oportunidades valiosas ao seu negócio.

🔒 Seus dados estão seguros e você pode sair a qualquer momento.

Divisor Triangular
POR QUE A LOJAMUNDI É CONFIÁVEL?
selo de verificação reclame aqui da lojamundiselo google site seguroselo reclame aqui com link de acessoselo https seguroselo let's encrypt

ENTRE EM CONTATO COM A LOJAMUNDI.
Fanvil X1S — telefone IP custo-benefício