Saudações a todos os amantes da automação residencial. Decidi compartilhar a experiência de usar dispositivos sem fio Xiaomi com a interface ZigBee. Honestamente, sou contra o uso de qualquer dispositivo sem fio em qualquer automação, desde sistemas sérios de controle de processos de objetos grandes a pequenas automações, como alarmes de incêndio ou residências inteligentes, mas ... As soluções Xiaomi subornaram com baixo custo, acessibilidade, excelente design e muitas críticas positivas dos usuários, decidi para tentar.
Esta publicação deve ser tomada como uma instrução passo a passo para a integração de dispositivos ZigBee na infraestrutura doméstica inteligente. O descrito aqui não é de forma alguma um axioma e você pode encontrar muitas outras maneiras de conectar dispositivos ZigBee. Se você ainda pular a descrição detalhada, poderá ter a impressão da complexidade ou facilidade de combinar dispositivos de diferentes fabricantes em uma plataforma local usando o exemplo do ZigBee e ioBroker (mais sobre isso mais tarde). Neste artigo, mostrarei como conectar dispositivos a uma casa inteligente, exibir informações sobre eles em um tablet ou simplesmente em um navegador e enviar mensagens por telegramas sobre a alteração do status do dispositivo. Se sou do seu interesse, peço um gato.
De acordo com o fabricante da Xiaomi, os usuários devem usar um aplicativo nativo com uma conexão em nuvem e um gateway Wi-Fi para dispositivos ZigBee. No entanto, há muito que se conhece um método para ativar o modo de desenvolvedor em um aplicativo para obter um token de controle. Assim, dentro da rede local, você pode se comunicar com o gateway, o que permite
executar o driver
mihome , que faz parte do ioBroker.
O ioBroker é uma plataforma aberta para a IoT, inclusive para a construção de sistemas domésticos inteligentes. O que é o ioBroker pode ser encontrado no
artigo anterior.
Agora, minha casa inteligente está "girando" em uma placa ARM Cubietruck com algum "kit de corpo" na forma de um disco rígido de 80 GB, baterias recarregáveis de 5000 mAh, um mestre USB de 1 fio, um conversor USB-RS485 para pesquisar dispositivos usando o protocolo modbus. O sistema operacional Armbian é instalado no disco rígido com a transferência da partição raiz, apenas o carregador de inicialização permanece no cartão de memória microSD.
Comecei a conhecer os dispositivos sem fio Xiaomi comprando sensores de temperatura e umidade. Naquela época, a única possibilidade de integração era o driver
mihome , mencionado acima.
Driver Mihome
Adicionar um driver ao sistema é muito simples; você precisa clicar no botão “+” na lista de drivers disponíveis e observar o processo de instalação.

Não descreverei a instalação e a configuração inicial do aplicativo nativo do Android Mi Home, você pode vê-lo na página do driver do
github ou na Internet. Portanto, o modo de desenvolvedor é ativado, o token é recebido, configuramos o adaptador mihome, salvamos e executamos se ele não tiver sido iniciado.

O gateway Xiaomi e os dispositivos conectados no aplicativo Mi Home devem aparecer na árvore de objetos.

Em seguida, você pode configurar os objetos recém-criados. Por exemplo, armazenando o histórico dos sensores de temperatura e umidade. Eu uso um driver SQL para dados históricos configurados em um banco de dados SQLite.

O armazenamento do histórico da variável é configurado na janela de objetos do sistema: na hierarquia de objetos, você precisa acessar a variável em si e pressionar o botão com uma chave inglesa à direita. Na guia "Configurações", tenho o armazenamento de histórico ativado por sensores - apenas alterações na variável.
Outras configurações:
- intervalo mínimo de 10 segundos - se a variável for alterada com mais frequência, a entrada no banco de dados será ignorada
- registrando valores a cada 300 segundos (5 minutos) - se a variável não for alterada por mais de 5 minutos, o valor atual ainda será gravado no banco de dados
- tipo de valor - número
- prazo de validade - 1 ano

A adição de novos dispositivos ocorre através do aplicativo nativo. I.e. você precisa emparelhar o novo dispositivo com o gateway de acordo com as instruções anexadas e, em seguida, ele aparecerá automaticamente na lista de objetos do ioBroker.
Driver Zigbee
Era inconveniente para mim usar o aplicativo Xiaomi nativo, especialmente porque eu tinha que comprar um gateway com um plug chinês, que no meu caso, exceto pela comunicação com os dispositivos, não era útil para nada. Sim, pode ser usado como luz noturna ou usar um sensor de luz em alguns cenários. Na Internet, você pode encontrar instruções sobre como "alimentar" uma lista de reprodução para um gateway para reproduzir suas próprias estações de rádio, mas nada disso ficou comigo. Além disso, o pensamento de que meus dados estavam vazando em algum lugar, sendo processados e armazenados em algum lugar era assustador.
Um dos usuários ativos da plataforma ioBroker encontrou na Internet a biblioteca
zigbee-shepherd no node.js, na qual havia uma menção à conexão de dispositivos Xiaomi. Um driver para ioBroker foi escrito com base nele, e o autor deste driver não se limitou apenas aos dispositivos Xiaomi, a lista de dispositivos suportados é constantemente atualizada e está disponível na página do
github do projeto.
É suposto usar dispositivos prontos e baratos com base nos chips
CC25xx da TI como coordenador de rede. Você pode comprar módulos ZigBee prontos com conexão USB e uma antena embutida, além de modelos mais caros e mais sérios: com antena externa, amplificador e conexão via UART.
Para trabalhar com o driver, você só precisa alterar o firmware. Assim, verifica-se que esse driver não precisa de um gateway caro, não são necessárias redes Wi-Fi. O "ponto de entrada" é o coordenador - um dispositivo baseado no chip SS25xx com firmware especial. Por meio do coordenador, há comunicação direta dos dispositivos zigbee e do sistema Smart Home, além da vinculação de novos dispositivos.
Como coordenador, uso uma placa-mãe pronta com base em um chip CC2530 com uma antena externa, que eu conectei ao servidor via UART.
Para o firmware do dispositivo, foi adquirido um depurador SmartRF04EB especial, cuja porta microUSB eu conectei ao computador e o módulo ZigBee conectado usando a fiação para depuração de acordo com o esquema:
SS2530 | Placa SmartRF04EB |
---|
P22 | DC |
P21 | DD |
Rst | RESET |
GND | GND |
Vcc | 3.3V |

Na página
github do projeto, baixe o firmware (o arquivo é chamado CC2530ZNP-Pro-Secure_LinkKeyJoin.hex para este dispositivo) e o programa de firmware (programador flash), após o qual os drivers necessários são adicionados ao sistema.
Quando você conecta a placa depuradora à porta USB do computador, o programa exibe imediatamente o dispositivo conectado. Você só precisa especificar o caminho para o arquivo de firmware e clicar no botão "Executar ações"

As portas do módulo ZigBee P03 (Rx) e P02 (Tx) são conectadas nas placas de cubietruck UART4 (no SO como ttyS4), alimentadas em 3V3, o GND assumiu o pino vizinho. Para uma operação estável, você ainda precisa puxar as portas P20, P4, P5 do coordenador para o chão. Como escrevi acima, eu uso o sistema operacional Armbian, a porta UART é ativada de maneira muito simples, usando o comando
armbian-config na seção
Sistema -
Hardware , você precisa ativar a porta desejada e reiniciar o sistema.

O driver zigbee é adicionado no painel de administração com um clique.

No meu caso, o coordenador está conectado à porta
/ dev / ttyS4 (como escrevi acima), nós a especificamos nas configurações.

Outras configurações podem ser deixadas por padrão. Após o primeiro lançamento do driver, você precisa emparelhar (adicionar) dispositivos. As instruções completas no
github , emparelhar através deste driver, são um pouco mais complicadas do que no aplicativo nativo, mas não tive problemas.
Portanto, por exemplo, adicione o botão Xiaomi (série Mijia). Para isso, pressionamos o botão verde nas configurações do driver e, seguindo as instruções, primeiro segure o botão de emparelhamento na parte traseira com um clipe de papel até que o LED comece a piscar e clique nesse botão a cada 2 segundos, veja o progresso do emparelhamento.

Meu apartamento não é grande, com todos os dispositivos a conexão é estável, mesmo com um sensor de porta aberta no patamar (muro de concreto armado de 100 mm e 5 m em linha reta). Os problemas começaram quando eu decidi adicionar um sensor de temperatura e umidade ao ar da rua, que eu instalei na parede externa da casa, ao lado da galeria isolada. O sinal de um sensor fraco, que também estava na rua, não chegou ao gabinete de automação. O problema pode ser resolvido de maneira simples - você precisa adicionar um roteador à rede ZigBee e colocá-lo mais próximo do sensor. Alguns dispositivos sem fio, por exemplo, o soquete Xiaomi, podem funcionar como roteadores, mas eu não os tinha. Eu não queria comprar uma tomada cara ou uma luz controlada apenas para "encaminhar" dados de um sensor na rua. Como se viu, para os mesmos dispositivos terminais baseados no chip SS25xx, existe um firmware especial que permite que eles sejam usados como roteadores no sistema. Como resultado, adicionei um roteador baseado no chip CC2531 com uma conexão USB. Não vou me concentrar no processo do firmware, o esquema e o arquivo do firmware podem ser encontrados na página do projeto no
github .
Como, de fato, a comunicação com o módulo via porta USB não ocorre, conectei-o temporariamente ao carregamento com a porta USB e a uma tomada na cozinha. Em um futuro próximo, planejo colocá-lo estacionário em um edifício normal na varanda e com energia normal de um no-break doméstico.

O processo de adição de um roteador ao sistema é simples: pressione o botão de emparelhamento no driver e, no roteador ligado, pressione o botão S2 várias vezes até que os dispositivos se conectem.

Vamos adicionar um exemplo de sensor de temperatura / umidade, localizado na varanda externa e que deve funcionar através de um roteador.
Você pode simplesmente fazer o emparelhamento através do driver e o sensor deve se conectar através do roteador, se estiver mais próximo. Mas você pode especificar à força que o emparelhamento passa por um roteador específico. Para isso, na lista de dispositivos no ícone do roteador, clique no botão verde de emparelhamento.

Verifique se o sensor está conectado corretamente - consulte o mapa da rede.

O mapa mostra as linhas de emparelhamento de dispositivos, indicando a qualidade do sinal entre os segmentos de rede. Como escrevi acima, tenho um pequeno odnushka de 35 m2, portanto o mapa é bastante modesto. Com a permissão de outros usuários, publicarei opções possíveis com um cartão maior.



A funcionalidade de alguns dispositivos Xiaomi através deste adaptador é um pouco mais do que através do aplicativo nativo e do driver mihome. No futuro, quero expandir um pouco a rede e experimentar novos dispositivos, em particular, um drive inteligente para cortinas e um cubo de sensor.
Driver de material
Temos os dados, os atuadores ligados, o que fazer agora com eles? Primeiro, vamos exibir em uma interface bonita. Eu tenho um projeto grande no driver do VIS, que existe em várias versões para permissões diferentes, mas há material suficiente para um artigo separado. Talvez ela seja a próxima.
Para exibição simples e rápida de dados e controle de vários dispositivos, eu uso o driver de material. Instalação como de costume em alguns cliques. Os blocos de interface exibem dados com base nas configurações de categoria, adicionadas na janela de administração da interface com o mesmo nome. A lista de categorias é limitada apenas pela imaginação, eu uso o esquema de "função da sala" e o agrupamento ocorre de acordo com elas. Adicionadas todas as salas (cozinha, corredor, sala, varanda, etc.) e funções (iluminação, sensores, sistema, etc.).

Agora, na janela de configurações dos objetos do sistema, é necessário que as variáveis que serão exibidas na tela indiquem a sala, função e atribuam uma função (para exibição adequada). Um exemplo é o sensor de temperatura e umidade da parede interna da Xiaomi, conectado via Bluetooth.

Com base nessas configurações, o bloco exibirá dados na tela, o ícone será apertado e objetos de um determinado tipo de controle estarão disponíveis.
Exemplo 1. A saída de todas as informações em uma categoria - função. Iluminação em todo o apartamento.
Exemplo 2. A saída de todas as informações sobre o quarto - Banheiro.
Exemplo 3. O nível de tensão e descarga da bateria de todos os dispositivos sem fio Xiaomi.

Esse driver funciona para mim para o controle local do sistema a partir de um telefone celular, um tablet fixo na parede. Às vezes eu me conecto via VPN. Para controlar e visualizar estados remotamente, para receber notificações, eu uso o driver de telegrama.
Driver de telegrama
Não vou descrever a instalação, basta revisar as configurações. Eu uso o modo de operação através de pesquisas periódicas (300ms por padrão) e conexão através de um servidor proxy. Para obter o token, você precisa "conversar" com o criador do bots, o BotFather. O processo é simples - encontre uma pesquisa para este bot, dê um comando para criar um novo, especifique seu nome exclusivo e sua chave, indique-o nas configurações do driver e, por segurança, especifique a senha de "saudação". Seu bot perguntará a ele quando se comunicar com um novo usuário.

Agora você precisa configurar os casos de comunicação através do bot. Você pode usar o driver text2command ou JavaScript para fazer isso. Aconteceu historicamente que eu uso JavaScript tanto na forma de texto quanto em blocos Blockly. A instalação do driver JS não deve causar dificuldades; a configuração neste caso não é necessária. Após a instalação e o lançamento, você precisa ativar a exibição do menu para criar e editar scripts.
Exemplo 1. Alertas.
Primeiro, vamos tentar enviar uma notificação sobre a abertura, por exemplo, da porta da frente. Eu tenho um interruptor de sensor de palheta sem fio Xiaomi na porta da frente. Monitoro como minha esposa anda com o pequeno enquanto estou no trabalho. Crie um novo script no grupo comum.

Especifique o que será "draw" em bloco e chame-o de "telegram_bot".

No grupo "Eventos", pegamos a unidade de reação para alterar a variável e a arrastamos para o campo de trabalho.

Em seguida, selecione o ID do objeto no qual estamos assinando, insira a verificação do objeto através de "se" - "caso contrário, se" como verdadeiro / falso. O resultado deve ser algo como o seguinte.

Ok, agora estamos correndo, abrimos a porta - fechamos a porta e vemos mensagens no telegrama.
Exemplo 2. Controle de iluminação através do menu.
Um exemplo é mais complicado, vamos fazer o controle de iluminação usando os botões de menu no telegrama. Aqui você tem que ficar um pouco, isto é, ao criar um script, você precisa selecionar JS. A tarefa é aproximadamente a seguinte: criar botões na forma de um menu com o status dos acessórios exibidos imediatamente no texto da assinatura do botão. Ainda assim, verifique se, ao pressionar o botão, o status da iluminação é invertido e o status é imediatamente atualizado no texto do botão com a aparência / desaparecimento da lâmpada. Além disso, se o menu já estiver em execução e ligar / desligar manualmente a luz com o botão, é necessário que o menu também seja atualizado com o status dos equipamentos.
O código contém comentários e é relativamente simples:
| // ID |
| const LIGHT1 = ' ', CH_LIGHT1 = 'mqtt.0.PLC55_Lighting.lighting.MainRoom_main1'; |
| const LIGHT2 = ' ', CH_LIGHT2 = 'mqtt.0.PLC55_Lighting.lighting.MainRoom_main2'; |
| const LIGHT3 = ' ', CH_LIGHT3 = 'mqtt.0.PLC55_Lighting.lighting.MainRoom_sec'; |
| const LIGHT4 = ' ', CH_LIGHT4 = 'mqtt.0.PLC55_Lighting.lighting.Kitchen_main'; |
| const LIGHT5 = ' 1', CH_LIGHT5 = 'mqtt.0.PLC55_Lighting.lighting.Kitchen_sec_top'; |
| const LIGHT6 = ' 2', CH_LIGHT6 = 'mqtt.0.PLC55_Lighting.lighting.Kitchen_sec_bottom'; |
| const LIGHT7 = ' ', CH_LIGHT7 = 'mqtt.0.PLC55_Lighting.lighting.BathRoom_main'; |
| const LIGHT8 = ' ', CH_LIGHT8 = 'mqtt.0.PLC55_Lighting.lighting.Hall_main'; |
| const LIGHT9 = ' ', CH_LIGHT9 = 'mqtt.0.PLC55_Lighting.lighting.Balcon_main'; |
| |
| // |
| function sendLightMenu(message_text) { |
| // |
| var l1 = getState(CH_LIGHT1).val ? '💡' : ''; |
| var l2 = getState(CH_LIGHT2).val ? '💡' : ''; |
| var l3 = getState(CH_LIGHT3).val ? '💡' : ''; |
| var l4 = getState(CH_LIGHT4).val ? '💡' : ''; |
| var l5 = getState(CH_LIGHT5).val ? '💡' : ''; |
| var l6 = getState(CH_LIGHT6).val ? '💡' : ''; |
| var l7 = getState(CH_LIGHT7).val ? '💡' : ''; |
| var l8 = getState(CH_LIGHT8).val ? '💡' : ''; |
| var l9 = getState(CH_LIGHT9).val ? '💡' : ''; |
| // |
| sendTo('telegram.0', { |
| text: message_text, |
| reply_markup: { |
| keyboard: [ |
| [LIGHT1+l1, LIGHT2+l2, LIGHT3+l3], |
| [LIGHT4+l4, LIGHT5+l5, LIGHT6+l6], |
| [LIGHT7+l7, LIGHT8+l8, LIGHT9+l9] |
| ], |
| resize_keyboard: true, |
| one_time_keyboard: true |
| } |
| }); |
| } |
| // |
| function changeLight(room, channel) { |
| // |
| var alive = getState("mqtt.0.info.connection").val; |
| if (alive.includes("PLC55_Lighting")) { |
| if (getState(channel).val) { |
| setState(channel, false, false, function () { |
| sendLightMenu(room+' '); |
| }); |
| } else { |
| setState(channel, true, false, function () { |
| sendLightMenu(room+' '); |
| }); |
| } |
| } else { |
| sendLightMenu(' OFFLINE'); |
| } |
| } |
| // request , |
| on({id: "telegram.0.communicate.request", ack: false, change: 'any'}, function (obj) { |
| var msg = obj.state.val; |
| var command = obj.state.val.substring(obj.state.val.indexOf(']')+1); |
| var user = obj.state.val.substring(obj.state.val.indexOf('[')+1,obj.state.val.indexOf(']')); |
| var chat_id = getState("telegram.0.communicate.requestChatId").val; |
| var message_id = getState("telegram.0.communicate.requestMessageId").val; |
| var handled = false; |
| // |
| if (command == '/start' || command == '/menu' || command == '' || command == '') { |
| sendLightMenu(""); |
| handled = true; |
| } |
| //######################## Lighting menu and commands ################ |
| if (command == LIGHT1 || command == LIGHT1+'💡') { |
| changeLight(LIGHT1, CH_LIGHT1); |
| handled = true; |
| } |
| if (command == LIGHT2 || command == LIGHT2+'💡') { |
| changeLight(LIGHT2, CH_LIGHT2); |
| handled = true; |
| } |
| if (command == LIGHT3 || command == LIGHT3+'💡') { |
| changeLight(LIGHT3, CH_LIGHT3); |
| handled = true; |
| } |
| if (command == LIGHT4 || command == LIGHT4+'💡') { |
| changeLight(LIGHT4, CH_LIHT4); |
| handled = true; |
| } |
| if (command == LIGHT5 || command == LIGHT5+'💡') { |
| changeLight(LIGHT5, CH_LIGHT5); |
| handled = true; |
| } |
| if (command == LIGHT6 || command == LIGHT6+'💡') { |
| changeLight(LIGHT6, CH_LIGHT6); |
| handled = true; |
| } |
| if (command == LIGHT7 || command == LIGHT7+'💡') { |
| changeLight(LIGHT7, CH_LIGHT7); |
| handled = true; |
| } |
| if (command == LIGHT8 || command == LIGHT8+'💡') { |
| changeLight(LIGHT8, CH_LIGHT8); |
| handled = true; |
| } |
| if (command == LIGHT9 || command == LIGHT9+'💡') { |
| changeLight(LIGHT9, CH_LIGHT9); |
| handled = true; |
| } |
| // , text2command |
| if (!handled) { |
| sendTo('text2command.0', { |
| text: command.replace(/\//g, '#').replace(/_/g, ' '), |
| id: chat_id, |
| user: user |
| }, function (response) { |
| if (response && response.response) { |
| sendTo('telegram.0', {user: user, text: response.response}); |
| } |
| }); |
| } |
| }); |
| // , |
| on({id: /^mqtt\.0\.PLC55_Lighting\.lighting\..*$/, ack: true, change: 'ne'}, function (obj) { |
| sendLightMenu(" "); |
| }); |
| // |
| sendLightMenu(""); |
O resultado deve ser algo como isto:

Conclusão
O artigo acabou sendo longo, mas espero que seja útil, e talvez facilite a vida de alguns usuários ou incentive alguém a criar sua própria casa inteligente.
No momento, meu sistema residencial inteligente baseado no ioBroker está em funcionamento há 4 anos e estou bastante satisfeito com isso. Além do ZigBee, vários controladores caseiros via MQTT e HTTP também estão conectados a ele para controlar iluminação, ventilação e outros sistemas, uma rede de sensores de temperatura no barramento de 1 fio, um dispositivo de monitoramento de fonte de alimentação no barramento RS485 e no protocolo RTU modbus e muito mais.
No meu cofrinho de soluções para uma casa inteligente, acumulei muitas idéias, embora, provavelmente, elas devam ser percebidas mais como um cofrinho de problemas para uma casa inteligente (aqueles que entendem o tópico sobre o que quero dizer). Deixe seus desejos nos comentários para me ajudar a decidir sobre o tópico do próximo artigo.