Engenharia reversa da bomba Dancor Jet Comfort Inverter 40: do Wi-Fi escondido ao Home Assistant

A placa do controlador, com o módulo HF-LPT230 no centro (IC5). Borrei a etiqueta do módulo porque ela traz o MAC.

Comprei uma bomba pressurizadora para resolver um problema de pressão aqui em casa e acabei passando algumas semanas fazendo engenharia reversa dela. Este post conta essa história: o módulo Wi-Fi escondido que encontrei lá dentro, como decodifiquei o protocolo só olhando o tráfego da rede, os problemas de segurança que apareceram no caminho e como a bomba terminou integrada ao meu Home Assistant sem mandar nenhum dado para fora de casa.

O texto é longo e bem técnico. Se você só quer saber se a sua bomba está mandando dados para a China (está, se você configurou o Wi-Fi dela) e como evitar isso, pule para a seção de segurança.

Como tudo começou

A pressão da água aqui sempre foi fraca. Quando subimos o novo pavimento, ficou pior: em alguns pontos a água simplesmente não chegava. Depois de pesquisar um pouco, comprei uma Dancor Jet Comfort Inverter 40, uma bomba de 1 CV com inversor de frequência. A graça dela é manter a pressão constante, acelerando ou desacelerando o motor conforme o consumo, em vez de ficar ligando e desligando a pleno.

Como a casa é praticamente toda automatizada, eu queria ver essa bomba no Home Assistant. Saber quando ela liga, se está ligando demais, se acusou algum erro. A ideia original era abrir o equipamento e colocar um ESP32 lendo a serial do controlador.

Abri a tampa e tive a primeira surpresa. Já tinha um módulo Wi-Fi soldado na placa, e ele estava anunciando uma rede sem fio aberta, sem senha. Não há uma linha sobre isso no manual, na caixa ou no painel, e a Dancor não tem aplicativo.

A placa do controlador, com o módulo HF-LPT230 no centro (IC5). Borrei a etiqueta do módulo porque ela traz o MAC.
A placa do controlador, com o módulo HF-LPT230 no centro (IC5). Borrei a etiqueta do módulo porque ela traz o MAC.

Na etiqueta estava escrito HF-LPT230 VER2.0, um módulo serial-Wi-Fi da High-Flying que aparece em muito equipamento chinês. A placa é uma LDT-A3, de um fabricante OEM chinês. A Dancor coloca a marca dela, mas o projeto eletrônico vem de fora. Pesquisando com a ajuda de IA, cheguei à conclusão de que o recurso sem fio está ali sem uso no produto vendido no Brasil, provavelmente esperando uma futura linha “smart”. O hardware já veio pronto. Faltava só o software.

Então mudei de plano: esquecer o ESP32 e descobrir o que esse módulo falava.

Uma regra antes de começar

Esse controlador não tem documentação pública nem suporte, e eu não faço ideia de como recuperá-lo se algo der errado. Por isso, durante toda a fase de descoberta, eu me impus uma regra simples: só observar. Nenhum byte enviado ao controlador e nenhuma configuração alterada no módulo. A primeira coisa que fiz foi ler e guardar a configuração original do módulo, porque um reset de fábrica apagaria o endereço do servidor do fabricante e eu não teria como descobri-lo de novo.

Também tentei ser disciplinado com as hipóteses. Antes de cada experimento eu escrevia o que esperava ver, para não ficar interpretando o resultado depois do fato. Isso me salvou mais de uma vez, como você vai ver.

Conversando com o módulo

Os módulos da High-Flying têm um canal de configuração separado do canal de dados, via UDP na porta 48899. Você manda a string HF-A11ASSISTHREAD, o módulo responde com IP, MAC e modelo, você manda um +ok e ele passa a aceitar comandos AT+. Escrevi uma ferramentinha que só permitia consultas e recusava qualquer comando de escrita. Um pedaço do que ela trouxe:

AT+MID      → +ok=HF-LPT230
AT+VER      → +ok=4.13.26 (2020-03-31 11:00 1M)
AT+APPVER   → +ok=v1.05 BangYi (2020-04-21)      ← build customizada do OEM
AT+NETP     → +ok=TCP,Client,8866,app.prodnzk.com
AT+UART     → +ok=9600,8,1,None,NFC
AT+TMODE    → +ok=throughput                     ← ponte transparente
AT+SOCKB    → +ok=NONE
AT+TCPTO    → +ok=300
AT+WEBU     → +ok=admin,admin                    ← login da página web do módulo
AT+NTPSER   → +ok=cn.ntp.org.cn
AT+NTPTM    → +ok=Not Available
AT+HEART    → +ERR=-3                            ← nem existe nessa build
AT+MQTT...  → (sem resposta)

Com essas poucas linhas deu para montar quase toda a arquitetura. O módulo é um cliente TCP que se conecta em app.prodnzk.com na porta 8866, um endereço que aponta para a Alibaba Cloud em Hangzhou. Ele está em modo “throughput”, que é o modo mais burro possível: pega o que chega pela serial (9600 8N1) e joga no TCP, e vice-versa. Não acrescenta cabeçalho, heartbeat nem nada. De quebra, descobri que a página web dele usa admin / admin e que ele nem sabe que horas são.

Como a bomba fala com a nuvem, antes de qualquer alteração.
Como a bomba fala com a nuvem, antes de qualquer alteração.

A parte boa disso tudo é que o conteúdo da conexão TCP é exatamente o que passa na serial do controlador. Capturar a conexão é o mesmo que grampear a serial com fios, só que sem abrir nada e sem risco nenhum.

Capturando com um roteiro na mão

A bomba fica numa VLAN de IoT, e todo o tráfego dela passa pelo meu firewall (OPNsense), que tem captura de pacotes embutida. Uma dica que me custou uma captura inteira: os campos Packet Length e Count precisam estar em zero. O padrão corta o payload e para a captura depois de 100 pacotes.

O que realmente fez diferença foi não capturar “no escuro”. Bytes sem contexto não dizem nada. Então montei um roteiro de uns 25 minutos e fui seguindo com o celular na mão, anotando o que o display mostrava e o horário de cada ação:

FaseO que eu fizPara quê
Anada, bomba em repousover quais bytes nunca mudam
Babri uma torneira todamarcar no tempo o momento em que o motor liga
Cdeixei abertapressão estável com consumo
Dfechei a torneiramarcar o desligamento
Enada de novover a pressão caindo devagar
Fabri só um fio d’águavazão baixa, ciclos curtos

O quadro de status

A primeira captura trouxe 344 mensagens da bomba, todas com exatamente 58 bytes, chegando a cada 5 segundos. Do servidor vieram 344 respostas de 16 bytes, todas iguais. Não era Modbus nem nada que eu conhecesse, mas também não tinha criptografia. Um exemplo (troquei o MAC por um fictício e recalculei as verificações, então o quadro continua válido):

5a 5c 3a 00 00 00 9a 78 56 34 12 02 01 80 0a 27
00 df fd 27 98 01 01 00 02 c8 00 03 c8 00 04 14
00 05 00 00 06 00 00 07 02 00 08 00 00 09 50 00
0a 03 00 0b 00 00 d7 de de a5
O quadro de status de 58 bytes, colorido por função.
O quadro de status de 58 bytes, colorido por função.

A estrutura apareceu aos poucos, comparando quadros. O que nunca mudava era cabeçalho, e o que mudava junto com o display era dado. O quadro abre com 5A e fecha com A5. O segundo byte é o tipo e o terceiro é o tamanho total (58, ou 3A), um detalhe que mais tarde fez toda a diferença. Do byte 6 ao 11 está o MAC do módulo, de trás para frente. Depois vem um bloco fixo de 9 bytes e, a partir do byte 21, onze registros de 3 bytes no formato índice, valor baixo, valor alto. Isso é um TLV clássico. Fecham o quadro duas somas de verificação e uma constante DE.

Os onze campos do exemplo, já decodificados.
Os onze campos do exemplo, já decodificados.

As verificações

Meu primeiro chute foi CRC-16, como no Modbus, e errei. O que me deu a pista foi perceber que o byte 54 subia e descia sempre na mesma medida que a soma dos dois únicos campos que variavam. Em todas as amostras, byte 54 − pressão − estado dava o mesmo número, e isso só acontece com uma soma simples. Eram duas: uma só sobre o bloco de dados e outra sobre o quadro inteiro.

As duas somas de 8 bits que fecham o quadro.
As duas somas de 8 bits que fecham o quadro.

As duas regras conferem em todos os 107 quadros diferentes que capturei, e depois valeram também para o quadro de comando, do qual falo mais adiante. No fim, o decodificador inteiro coube nisto:

def soma8(b):
    return sum(b) & 0xFF

def decodifica_status(q: bytes) -> dict:
    n = q[2]                                  # tamanho declarado (58)
    assert q[0] == 0x5A and q[1] == 0x5C and q[n - 1] == 0xA5 and len(q) == n
    assert q[n - 4] == soma8(q[17:n - 4])     # bloco de dados
    assert q[n - 2] == soma8(q[:n - 2])       # quadro inteiro
    tlv = {q[i]: q[i + 1] | q[i + 2] << 8 for i in range(21, n - 4, 3)}
    return {
        "motor":      bool(tlv[0x01] & 0x02),
        "vazamento":  bool(tlv[0x01] & 0x08),
        "falha":      bool(tlv[0x01] & 0x10),
        "pressao":    tlv[0x02] / 100,        # kgf/cm²
        "alvo":       tlv[0x03] / 100,
        "modo":       {0: "enchendo a caixa", 1: "pressurizador ↓",
                       2: "pressurizador ↑"}.get(tlv[0x07]),
        "religa_pct": tlv[0x09],
        "erro":       tlv[0x0B],              # 1 = E01
    }

Provando o que cada campo significa

Achar um campo que varia é fácil. Difícil é provar o que ele mede. Foi aí que as anotações do roteiro pagaram o esforço. Cruzei quadro a quadro com as 40 leituras que eu tinha anotado (os relógios ficaram a menos de um segundo de diferença) e as duas hipóteses principais bateram em todas:

H1  pressão = campo 0x02 / 100 kgf/cm²  ....  40/40  (100%)
H2  estado 3 = ligada / 1 = parada      ....  40/40  (100%)

Bateu até em valores quebrados como 1,98, 1,99, 2,07 e 2,08, então não era sorte de arredondamento.

A captura do roteiro: pressão em azul, alvo em laranja e, em verde, os períodos com o motor ligado.
A captura do roteiro: pressão em azul, alvo em laranja e, em verde, os períodos com o motor ligado.

O gráfico acabou me ensinando como a bomba controla a pressão. Com o motor ligado, a pressão fica grudada no alvo, que é o inversor fazendo o trabalho dele. Quando o consumo passa do que ele consegue acompanhar, a pressão dá uma caída (chegou a 1,58 na fase F) e volta em segundos. Ao fechar a torneira, o motor ainda trabalhou uns 9 segundos e levou a pressão até 2,10, 5% acima do alvo, antes de desligar. Para religar, com tudo parado, ele espera a pressão cair até mais ou menos o alvo vezes o parâmetro b01, que estava em 80%.

Experimentos pelo painel

Com pressão e estado resolvidos, sobravam nove campos que nunca mudavam. A única forma de descobrir o que eram foi mexer nas configurações, sempre pelo painel da própria bomba, que é o uso normal do produto. Cada teste tinha uma previsão escrita antes.

O que eu mudei no painelO que eu esperavaO que aconteceu
Pressão de trabalho de 2,0 para 1,30x03 ir de 200 para 130Foi, e ainda mostrou o valor intermediário 165 enquanto eu apertava o botão
Os três modos de trabalhoalgum campo mudar0x07: 0 enchendo a caixa, 1 pressurizador ↓, 2 pressurizador ↑. Cada modo guarda o próprio alvo
Parâmetro b01 de 80% para 75%0x09 ir de 80 para 75Foi, na hora
Parâmetro b06 (unidade do display)algum campo ir de 0 para 1Nada mudou. O b06 só afeta o display

O estado é um campo de bits

Por um tempo achei que 0x01 fosse uma lista de estados: 1 parada, 3 ligada. Aí apareceram 9, 11 e 17. O 11 matou a dúvida, porque era o motor ligado e o alarme de vazamento ao mesmo tempo, algo que uma lista simples não representaria. São bits independentes.

O campo 0x01 bit a bit, com todos os valores que vi.
O campo 0x01 bit a bit, com todos os valores que vi.

O bit de vazamento eu descobri por acaso: havia um vazamento de verdade num cano. O bit 3 acendeu junto com o LED do painel e apagou quando o cano foi fechado. Ele acende uns 10 segundos depois que o motor para, o que me faz pensar que o controlador mede a queda de pressão em repouso para concluir que tem água escapando.

O vazamento aparecendo no protocolo. A faixa azul embaixo mostra quando o bit 3 esteve ativo.
O vazamento aparecendo no protocolo. A faixa azul embaixo mostra quando o bit 3 esteve ativo.

O bit de falha eu provoquei de propósito, ligando a bomba de 220 V numa tomada de 110 V. Parece arriscado, mas o manual prevê essa situação e o equipamento se protege (é o erro E01, tensão abaixo de 130 V). O painel mostrou E01, o bit 4 acendeu e o campo 0x0B foi para 1. Ou seja, 0x0B carrega o número do erro.

O erro E01 provocado. A faixa vermelha mostra o bit de falha ativo.
O erro E01 provocado. A faixa vermelha mostra o bit de falha ativo.

O que não vem no protocolo

Eu tinha esperança de ler rotação, corrente e temperatura. O controlador mede tudo isso (o manual tem erros específicos para tensão, corrente e temperatura), mas não manda nada para a nuvem. Fiz uma ferramenta que tentava reconstruir cada quadro de 58 bytes usando só estado, pressão, alvo e modo, e ela conseguiu em todas as capturas, sem sobrar um byte. Além disso, durante 28 minutos em que a rotação do motor comprovadamente variou, todos os outros campos ficaram parados. Não tem RPM, frequência, tensão, corrente, temperatura, horímetro nem contador de partidas.

Do boot ao primeiro dado

Uma captura sem filtro, ligando a bomba na tomada, mostrou a conexão inteira:

O que acontece nos primeiros segundos depois de ligar a bomba.
O que acontece nos primeiros segundos depois de ligar a bomba.

O tal “registro” é só um quadro de 16 bytes com o MAC, que o servidor devolve igualzinho. Esse mesmo quadro serve de confirmação depois de cada status. Não tem chave, senha, desafio nem versão de firmware. A única identidade na conversa toda é o MAC.

Foi nessa captura que apareceu um segundo canal: a cada 5 segundos o módulo manda um broadcast UDP na porta 12476 com um JSON do tipo {"deviceInfo":{"deviceType":"gh_…","deviceId":"<MAC>"}}. Esse prefixo gh_ é de conta oficial do WeChat, e a porta é a de descoberta de dispositivos da plataforma de hardware deles. Foi aí que entendi que o produto nasceu para o mercado chinês. Esse broadcast nunca mudou, nem durante falhas, então dá para ignorar.

O truque do DNS

Como a bomba é cliente e descobre o IP do servidor pelo DNS da minha rede, eu não precisava mexer nela para trazê-la para casa. Bastou criar no roteador um override dizendo que app.prodnzk.com é o IP de uma máquina minha.

Antes e depois do override de DNS. A bomba não percebe a diferença.
Antes e depois do override de DNS. A bomba não percebe a diferença.

No começo montei um relay que recebia a conexão da bomba, repassava tudo para a nuvem verdadeira e anotava os bytes no caminho. Com isso eu podia comparar o relay com a captura do firewall e ter certeza de que nada se perdia. Aprendi algumas coisas na marra nessa fase.

O módulo guarda o IP em cache enquanto estiver ligado, então mudar o DNS não adianta sozinho. Derrubar a conexão não resolve, porque ele reconecta no mesmo IP guardado. O jeito garantido é desligar a bomba da tomada e ligar de novo. O timeout de 300 segundos que aparece na configuração conta o silêncio do servidor, não o da bomba: se ninguém responde, o módulo troca de conexão a cada cinco minutos. E ele abandona as conexões velhas sem fechá-las, então o servidor precisa fazer essa limpeza, senão elas se acumulam às centenas por dia. A boa notícia é que a bomba continua mandando dados mesmo sem nenhuma resposta, então cortar a nuvem de vez não quebra nada.

TCP não é serial

Esse bug foi meu. A primeira versão do monitor tratava cada pacote TCP como um quadro. Numa reconexão chegou um pacote de 870 bytes, que eram 15 quadros de 58 grudados, todos válidos. O monitor jogou os 15 fora sem dizer nada.

Por que o parser precisa de um buffer e precisa ler o tamanho do quadro.
Por que o parser precisa de um buffer e precisa ler o tamanho do quadro.

A correção foi usar um buffer contínuo e cortar os quadros pelo 5A, pelo tamanho declarado e pelo A5. Ela acabou rendendo mais do que eu esperava. Como o parser passou a ler o tamanho em vez de assumir 58, mais tarde ele reconheceu de primeira um tipo de quadro que eu nem sabia que existia.

O comando que eu achava que não existia

Em mais de mil quadros capturados, o servidor nunca tinha mandado nada além da mesma resposta de 16 bytes. Concluí que a bomba era só leitura e cheguei a registrar isso como decisão do projeto. Estava errado. Eu tinha medido que ninguém estava comandando a bomba e generalizei para “ninguém consegue comandá-la”.

O que mudou foi encontrar o aplicativo Android oficial do fabricante chinês. Instalei, operei a bomba por ele com a captura rodando, e cada toque no app gerava, segundos depois, um quadro novo indo da nuvem para a bomba, seguido da mudança na telemetria. Juntei 36 quadros de comando, 12 diferentes, todos com as somas certinhas.

Os quadros de registro (16 bytes) e de comando (28 bytes). No comando, só o trecho verde e as somas mudam.
Os quadros de registro (16 bytes) e de comando (28 bytes). No comando, só o trecho verde e as somas mudam.

O comando começa igual ao status, inclusive com o mesmo byte de tipo, e só o tamanho (28) o diferencia. Ele leva um único campo e não tem contador, carimbo de tempo nem assinatura: o mesmo comando mandado duas vezes é exatamente igual. Com eles deu para gravar pressão-alvo, modo, religamento e tempo de enchimento. Esse último, aliás, é um código e não uma quantidade de horas: 0,5 h vira 1, enquanto 3, 6 e 12 h viram 3, 6 e 12.

O campo 0x08 foi o mais curioso. Ele liga e desliga o motor na marra, passando por cima da lógica de controle. Com a torneira aberta e a pressão em 0,32 (o alvo era 1,00), a bomba parou. Um segundo comando a religou. Cada toque no app gera uma rajada de 4 ou 5 quadros iguais, e a bomba entende como um só. Depois de uma parada manual ela ficou 50 segundos sem transmitir nada, o que para qualquer monitor parece uma desconexão.

Duas coisas me deixaram mais tranquilo. A primeira é que o controlador valida o que recebe: o app aceitou religamento de 0%, a nuvem repassou o 0 e a bomba aplicou 10%, o mínimo dela. Um pedido de 5% foi simplesmente ignorado. A segunda me deixou menos tranquilo com o app. Numa das sessões ele continuou mostrando a bomba ligada a 1,00 por mais de um minuto depois da parada manual, enquanto a própria bomba já informava 0,32 e motor parado. A nuvem tinha parado de ler os dados, mas continuava repassando comandos.

Segurança: o que todo dono dessa bomba deveria saber

Foi essa parte que me fez querer publicar tudo.

O caminho de um comando, e onde falta segurança nele.
O caminho de um comando, e onde falta segurança nele.

Enquanto não é configurado, o módulo deixa uma rede Wi-Fi aberta, sem senha, ao alcance de qualquer um por perto. A página de configuração dele usa admin / admin, e o canal de comandos AT na porta UDP 48899 aceita reconfiguração sem pedir senha nenhuma.

Se você coloca a bomba na rede da sua casa (que é o que a maioria faria ao descobrir que ela tem Wi-Fi), ela passa a mandar para um servidor na China, a cada 5 segundos, o estado de funcionamento, a pressão, os alarmes e o MAC. Nada no produto avisa isso ou pede consentimento.

Nada disso é criptografado. O protocolo da bomba trafega em texto claro, e o app oficial faz login mandando usuário e senha dentro da URL, em HTTP puro. Nas chamadas que capturei, a consulta do estado de um equipamento na API do fabricante leva só o MAC, sem token e sem sessão, e MAC não é segredo. Por cautela, não vou publicar os endereços exatos dessas chamadas.

Por fim, a bomba obedece a quem estiver do outro lado da conexão TCP. Quem responder no lugar da nuvem, seja a própria nuvem ou alguém que adulterou o DNS da sua rede, consegue mudar a pressão e ligar ou desligar o motor.

Como se proteger

O que dá para fazer, do mais simples ao mais avançado.
O que dá para fazer, do mais simples ao mais avançado.

O que eu usei, e recomendo, é o override de DNS: apontar app.prodnzk.com para um servidor seu, que pode ser o Home Assistant ou o monitor que mostro abaixo. Não exige mexer na bomba, dá para desfazer em um clique e corta a nuvem de vez. Depois de criar o override, desligue a bomba da tomada e ligue de novo, por causa do cache.

Vale também bloquear no firewall a saída da bomba para a internet, ou pelo menos para 47.98.32.0/24. Assim, mesmo que um dia o módulo use outro DNS, ele não consegue sair. Se você tem como separar a rede de IoT numa VLAN, melhor ainda: deixe a bomba falar apenas com o seu servidor na porta 8866.

Quem quiser ir além pode reconfigurar o próprio módulo com AT+NETP=TCP,Client,8866,<IP do seu servidor>, que faz ele conectar direto em você sem depender de DNS. Testei e funciona, mas leia e anote o valor original antes (AT+NETP), e nunca use AT+RELD: o reset de fábrica apaga essa configuração e você fica sem saber para onde ela apontava.

E se você não vai usar o Wi-Fi da bomba, não deixe aquela rede aberta disponível para sempre.

O monitor web

A primeira coisa que construí foi um painel web local. O backend é em FastAPI e o frontend em Vite com TypeScript, e o histórico fica em SQLite. Ele recebe a conexão da bomba e mostra tudo em tempo real. As telas abaixo são da minha bomba, rodando agora (escondi o MAC e o IP).

A tela principal: pressão atual, alvo, ponto de religamento, modo e os indicadores.
A tela principal: pressão atual, alvo, ponto de religamento, modo e os indicadores.
A mesma tela no tema claro.
A mesma tela no tema claro.
Pressão ao longo do tempo e quantas vezes o motor ligou em cada período.
Pressão ao longo do tempo e quantas vezes o motor ligou em cada período.

O painel também controla a bomba, mas fiz isso com bastante cuidado. Cada comando é montado no servidor e mostrado byte a byte antes de sair, separando o que foi copiado de quadros reais do que foi calculado. Nada é enviado sem um segundo clique de confirmação, e os limites de cada campo são os que eu medi no equipamento.

Um comando de pressão-alvo preparado, mas não enviado. Escondi os bytes do MAC.
Um comando de pressão-alvo preparado, mas não enviado. Escondi os bytes do MAC.
O diagnóstico da conexão, com o bloco de dados bruto do último quadro.
O diagnóstico da conexão, com o bloco de dados bruto do último quadro.

Tem também uma seção de “descobertas” que registra qualquer coisa que o protocolo traga e eu ainda não conheça, como um bit novo, um modo desconhecido ou um código de erro inédito. Foi ali que apareceu um código de erro 8, mais de uma vez. Pelo manual seria E08 (sobrecorrente ou rotor travado), mas ainda não consegui confirmar isso olhando o painel. Por isso o sistema mostra o número cru e marca o texto do manual como não verificado.

A integração com o Home Assistant

O objetivo final sempre foi o Home Assistant. A integração é do tipo local_push: o Home Assistant abre a porta 8866, a bomba se conecta nele graças ao override de DNS, e cada quadro que chega atualiza as entidades na hora. Não tem polling nem nuvem. Ela instala pelo HACS, e o código está em github.com/jmceara/dancor_pumps.

A integração instalada pelo HACS.
A integração instalada pelo HACS.
A página do dispositivo no Home Assistant, com controles, sensores e configuração. Borrei o MAC.
A página do dispositivo no Home Assistant, com controles, sensores e configuração. Borrei o MAC.

Ela traz a pressão e o ponto de religamento como sensores, além do modo, do tempo de enchimento e do código de erro. Este sempre aparece como o número que a bomba mandou, com o texto do manual num atributo à parte. Os alarmes de motor, vazamento, falha e falta d’água viram sensores binários. Pela interface dá para mudar a pressão-alvo (de 0,05 em 0,05, igual ao painel), o modo, o religamento e o tempo de enchimento. O botão manual do motor vem desabilitado de fábrica, porque não quero que uma automação mal escrita desligue a bomba às três da manhã.

Como o protocolo não tem contadores, a integração calcula alguns: tempo de motor ligado, tempo com vazamento ou falha, e quantas vezes o motor partiu no total e nos últimos 15 minutos, 30 minutos, 1 hora e 24 horas. Esse último é ótimo para pegar vazamento pequeno, daqueles que fazem a bomba ligar sozinha de madrugada.

Os contadores calculados pela integração, na seção de diagnóstico.
Os contadores calculados pela integração, na seção de diagnóstico.

Esses números são da minha bomba. São 2.368 partidas desde que a integração começou a contar, 30 nas últimas 24 horas e mais de 24 horas acumuladas com o alarme de vazamento aceso. No histórico dá para ver a pressão caindo devagar com a bomba parada até chegar perto do ponto de religar. Quando isso acontece de madrugada, sem ninguém usando água, é sinal de que tem água escapando em algum lugar, que é justamente o que o alarme de vazamento do controlador tenta detectar.

Quase um dia de pressão no Home Assistant, com o alvo em 1,7 kgf/cm². Repare nas descidas lentas com a bomba parada.
Quase um dia de pressão no Home Assistant, com o alvo em 1,7 kgf/cm². Repare nas descidas lentas com a bomba parada.

As pressões ficam em kgf/cm², a mesma unidade do painel. Comecei usando bar, mas o controle deslizante em bar não conseguia acertar a grade de 0,05 kgf/cm² do controlador, e valores como 2,30 e 3,70 simplesmente não dava para escolher.

Uma regra que segui em tudo: a entidade mostra o que a bomba informa, nunca o que você pediu. A bomba não confirma comandos, ela só passa a mandar o valor novo no quadro seguinte. Se ela limitar o que você pediu, o Home Assistant mostra o valor limitado.

Alguns bastidores

Guardei todas as capturas e os vetores de teste reais (107 quadros de status e 12 de comando) e escrevi uma especificação pensada para que alguém consiga implementar um cliente do zero, sem ter a bomba. As decisões importantes ficaram registradas como ADRs, inclusive as que se provaram erradas depois, como a do “é só leitura”. O código que monta comandos aceita só cinco campos, com limites, e foi testado contra os 12 comandos reais: reproduz byte a byte os 10 válidos e recusa exatamente os 2 que a própria bomba rejeitou.

O repositório completo é privado, porque tem capturas, MAC e a topologia da minha rede. O que vai para o GitHub passa por um filtro de lista branca e por uma varredura automática atrás de dados sensíveis antes de qualquer publicação.

O que ainda falta descobrir

Três campos (0x04, 0x05 e 0x06) nunca mudaram. O 0x04 vale sempre 20 e desconfio que seja o parâmetro b03, mas não confirmei. Dos códigos de erro, só o E01 foi confirmado contra o painel, e o 8 está na fila. Também não sei a faixa real de pressão-alvo que o controlador aceita, então a integração usa uma faixa conservadora. Quanto à rotação do motor, ela só passa no barramento entre o display e o controlador. Existe um conector TX RX GND na placa que está pedindo para ser grampeado, e talvez esse seja o próximo capítulo.

Fechando

Comecei querendo soldar um ESP32 numa bomba d’água e terminei com o protocolo documentado, um painel web e uma integração para o Home Assistant, sem soldar nada. A bomba continua de fábrica e hoje só conversa com a minha rede.

O que mais me marcou foi o contraste. O controlador é bem feito: valida os valores, tem alarmes coerentes e um protocolo simples e consistente. Já a parte de conectividade colocada em volta dele deixa rede aberta, senha padrão, tráfego sem criptografia e uma nuvem que reconhece o equipamento só pelo MAC. Se você tem essa bomba, vale a pena gastar dez minutos com o override de DNS e uma regra no firewall.

Tudo aqui foi feito no meu próprio equipamento, observando o tráfego da minha própria rede. As mudanças de configuração durante os testes foram feitas pelo painel da bomba ou pelo app oficial. Os quadros de exemplo usam um MAC fictício.

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *