O protocolo OpenWebNet é um protocolo de comunicação criado pela empresa italiana BTicino, parte do grupo Legrand, para permitir a comunicação com seus sistemas de automação residencial (domótica), como luz, temperatura, persianas, sensores, etc.

Aqui estão os principais pontos sobre o protocolo:

---

1. Objetivo

Permitir a comunicação entre dispositivos e controladores (como gateways, servidores ou apps) dentro de um sistema de automação residencial.

---

2. Características

• Baseado em mensagens de texto com sintaxe simples.

• Usa ASCII puro, com comandos separados por * e finalizados com ##.

• Pode funcionar via serial (RS-232/RS-485) ou IP (TCP/UDP), especialmente através do gateway MyHome BTicino.

---

3. Exemplo de Mensagem

Para ligar uma luz no endereço 1 da área 1:

*1*1*1##  

Explicando:

• *1* → comando para iluminação

• 1 → ligar

• 1 → endereço do dispositivo (ex: botão, relé)

• ## → fim da mensagem

---

4. Tipos de mensagens

• WHO (quem): tipo de dispositivo ou função (ex: iluminação, temperatura)

• WHAT (o quê): comando ou status (ex: ligar, desligar, nível)

• WHERE (onde): endereço do dispositivo

• OPTIONAL (opcional): argumentos extras para certos dispositivos

---

5. Protocolo sobre IP

• Porta padrão: 20000 (TCP/IP)

• Comunicação normalmente feita com gateways como o MH202 ou F454 e outros

---

6. Aplicações comuns

• Controle de iluminação

• Persianas automáticas

• Termorregulação

• Sensores de presença e segurança

• Integração com assistentes virtuais (através de interfaces adicionais)

---

7. Documentação

A documentação oficial era disponibilizada pela própria BTicino/Legrand para integradores registrados. Hoje, algumas comunidades open-source também oferecem suporte, como:

• OpenWebNet Gateway

• Home Assistant (com integração OpenWebNet)

---

Para interagir com um servidor OpenWebNet (como os gateways BTicino F454, F459, ou módulos como o MH202), você basicamente envia mensagens de texto formatadas via conexão TCP/IP na porta padrão 20000.

Abaixo explico como fazer isso de forma simples e prática.

---

1. Pré-requisitos

• Ter o gateway OpenWebNet configurado na rede (ex: F454, F459, MH202, etc.).

• Saber o IP do gateway.

• Ter acesso à porta 20000 TCP.

• Estar na mesma rede local (ou configurar acesso remoto).

---

2. Exemplo usando Telnet (para testes rápidos)

No terminal (Linux/macOS) ou Prompt de Comando (Windows):

telnet 192.168.1.100 20000

Substitua 192.168.1.100 pelo IP do seu gateway.

Depois que conectar, digite o comando OpenWebNet, por exemplo:

*1*1*1##

Isso envia o comando para ligar a luz no endereço 1.

---

3. Exemplo em Python

Se você quiser fazer algo mais automatizado:

import socket

HOST = '192.168.1.100'  # IP do gateway
PORT = 20000            # Porta padrão do OpenWebNet

mensagem = '*1*1*1##'   # Ligar luz no ponto 1

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    s.sendall(mensagem.encode())
    resposta = s.recv(1024)
    print('Resposta:', resposta.decode())

---

4. Escutando eventos (modo "monitor")

Você pode também "ouvir" eventos do sistema enviando o comando especial:

*#1##

Isso inicia o monitoramento de todos os eventos do tipo "iluminação", por exemplo.

Importante para "apreder" novos comandos e ou manobras realizadas pelo servidor

---

5. Segurança

Alguns gateways exigem autenticação (especialmente os mais novos). Nesses casos:

• Você pode precisar se autenticar via uma sessão HTTP antes.

• Ou usar certificados/chaves dependendo do modelo.

---

6. Ferramentas úteis

• netcat (nc): alternativa ao telnet

• Wireshark: para monitorar pacotes OpenWebNet

• Home Assistant: integração nativa via plugin OpenWebNet

---

Os sistemas BTicino/Legrand (especialmente a linha MyHome) utilizam um cabo chamado BUS para interligar fisicamente todos os dispositivos do sistema de automação (interruptores, sensores, atuadores, etc.). Esse barramento é fundamental — é por ele que os comandos reais circulam entre os módulos.

---

Como funciona o BUS da BTicino?

1. Estrutura física

• É um cabo de 2 fios, geralmente chamado de BUS SCS (Sistema Cablagem Simplificada).

• Conecta todos os dispositivos em paralelo (topologia em árvore ou estrela, geralmente não em anel).

• Alimenta e comunica os módulos ao mesmo tempo (baixa tensão, geralmente 27V DC).

• Usa um protocolo proprietário da BTicino sobre esses fios.

---

Como interagir diretamente com o cabo BUS?

A) Acesso direto ao BUS via hardware

Você não pode interagir diretamente com o BUS só conectando os fios ao computador, pois:

• O protocolo sobre o BUS é proprietário e não é RS-232 nem RS-485. (all closed)

• Os sinais no cabo são específicos do padrão SCS da BTicino.

B) Como fazer então? Usar um Gateway

O caminho correto é:

Software → Gateway (IP ou serial) → Cabo BUS → Dispositivos

Ou seja, o gateway faz a ponte entre seu software e o cabo BUS.

Exemplos de Gateways:

Modelo	Interface	Função
F454	Ethernet	Conversor IP ↔ BUS
F459	Ethernet + Visualização	Interface gráfica e controle IP
MH202	Serial/RS232	Gateway programável + lógica
USB/SCS Interface	USB ↔ BUS	Para integradores

---

Alternativa: Placa interface DIY (não oficial)

Alguns desenvolvedores tentaram fazer interfaces usando Arduino + optoacopladores ou até RS485 adaptado, mas:

• Não é confiável.

• Pode queimar o hardware.

• Quebra o suporte da BTicino.

Não recomendado para produção, só para experimentos.

---

Resumo da comunicação

1. Se você quer falar com os dispositivos físicos (luzes, sensores, etc):

   • Use o protocolo OpenWebNet via gateway oficial.

   • O gateway traduz seus comandos IP/serial para sinais SCS no cabo BUS.

2. Sem o gateway, você não consegue falar com o BUS.

---

1. Adicionar dispositivos BTicino nativos ao BUS

Se você quer apenas expandir com módulos compatíveis BTicino (novos relés, sensores, etc.), basta:

• Conectar os novos módulos aos dois fios do BUS SCS (sem polaridade).

• Endereçar corretamente os dispositivos (via configurador físico ou software, dependendo do modelo).

• Pronto: o sistema reconhece e você pode comandar via gateways já existentes.

---

2. Integrar dispositivos de terceiros ao BUS

Agora, se o objetivo é controlar ou integrar dispositivos não-BTicino (como relés externos, sensores, ESP32, Arduino, etc.), você tem 2 caminhos possíveis:

A) Usar o gateway como ponte IP ↔ BUS

Você continua usando OpenWebNet via IP e escreve scripts que disparam comandos para o BUS, baseados em eventos de outros dispositivos.

Exemplo:

• Sensor Zigbee detecta movimento → Home Assistant → Envia *1*1*5## → Gateway → Relé BTicino aciona luz no endereço 5.

B) Criar um "dispositivo virtual" que fale SCS direto (avançado)

Isso envolve emular um dispositivo BTicino via hardware no BUS. Possível, mas exige:

• Entender a codificação elétrica do BUS (27V, dados modulados).

• Criar circuitos com optoacopladores, microcontroladores e isolamento.

• Implementar o protocolo SCS (que é proprietário e pouco documentado).

Alguns makers tentaram com ESP32, STM32 ou Arduino + transceptores — posso te mostrar esses projetos se quiser arriscar.

---

3. Usar módulos "interface" da BTicino

A BTicino tem módulos de entrada binária e saída de relé que servem justamente para integrar com o mundo externo:

Módulos interessantes:

• F428: interface para botões externos → transforma sinal seco em comandos BUS.

• F441: relé de 16A comandado via BUS.

• F422: interface universal, boa para integrar sensores com contato seco.

• MH202/302: gateways programáveis com lógica interna (sem depender de sistema externo).

---

Controlar uma persiana usando Arduino conectado ao cabo BUS SCS da BTicino é um desafio técnico interessante, mas viável com limitações. Vamos por partes para entender os caminhos possíveis:

---

Cenário: Persiana via BUS com Arduino

O que você quer:

Usar o Arduino para enviar comandos no barramento BUS SCS e com isso controlar uma persiana (subir, descer, parar) como se fosse um botão BTicino.

Desafio:

O BUS SCS é proprietário, roda com 27V DC, e não é RS485/RS232 nem I2C/SPI. Ou seja, o Arduino não pode ser conectado diretamente sem um circuito intermediário (risco de queima e protocolo incompleto).

---

Caminhos possíveis

1. Caminho recomendado: usar interface de entrada binária BTicino (ex: F428 ou F422)

Você não tenta falar o protocolo SCS, e sim simula botões reais.

Como funciona:

• Você conecta saídas digitais do Arduino (3.3V ou 5V) a uma interface de entrada binária BTicino (como a F428).

• Cada saída do Arduino simula um "botão", e o módulo envia o comando correto para o barramento.

Vantagens:

• 100% compatível.

• Sem risco de queimar o barramento.

• Fácil de integrar vários comandos (subir, descer, parar, cenário...).

---

2. Caminho experimental: emular protocolo SCS diretamente com Arduino

Esse é o caminho "hacker", onde o Arduino fala diretamente com o BUS.

O que você precisa:

• Um circuito com optoacopladores, transistores, isolamento galvânico e regulador de tensão (27V DC para lógica do Arduino).

• Um software que emule os comandos do protocolo SCS (o que não é oficialmente documentado).

• Muitos testes e paciência.

Referência de projeto:

• Existe um projeto muito legal chamado OpenSCS ou SCS Arduino Bridge, feito por entusiastas italianos. Posso te passar o link do GitHub com esquemas e código.

Riscos:

• É instável.

• Pode interferir no funcionamento da rede.

• Não recomendado para aplicações críticas ou permanentes.

---

3. Caminho via gateway e OpenWebNet (IP)

Alternativamente, seu Arduino pode:

• Ficar fora do BUS.

• Enviar comandos via rede (Wi-Fi ou Ethernet) para o gateway BTicino usando OpenWebNet TCP/IP.

• O gateway então injeta o comando na linha BUS.

Exemplo:

• Arduino detecta botão pressionado → envia via socket o comando *2*1*8## → Gateway → persiana no endereço 8 sobe.

Resumo: qual caminho seguir?

Caminho	Nível de dificuldade	Risco	Compatibilidade
Interface binária (F428)	Fácil	Nenhum	Total
Emular SCS direto	Difícil	Alto	Experimental
Via OpenWebNet/IP	Médio	Baixo	Total (com gateway)

Todos os créditos desta matéria pertecem ao Chat GPT