package art.servers.etdserver.controller;
|
|
|
import art.library.model.devices.DeviceStatus;
|
import art.library.model.devices.etd.Etd;
|
import art.library.model.devices.etd.EtdInformation;
|
import art.library.interop.serialization.Serialization;
|
import art.library.model.devices.Device;
|
import art.library.model.devices.etd.status.EtdStatusVehicle;
|
import art.library.model.transactions.traces.Trace;
|
import art.library.utils.synchro.Mutex;
|
import art.servers.ServerException;
|
import art.servers.etdserver.Shared;
|
import art.servers.etdserver.protocols.diamond.Diamond_Message;
|
import art.servers.etdserver.protocols.diamond.Diamond_ProtocolAnalyser;
|
import art.servers.etdserver.protocols.diamond.Diamond_ProtocolConstructor;
|
import java.io.File;
|
import java.io.FileOutputStream;
|
import java.io.InputStream;
|
import java.io.OutputStream;
|
import static java.lang.Thread.sleep;
|
import java.net.Socket;
|
import java.net.SocketTimeoutException;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Calendar;
|
import java.util.Date;
|
import java.util.List;
|
|
|
public class ControllerDiamondRaw extends ControllerEtd
|
{
|
private SimpleDateFormat sdh = new SimpleDateFormat("HH:mm");
|
private boolean connected = false;
|
private Socket socket = null;
|
private InputStream is = null;
|
private OutputStream os = null;
|
private int status = DeviceStatus.STATUS_ALARM;
|
private boolean firstTime = true;
|
private long lastVehicle = System.currentTimeMillis();
|
private long MAX_TIME_WITHOUT_VEHICLE_DETECTION = 30L*60000L;
|
private int MAX_VEHICLES = 100;
|
private Mutex mutexList = new Mutex();
|
private List<EtdStatusVehicle> lvehicle = new ArrayList<EtdStatusVehicle>();
|
private ControllerDataIntegration controllerDataIntegration = null;
|
private long diftime = 0;
|
|
|
public ControllerDiamondRaw(Etd etd)
|
{
|
super(etd);
|
this.device = etd;
|
this.name = Shared.getMessage("Controller etd") + " " + etd.information.name;
|
}
|
|
|
|
|
public void run()
|
{
|
controllerDataIntegration = new ControllerDataIntegration((ControllerEtd)this);
|
controllerDataIntegration.start();
|
// <editor-fold defaultstate="collapsed" desc="Trace">
|
art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Starting"), art.servers.Shared.getMessage("Success")), true);
|
// </editor-fold>
|
status = DeviceStatus.STATUS_ONLINE;
|
|
while ((isInterrupted() == false) && (exit == false))
|
{
|
long startTimestamp = System.currentTimeMillis();
|
|
try
|
{
|
if (art.servers.Shared.isServerEnabled() == true)
|
{
|
if (connected == false)
|
{
|
connect();
|
}
|
|
update();
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
if (startTimestamp > System.currentTimeMillis())
|
{
|
startTimestamp = System.currentTimeMillis();
|
}
|
|
long stopTimestamp = startTimestamp + (device.getDeviceInformation().polling * 1000);
|
|
while ((System.currentTimeMillis() < stopTimestamp) && (exit == false))
|
{
|
try
|
{
|
sleep(50);
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
if (art.servers.Shared.model.existsDevice(device.getIdentifier()) == false)
|
{
|
art.servers.Shared.println(name, art.servers.Shared.getMessage("Device no longer exists"));
|
exit = true;
|
}
|
}
|
|
// <editor-fold defaultstate="collapsed" desc="Trace">
|
art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Finishing"), art.servers.Shared.getMessage("Success")), true);
|
// </editor-fold>
|
}
|
|
|
|
|
/*
|
Private controller functions
|
*/
|
|
private void update() throws Exception
|
{
|
Etd etdclone = (Etd)Serialization.clone(device);
|
|
try
|
{
|
EtdInformation etdInformation = (EtdInformation)etdclone.getDeviceInformation();
|
|
startMonitorTrafficData(etdclone);
|
|
// TODO
|
// How to maintain traffic counter in time?
|
|
while (true)
|
{
|
try
|
{
|
// Have a timeout, which if exceeded close connection and re-activate monitoring
|
// EtdRealtime realtime = (EtdRealtime)etd.getDeviceRealtime();
|
|
Diamond_Message response = read(new byte[0]);
|
List<EtdStatusVehicle> list = Diamond_ProtocolAnalyser.analyseVehicleResponse(etdclone, response.getResponseString());
|
if (list.size() > 0) lastVehicle = System.currentTimeMillis();
|
if (list.size() == 1)
|
{
|
EtdStatusVehicle vehicle = list.get(0);
|
diftime = System.currentTimeMillis()-vehicle.timestamp;
|
}
|
|
try
|
{
|
for (EtdStatusVehicle vehicle : list)
|
{
|
mutexList.lockWrite(5000);
|
|
try
|
{
|
vehicle.timestamp = vehicle.timestamp + diftime;
|
logVehicle(etdclone, vehicle);
|
lvehicle.add(vehicle);
|
checkListSize();
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
mutexList.releaseWrite();
|
}
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
|
if ((System.currentTimeMillis()-lastVehicle) > MAX_TIME_WITHOUT_VEHICLE_DETECTION)
|
{
|
lastVehicle = System.currentTimeMillis();
|
try{disconnect();} catch (Exception ex){};
|
return;
|
}
|
}
|
catch (SocketTimeoutException e)
|
{
|
if ((System.currentTimeMillis()-lastVehicle) > MAX_TIME_WITHOUT_VEHICLE_DETECTION)
|
{
|
e.printStackTrace();
|
lastVehicle = System.currentTimeMillis();
|
try{disconnect();} catch (Exception ex){};
|
return;
|
}
|
}
|
catch (ServerException e)
|
{
|
e.printStackTrace();
|
throw e;
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
throw e;
|
}
|
}
|
}
|
catch (Exception exception)
|
{
|
if ((etdclone.alarms.alarm_offline <= 0) || (firstTime == true))
|
{
|
firstTime = false;
|
String message = art.servers.Shared.getMessage("Etd offline");
|
art.servers.Shared.println(name, exception);
|
}
|
|
try{disconnect();} catch (Exception ex){};
|
}
|
}
|
|
|
public List<EtdStatusVehicle> getVehicles (long timestamp)
|
{
|
List<EtdStatusVehicle> lresult = new ArrayList<EtdStatusVehicle>();
|
|
try
|
{
|
mutexList.lockRead();
|
|
for (EtdStatusVehicle vehicle : lvehicle)
|
{
|
if (vehicle.timestamp > timestamp)
|
{
|
lresult.add(vehicle);
|
}
|
}
|
|
return(lresult);
|
}
|
catch (Exception e)
|
{
|
}
|
finally
|
{
|
mutexList.releaseRead();
|
}
|
|
return(lresult);
|
}
|
|
|
public List<EtdStatusVehicle> getVehiclesPeriod (long timestamp1, long timestamp2)
|
{
|
List<EtdStatusVehicle> lresult = new ArrayList<EtdStatusVehicle>();
|
|
try
|
{
|
mutexList.lockRead();
|
|
for (EtdStatusVehicle vehicle : lvehicle)
|
{
|
if ((vehicle.timestamp >= timestamp1) && (vehicle.timestamp <= timestamp2))
|
{
|
lresult.add(vehicle);
|
}
|
}
|
|
return(lresult);
|
}
|
catch (Exception e)
|
{
|
}
|
finally
|
{
|
mutexList.releaseRead();
|
}
|
|
return(lresult);
|
}
|
|
|
|
|
private void startMonitorTrafficData (Etd etdclone) throws Exception
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.CR();
|
Diamond_Message response = read(command);
|
response.checkError();
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.RESETCOMMS();
|
Diamond_Message response = read(command);
|
response.checkError();
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
int retries = 0;
|
while (retries < 5)
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.CR();
|
Diamond_Message response = read(command);
|
response.checkError();
|
|
if ((response.getResponseString().toUpperCase().indexOf("PHO") > -1) ||
|
(response.getResponseString().toUpperCase().indexOf("UN") > -1))
|
{
|
int index = response.getResponseString().indexOf("PHO#");
|
if (index < 0)
|
{
|
index = response.getResponseString().indexOf("UNI#");
|
}
|
|
if (index > -1)
|
{
|
String sversion = response.getResponseString().substring(index+4, index+7);
|
int version = Integer.parseInt(sversion);
|
float f = (float)(((float)version) / 100f);
|
if ((etdclone.getDeviceInformation().firmwareVersion == null) || (etdclone.getDeviceInformation().firmwareVersion.length() == 0))
|
etdclone.getDeviceInformation().firmwareVersion = "" + f;
|
}
|
|
retries = 5;
|
}
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
retries++;
|
}
|
|
|
// Check datetime before starting monitor traffic data
|
checkDatetime(etdclone);
|
|
boolean error = true;
|
retries = 0;
|
while (error == true)
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.startMonitorTrafficData();
|
Diamond_Message response = read(command);
|
response.checkError();
|
Diamond_ProtocolAnalyser.analyseStartMonitorTrafficDataResponse(response);
|
error = false;
|
}
|
catch (Exception e)
|
{
|
retries++;
|
if (retries == 3) throw e;
|
}
|
}
|
}
|
|
|
private void startCollecting (Etd etdclone)
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.startCollecting();
|
Diamond_Message response = read(command);
|
response.checkError();
|
response.checkCommand(response.getResponseString().getBytes(), command);
|
}
|
catch (Exception e)
|
{
|
|
}
|
}
|
|
|
private void stopCollecting ()
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.stopCollecting();
|
Diamond_Message response = read(command);
|
response.checkError();
|
response.checkCommand(response.getResponseString().getBytes(), command);
|
}
|
catch (Exception e)
|
{
|
|
}
|
}
|
|
|
private void checkDatetime (Etd etdclone)
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.getSystemStatusCounter();
|
Diamond_Message response = read(command);
|
long timestamp = System.currentTimeMillis();
|
response.checkError();
|
response.checkCommand(response.getResponseString().getBytes(), command);
|
|
Diamond_Message message = new Diamond_Message();
|
message.setData(response.getDataByte(), command);
|
long timeDifference = 0;
|
long currenttime = 0;
|
boolean collecting = false;
|
|
if (etdclone.getDeviceInformation().firmwareVersion.indexOf("5.") > -1)
|
{
|
message.get6X();
|
message.get2X();
|
message.get2X();
|
message.get2X();
|
message.get4X();
|
message.get4X();
|
message.get4X();
|
message.get6X();
|
message.get6X();
|
message.get1X();
|
collecting = (message.get1X() == 0x01);
|
int hour = message.get2X();
|
int minute = message.get2X();
|
int seconds = message.get2X();
|
int mseconds = message.get2X();
|
int month = message.get2X();
|
int date = message.get2X();
|
int year = message.get2X();
|
int dayOfWeek = message.get2X();
|
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(Calendar.HOUR_OF_DAY, hour);
|
calendar.set(Calendar.MINUTE, minute);
|
calendar.set(Calendar.SECOND, seconds);
|
calendar.set(Calendar.MILLISECOND, mseconds);
|
calendar.set(Calendar.YEAR, year+2000);
|
calendar.set(Calendar.MONTH, month-1);
|
calendar.set(Calendar.DATE, date);
|
|
currenttime = calendar.getTimeInMillis();
|
timeDifference = Math.abs((currenttime-timestamp));
|
}
|
else
|
{
|
message.get6X();
|
message.get2X();
|
message.get2X();
|
message.get4X();
|
message.get4X();
|
message.get6X();
|
message.get6X();
|
message.get1X();
|
collecting = (message.get1X() == 0x01);
|
int hour = message.get2X();
|
int minute = message.get2X();
|
int seconds = message.get2X();
|
int mseconds = message.get2X();
|
int month = message.get2X();
|
int date = message.get2X();
|
int year = message.get2X();
|
int dayOfWeek = message.get2X();
|
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(Calendar.HOUR_OF_DAY, hour);
|
calendar.set(Calendar.MINUTE, minute);
|
calendar.set(Calendar.SECOND, seconds);
|
calendar.set(Calendar.MILLISECOND, mseconds);
|
calendar.set(Calendar.YEAR, year+2000);
|
calendar.set(Calendar.MONTH, month-1);
|
calendar.set(Calendar.DATE, date);
|
|
currenttime = calendar.getTimeInMillis();
|
timeDifference = Math.abs((currenttime-timestamp));
|
}
|
|
if (timeDifference >= 10000)
|
{
|
Shared.println(device.information.name, "Datetime incorrect: " + new Date(timestamp).toString() + " - " + new Date(currenttime).toString() + " - DIF: " + timeDifference + " - Collecting?: " + collecting);
|
|
if (collecting == true)
|
{
|
// Stop collecting before set datetime
|
stopCollecting();
|
}
|
|
updateDatetimeCounter(etdclone);
|
|
startCollecting(etdclone);
|
}
|
}
|
catch (Exception e)
|
{
|
|
}
|
}
|
|
|
private void updateDatetimeCounter (Etd etdclone)
|
{
|
try
|
{
|
byte[] command = Diamond_ProtocolConstructor.sendDatetimeCounter();
|
Diamond_Message response = read(command);
|
response.checkError();
|
response.checkCommand(response.getResponseString().getBytes(), command);
|
Shared.println(device.information.name, "Datetime updated OK");
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
Shared.println(device.information.name, e);
|
}
|
}
|
|
|
|
|
private void updateVersion (Etd etdclone, String connectionString)
|
{
|
try
|
{
|
int index = connectionString.indexOf("PHO#");
|
if (index < 0)
|
{
|
index = connectionString.indexOf("UNI#");
|
}
|
|
if (index > -1)
|
{
|
String sversion = connectionString.substring(index+4, index+7);
|
int version = Integer.parseInt(sversion);
|
float f = (float)(((float)version) / 100f);
|
if ((etdclone.getDeviceInformation().firmwareVersion == null) || (etdclone.getDeviceInformation().firmwareVersion.length() == 0))
|
etdclone.getDeviceInformation().firmwareVersion = "" + f;
|
}
|
}
|
catch (Exception e)
|
{
|
|
}
|
}
|
|
|
public boolean isConnected ()
|
{
|
return(this.connected);
|
}
|
|
|
private void connect()
|
{
|
try
|
{
|
if (this.socket != null)
|
{
|
if (this.connected == true)
|
{
|
return;
|
}
|
}
|
|
this.socket = new Socket(this.device.getDeviceInformation().connection.address, this.device.getDeviceInformation().connection.port);
|
this.socket.setSoTimeout(this.device.getDeviceInformation().connection.timeout);
|
this.is = this.socket.getInputStream();
|
this.os = this.socket.getOutputStream();
|
this.connected = true;
|
|
if (status != DeviceStatus.STATUS_ONLINE)
|
{
|
String message = Shared.getMessage("Connected, address = %1, port = %2, timeout = %3");
|
message = message.replace("%1", device.getDeviceInformation().connection.address);
|
message = message.replace("%2", "" +device.getDeviceInformation().connection.port);
|
message = message.replace("%3", "" + device.getDeviceInformation().connection.timeout);
|
Shared.println(device.information.name, message);
|
status = DeviceStatus.STATUS_ONLINE;
|
}
|
|
}
|
catch (Exception e)
|
{
|
try{disconnect();} catch (Exception ex){};
|
}
|
|
}
|
|
|
private void disconnect() throws Exception
|
{
|
try { is.close(); }catch (Exception e) {}
|
try { os.close(); }catch (Exception e) {}
|
try { socket.close(); }catch (Exception e) {}
|
is = null;
|
os = null;
|
socket = null;
|
this.connected = false;
|
}
|
|
|
|
private Diamond_Message read(byte[] command) throws Exception
|
{
|
try
|
{
|
if (command.length > 0) send(command);
|
return receive();
|
}
|
catch (Exception e)
|
{
|
throw e;
|
}
|
}
|
|
|
|
private void send(byte[] command) throws Exception
|
{
|
socket.getOutputStream().write(command);
|
socket.getOutputStream().flush();
|
}
|
|
|
|
private Diamond_Message receive() throws Exception
|
{
|
boolean salir = false;
|
int res = 0;
|
byte[] trama = null;
|
|
int longitud = 0;
|
int apuntador = 0;
|
|
try
|
{
|
while ((res = is.read()) == 0){sleep(10);};
|
|
trama = new byte[65535];
|
trama[apuntador] = (byte)res;
|
apuntador++;
|
res = is.read();
|
|
while (true)
|
{
|
trama[apuntador] = (byte)res;
|
apuntador++;
|
res = is.read();
|
}
|
}
|
catch (SocketTimeoutException e)
|
{
|
if (apuntador > 0)
|
{
|
longitud = apuntador;
|
}
|
else
|
throw e;
|
}
|
catch (Exception e)
|
{
|
throw e;
|
}
|
|
byte[] resultado = new byte[longitud];
|
System.arraycopy(trama, 0, resultado, 0, longitud);
|
|
Diamond_Message message = new Diamond_Message();
|
message.setData(resultado);
|
return(message);
|
}
|
|
|
private void checkListSize()
|
{
|
if (lvehicle.size() > MAX_VEHICLES)
|
{
|
int number = lvehicle.size() - MAX_VEHICLES;
|
for (int i=0; i<number; i++)
|
{
|
lvehicle.remove(0);
|
}
|
}
|
}
|
|
|
private void logVehicle (Etd etdclone, EtdStatusVehicle vehicle)
|
{
|
try
|
{
|
String sline = Device.getDate(System.currentTimeMillis()) + ": " + etdclone.getIdentifier() + " - TS: " + new Date(vehicle.timestamp) + " - Lane: " + vehicle.lane + " - Speed " + vehicle.speed + " - Length: " + vehicle.length + " - Axles: " + vehicle.axles + "\r\n";
|
FileOutputStream fos = new FileOutputStream(new File("etd/" + etdclone.getIdentifier() + ".dat"), true);
|
fos.write(sline.getBytes());
|
fos.flush();
|
fos.close();
|
fos = null;
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
}
|
}
|
