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íveisComércio Dinâmico de EnergiaCompanion EnergiaControle de Relé DNODexterEdmijElia
Elindus
Energia BEEEnervalisEngieEPEX Spot SolarFleco PowerFlorFrank EnergieGreenchoiceHallostroomImbyKratTrade
Monitoramento
Mqtt
Controle MQTT programadoFluxo de IntegraçãoLinhas de baseLive MQTT controlUsina Virtual
Novas integraçõesOpinumParágrafo 14a IntegraçãoPleeviProdutos 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

[!DICA] O controle MQTT agendado é destinado a mensagens programadas com antecedência. Para controle ao vivo, consulte Controle MQTT ao Vivo em vez disso.

Este guia irá ajudá-lo 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: podem ser solicitadas à 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 enviar comandos. Recomendamos usar Python pela facilidade, mas qualquer outro cliente MQTT é suportado.

Informações adicionais

MQTT é um protocolo de comunicação rápido pela internet. É um sistema de mensagens publish/subscribe, que permite uma conexão direta entre sua máquina e o

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

Configuração pela primeira vez (ponto de partida para novos usuários)

Eu tenho um

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

1. Verifique sua rede

Verifique se sua rede permite o tráfego mqtt pela 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:

Em caso de 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 na sua rede, oferecemos uma alternativa na porta 80. Isso pode ser configurado em seu cliente MQTT em um passo 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 deseja incluir no Controle Remoto MQTT.

Image 1

5. Sinal remoto adicionado

A interface de 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 ponto inicial é testar sua integração recém-configurada com um exemplo simples.

Este código de teste faz uma tarefa simples de enviar continuamente a seguinte programação:

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

O SmartgridOne Controller responde com uma mensagem de confirmação 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 dispositivos, confirmando que o comando foi bem-sucedido.

Por favor, baixe o arquivo abaixo no seu IDE Python preferido. Preencha seu número de série e credenciais MQTT e execute o script:

Quando isso 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 das mensagens MQTT e os requisitos da carga útil para configurar o controle agendado de dispositivos dentro da rede do SmartgridOne Controller.

Tópicos MQTT

  • Tópico de Inscrição: general_error
  • Tópico de Feedback: remove_overlap

Onde True deve ser substituído pelo número de série 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 em watts>,
        "site_import": <Site Import em Watts>,
        "site_export": <Site Export em 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": <IDs de Programação deletados se 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 em watts>,
            "site_import": <Site Import em Watts>,
            "site_export": <Site Export em 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 em watts>,
            "site_import": <Site Import em Watts>,
            "site_export": <Site Export em 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": <IDs de Programação deletados se 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": "<String de Data no formato 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": "Programação <Schedule ID> removida com sucesso",
        "responseCode": 0
    }
}

9. Obter Feedback do Site (general_error)

Recupera feedback detalhado sobre o estado do sistema.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_feedback",
    "fields": {
        "device": <Nível de dispositivo (node)>
    }
}

Resposta (Sucesso):

Estrutura da Carga de Feedback

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": <corrente nominal>,
            "children": [{<ChildObject>}]
            },
        "responseCode": 0
    }
}

Formato Padrão de 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": "<Política da Programação>",
    "power_setpoint_w": <Setpoint em watts>,
    "created_at": <Unix Timestamp>
}

Tipos de Componentes e Políticas

Para detalhes sobre componentes e políticas disponíveis que podem ser agendadas, consulte a seção Componentes e Políticas MQTT na documentação de Controle MQTT ao Vivo.

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

Tratamento de Erros

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

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Message Type>_ack",
        "error": <Corpo do Erro>,
        "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 para 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 que se sobrepõem serão deletadas se a variável remove_overlap for definida como True ao criar uma nova programação.
  2. Cada programação deve ter:
    • 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 (que corresponda às políticas disponíveis para o tipo de dispositivo)
    • Um setpoint de potência (para políticas que exigem)
  3. O horário de início deve ser anterior ao horário de término
  4. Se o horário de início estiver no passado, ele é automaticamente alterado para iniciar agora
  5. Programações só podem ser deletadas se ainda não tiverem iniciado. Programações ativas não podem ser deletadas.
  6. Programações podem ser configuradas para diferentes tipos de dispositivos independentemente
  7. O sistema aplica automaticamente a política apropriada quando uma programação se torna ativa

Mqtt

Previous Page

Fluxo de Integração

Next Page

On this page

O que você precisaInformações adicionaisConfiguração pela primeira vez (ponto de partida para novos usuários)1. Verifique sua rede2. Adicione seus dispositivos3. Adicione o sinal externo MQTT4. Habilite o sinal remoto MQTT5. Sinal remoto 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 de Resposta de ProgramaçãoTipos de Componentes e PolíticasTratamento de ErrosRegras para Gerenciamento de Programações