Funções

Permitem converter os valores dos pontos de natureza analógica de contagens em unidades de engenharia.

Os registradores dos Dispositivos são transmitidos ao SCADA como contagens ou valores numéricos sem uma unidade ou grandeza definida; às vezes requerem escalonamentos, inversões, conversões de ponto flutuante, etc. Por isso, muitas vezes é necessário convertê-los por meio de uma função apropriada.

Para isso utiliza-se uma Função, que conterá um trecho de código JavaScript que será executado tomando como entrada o valor do registrador e devolverá como saída o valor convertido.

Dessa forma, podemos converter o valor bruto 996 em 9,96 Volts aplicando uma Função que divide por 100.

As funções também são utilizadas na seção Cálculos para realizar operações com o valor de um ou mais pontos ou instruções SQL.

Captura de tela

Definição

• Clique em Novo na parte superior direita da janela
• Preencha os seguintes campos

  Campo	Descrição
  Nome	Nome da Função. Será exibido sob este nome na coluna correspondente da seção Pontos
  Função	Informe a função JavaScript a utilizar. Para conversões de valores de pontos, ela deve receber um único argumento; já se for utilizada em um cálculo, deve receber tantos argumentos quantos valores de entrada forem necessários

• Clique em Salvar
• A partir de agora, a nova função estará disponível para ser atribuída nas seções Pontos e Cálculos

Exemplos de funções

Retas

Sua fórmula será do tipo a*x+b; a função deve ser do tipo:

function(x) { return m*x+b;	}

Substitua o coeficiente angular m e o coeficiente linear b pelos valores correspondentes.

O valor bruto sem unidade proveniente do registrador será tomado como parâmetro de entrada x e será calculada a ordenada y.

Por exemplo, se o valor de entrada for 123, o coeficiente angular 2 e o coeficiente linear 5, o valor do ponto será 251

Ponto Flutuante de 32 bits

Função para converter um registrador de 32 bits (ou dois registradores MODBUS de 16 bits consecutivos) quando seu conteúdo tem formato de ponto flutuante de precisão simples (1 bit de sinal, 8 bits de expoente e 23 bits de mantissa).

 1    8               23
+-+--------+-----------------------+
|S|  Exp   |  Mantissa             |
+-+--------+-----------------------+
31 30    23 22                    0

function ieee32ToFloat(intval) {
    var fval = 0.0;
    var x;//exponent
    var m;//mantissa
    var s;//sign
    s = (intval & 0x80000000)?-1:1;
    x = ((intval >> 23) & 0xFF);
    m = (intval & 0x7FFFFF);
    switch(x) {
        case 0:
            //zero, do nothing, ignore negative zero and subnormals
            break;
        case 0xFF:
            if (m) fval = NaN;
            else if (s > 0) fval = Number.POSITIVE_INFINITY;
            else fval = Number.NEGATIVE_INFINITY;
            break;
        default:
            x -= 127;
            m += 0x800000;
            fval = s * (m / 8388608.0) * Math.pow(2, x);
            break;
		}
    return fval;
	}

Ponto Flutuante de 16 bits

Função para converter um registrador de 16 bits quando seu conteúdo tem formato de ponto flutuante de meia precisão (1 bit de sinal, 5 bits de expoente e 10 bits de mantissa).

 1    5      10
+-+-----+----------+
|S| Exp |  Mantissa|
+-+-----+----------+
15 14 10 9        0

function ieee16ToFloat(intval) {
    var exponent = (intval & 0x7C00) >> 10;
        fraction = intval & 0x03FF;
    return (intval >> 15 ? -1 : 1) * (
        exponent ?
        (
            exponent === 0x1F ?
            fraction ? NaN : Infinity :
            Math.pow(2, exponent - 15) * (1 + fraction / 0x400)
        ) :
        6.103515625e-5 * (fraction / 0x400)
    );

Exemplos de funções para a seção Cálculos

Soma de três valores

Esta simples função permite somar o valor de três pontos. Diferentemente das funções anteriores, não pensadas para cálculos, esta recebe três parâmetros de entrada.

function(a,b,c) { return a+b+c;	}

Potência aparente

Função com dois argumentos de entrada, onde p é a potência ativa e q a reativa.

function(p,q) { return Math.sqrt(Math.pow(p,2)+Math.pow(q,2)); }