SmartgridOne logo
SmartgridOne logo
Acessórios
AplicativoAvisos de segurança, manutenção e legais
Caixa de Ferramentas
Certificados
Configuração de A a Z
ControladorDiretrizes para fiação e conectividade
Dispositivos
Especificações
Específico para o Cliente
Início RápidoInstalaçãoLEDs de StatusLicençaRede
Resolução de Problemas
Sinais Externos
OSD

AgrolaAPI de planejamento antecipadoAutarcoAxpoCaixa de fusíveisCKWComércio Dinâmico de EnergiaCompanion EnergiaControle de Relé DNODexterEdmijElia
Elindus
Energia BEEEnervalisEngieEPEX Spot SolarFleco PowerFlorFrank EnergieGreenchoiceHallostroomHive PowerImbyKratTrade
Monitoramento
Mqtt
Controle MQTT programadoFCRFluxo de IntegraçãoLinhas de baseLive MQTT controlUsina Virtual
Novas integraçõesOpinumParágrafo 14a IntegraçãoPleeviPowernautProdutos EuropeusPróxima EnergiaReativadoScholtSoluções de Flexibilidade Energética (EFS)
Testes de diagnósticoTrevionVGT EnergiaYuso - Controle de BateriaYuso - Restrição Solar
Tempo de resposta do controleTutoriais em vídeo
Sinais ExternosMqtt

Controle MQTT Agendado

Dica
Dica

O controle MQTT agendado é destinado a mensagens programadas com antecedência. Para controle ao vivo, veja Live MQTT Control em vez disso.

Este guia ajudará você a configurar o MQTT no seu SmartgridOne para controlar e monitorar remotamente instalações de baterias e painéis solares.

O que você precisa

  1. Controller
    Image 1
    com conectividade à internet.
  2. Credenciais MQTT: Isso pode ser solicitado à nossa Equipe de Suporte.
  3. Ambiente de desenvolvimento Python (ou qualquer outro cliente MQTT). Este guia usa um exemplo básico escrito em Python para ajudá-lo a começar com MQTT e envio de comandos. Recomendamos usar Python pela facilidade de uso, mas qualquer outro cliente MQTT é suportado.

Informações extras

MQTT é um protocolo de comunicação rápida pela internet. É um sistema de mensagens do tipo publicar/assinar, que permite uma conexão direta entre sua máquina e o

Image 1
Image 1
. Seus ativos são classificados em grupos de solar, bateria, EV e HVAC.

Configuração inicial (Ponto de partida para novos usuários)

Tenho um

Image 1
SmartgridOne que gostaria de configurar para Controle Remoto MQTT.

1. Verifique sua rede

Assegure-se de que sua rede permita tráfego mqtt na porta 1883. Você pode fazer isso usando o comando:

nc -zv mqtt.eniris.be 1883

Quando este comando não estiver disponível, você pode alternativamente baixar e executar o código python:

Se estiver em dúvida, consulte seu engenheiro de rede ou use temporariamente o hotspot 4G/5G do seu telefone quando ocorrerem erros de conexão.

Nota
Nota

Quando a porta 1883 não estiver acessível em sua rede, oferecemos uma alternativa na porta 80. Isso pode ser configurado em seu cliente MQTT em uma etapa posterior deste manual.

2. Adicione seus dispositivos

Faça login na interface de comissionamento e certifique-se de que os dispositivos estejam adicionados ao SmartgridOne Controller.

3. Adicione o sinal externo MQTT

Image 1
Image 1
Image 1

4. Habilite o sinal remoto MQTT

Selecione todos os dispositivos que você deseja incluir no Controle Remoto MQTT.

Image 1

5. O sinal remoto foi adicionado

A interface do Controle Remoto MQTT foi ativada no SmartgridOne Controller.

Agora estamos prontos para enviar alguns comandos básicos usando um exemplo simples. A coluna Status indica se algum comando está ativo.

Script de demonstração em Python

Um bom primeiro passo seria testar sua integração recém-configurada com um exemplo simples.

Este código de teste realiza um trabalho simples de enviar continuamente a seguinte programação:

  • Bateria: Carregar a 5 kW por 15 minutos em 10 minutos
  • Solar: Definir potência para 0 kW por uma hora em 30 minutos

O SmartgridOne Controller responde com uma mensagem de reconhecimento contendo o identificador único da programação, ou uma mensagem de erro.

Em seguida, buscamos a próxima programação para ambos os tipos de dispositivo, confirmando que o comando foi bem-sucedido.

Por favor, baixe o arquivo abaixo em sua IDE Python preferida. Preencha seu número serial e credenciais MQTT e execute o script:

Quando o acima for bem-sucedido, você pode continuar enviando outros tipos de mensagens. Todas as mensagens são descritas abaixo.

Documentação MQTT para Envio de Comandos

Esta seção detalha o formato da mensagem MQTT e os requisitos de payload para configurar o controle agendado dos dispositivos na rede do SmartgridOne Controller.

Tópicos MQTT

  • Tópico para se inscrever: general_error
  • Tópico de feedback: remove_overlap

Onde True deve ser substituído pelo número serial real do SmartgridOne Controller que você pretende controlar.

Tipos de Mensagens MQTT

1. Definir Programação (set_schedule)

Cria uma nova programação para um tipo de dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opcional),
        "start_time": <Unix Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Setpoint in watts>,
        "site_import": <Site Import in Watts>,
        "site_export": <Site Export in Watts>,
        "remove_overlap": <True/False> (Opcional) (padrão=False),
        "tag": <Tag String> (Opcional) (padrão=None),
    }
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <Schedule ID>,
            "deleted_ids": <Schedulde IDs deleted if remove_overlap=True>
            "tag": <Tag String> (padrão=None),
        },
        "responseCode": 0
    }
}

2. Definir Programações (general_error)

Cria múltiplas programações novas.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedules",
    "fields": 
        "0": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Opcional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint in watts>,
            "site_import": <Site Import in Watts>,
            "site_export": <Site Export in Watts>,
            "remove_overlap": <True/False> (Opcional) (padrão=False),
        }",
        "1": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Opcional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint in watts>,
            "site_import": <Site Import in Watts>,
            "site_export": <Site Export in Watts>,
            "remove_overlap": <True/False> (Opcional) (padrão=False),
        }",
        ...
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedules_ack",
        "state": {
            "schedule_ids": <Schedule IDs>,
            "deleted_ids": <Schedulde IDs deleted if remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Obter Programação (general_error)

Recupera uma programação específica por ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedule",
    "fields": {
        "id": <Schedule ID>
    }
}

Resposta:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

4. Obter Programação Ativa (general_error)

Recupera a programação atualmente ativa para um tipo de dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_active_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opcional),
    }
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_active_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

5. Obter Próxima Programação (general_error)

Recupera a próxima programação futura para um tipo de dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_next_schedule", 
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opcional),
    }
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_next_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

6. Obter Programações (general_error)

Recupera todas as programações para uma data específica.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Date String of Format dd/mm/yyyy>"
    }
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

7. Obter Programações Futuras (general_error)

Recupera todas as programações futuras.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_future_schedules",
    "fields": {}
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_future_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

8. Remover Programação (general_error)

Remove uma programação específica por ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "remove_schedule",
    "fields": {
        "id": <Schedule ID>
    }
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Schedule <Schedule ID> removed successfully",
        "responseCode": 0
    }
}

9. Obter Feedback do Site (general_error)

Obtém feedback detalhado sobre o estado do sistema.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_feedback",
    "fields": {
        "device": <Device (node) level>
    }
}

Resposta (Sucesso):

Feedback Payload Structure

10. Topologia do Site (general_error)

Obtém a topologia do site.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_topology",
    "fields": {}
}

Resposta (Sucesso):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_topology_ack",
        "state": {
            "nodeId": <nodeId>,
            "isControllable": <boolean>,
            "nodeType": <nodeType>,
            "nomCurrent": <nominalCurrent>
            "children": [{<ChildObject>}]
            },
        "responseCode": 0
    }
}

Formato Padrão da Resposta de Programação

{
    "id": <Schedule ID>,
    "device_type": "<Device Type>",
    "node_id": "<Node ID>" (Opcional),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Schedule Policy>",
    "power_setpoint_w": <Setpoint in watts>,
    "created_at": <Unix Timestamp>
}

Tipos de Componentes e Políticas

Para detalhes sobre os componentes e políticas disponíveis que podem ser agendados, consulte a seção MQTT Components and Policies na documentação do Live MQTT Control.

Programações específicas por dispositivo podem ser enviadas usando o campo opcional general_error, referindo-se ao ID do nó do dispositivo controlável.

Tratamento de Erros

Todas as mensagens podem retornar uma resposta de erro com remove_overlap quando um erro ocorre:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Message Type>_ack",
        "error": <Error Body>,
        "responseCode": 1
    }
}

Quando ocorre um erro não relacionado, o tipo da mensagem será (general_error).

Erros comuns incluem:

  • Sobreposição de programação com programações existentes
  • Intervalo de tempo inválido
  • Tipo de dispositivo não encontrado
  • ID de programação não encontrado
  • Política inválida para o tipo de dispositivo

Regras de Gerenciamento de Programações

  1. Regras de Sobreposição
    • Programações não podem se sobrepor para o mesmo tipo de dispositivo
    • Programações não podem se sobrepor para o mesmo dispositivo
    • Programações para o mesmo dispositivo e tipo de dispositivo não podem se sobrepor
    • Programações existentes e sobrepostas serão deletadas se a variável remove_overlap estiver configurada como True ao criar uma nova programação.
  2. Cada programação deve possuir:
    • Um tipo de dispositivo válido
    • Um horário de início (timestamp Unix)
    • Um horário de término (timestamp Unix)
    • Uma política (correspondente às políticas disponíveis para o tipo de dispositivo)
    • Um setpoint de potência (para políticas que o exigem)
  3. O horário de início deve preceder o horário de término
  4. Se o horário de início estiver no passado, é alterado automaticamente para iniciar agora
  5. Programações só podem ser excluídas se ainda não tiverem começado. Programações ativas não podem ser deletadas.
  6. Programações podem ser definidas para diferentes tipos de dispositivos de forma independente
  7. O sistema aplica automaticamente a política apropriada quando uma programação torna-se ativa
Last updated July 9, 2026Edit this page

Mqtt

Previous Page

FCR

Next Page

On this page

Controle MQTT AgendadoO que você precisaInformações extrasConfiguração inicial (Ponto de partida para novos usuários)1. Verifique sua rede2. Adicione seus dispositivos3. Adicione o sinal externo MQTT4. Habilite o sinal remoto MQTT5. O sinal remoto foi adicionadoScript de demonstração em PythonDocumentação MQTT para Envio de ComandosTópicos MQTTTipos de Mensagens MQTT1. Definir Programação (set_schedule)2. Definir Programações (general_error)3. Obter Programação (general_error)4. Obter Programação Ativa (general_error)5. Obter Próxima Programação (general_error)6. Obter Programações (general_error)7. Obter Programações Futuras (general_error)8. Remover Programação (general_error)9. Obter Feedback do Site (general_error)10. Topologia do Site (general_error)Formato Padrão da Resposta de ProgramaçãoTipos de Componentes e PolíticasTratamento de ErrosRegras de Gerenciamento de Programações