package art.servers.signalsboardserver.controller.pollers;
|
|
import art.library.interop.InteropParameter;
|
import art.library.interop.InteropParameters;
|
import art.library.interop.InteropResponse;
|
import art.library.interop.serialization.Serialization;
|
import art.library.model.devices.Device;
|
import art.library.model.devices.eru.status.inout.InputStatus;
|
import art.library.model.devices.signalsboard.SignalsBoard;
|
import art.library.model.devices.signalsboard.SignalsBoardStatus;
|
import art.library.model.devices.signalsboard.alarms.SignalAlarm;
|
import art.library.model.devices.signalsboard.alarms.SignalAlarm_ERU;
|
import art.library.model.devices.signalsboard.alarms.SignalAlarm_SNMP;
|
import art.library.model.devices.signalsboard.information.SignalInformation;
|
import art.library.model.devices.signalsboard.information.SignalInformation_ERU;
|
import art.library.model.devices.signalsboard.information.SignalsInformation_ERU;
|
import art.library.model.devices.signalsboard.status.SignalStatus;
|
import art.library.model.devices.signalsboard.status.SignalStatusGroup;
|
import art.servers.Shared;
|
import art.servers.signalsboardserver.configuration.ConfigurationDetail_Definition;
|
import art.servers.signalsboardserver.configuration.ConfigurationDetail_Model;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import javax.script.ScriptEngine;
|
import javax.script.ScriptEngineManager;
|
|
|
public class PollerERU extends Thread
|
{
|
private SignalsBoard device = null;
|
private SignalsInformation_ERU signalsInformation_ERU = null;
|
private ConfigurationDetail_Model model = null;
|
private ScriptEngineManager factory = new ScriptEngineManager();
|
private ScriptEngine engine = factory.getEngineByName("JavaScript");
|
private String name = null;
|
|
|
public PollerERU(String name, ConfigurationDetail_Model model, SignalsBoard device, SignalsInformation_ERU signalsInformation_ERU)
|
{
|
this.name = name;
|
this.model = model;
|
this.device = device;
|
this.signalsInformation_ERU = signalsInformation_ERU;
|
}
|
|
|
|
public void run()
|
{
|
try
|
{
|
update();
|
}
|
catch (Exception exception)
|
{
|
}
|
}
|
|
|
|
public boolean update() throws Exception
|
{
|
try
|
{
|
SignalsBoardStatus status = device.getDeviceStatus();
|
|
boolean result = true;
|
|
// Inputs
|
Device eru = Shared.model.getDeviceExternal(signalsInformation_ERU.eru);
|
|
if (signalsInformation_ERU.inputs != null)
|
{
|
List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
|
result = result & read(eru, groups, signalsInformation_ERU.inputs);
|
|
if (groups.size() > 0)
|
{
|
if (status.inputs == null)
|
{
|
status.inputs = new ArrayList<SignalStatusGroup>();
|
}
|
|
status.inputs.addAll(groups);
|
}
|
}
|
|
// Inouts
|
|
if (signalsInformation_ERU.inouts != null)
|
{
|
List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
|
result = result & read(eru, groups, signalsInformation_ERU.inouts);
|
|
if (groups.size() > 0)
|
{
|
if (status.inouts == null)
|
{
|
status.inouts = new ArrayList<SignalStatusGroup>();
|
}
|
|
status.inouts.addAll(groups);
|
}
|
}
|
|
// Alarms
|
|
if (signalsInformation_ERU.alarms != null)
|
{
|
result = result & read(eru, signalsInformation_ERU.alarms, status);
|
}
|
|
return result;
|
|
}
|
catch (Exception exception)
|
{
|
Shared.traceError(name + ", " + this.signalsInformation_ERU.eru, Shared.getMessage("Update"), exception);
|
return false;
|
}
|
finally
|
{
|
}
|
}
|
|
|
|
|
|
private boolean read(Device eru, List<SignalStatusGroup> groups, List<SignalInformation> signalsInformation)
|
{
|
HashMap<String, SignalStatusGroup> mapGroups = new HashMap<String, SignalStatusGroup>();
|
HashMap<String, SignalStatus> mapSignalsStatus = new HashMap<String, SignalStatus>();
|
|
// Initialise all status signals
|
|
for (SignalInformation signalInformation : signalsInformation)
|
{
|
SignalStatus signalStatus = new SignalStatus();
|
signalStatus.name = signalInformation.name;
|
signalStatus.units = signalInformation.units;
|
signalStatus.description = signalInformation.description;
|
mapSignalsStatus.put(signalStatus.name, signalStatus);
|
|
SignalStatusGroup group = mapGroups.get(signalInformation.group);
|
|
if (group == null)
|
{
|
group = new SignalStatusGroup();
|
group.name = signalInformation.group;
|
group.signals = new ArrayList<SignalStatus>();
|
groups.add(group);
|
mapGroups.put(group.name, group);
|
}
|
|
group.signals.add(signalStatus);
|
}
|
|
|
// Read all signals
|
|
try
|
{
|
for (SignalInformation signal : signalsInformation)
|
{
|
if (signal instanceof SignalInformation_ERU)
|
{
|
SignalInformation_ERU signalInformation = (SignalInformation_ERU)signal;
|
SignalStatus signalStatus = mapSignalsStatus.get(signalInformation.name);
|
read(eru, signalInformation, signalStatus);
|
}
|
}
|
|
return true;
|
}
|
catch (Exception exception)
|
{
|
return false;
|
}
|
}
|
|
|
|
|
|
|
private boolean read(Device eru, List<SignalAlarm> signalsAlarm, SignalsBoardStatus status)
|
{
|
try
|
{
|
for (SignalAlarm signalAlarm : signalsAlarm)
|
{
|
if (signalAlarm instanceof SignalAlarm_ERU)
|
{
|
read(eru, (SignalAlarm_ERU)signalAlarm);
|
}
|
else if (signalAlarm instanceof SignalAlarm)
|
{
|
read(eru, signalAlarm, status);
|
}
|
}
|
|
return true;
|
}
|
catch (Exception exception)
|
{
|
return false;
|
}
|
finally
|
{
|
}
|
}
|
|
|
|
|
|
|
|
|
private void read(Device eru, SignalInformation_ERU signalInformation, SignalStatus signalStatus) throws Exception
|
{
|
try
|
{
|
InteropParameters parameters = new InteropParameters();
|
parameters.addParameter(new InteropParameter("operation", "getInput"));
|
parameters.addParameter(new InteropParameter("device", eru.getIdentifier()));
|
parameters.addParameter(new InteropParameter("inputs", "" + signalInformation.number));
|
InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, eru.getDeviceInformation().serverAddress, eru.getDeviceInformation().serverPort, 15000);
|
InputStatus inputStatus = (InputStatus)response.getValue()[0];
|
|
ConfigurationDetail_Definition definition = model.getDefinition(signalInformation.name);
|
|
if (definition != null)
|
{
|
signalStatus.format = SignalStatus.FORMAT_STRING;
|
signalStatus.value = definition.values.get(Integer.parseInt(inputStatus.value));
|
if (signalStatus.value == null) signalStatus.value = inputStatus.value;
|
return;
|
}
|
|
if (signalInformation.format == SignalInformation.FORMAT_DOUBLE)
|
{
|
if (signalInformation.conversion != null)
|
{
|
double receivedFactor = (signalInformation.conversion.maximumReceivedValue-signalInformation.conversion.minimumReceivedValue);
|
double signalFactor = (signalInformation.conversion.maximumSignalValue-signalInformation.conversion.minimumSignalValue);
|
double factor = (signalFactor / receivedFactor);
|
double value = Double.parseDouble(inputStatus.value) - signalInformation.conversion.minimumReceivedValue;
|
value = (value * factor);
|
int v = (int)value * 100;
|
value = (double)v / 100d;
|
signalStatus.value = "" + value;
|
}
|
else if (signalInformation.factor != 1.0d)
|
{
|
signalStatus.value = "" + Double.parseDouble(inputStatus.value) * signalInformation.factor;
|
}
|
else
|
{
|
signalStatus.value = inputStatus.value;
|
}
|
}
|
else
|
{
|
signalStatus.value = inputStatus.value;
|
}
|
}
|
catch (Exception exception)
|
{
|
Shared.printstack(name, exception);
|
Shared.println(name, "Group: " + signalInformation.group + " Name: " + signalInformation.name + " Eru: " + eru.getIdentifier() + " Number: " + signalInformation.number);
|
}
|
}
|
|
|
|
|
private void read(Device eru, SignalAlarm_ERU signalAlarm) throws Exception
|
{
|
InteropParameters parameters = new InteropParameters();
|
parameters.addParameter(new InteropParameter("operation", "getInput"));
|
parameters.addParameter(new InteropParameter("device", eru.getIdentifier()));
|
parameters.addParameter(new InteropParameter("inputs", "" + signalAlarm.number));
|
InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, eru.getDeviceInformation().serverAddress, eru.getDeviceInformation().serverPort, 15000);
|
InputStatus inputStatus = (InputStatus)response.getValue()[0];
|
|
if (signalAlarm.eval != null)
|
{
|
String assignment = Double.parseDouble(inputStatus.value) + " " + signalAlarm.eval;
|
device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
|
}
|
else
|
{
|
device.setAlarm(signalAlarm.name, Double.parseDouble(inputStatus.value) > 0);
|
}
|
}
|
|
|
|
|
private void read(Device eru, SignalAlarm signalAlarm, SignalsBoardStatus status) throws Exception
|
{
|
SignalStatus signalStatus = status.getSignal(signalAlarm.signal);
|
if (signalStatus.value == null) device.setAlarm(signalAlarm.name, true);
|
|
if (signalAlarm.eval != null)
|
{
|
String assignment = Double.parseDouble(signalStatus.value) + " " + signalAlarm.eval;
|
device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
|
}
|
else
|
{
|
device.setAlarm(signalAlarm.name, Double.parseDouble(signalStatus.value) > 0);
|
}
|
}
|
|
}
|
