Q4GA1_SIDECC_R

Gerencia a conexão de um modem celular ao servidor SIDECC-R e publica valores de vazão com timestamp, apoiando-se no bloco SIDECC_R para formatar e enviar as informações. Exige um canal de comunicação previamente configurado para protocolo ASCII. É um bloco de função (mantém estado entre scans; requer instância).

Biblioteca: HI_STD · Namespace: HILS · Tipo: bloco de função

Bloco de função

                Q4GA1_SIDECC_R
           +-----------------------+
  BOOL ----|START             READY|---- BOOL
           |                       |
  BOOL ----|PUBLISH              EV|---- BOOL
           |                       |
  BOOL ----|SW_URL           RESULT|---- INT
           |                       |
  BOOL ----|CONNECTED      CONN_CMD|---- USINT
           |                       |
  BOOL ----|ON_CONFIG              |
           |                       |
  REAL ----|FLOW                   |
           |                       |
    DT ----|TS                     |
           |                       |
STRING ----|USER ----------------- |----
           |                       |
STRING ----|METER ---------------- |----
           |                       |
STRING ----|KEY ------------------ |----
           |                       |
STRING ----|RESTORE_URL ---------- |----
           |                       |
STRING ----|RESTORE_PORT --------- |----
           +-----------------------+

O bloco controla o estado do modem recebendo do módulo de gerência Q4GA1_CONTROLLER os sinais CONNECTED e ON_CONFIG. Através da saída CONN_CMD ele notifica ao modem para ativar ou desativar a conexão corrente.

Quando a entrada SW_URL está ativa, o bloco desconecta o modem e o reprograma com a URL e a porta do SIDECC-R; em seguida reconecta o modem para envio dos dados. Quando SW_URL está inativa, considera-se que o modem já está configurado com a URL do servidor SIDECC-R e o bloco apenas conecta.

Uma vez conectado com sucesso, essa condição é notificada pela saída READY e a aplicação pode enviar os dados através da entrada PUBLISH. Cada transição para ativo dessa entrada envia ao servidor o valor de vazão e o timestamp especificados nos parâmetros FLOW e TS.

Ao terminar o processo pela entrada START, o bloco desconecta o modem; se SW_URL estiver ativa, recarrega os parâmetros originais (RESTORE_URL / RESTORE_PORT) e sinaliza o fim desativando a saída READY. Se necessário, cabe ao usuário reabrir a conexão do modem (pela entrada CONN_ON do módulo de gerência Q4GA1_CONTROLLER).

Nota

Se o processo de inicialização demorar mais que 30 segundos, a saída READY é ativada reportando erro de timeout HILS.GL_CMD_TMO, e o bloco permanece inativo até uma nova transição da entrada START.

Importante

A entrada PUBLISH só deve ser ativada após READY estar ativa e o valor de RESULT da inicialização ser zero, indicando sucesso na abertura da conexão do modem com o servidor SIDECC-R.

Importante

O tamanho da cache do canal de comunicação utilizado para acesso ao servidor SIDECC-R deve ser de no mínimo 700 bytes.

Parâmetros

Nome	Direção	Tipo	Padrão	Faixa / Unidade	Descrição
START	IN	BOOL	FALSE	—	Avaliado por transição de subida: inicia o processo de transmissão para o SIDECC-R.
PUBLISH	IN	BOOL	FALSE	—	Avaliado por transição: publica no servidor SIDECC-R o dado corrente (FLOW / TS).
SW_URL	IN	BOOL	—	—	Reprograma a URL/porta do servidor no modem na inicialização do bloco.
CONNECTED	IN	BOOL	—	—	Sinal CONNECTED do gerenciador do módulo de modem Q4GA1_CONTROLLER.
ON_CONFIG	IN	BOOL	—	—	Sinal ON_CONFIG do gerenciador do módulo de modem Q4GA1_CONTROLLER.
FLOW	IN	REAL	—	m³/s ou l/s	Vazão instantânea a ser publicada.
TS	IN	DT	—	—	Timestamp do valor a ser transmitido.
USER	IN_OUT	STRING	—	—	Nome do usuário cadastrado no SIDECC-R.
METER	IN_OUT	STRING	—	—	Identificação do medidor cadastrado no SIDECC-R.
KEY	IN_OUT	STRING	—	—	Chave de acesso obtida no cadastro no SIDECC-R.
RESTORE_URL	IN_OUT	STRING	—	—	URL/IP a ser reprogramado no modem no retorno (provisório).
RESTORE_PORT	IN_OUT	STRING	—	—	Porta a ser reprogramada no modem no retorno (provisório).
READY	OUT	BOOL	FALSE	—	Pronto para publicar os dados.
EV	OUT	BOOL	FALSE	—	Pulso notificando o fim de um processo (inicialização ou publicação).
RESULT	OUT	INT	0	RET_CODE	Código de retorno da inicialização ou do último processo de publicação.
SIDECC_RESULT	OUT	INT	0	—	Resultado da saída SIDECC_RESP do bloco SIDECC_R (-1 se houve falha antes do acesso ao servidor).
CONN_CMD	OUT	USINT	0	0 .. 2	Comando de conexão do modem (0: idle, 1: conecta, 2: desconecta).

Códigos de retorno

A saída RESULT reporta o resultado do processo notificado por EV. Use os identificadores com o namespace HILS (ex.: HILS.CO_CONEX_FAIL). Valor 0 (HILS.SUCCESS) indica sucesso; valor maior que zero indica falha no acesso ao servidor. Um valor menor que zero indica falha detectada pelo servidor SIDECC-R — nesse caso o código de falha (positivo) é obtido em SIDECC_RESULT (ver SIDECC_RESP). Códigos mais comuns deste bloco:

Código	Identificador	Significado
0	SUCCESS	Processo executado com sucesso.
10	GL_CMD_TMO	Timeout na inicialização (mais de 30 s abrindo a conexão).
63	CO_CONEX_FAIL	Falha no processo de conexão (conexão caiu durante a publicação; reative por START).
67	CO_SOCK_ERR	Erro de socket (não foi possível adquirir/usar o socket).
68	CO_TRA_BUF_OVL	Overflow no buffer de transmissão.

Lista completa dos códigos de retorno: RET_CODE - Códigos de retorno do firmware G5.

Pré-condições

• O canal de comunicação usado para acesso ao servidor SIDECC-R deve estar previamente configurado para protocolo ASCII, sem SOF/EOF e com o recurso de ponto a ponto estendido desabilitado.

• A cache desse canal deve ter no mínimo 700 bytes.

• PUBLISH só deve ser ativada com READY ativa e RESULT da inicialização igual a zero.

• Não altere SW_URL enquanto START estiver ativada.

Observações

• A saída EV gera um pulso ao concluir cada processo: primeiro o de inicialização (após START) e, depois, cada publicação (após PUBLISH). Enquanto EV está ativa, RESULT contém o resultado do processo. Com START desativada, EV permanece inativa.

• CONN_CMD comanda o módulo de modem: 0 = sem ação (mantém o estado corrente), 1 = ativa a conexão, 2 = ativa a desconexão.

• Se RESULT for HILS.SUCCESS (0), SIDECC_RESULT reflete o resultado do processamento efetuado pelo servidor SIDECC-R; caso contrário retorna -1.

Ver também

SIDECC_R, Q4GA1_CONTROLLER

Exemplo

Clique aqui para baixar a tabela de variáveis

Código ST

VAR
    START            : BOOL := FALSE;                   (* Flag de ativação do timer de publicação *)
    TIME_TO_PUBLISH  : BOOL := FALSE;                   (* Flag para ativar o processo de publicação no servidor *)
    PUB_ON_SERVER    : BOOL := FALSE;                   (* Flag para ativar o envio da vazao para o servidor *)
    PUBLISH_COUNT    : USINT := 10;                     (* Nro de dados a serem transferidos para o servidor *)
    PUBLISH_STATE    : USINT := 0;                      (* Estado corrente de publicação no servidor SIDECC *)
    CUR_PUB_INX      : USINT := 0;                      (* Indice do dado a ser enviado para o servidor SIDEC *)
    MODEM_ON         : BOOL := FALSE;                   (* Entrada para ligar conexão do modem *)
    MODEM_OFF        : BOOL := FALSE;                   (* Entrada para desligar conexão do modem *)
    MODEM_RETCODE    : INT := 0;                        (* Ultima falha no módulo de modem *)
    MODEM_ERR_COUNT  : INT := 0;                        (* Contador de falha do módulo de modem *)
    SIDEC_MIN_SAMPLE : USINT := 10;                     (* Intervalo de tempo entre aquisições *)
    SIDECC_RETCODE   : INT := 0;                        (* Codigo de retorno da ultima falha do servidor SIDECC *)
    SIDECC_ERR_COUNT : INT := 0;                        (* Contador de falhas na resposta do servidor SIDECC *)
    TS_VEC           : ARRAY [0..9] OF DT;
    FLOW_VEC         : ARRAY [0..9] OF REAL := 0.0;
    TS               : DT := DT#2024-03-30-00:00:00.00; (* Timestamp associado a vazão *)
    FLOW             : REAL := 100.123;                 (* Vazão a ser publicada *)
    METER            : STRING := '01';                  (* Medidor asoociado a conta SIDECC *)
    USER             : STRING := '400943';              (* Usuário associado a conta SIDECC *)
    KEY              : STRING := 'Ii1uU6cC9Oo4Rr6';     (* Chave de acesso Ao SIDECC *)
    HITEL_IP         : STRING := '54.227.237.88';       (* Endereço do portal de telementria HI *)
    HITEL_PORT       : STRING := '16795';               (* Porta de acesso MODBUS V0 *)
    MODEM            : HILS.Q4GA1_CONTROLLER;           (* Gerenciador de conexão com o MODEM *)
    MODEM_SIDEC      : HILS.Q4GA1_SIDECC_R;             (* Bloco de acesso ao SIDEC via MODEM *)
    SID_TIMER        : HILS.SIDECC_TIMER;               (* Bloco de temporização para publicação no SIDECC *)
END_VAR

// Identifica o momento de registrar um valor de vazão no servidor
SID_TIMER(  // SIDECC_TIMER
  START    := START,  // [BOOL] Ativa o bloco
  UTC_TIME := HILS.GET_UTC_SYSTIME(),  // [DT] Hora corrente em UTC
  INTERVAL := SIDEC_MIN_SAMPLE   // [USINT] Intervalo de tempo em minutos entre registros
  );

IF SID_TIMER.EV THEN
  // Guarda em um vetor os valores para publicação
  TS_VEC[CUR_PUB_INX]   := SID_TIMER.OUT_TIME;
  FLOW_VEC[CUR_PUB_INX] := FLOW;

  // Simula um novo valor de vazão
  FLOW := FLOW + 1.0;

  CUR_PUB_INX           := CUR_PUB_INX + 1;
  IF CUR_PUB_INX = PUBLISH_COUNT THEN
    // Ativa o processo de pulicação de todos os dados salvos
    CUR_PUB_INX     := 0;
    TIME_TO_PUBLISH := TRUE;
  END_IF;
END_IF;

// Se dado em processo de publicação libera o modem para ser controlado
// pelo bloco de função do SIDECC-R
IF TIME_TO_PUBLISH OR MODEM_SIDEC.READY THEN
  MODEM_ON  := (MODEM_SIDEC.CONN_CMD = 1);
  MODEM_OFF := (MODEM_SIDEC.CONN_CMD = 2);
END_IF;

// Gerencia de acesso ao módulo do modem
MODEM(  // Q4GA1_CONTROLLER
  CONN_ON  := MODEM_ON, // [BOOL] Habilita CONEXAO
  CONN_OFF := MODEM_OFF // [BOOL] Habilita CONFIGURACAO
  );

IF (MODEM.EV) THEN
  IF (MODEM.RESULT <> HILS.SUCCESS) THEN
    //(* ... *) Falha identificada no modem
    // Avaliar o trtamento adequado neste caso
    MODEM_RETCODE   := MODEM.RESULT;
    MODEM_ERR_COUNT := MODEM_ERR_COUNT + 1;
  END_IF;
END_IF;

// Gerencia de configuração e acesso ao servidor SIDECC-R
MODEM_SIDEC(  // Q4GA1_SIDECC_R
  START        := TIME_TO_PUBLISH,  // [BOOL] Ativa o processo de transmissão de dados para o SIDEC-R
  PUBLISH      := PUB_ON_SERVER,    // [BOOL] Publica no servidor SIDECC-R o dado especificado
  SW_URL       := TRUE,             // [BOOL] Reprograma URL do servidor no MODEM na inicializacao do bloco
  CONNECTED    := MODEM.CONNECTED,  // [BOOL] Sinal CONNECTED do gerenciador do módulo de modem Q4G4A1
  ON_CONFIG    := MODEM.ON_CONFIG,  // [BOOL] Sinal ON_CONFIG do gerenciador do módulo de modem Q4G4A1
  FLOW         := FLOW,             // [REAL] Vazao instantanea (m3/s ou l/s)
  TS           := TS,               // [DT] Timestamp do valor a ser transmitido
  USER         := USER,             // [STRING] Nome do usuário cadastrado no SIDECC-R
  METER        := METER,            // [STRING] Identificação do medidor cadastrado no SIDECC-R
  KEY          := KEY,              // [STRING] Chave de acesso obtida no cadastro no SIDECC-R
  RESTORE_URL  := HITEL_IP,         // [STRING] URL/IP a ser reprogramado no retorno (provisório)
  RESTORE_PORT := HITEL_PORT        // [STRING] Porta a ser reprogramada no retorno (provisório)
  );

// Maquina de esta de publicação dos valores disponívei no servidor
CASE PUBLISH_STATE OF
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  0:
    IF MODEM_SIDEC.READY THEN
      IF MODEM_SIDEC.RESULT = 0 THEN
        // Pronto para publicar dados
        PUBLISH_STATE := 1;    // Inicia o processo de publicação
      ELSE
        // Falha na inicialização do gerenciado de acesso ao SIDECC
        SIDECC_RETCODE   := MODEM_SIDEC.RESULT;
        SIDECC_ERR_COUNT := SIDECC_ERR_COUNT + 1;
        TIME_TO_PUBLISH  := FALSE; // desativa o BLOCO
      END_IF;
    END_IF;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  1: // Inicia o processo de publicação
    CUR_PUB_INX   := 0;
    PUBLISH_STATE := 2;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  2: // Publica o dado corrente
    IF MODEM_SIDEC.READY THEN
      TS            := TS_VEC[CUR_PUB_INX];   // Obtem o valor da timestamp
      FLOW          := FLOW_VEC[CUR_PUB_INX]; // Obtem o valor da vazao
      PUB_ON_SERVER := TRUE; // sinaliza para publicar no servidor
      PUBLISH_STATE := 3;
    ELSE
      PUBLISH_STATE := 0; // Aguarda habilitar novamente o bloco
    END_IF;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  3: // Aguarda a publicação do módulo
    IF MODEM_SIDEC.EV THEN
      PUB_ON_SERVER  := FALSE;
      SIDECC_RETCODE := MODEM_SIDEC.SIDECC_RESULT;

      // Neste caso deve-se analisar o erro ocorrido para verificar
      // se o processo deve ser cancelado ou não
      IF (SIDECC_RETCODE = 0) OR     //000 SUCESSO
         (SIDECC_RETCODE = 4) OR     //004 DATA/HORA INVÁLIDA
         (SIDECC_RETCODE = 5) OR     //005 MINUTO/SEGUNDO INVÁLIDO
         (SIDECC_RETCODE = 7) OR     //007 OUTRO VALOR GRAVADO NO MESMO MOMENTO
         (SIDECC_RETCODE = 8) THEN   //008 VAZÃO INFORMADA INVÁLIDA
        PUBLISH_STATE := 4; // Se erro ignora o erro e publica o proximo
      ELSE
        //001         SERVIÇO DE ENVIO INATIVO
        //002         USUÁRIO OU CHAVE INVÁLIDO
        //003         MEDIDOR INVÁLIDO
        //006         ERRO REGISTRANDO O VALOR, TENTE MAIS TARDE
        //500         ERRO PROCESSANDO REQUISIÇÃO TENTE NOVAMENTE MAIS TARDE
        //999         ERRO NO PROCESSAMENTO DA REQUISIÇÃO
        PUBLISH_STATE := 5; // Cancela o processo
      END_IF;
    END_IF;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  4: // Avalia se publicou todos os dados
    CUR_PUB_INX := CUR_PUB_INX + 1;
    IF CUR_PUB_INX < PUBLISH_COUNT THEN
      // Publica o proximo dado
      PUBLISH_STATE := 2;
    ELSE
      // Fim do processo de publicação
      PUBLISH_STATE := 5;
    END_IF;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  5: // Fim do processo de publicação
    // O resuultado do processo esta em SIDECC_RETCODE
    PUB_ON_SERVER   := FALSE;
    TIME_TO_PUBLISH := FALSE;
    PUBLISH_STATE := 6;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  6: // Aguarda o processo de desconexão do modem terminar
    IF NOT MODEM_SIDEC.READY THEN
      CUR_PUB_INX     := 0; // reinicializa o indice para recarregar o vetor
      PUBLISH_STATE   := 0; // termina processo da máquina de estados
    END_IF;

  END_CASE;