package art.servers.signalsboardserver.controller.pollers;
|
|
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_MODBUSTCP;
|
import art.library.model.devices.signalsboard.information.SignalInformation;
|
import art.library.model.devices.signalsboard.information.SignalInformation_MODBUSTCP;
|
import art.library.model.devices.signalsboard.information.SignalsInformation_MODBUSTCP;
|
import art.library.model.devices.signalsboard.status.SignalStatus;
|
import art.library.model.devices.signalsboard.status.SignalStatusGroup;
|
import art.library.net.modbus.ReaderModbus;
|
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 PollerModbus extends Thread
|
{
|
private SignalsBoard device = null;
|
private SignalsInformation_MODBUSTCP signalsInformation_Modbus = null;
|
private ConfigurationDetail_Model model = null;
|
private ScriptEngineManager factory = new ScriptEngineManager();
|
private ScriptEngine engine = factory.getEngineByName("JavaScript");
|
private String name = null;
|
|
|
public PollerModbus(String name, ConfigurationDetail_Model model, SignalsBoard device, SignalsInformation_MODBUSTCP signalsInformation_Modbus)
|
{
|
this.name = name;
|
this.model = model;
|
this.device = device;
|
this.signalsInformation_Modbus = signalsInformation_Modbus;
|
}
|
|
|
|
public void run()
|
{
|
try
|
{
|
update();
|
}
|
catch (Exception exception)
|
{
|
}
|
}
|
|
|
|
public boolean update() throws Exception
|
{
|
try
|
{
|
SignalsBoardStatus status = device.getDeviceStatus();
|
|
boolean result = true;
|
|
// Inputs
|
|
if (signalsInformation_Modbus.inputs != null)
|
{
|
List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
|
result = result & read(groups, signalsInformation_Modbus.inputs);
|
|
if (groups.size() > 0)
|
{
|
if (status.inputs == null)
|
{
|
status.inputs = new ArrayList<SignalStatusGroup>();
|
}
|
|
status.inputs.addAll(groups);
|
}
|
}
|
|
// Inouts
|
|
if (signalsInformation_Modbus.inouts != null)
|
{
|
List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
|
result = result & read(groups, signalsInformation_Modbus.inouts);
|
|
if (groups.size() > 0)
|
{
|
if (status.inouts == null)
|
{
|
status.inouts = new ArrayList<SignalStatusGroup>();
|
}
|
|
status.inouts.addAll(groups);
|
}
|
}
|
|
// Alarms
|
|
if (signalsInformation_Modbus.alarms != null)
|
{
|
result = result & read(signalsInformation_Modbus.alarms);
|
}
|
|
// Update values with definitions
|
updateDefinitions(status);
|
|
return result;
|
|
}
|
catch (Exception exception)
|
{
|
Shared.traceError(name + ", " + this.signalsInformation_Modbus.address, Shared.getMessage("Update"), exception);
|
return false;
|
}
|
}
|
|
|
|
private void updateDefinitions(SignalsBoardStatus status) throws Exception
|
{
|
try
|
{
|
// Inputs
|
|
if (status.inputs != null)
|
{
|
updateDefinitions(status.inputs);
|
}
|
|
// Inouts
|
|
if (status.inouts != null)
|
{
|
updateDefinitions(status.inouts);
|
}
|
}
|
catch (Exception exception)
|
{
|
Shared.traceError(name + ", " + this.signalsInformation_Modbus.address, Shared.getMessage("Update"), exception);
|
}
|
}
|
|
|
|
|
|
private void updateDefinitions(List<SignalStatusGroup> signalStatusGroup)
|
{
|
for (SignalStatusGroup group : signalStatusGroup)
|
{
|
for (SignalStatus signalStatus : group.signals)
|
{
|
ConfigurationDetail_Definition definition = model.getDefinition(signalStatus.name);
|
|
if (definition != null)
|
{
|
signalStatus.format = SignalStatus.FORMAT_STRING;
|
String value = definition.values.get(signalStatus.value);
|
if (value != null) signalStatus.value = value;
|
}
|
}
|
}
|
}
|
|
|
|
|
|
private boolean read(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
|
{
|
// Read data to update status
|
|
long timestamp = System.currentTimeMillis();
|
|
// Read modbus tcp and update state
|
|
for (SignalInformation signal : signalsInformation)
|
{
|
if (signal instanceof SignalInformation_MODBUSTCP)
|
{
|
SignalInformation_MODBUSTCP signalInformation = (SignalInformation_MODBUSTCP)signal;
|
read(mapSignalsStatus, signalInformation);
|
}
|
}
|
|
return true;
|
}
|
catch (Exception exception)
|
{
|
return false;
|
}
|
finally
|
{
|
}
|
}
|
|
|
|
private void read(HashMap<String, SignalStatus> mapSignalsStatus, SignalInformation_MODBUSTCP signal) throws Exception
|
{
|
ReaderModbus reader = null;
|
|
try
|
{
|
SignalStatus signalStatus = mapSignalsStatus.get(signal.name);
|
reader = new ReaderModbus(signalsInformation_Modbus.address, signalsInformation_Modbus.port, signalsInformation_Modbus.timeout, signalsInformation_Modbus.retries);
|
reader.loadRegisters(signal.address, signal.words);
|
int valueRegister = 0;
|
if (signal.words == 1)
|
{
|
valueRegister = reader.readInt16();
|
}
|
else if (signal.words == 2)
|
{
|
valueRegister = reader.readInt16();
|
}
|
|
double value = (double)valueRegister;
|
int valueInteger = valueRegister;
|
|
if (signal.conversion != null)
|
{
|
double receivedFactor = (signal.conversion.maximumReceivedValue-signal.conversion.minimumReceivedValue);
|
double signalFactor = (signal.conversion.maximumSignalValue-signal.conversion.minimumSignalValue);
|
double factor = (signalFactor / receivedFactor);
|
value = (double)valueRegister - signal.conversion.minimumReceivedValue;
|
value = (value * factor);
|
int v = (int)value * 100;
|
value = (double)v / 100d;
|
valueInteger = (int)value;
|
}
|
|
if (signal.format == SignalInformation.FORMAT_DOUBLE)
|
{
|
if (signal.factor != 1.0d)
|
{
|
signalStatus.value = "" + value * signal.factor;
|
}
|
else
|
{
|
signalStatus.value = "" + value;
|
}
|
}
|
else
|
{
|
if (signal.bit < 0)
|
{
|
signalStatus.value = "" + valueInteger;
|
}
|
else
|
{
|
double pow = Math.pow(2, signal.bit);
|
boolean active = ((valueInteger & (int)pow) > 0);
|
signalStatus.value = "" + active;
|
}
|
}
|
}
|
catch (Exception exception)
|
{
|
Shared.printstack(name, exception);
|
}
|
finally
|
{
|
try{reader.close();} catch (Exception exception){};
|
}
|
}
|
|
|
|
|
private boolean read(List<SignalAlarm> signalsAlarm)
|
{
|
try
|
{
|
for (SignalAlarm signalAlarm : signalsAlarm)
|
{
|
if (signalAlarm instanceof SignalAlarm_MODBUSTCP)
|
{
|
read((SignalAlarm_MODBUSTCP)signalAlarm);
|
}
|
}
|
|
return true;
|
}
|
catch (Exception exception)
|
{
|
return false;
|
}
|
}
|
|
|
|
|
|
|
|
|
private void read(SignalAlarm_MODBUSTCP signalAlarm) throws Exception
|
{
|
ReaderModbus reader = null;
|
|
try
|
{
|
reader = new ReaderModbus(signalsInformation_Modbus.address, signalsInformation_Modbus.port, signalsInformation_Modbus.timeout, signalsInformation_Modbus.retries);
|
reader.loadRegisters(signalAlarm.address, signalAlarm.words);
|
int valueRegister = 0;
|
if (signalAlarm.words == 1)
|
{
|
valueRegister = reader.readInt16();
|
}
|
else if (signalAlarm.words == 2)
|
{
|
valueRegister = reader.readInt16();
|
}
|
|
double value = (double)valueRegister;
|
int valueInteger = valueRegister;
|
|
if (signalAlarm.bit >= 0)
|
{
|
double pow = Math.pow(2, signalAlarm.bit);
|
valueInteger = (int)((valueInteger & (int)pow));
|
}
|
|
if (signalAlarm.eval != null)
|
{
|
String assignment = valueInteger + " " + signalAlarm.eval;
|
device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
|
}
|
else
|
{
|
device.setAlarm(signalAlarm.name, valueInteger > 0);
|
}
|
|
}
|
catch (Exception exception)
|
{
|
Shared.printstack(name, exception);
|
}
|
finally
|
{
|
try{reader.close();} catch (Exception exception){};
|
}
|
}
|
|
}
|
