Hackeando uma divisão LG Ducted para automação residencial: 8 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Primeiro de tudo - este não é outro hack de emulação de controle remoto infravermelho. Meu AC particular não tem interface utilizável projetada para qualquer tipo de controle além dos controles inteligentes montados na parede incluídos.

Eu tenho um sistema de divisão reversa LG Ducted em minha casa. Infelizmente, ele foi feito em uma época em que a IoT não estava no topo de nenhuma lista de fabricantes. Descobri que ele tinha algumas opções para o controle 'mestre', mas embora a unidade tivesse apenas 2 anos na época em que tentei isso pela primeira vez, as placas de expansão eram unobtanium e os preços eram astronômicos de qualquer maneira. Assim como o addon 'Wireless RF Remote', que teria tornado as coisas muito mais fáceis, mas impossíveis de comprar.

Se tivesse sido minha escolha, não seria um LG, mas como foi instalado na casa quando eu o comprei (e seu custo de substituição provavelmente seria superior a US $ 10 mil), tive que lidar com isso.

Objetivo - Ser capaz de controlar o AC via MQTT para fins de automação via OpenHAB e IFTTT / Google Assistant

Etapa 1: decodificando o formato dos dados

Comecei este processo há 4 anos, mas não fui muito longe e não queria arriscar danificar a unidade - Principalmente porque as peças parecem quase impossíveis de encontrar.

Arrancando o controlador da parede, encontrei 3 fios que determinei serem aterrados, 12v e 'sinal'

A tensão de sinalização na linha de dados estava em 12v, mas percebi que parecia flutuar no multímetro (algum tipo de pulso na linha).

Eu embarquei em um circuito básico para acionar um opto isolador através do pino de dados e conectei o outro lado do opto isolador como uma entrada na placa de som do meu PC e obtive uma versão pobre de uma saída de osciloscópio (Fig. 1).

Foi o mais longe que cheguei na época - pude ver que havia algo ali, mas não sabia realmente como 'decodificá-lo'.

Desde que habilitei minha máquina de café IoT, tive um interesse renovado em tentar isso novamente com um pouco mais de determinação desta vez.

Publiquei minhas descobertas nos fóruns da EEVBlog para ver se alguém poderia lançar alguma luz e um grande cara chamado Ian veio em meu socorro - ele explicou de uma forma que fazia sentido (Foto 2)

Basicamente, o fluxo de dados é de 13 bytes de 'serial padrão' - 8 bits de dados, um bit de início e um bit de parada (sem paridade), mas a uma taxa de transmissão MUITO baixa de 104bps.

Etapa 2: Olhando mais profundamente

Agora que tinha uma ideia de como os dados eram formatados, precisava de uma forma de ler os dados de uma forma mais dinâmica.

Tirei um dos meus controladores da parede e o conectei por meio de um deslocador de nível lógico a um Arduino com um esboço simples para ler 13 bytes de dados via porta serial de software configurada a 104bps e imprimi-lo:

168, 18, 0, 8, 0, 192, 6, 22, 0, 0, 0, 0, 168, 18, 0, 8, 0, 192, 6, 22, 0, 0, 0, 0, 40, 19, 0, 8, 0, 200, 6, 31, 0, 0, 0, 0, 40, 19, 0, 8, 0, 200, 6, 31, 0, 0, 0, 0, 200, 18, 0, 8, 64, 0, 6, 25, 0, 0, 0, 0, 200, 18, 0, 8, 64, 0, 6, 25, 0, 0, 0, 0, 168, 18, 0, 8, 0, 200, 6, 22, 0, 0, 0, 0, 168, 18, 0, 8, 0, 200, 6, 22, 0, 0, 0, 0, 168, 18, 0, 8, 0, 200, 6, 22, 0, 0, 0, 0, ** Na verdade, 12 bytes aqui

Tivemos ação!

Depois de alterar as várias configurações do controlador, consegui calcular os bytes que mudam:

168, 3, 0, 0, 0, 192, 3, 31, 0, 0, 0, 0, 248, Ventilador LOW168, 35, 0, 0, 0, 192, 3, 31, 0, 0, 0, 0, 248, Fan MED 168, 67, 0, 0, 0, 192, 3, 31, 0, 0, 0, 0, 152, Fan HIGH

168, 67, 0, 0, 0, 248, 3, 33, 0, 0, 0, 0, 82, Z1234 168, 67, 0, 0, 0, 192, 3, 34, 0, 0, 0, 0, 133, Z1 168, 67, 0, 0, 0, 160, 3, 34, 0, 0, 0, 0, 229, Z2 168, 67, 0, 0, 0, 144, 3, 34, 0, 0, 0, 0, 245, Z3 168, 67, 0, 0, 0, 0, 136, 3, 35, 0, 0, 0, 0, 0, 204, Z4

168, 75, 0, 0, 0, 136, 3, 35, 0, 0, 0, 0, 244, Modo FAN 168, 79, 0, 0, 0, 136, 10, 35, 0, 0, 0, 0, 249, Modo AUTO 168, 67, 0, 0, 0, 136, 3, 35, 0, 0, 0, 0, 0, 204, Modo COOL 168, 83, 0, 0, 0, 136, 15, 34, 0, 0, 0, 0, 225, Modo HEAT 168, 7, 0, 0, 0, 136, 15, 34, 0, 0, 0, 0, 61, Modo DH

168, 15, 0, 0, 0, 136, 3, 34, 0, 0, 0, 0, 49, Temp 18 168, 15, 0, 0, 0, 136, 4, 34, 0, 0, 0, 0, 48, Temp 19 168, 15, 0, 0, 0, 136, 5, 34, 0, 0, 0, 0, 51, Temp 20 168, 15, 0, 0, 0, 136, 15, 34, 0, 0, 0, 0, 37, Temp 30

Os números fazem muito mais sentido quando você olha para eles em binário, mas o que há com o 13º byte ?? Está em todo lugar …

Etapa 3: Mapeamento

Por tentativa e erro, consegui determinar os bits relevantes nos 13 bytes de dados que precisaria para ser capaz de transmitir.

Etapa 4: Parede de tijolos à frente

É aqui que as coisas ficam complicadas. Eu tive dois obstáculos para superar

a) O 13º byte parecia ser uma soma de verificação dos dados que eu precisava resolver de alguma forma. b) Como transmito os dados então? É apenas um fio.

A edição 'a' acabou sendo MUITO fácil, mas foi por pura coincidência que consegui superá-la.

Em meus testes, observei dados como: A802000000040F61000000004B A81200004004169A00000000FB A81200004004159A00000000F8 A81200004004149A00000000E5 A81200084000149C00000000E7 A83200084000149C0000000087 A85200084000149C00007

Estes são os 13 bytes de dados, incluindo a soma de verificação (aqui em HEX em vez de DEC).

Quando eu estava pesquisando no oráculo que é o google sobre 'como fazer engenharia reversa de uma soma de verificação', me deparei com esta página na troca de pilha com outra pessoa chamada Nick perguntando praticamente a mesma coisa que eu, mas não só isso, eles conversaram sobre um ar condicionado e seus dados eram de formato quase idêntico ao meu - poderia ser ??? Em todas as minhas pesquisas (em cerca de 4 anos), nenhuma pessoa postou qualquer informação sobre como hackear o protocolo desses condicionadores de ar e eu simplesmente tropecei em alguém fazendo a mesma coisa ao procurar por algo quase completamente não relacionado? Foi uma bênção - ele até postou que deu um jeito e a solução foi: Some todos os bytes de dados e então XOR com "U".

Com isso em mãos eu o adicionei ao meu código para calcular o que eu achava que a soma de verificação deveria ser vs o que realmente era, mas estava tudo ERRADO !!

Acontece que estava meio errado. Quando comecei a olhar para os números em binário, isso fez todo o sentido.

A resposta do 'XOR com U' sempre retornou 9 bits de dados (o 9º bit sempre um), mas os outros bits estavam certos. Eu simplesmente removi o 9º bit tirando 256 do número resultante e então ele combinou !!

Se não fosse por esse indivíduo, eu ainda poderia estar coçando minha cabeça. Tiremos o chapéu para ele também, mas não consigo contatá-lo - Essa foi basicamente a única postagem dele no fórum stackexchange. Bem, obrigado estranho:)

O próximo desafio era fazer um circuito que me permitisse simular o controlador existente. Eu mapeei o esquema para o circuito da unidade (Foto 1 e Foto 2), mas parecia muito complicado para mim precisar reproduzi-lo para conseguir o que queria. Afinal, eu já estava lendo o sinal. Optei por um método muito mais simples - usar o arduino para acionar um opto isolador para reduzir a linha de sinal de 12 V conforme necessário.

Eu também projetei um circuito mais simples para o Rx, mas isso não foi testado, acabei optando pelo conversor de nível pela simplicidade.

Etapa 5: Fazendo funcionar

Depois que fiz o breadboard do circuito de transmissão e com o coração acelerado, mutilei uma string (estática) de 12 bytes, calculei a soma de verificação e fiz o arduino enviar o comando - Incrivelmente, a tela foi atualizada !!! Vencer!

O teste real final foi adicionar meu arduino ao BUS com os outros 2 controladores para um teste real ao vivo e com certeza, funcionou.

Agora eu podia ler e escrever no ônibus, mas não conseguia fazer isso de maneira simples.

Como eu uso o MQTT quase exclusivamente para toda a minha automação residencial, era natural que fosse o mesmo. Eu escrevi o código ao longo de vários dias para controlar os 4 elementos principais do AC, também lendo o status existente (de outros módulos no BUS)

A intenção era ter o código rodando em um módulo ESP8266, entretanto, parece que o ESP8266 não é capaz de produzir uma taxa de transmissão tão baixa quanto 104bps. Tive que reverter para um Arduino Uno genérico com Wiznet ethernet, mas não foi difícil, pois meu rack de comunicação estava literalmente do outro lado da parede de um dos controladores AC.

O código está um pouco difuso, mas deve ser legível. Tive muitos problemas para impedir que o controlador lesse sua própria saída, mas também repetindo o código de seus próprios tópicos publicados recebidos do MQTT de volta para o ar condicionado. Basicamente, isso criaria um loop infinito. No final, alguma limpeza de buffer e atrasos no processamento do código após a publicação no MQTT o classificaram.

Os pinos Rx, Tx para o AC são codificados como 3, 4, mas mudam se quiser

O código está configurado para publicar e aceitar comandos como:

ha / mod / 5557 / P 0/1 - Powerha / mod / 5557 / M 0/1/2/3/4 - Modo Cool, Desumidificar, Ventilar, Auto, Heatha / mod / 5557 / F 0/1/2 - Ventilador baixo, médio, altoha / mod / 5557 / Z, ou seja, 1111 para todas as zonas em 1000 apenas para a zona 1 ligada.

** A partir do controlador, as zonas não podem ser definidas para '0000', no entanto, parece que se você emitir o valor, ele será revertido para '1000'.

A versão mais recente do código está disponível em meu repositório GitHub:

Etapa 6: algo mais permanente

Peguei uma placa de protótipo do Arduino e instalei todas as peças conforme as mandei colocar no lugar.

Etapa 7: Configuração do OpenHAB

Veja o arquivo em anexo para itens OpenHAB, mapa do site e regras

Combine isso com a ligação IFTTT OpenHab e Google Assistant / Home e você terá um poderoso ar condicionado controlado por voz e / ou 'Smart' que supera quase todos os produtos disponíveis comercialmente!

Etapa 8: Resumo

Em conclusão - Se você é uma das pobres almas com um ar condicionado split LG um pouco mais velho, você não está sozinho. Ainda há esperança para nós!

Espero que este instrutível encontre alguém que precise tanto quanto eu. Não há basicamente nenhuma informação que eu possa encontrar (além da soma de verificação de 'Nick'). Tive que começar do zero, mas estou em êxtase com o resultado.

A informação é um pouco vaga, eu sei, mas se você estiver na mesma situação que eu, estarei mais do que disposto a ajudar.

- Cuidado / atualização --- Embora seja possível alterar as configurações do AC com a unidade desligada, descobri que, quando se trata do controle de zona, parece que ele bagunça. Fiz muitos testes com a unidade desligada e descobri que as zonas apareceriam como inativas, mas quando a unidade está operando, parece que os amortecedores não estão totalmente fechados (mas também não totalmente abertos). Reinicializei a unidade no disjuntor principal e isso resolveu o problema. Uma vez que só muda de zona quando a unidade está ligada, isso não tem sido um problema

Eu também atualizei o código para publicar apenas (para MQTT) mudanças que vêm do controlador mestre e não da unidade principal. Mais uma vez, isso pode causar problemas porque a unidade principal enviará '0000' para as zonas (o que também pode ter sido o problema)

O código atualizado também introduz algumas restrições de tempo para tentar evitar que o arduino transmita ao mesmo tempo da unidade mestre e principal. Tenho certeza de que provavelmente há um método que o controlador usa para iniciar um envio de dados, como puxar a linha para baixo para Xms antes de enviar, mas ainda não descobri se houver

Descobri que a unidade principal enviará dados a cada 60 segundos e o controlador mestre enviará a cada 20 segundos. O código tenta bloquear o envio de dados em 2 segundos após o recebimento do pacote de dados. No entanto, às vezes o mestre e a unidade principal transmitem muito próximos um do outro. Isso provavelmente será refinado mais em breve.----------------------------

** Pode funcionar em unidades mais novas

*** Algumas informações encontradas em minhas viagens de pesquisa indicaram que a divisão em duto da Panasonic pode usar o mesmo protocolo. YMMV.