Conselhos para conectar este relé wi-fi (PPA) para o portão da garagem?

Bom dia!

Estou tentando fazer com que este produto seja integrado ao Home Assistant que é um dos últimos aparelhos que sobrou em minha casa: PPA - Conforto com Segurança

Ele usa um aplicativo dedicado https://play.google.com/store/apps/details?id=com.ppa.contatto&hl=pt&gl=US e não vejo uma integração com o Home Assistant. Existem outros métodos manuais para fazer esses tipos de integrações? Não sou engenheiro, mas posso seguir os guias e fazer minha própria solução de problemas, em geral.

Obrigado!

Pela imagem do link que você enviou, esse relé utiliza um ESP, logo é possível trocar o firmware dele para ESPHome e usar no Home Assistant.

Porém com essa alteração de firmware irá perder a função pelo aplicativo do fornecedor.

Mas você terá os seguintes desafios:

  • Identificar os pinos que são usados para comandar os relés.
  • Identificar uma forma de realizar o flash de outro firmware nele (identificando os pinos de comunicação e usando um conversor USB-TTL ou tentando via atualização de firmware, etc)

Te ajudaria bastante se você encontrasse o esquema eletrônico deste modelo. Você pode tentar contato com o suporte deles para ver se fornecem alguma informação que ajude.

Muito obrigado para sua resposta.

Esse tem a informacao? https://bitzar.blob.core.windows.net/ppa/content/library/files/SAIDA_P06810_MANUAL_CONTATTO_WI-FI_AUTOMACAO_REV0.pdf

Além disso, usei o PCAPdroid para registrar minha atividade de rede ao abrir e fechar o portão e enviá-lo para o Wireshark no meu laptop. Parece que está tudo criptografado, infelizmente.

Não tem, a primeira coisa que deve fazer é abrir ele e verificar qual modulo ESP é usado, geralmente pode ser ESP12E, ESP8266MOD, etc…

Com a informação do módulo você deve encontrar a identificação de cada pino e verificar formas de soldar nos pinos necessários para realizar o flash com conversor USB-TTL.

Ainda nos pinos deve procurar quais pinos são usados para acionar os relés e anotar essa informação para usar no ESPHome.

Eu abri a caixa… wifi rele tem o modulo ESP12F

Com base nesse modelo você consegue a pinagem no datasheet.

Localização dos pinos:

image

Descrição dos pinos:

Nunca realizei gravação de firmware nesse modelo, você pode pesquisar como realizar a ligação do conversor USB-TTL (por exemplo nesse trabalho possui algo sobre).

Boa sorte!

Boa tarde!

Esta é a configuracao que gravei na placa wifi do meu portao.

Para fazer a gravação, use os pinos RX, TX que estão na placa e use o fio preto do negativo.
Para que o ESP entre em modo flash, coloque um jumper (manualmente) entre o negativo e o pino GIO0, com a placa desligada e ligue em seguida. O jumper pode ser retirado depois do boot a gravação acontecerá normalmente. O LED vermelho da placa, se acenderá se o ESP conectar no wifi.

Segue o arquivo para gerar o novo firmware:

substitutions:
devicename: portao_frente

web_server:
port: 80
auth:
username: admin
password: “password”

esphome:
name: $devicename
platform: ESP8266
board: nodemcuv2

time:

  • platform: homeassistant
    id: $devicename

wifi:
networks:

  • ssid: “wifi1”
    password: “password”
  • ssid: “wifi2”
    password: “password”
  • ssid: “wifi3”
    password: “password”
  • ssid: “wifi4”
    password: “password”

Enable fallback hotspot (captive portal) in case wifi connection fails

ap:
ssid: “$devicename”
password: “password”

Example configuration entry

sensor:

  • platform: wifi_signal
    name: “WiFi Signal $devicename”
    update_interval: 60s
  • platform: uptime
    name: “Uptime $devicename”
    #- platform: adc

pin: A0

name: “Teste ADC”

update_interval: 600s

  • platform: adc
    pin: VCC
    name: “VCC Voltage $devicename”

text_sensor:

  • platform: wifi_info
    ip_address:
    name: “ESP IP Address $devicename”
    ssid:
    name: “ESP Connected SSID $devicename”
    bssid:
    name: “ESP Connected BSSID $devicename”
    mac_address:
    name: “ESP Mac Wifi Address $devicename”

captive_portal:

Enable logging

logger:

Enable Home Assistant API

api:
password: “password”
reboot_timeout: 10min
ota:
password: “password”

switch:

  • platform: restart
    name: “$devicename Restart”

  • platform: gpio
    name: “Rele $devicename”
    id: idRele$devicename
    pin: D2
    restore_mode: ALWAYS_OFF

  • platform: gpio
    name: “Led Vermelho $devicename”
    id: idLedVermelho$devicename
    pin: D6
    restore_mode: ALWAYS_OFF

  • platform: gpio
    name: “Abre Fecha $devicename”
    id: idAbreFecha$devicename
    pin: D7
    restore_mode: ALWAYS_OFF

  • platform: restart
    name: “Luz Externa Sala Restart”

binary_sensor:

  • platform: status
    name: “$devicename Status”

  • platform: gpio
    #device_class: presence
    name: “PortaoAberto” # FIO AZUL
    id: idPortaoAberto
    pin:
    #number: RX
    number: D1
    inverted: True
    mode: INPUT_PULLUP
    filters:

    • delayed_on_off: 100ms
  • platform: gpio
    #device_class: presence
    name: “BotaoPlaca”
    id: idBotaoPlaca
    pin:
    #number: RX
    number: D4
    inverted: True
    mode: INPUT_PULLUP
    filters:

    • delayed_on_off: 100ms
  • platform: gpio
    #device_class: presence
    name: “PortaoFechado” # FIO Branco
    id: idPortaoFechado
    pin:
    #number: RX
    number: D5
    inverted: True
    mode: INPUT_PULLUP
    filters:

    • delayed_on_off: 100ms
  • platform: gpio
    #device_class: presence
    name: “D0”
    id: iD0
    pin:
    #number: RX
    number: D0
    inverted: True
    #mode: INPUT_PULLUP
    filters:

    • delayed_on_off: 100ms
  • platform: gpio
    #device_class: presence
    name: “D3”
    id: iD3
    pin:
    #number: RX
    number: D3
    inverted: True
    #mode: INPUT_PULLUP
    filters:

    • delayed_on_off: 100ms
  • platform: gpio
    #device_class: presence
    name: “D8”
    id: iD8
    pin:
    #number: RX
    number: D8
    inverted: True
    #mode: INPUT_PULLUP
    filters:

    • delayed_on_off: 100ms

interval:

  • interval: 1s
    then:
    if:
    condition:
    wifi.connected:
    then:
    if:
    condition:
    switch.is_off: idLedVermelho$devicename
    then:
    - switch.turn_on: idLedVermelho$devicename
    else:
    - switch.turn_off: idLedVermelho$devicename

Bom dia @eduardofbrito, obrigado pela contribuição. Esta configuração que compartilho é para o módulo contatto ppa wifi? Estou exatamente com o mesmo problema. Já inclusive entrei em contato com o fabricante para negociar acesso à API e potencialmente construir a integração, mas eles estão demorando a responder então estou querendo tentar o ESPhome.

@ffumarola você teve sucesso com ese projeto? O meu está com um Wroom02D não sei se o firmware do @eduardofbrito vai funcionar.

Modifiquei um pouco o código do @eduardofbrito. Mas como este tópico é antigo, vou postar um tutorial para quem quiser comprar o Contatto PPA e usar com ESPhome. Por 150 reais, acho que é uma plaquinha pronta que vale a pena usar, mesmo não tendo um portão da PPA em casa.

Oii se vai postar em video o totorial ou vai postar pra nos aqui tenho 2 desse e não funciona direito queria mudar fire dele e colocar no ESP32 que ai rodar mais liso

Bom dia Anderson!

Me dediquei a outro projeto logo após esse, e acabei deixando de lado o post, mas farei.
Utilizei um cover component no código, para aparecer no HA como portão. O hardware, mantive o mesmo que já vem no Contatto PPA, e fiz o flash com ESPhome, utilizando as instruções do @eduardofbrito acima. Preciso entender como postar a caixinha de código, para ficar mais bem organizado, e não sei se o ideal é fazer o próprio thread como um tutorial, ou aproveitar desse.

Meu código tem uma falha que ainda não consegui solucionar. Meu motor é uma jetflex rio 500, com a central triflex facility. Ela tem um recurso que difere das outras, e das gringas, para qual o Cover component foi desenhado. Se o portão está abrindo e um comando é dado, ele para. Mas se o portão está fechando e um comando é dado, ele inverte o sentido e abre. Não consegui achar uma lógica legal que incorporasse isso ao monitoramento. Fora isso, funciona bem. Tenho duas versoes, ambas com funcionamento similar. Deixa eu ter um tempo ocioso no trabalho aqui que posto fotos de como fiz o flash, e o codigo.

Vamos lá. Primeiramente, disclamer:

1: Use este tutorial por responsabilidade própria. NÃO SOU PROFISSIONAL da área. Provavelmente haverão erros, e o que funcionou para mim, não necessariamente funcionará para você.
2: Esta modificação com certeza vai invalidar a sua garantia do Contatto PPA, e talvez do seu motor.
3: Não cometa o mesmo erro que eu. DELIGUE A ENERGIA do portão antes de mexer nele. Tomei um BAITA choque quando estava mechendo e fiquei preso por alguns segundos ao portão. Isso tem mais de um mês, e o ferimento ainda não cicatrizou completamente. CUIDADO!

Será necessário um conversor USB - UART. Eu usei esse:

4 jumper wires para fazer o flash inicial, ou qualquer outro tipo de conexão que julgar melhor. Eu preferi soldar os jumper wires, porquê é o que eu tinha em casa.

Na imagem:

Fio verde: RX
Fio amarelo: GPIO0
Fio branco: TX
Fio azul: 3.3V

Para o flash, fiz via web.esphome.io

Conexão:

UART GND - Fio preto do chicote da foto
UART 3.3V - Fio azul da foto
UART RX - Fio branco da foto (TX)
UART TX - Fio verde da foto (RX)

Antes de ligar tudo, até o início do flash, o fio amarelo deve ser conectado ao GND para colocar o controlador em modo Download.

Se não quiser soldar o fio azul, e tiver facilmente uma fonte 12V, podem ser utilizados os fios vermelho e preto do chicote original como VCC e GND. Como eu não tinha, fiz desse jeito.

Após o flash, EU precisei reiniciar o controlador, cortando a energia e ligando novamente, para configurar o Wifi da casa. Após isso, é possível inclusive já instalar o Contatto no portão (Mais obre isso depois), mas eu fiz o desenvolvimento em bancada com uma fonte 12V que acabei comprando. :slight_smile:

Possiveis problemas: Inversão dos cabos RX/TX.
Falta de drivers do USB/Uart.
Mal contato nas conexões.
Comigo passei pelos 3, sua situação pode ser diferente.

A partir daí, seu novo ESPhome já deve aparecer no seu dashboard. Adicione ele ao home assistant e use um dos códigos abaixo:

Template cover:

substitutions:
    devicename: south_gate

globals:
  - id: performing_last_movement
    type: boolean
    restore_value: no
    initial_value: 'false'    

sensor:
    - platform: wifi_signal
      name: “WiFi Signal $devicename”
      update_interval: 60s
    - platform: uptime
      name: “Uptime $devicename”
    - platform: adc
      pin: A0
      name: “Teste ADC”
      update_interval: 600s
    - platform: adc
      pin: VCC
      name: “VCC Voltage $devicename”
text_sensor:
    - platform: wifi_info
      ip_address:
        name: “ESP IP Address $devicename”
      ssid:
          name: “ESP Connected SSID $devicename”
      bssid:
          name: “ESP Connected BSSID $devicename”
      mac_address:
          name: “ESP Mac Wifi Address $devicename”

switch:
    - platform: restart
      name: “$devicename Restart”

    - platform: gpio
      name: “$devicename Relay”
      id: relay$devicename
      pin: GPIO4
      restore_mode: ALWAYS_OFF

    - platform: gpio
      internal: true
      name: “$devicename LED”
      id: led$devicename
      pin: GPIO12
      restore_mode: ALWAYS_OFF

    - platform: gpio
      name: “Action $devicename”
      icon: "mdi:gate"
      id: Action$devicename
      pin: GPIO13
      restore_mode: ALWAYS_OFF
      on_turn_on:
        - delay: 500ms
        - switch.turn_off: Action$devicename

binary_sensor:
  - platform: status
    name: “$devicename Status”

  - platform: gpio
    #device_class: presence
    name: “$devicename Open” # FIO AZUL
    id: open_endstop_$devicename
    pin: 
      number: GPIO5
      inverted: True
      mode: INPUT_PULLUP
    filters:
        delayed_on_off: 100ms
  
  - platform: gpio
    #device_class: presence
    name: “$devicename Button”
    id: button$devicename
    pin:
    #number: RX
      number: GPIO2
      inverted: True
      mode: INPUT_PULLUP
    filters:
      delayed_on_off: 100ms
  
  - platform: gpio
    #device_class: presence
    name: “$devicename Closed” # FIO Branco
    id: closed_endstop_$devicename
    pin:
    #number: RX
      number: GPIO14
      inverted: True
      mode: INPUT_PULLUP
    filters:
      delayed_on_off: 100ms
  
cover:
  - platform: template
    name: South Gate
    id: southgate
    device_class: garage
    lambda: |-
      if (id(closed_endstop_$devicename).state) //Door at closed endstop
      {
        if (id(southgate).current_operation ==  esphome::cover::COVER_OPERATION_OPENING) //We should be opening
        {
          if (!id(performing_last_movement)) //Make sure we don't trigger this logic twice otherwise it will do unwanted things
          {
            delay(1000); //Wait for door to stop in case reed is triggered too early
            id(Action$devicename).turn_on(); //Press button again
            id(performing_last_movement) = true; //Set flag to indicate we madeknow where the door is
          }
        }
        else if (id(southgate).current_operation ==  esphome::cover::COVER_OPERATION_CLOSING)
        {
          //We should be closing, so all is good
          id(performing_last_movement) = false;
          id(southgate).current_operation =  esphome::cover::COVER_OPERATION_IDLE;
          id(southgate).position = COVER_CLOSED;
          id(southgate).publish_state();
          return COVER_CLOSED;
        }
        else
        {
          //No operation in progress, just send state
          id(performing_last_movement) = false;
          if (!(id(southgate).position == esphome::cover::COVER_CLOSED))
          {
            id(southgate).position = COVER_CLOSED;
            id(southgate).publish_state();
            return COVER_CLOSED;
          }
        }
      }
      else if (id(open_endstop_$devicename).state) //Door at open endstop
      {
        if (id(southgate).current_operation ==  esphome::cover::COVER_OPERATION_CLOSING) //We should be closing
        {
          if (!id(performing_last_movement))  //Make sure we don't trigger this logic twice otherwise it will do unwanted things
          {
            delay(1000);  //Wait for door to stop in case reed is triggered too early
            id(Action$devicename).turn_on(); //Press button again
            id(performing_last_movement) = true; //Set flag to indicate we madeknow where the door is
          }
        }
        else if (id(southgate).current_operation ==  esphome::cover::COVER_OPERATION_OPENING)
        {
          //We should be opening, so all is good
          id(performing_last_movement) = false;
          id(southgate).current_operation =  esphome::cover::COVER_OPERATION_IDLE;
          id(southgate).position = COVER_OPEN;
          id(southgate).publish_state();
          return COVER_OPEN;
        }
        else //Door not at any endstop
        {
          //No operation in progress, just send state
          id(performing_last_movement) = false;
          if (id(southgate).position != esphome::cover::COVER_OPEN)
          {
            id(southgate).position = COVER_OPEN;
            id(southgate).publish_state();
            return COVER_OPEN;
          }
        }
      }
      else
      {
        //The door is halfway open, so set it to OPEN
        if (id(southgate).position != esphome::cover::COVER_OPEN)
          {
            id(southgate).position = COVER_OPEN;
            id(southgate).publish_state();
            return COVER_OPEN;
          }
      }
      return {};
    open_action: 
      - lambda: |-
          id(southgate).current_operation =  esphome::cover::COVER_OPERATION_OPENING;
          if (!id(open_endstop_$devicename).state) {
            id(Action$devicename).turn_on();
            if (id(closed_endstop_$devicename).state) {
              id(performing_last_movement) = true; //Set flag to indicate we know where the door is
            }
          }
    close_action:
      - lambda: |-
          id(southgate).current_operation =  esphome::cover::COVER_OPERATION_CLOSING;
          if (!id(closed_endstop_$devicename).state) {
            id(Action$devicename).turn_on();
            if (id(open_endstop_$devicename).state) {
              id(performing_last_movement) = true; //Set flag to indicate we know where the door is
            }
          }
    stop_action:
      - lambda: |-
            if (id(southgate).current_operation ==  esphome::cover::COVER_OPERATION_OPENING )
            {
              id(southgate).current_operation =  esphome::cover::COVER_OPERATION_IDLE;
              //Stop the door if it is opening
              id(performing_last_movement) = false;
              id(Action$devicename).turn_on();
            }
            else if (id(southgate).current_operation ==  esphome::cover::COVER_OPERATION_CLOSING )
            {
              id(southgate).current_operation =  esphome::cover::COVER_OPERATION_OPENING;
              //return to open if gate is closing
              id(performing_last_movement) = true;
              id(Action$devicename).turn_on();
            }

interval: 
  - interval: 1s
    then:
      - if:
          condition:
            wifi.connected:
          then:
            - if:
                condition:
                  switch.is_off: led$devicename
                then:
                  - switch.turn_on: led$devicename
                else:
                  - switch.turn_off: led$devicename

Feedback Cover e Portão social:

substitutions:
    devicename: north_gate

sensor:
  - platform: wifi_signal
    name: “WiFi Signal $devicename”
    update_interval: 60s
  
  - platform: uptime
    name: “Uptime $devicename”
  - platform: adc
    pin: A0
    name: “Teste ADC”
    update_interval: 600s
  
  - platform: adc
    pin: VCC
    name: “VCC Voltage $devicename”
    
text_sensor:
  - platform: wifi_info
    ip_address:
      name: “ESP IP Address $devicename”
    ssid:
        name: “ESP Connected SSID $devicename”
    bssid:
        name: “ESP Connected BSSID $devicename”
    mac_address:
        name: “ESP Mac Wifi Address $devicename”

switch:
  - platform: restart
    name: “$devicename Restart”

  - platform: gpio
    name: “Social Gate Action"
    id: actionsocialgate
    pin: GPIO4
    restore_mode: ALWAYS_OFF
    on_turn_on:
      - delay: 1s
      - switch.turn_off: actionsocialgate

  - platform: gpio
    name: “Led $devicename”
    id: led$devicename
    internal: true
    pin: GPIO12
    restore_mode: ALWAYS_OFF

  - platform: gpio
    name: “Action $devicename”
    icon: "mdi:gate"
    id: Action$devicename
    pin: GPIO13
    restore_mode: ALWAYS_OFF
    on_turn_on:
      - delay: 500ms
      - switch.turn_off: Action$devicename

binary_sensor:
  - platform: status
    name: “$devicename Status”

  - platform: gpio
    #device_class: presence
    name: “$devicename Open” # FIO AZUL
    id: open$devicename
    pin: 
      number: GPIO5
      inverted: True
      mode: INPUT_PULLUP
    filters:
        delayed_on_off: 100ms
  
  - platform: gpio
    #device_class: presence
    name: “Reset Button $devicename”
    id: ResetButt$devicename
    pin:
    #number: RX
      number: GPIO2
      inverted: True
      mode: INPUT_PULLUP
    filters:
      delayed_on_off: 100ms
  
  - platform: gpio
    #device_class: presence
    name: “$devicename Closed” # FIO Branco
    id: closed$devicename
    pin:
    #number: RX
      number: GPIO14
      inverted: True
      mode: INPUT_PULLUP
    filters:
      delayed_on_off: 100ms

  - platform: homeassistant
    id: socialgatecontact
    # internal: false
    # state_class: presence
    entity_id: binary_sensor.social_gate_contact
    attribute: contact
 
cover:
  - platform: feedback
    name: "North Gate"
    id: NorthGate
    has_built_in_endstop: True
    infer_endstop_from_movement: false
    open_action:
      - switch.turn_on: Action$devicename
    open_duration: 9s
    open_endstop: open$devicename
    close_action:
      - switch.turn_on: Action$devicename
    close_duration: 9s
    close_endstop: closed$devicename
    stop_action:
      - switch.turn_on: Action$devicename
 
#controlador do portão social, usando um sensor zigbee do home assistant 
  - platform: template
    name: "Social Gate"
    id: socialgate
    device_class: door
    # assumed_state: true
    has_position: true
    lambda: |-
      if (id(socialgatecontact).state) {
        // socialgatecontact reports door as closed
        return cover::COVER_CLOSED;
      } 
      else if (!id(socialgatecontact).state) {
        // socialgatecontact reports door as open
        return cover::COVER_OPEN;
      } 
      else {
        return {}; 
      }
    open_action:
      - switch.turn_on: actionsocialgate
      - delay: 1s
      - cover.template.publish:
          id: socialgate

interval: 
  - interval: 1s
    then:
      - if:
          condition:
            wifi.connected:
          then:
            - if:
                condition:
                  switch.is_off: led$devicename
                then:
                  - switch.turn_on: led$devicename
                else:
                  - switch.turn_off: led$devicename 

Não vou entrar em detalhes aqui sobre a diferença entre Template e feedback cover. Como tenho dois portões, usei os dois e venho testando. Verifique a documentação para detalhes.

Instalação:


Esta imagem foi retirada do manual do Contatto PPA Wifi.

No nosso caso, podemos utilizar além do Fim de curso Fechado, o Fim de Curso Aberto do portão, dessa forma podendo confirmar quando o portão está completamente aberto. Infelizmente não tenho capacidade de código ainda para fazer um uso efetivo deste sensor, conseguindo demonstrar no HA se o portão está aberto, fechado, ou parcial. Ao mesmo tempo, caso o funcionamento do portão seja interrompido no meio do movimento, por vezes o HA não registra a posição correta.
De qualquer forma, fim de curso aberto é o fio azul do chicote original.

Utilize o manual de instalação do dispositivo, disponível no site do fabricante para instalação do hardware. Lembre-se de posicionar o Jumper da placa no modo portão. Não testei nenhum dos outros modos.

Muito do código, principalmente o que é cada cabo, veio do @eduardofbrito acima. Eu apenas fiz a correspondência do ESP12F para o ESP01 usando o diagrama de pinos dos dois. Fiz a correspondência apenas dos pinos que usei. Para os outros, deixei de acordo com o código que usei.

Esse é meu primeiro tutorial, então aceito toda e qualquer crítica, mesmo que só pra falar que fiz tudo errado.

cara não entra em dowload de jeito algum. como que luz fica quando está em modo donwload?

Antes de plugar o UART-USB você está conectando o GPIO0 no terra?
Não lembro do led do contatto PPA como ficava, mas o UART-USB, enquanto está fazendo o flash, fica um led azul aceso, depois piscando enquanto está trafegando dados. Posta uma foto de como fez, ou descreve seu processo que eu tento debugar.
Tá usando uma fonte 12V, ou o próprio UART-USB como fonte?
A sua plaquinha é idêntica à minha? O modelo antigo tinha um ESP01 em vez do 12F. O procedimento deveria ser o mesmo, mas vale verificar também.