package art.servers.etdserver.protocols.diamond;
|
|
import art.library.model.devices.Device;
|
import art.library.model.devices.DeviceStatus;
|
import art.library.model.devices.etd.Etd;
|
import art.library.model.devices.etd.EtdInformation;
|
import art.library.model.devices.etd.EtdStatus;
|
import art.library.model.devices.etd.status.EtdStatusLane;
|
import art.library.interop.serialization.Serialization;
|
import art.library.model.devices.etd.status.EtdStatusVehicle;
|
import art.servers.etdserver.Shared;
|
import art.servers.etdserver.controller.ControllerEtd;
|
import art.servers.etdserver.protocols.diamond.configuration.DIAMOND_LengthBinnedData;
|
import art.servers.etdserver.protocols.diamond.configuration.DIAMOND_SpeedBinnedData;
|
import art.servers.etdserver.protocols.diamond.file.DIAMOND_Binned;
|
import art.servers.etdserver.protocols.diamond.file.DIAMOND_File;
|
import art.servers.etdserver.protocols.diamond.files.DIAMOND_Directory;
|
import java.util.ArrayList;
|
import java.util.Calendar;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.StringTokenizer;
|
|
|
public class Diamond_ProtocolAnalyser
|
{
|
public static final int MASK_CHAR = 0x7D;
|
public static final int FLAG_CHAR = 0x7E;
|
|
|
public static int[] getData(int[] command)
|
{
|
int[] result = new int[command.length-3];
|
System.arraycopy(command, 1, result, 0, result.length);
|
return(unapplyMask(result));
|
}
|
|
|
public static int[] unapplyMask(int[] command)
|
{
|
try
|
{
|
int newLength = 0;
|
for (int i=0; i<command.length; i++)
|
{
|
if (command[i] == MASK_CHAR)
|
newLength--;
|
newLength++;
|
}
|
|
int[] result = new int[newLength];
|
int index = 0;
|
result[index++] = command[0];
|
for (int i=1; i<command.length-1; i++)
|
{
|
if (command[i] == MASK_CHAR)
|
{
|
if (command[i+1] == 0x5D)
|
result[index++] = MASK_CHAR;
|
else if (command[i+1] == 0x5E)
|
result[index++] = FLAG_CHAR;
|
i++;
|
}
|
else
|
{
|
result[index++] = command[i];
|
}
|
}
|
|
result[index++] = command[command.length-1];
|
return(result);
|
}
|
catch (Exception e)
|
{
|
return(command);
|
}
|
}
|
|
|
public static int[] createMessage(int[] command, int crc)
|
{
|
int[] result = new int[command.length + 3];
|
int index = 0;
|
result[index++] = FLAG_CHAR;
|
for (int i=0; i<command.length; i++)
|
{
|
result[index++] = command[i];
|
}
|
|
result[index++] = crc;
|
result[index++] = FLAG_CHAR;
|
return(result);
|
}
|
|
|
public static int crc(int[] command)
|
{
|
int crc = 0;
|
for (int i=0; i<command.length; i++)
|
{
|
crc += command[i];
|
}
|
|
return(crc%256);
|
}
|
|
|
public static void analyseSendPasswordResponse(Diamond_Message message) throws Exception
|
{
|
String str = message.getResponseString();
|
if (str.indexOf("OK") < 0) throw new Exception("Error sending counter password");
|
}
|
|
|
public static void analyseStartMonitorTrafficDataResponse(Diamond_Message message) throws Exception
|
{
|
String str = message.getResponseString();
|
if (str.indexOf("M01") < 0) throw new Exception("Error starting monitor traffic data");
|
}
|
|
|
public static DIAMOND_LengthBinnedData analyseGetLengthBinTableResponse(String firmwareversion, Diamond_Message message) throws Exception
|
{
|
DIAMOND_LengthBinnedData lenghtBinnedData = new DIAMOND_LengthBinnedData(firmwareversion, message.getResponseString());
|
return(lenghtBinnedData);
|
}
|
|
|
public static DIAMOND_SpeedBinnedData analyseGetSpeedBinTableResponse(Diamond_Message message) throws Exception
|
{
|
DIAMOND_SpeedBinnedData speedBinnedData = new DIAMOND_SpeedBinnedData(message.getResponseString());
|
return(speedBinnedData);
|
}
|
|
|
public static DIAMOND_Directory analyseGetFilesDirectoryResponse(Etd etd, Diamond_Message message) throws Exception
|
{
|
DIAMOND_Directory directory = new DIAMOND_Directory(etd.getDeviceInformation().firmwareVersion, message.getResponseString());
|
return(directory);
|
}
|
|
// A vehicle response is
|
// "2: 19:46:45.87 60.4kph, Length= 420cm, S#4 L#2 \r\n"
|
// "9: 19:46:45.45 SnMis #1\r\n"
|
// "2: 19:46:48.70 68.9kph, Length= 466cm, S#4 L#2 \r\n"
|
// "9: 19:47:47.77 SnMis #1\r\n"
|
// "9: 19:48:03.63 SnMis #1\r\n"
|
// "1: 19:48:13.31 103.4kph, Length= 327cm, S#8 L#2 \r\n"
|
// "2: 19:48:13.23 101.9kph, Length= 637cm, S#8 L#2 \r\n"
|
// "2: 19:48:24.70 92.7kph, Length= 434cm, S#7 L#2 \r\n"
|
// "2: 19:48:59.06 71.0kph, Length= 462cm, S#5 L#2 \r\n"
|
// "9: 19:49:06.29 SnMis #1\r\n"
|
// "2: 19:49:09.97 81.5kph, Length= 479cm, S#6 L#2 \r\n"
|
// "2: 19:50:11.26 58.7kph, Length= 614cm, S#3 L#2 \r\n"
|
// "2: 19:50:47.02 79.3kph, Length= 448cm, S#5 L#2 \r\n"
|
// "2: 19:50:50.82 72.8kph, Length= 408cm, S#5 L#2 \r\n"
|
// "9: 19:50:51.25 SnMis #1\r\n"
|
// "2: 19:52:51.65 75.9kph, Length= 772cm, S#5 L#3 \r\n"
|
|
public static List<EtdStatusVehicle> analyseVehicleResponse(Etd device, String response) throws Exception
|
{
|
try
|
{
|
List<EtdStatusVehicle> lvehicle = new ArrayList<EtdStatusVehicle>();
|
|
// System.out.println(device.getIdentifier() + " - ResponseVehicles: " + response);
|
|
StringTokenizer strtokVehicles = new StringTokenizer(response, "\n");
|
int countVehicles = strtokVehicles.countTokens();
|
|
for (int c=0; c<countVehicles; c++)
|
{
|
String svehicle = strtokVehicles.nextToken();
|
|
if (isVehicleDetection(svehicle) == true)
|
{
|
EtdStatusVehicle vehicle = new EtdStatusVehicle();
|
|
StringTokenizer strtok = new StringTokenizer(svehicle, " ");
|
int count = strtok.countTokens();
|
for (int i=0; i<count; i++)
|
{
|
String str = strtok.nextToken();
|
if ((str.indexOf(":") > -1) && (str.indexOf(".") < 0))
|
{
|
vehicle.lane = Integer.parseInt(str.replaceAll("\\*", "").replaceAll(":", ""));
|
}
|
else if ((str.indexOf(":") > -1) && (str.indexOf(".") > -1))
|
{
|
String stime = str + "0";
|
StringTokenizer strtokTime = new StringTokenizer(stime, ":");
|
int count2 = strtokTime.countTokens();
|
int hour = Integer.parseInt(strtokTime.nextToken());
|
int min = Integer.parseInt(strtokTime.nextToken());
|
String ssec = strtokTime.nextToken();
|
StringTokenizer strtokSeconds = new StringTokenizer(ssec, ".");
|
int seconds = Integer.parseInt(strtokSeconds.nextToken());
|
int milliseconds = Integer.parseInt(strtokSeconds.nextToken());
|
|
Calendar calCurrent = Calendar.getInstance();
|
calCurrent.setTimeInMillis(System.currentTimeMillis());
|
if ((calCurrent.get(Calendar.HOUR_OF_DAY) == 0) && (hour == 23))
|
{
|
// Es un vehiculo detectado en el cambio de día
|
Calendar cal = Calendar.getInstance();
|
cal.setTimeInMillis(calCurrent.getTimeInMillis());
|
cal.set(Calendar.DATE, cal.get(Calendar.DATE)-1);
|
cal.set(Calendar.HOUR_OF_DAY, hour);
|
cal.set(Calendar.MINUTE, min);
|
cal.set(Calendar.SECOND, seconds);
|
cal.set(Calendar.MILLISECOND, milliseconds);
|
vehicle.timestamp = cal.getTimeInMillis();
|
}
|
else
|
{
|
Calendar cal = Calendar.getInstance();
|
cal.setTimeInMillis(calCurrent.getTimeInMillis());
|
cal.set(Calendar.HOUR_OF_DAY, hour);
|
cal.set(Calendar.MINUTE, min);
|
cal.set(Calendar.SECOND, seconds);
|
cal.set(Calendar.MILLISECOND, milliseconds);
|
vehicle.timestamp = cal.getTimeInMillis();
|
}
|
}
|
else
|
{
|
if (str.indexOf("kph") > -1)
|
{
|
vehicle.speed = Double.parseDouble(str.substring(0, str.indexOf("kph")));
|
}
|
else if (str.indexOf("cm") > -1)
|
{
|
vehicle.length = Integer.parseInt(str.substring(0, str.indexOf("cm")));
|
}
|
else if (str.indexOf("SnMis") > -1)
|
{
|
vehicle.speed = 0d;
|
vehicle.length = 0;
|
vehicle.axles = 0;
|
vehicle.axlesSpacing = new int[0];
|
}
|
else if (str.indexOf("S#") > -1)
|
{
|
// vehicle.speedBin = Integer.parseInt(str.substring(str.indexOf("S#")+2));
|
}
|
else if (str.indexOf("L#") > -1)
|
{
|
// vehicle.lengthBin = Integer.parseInt(str.substring(str.indexOf("L#")+2));
|
}
|
}
|
}
|
|
lvehicle.add(vehicle);
|
}
|
else
|
{
|
}
|
}
|
|
return(lvehicle);
|
}
|
catch (Exception e)
|
{
|
throw e;
|
}
|
}
|
|
|
public static boolean analyseRetrieveFileDataContent(Etd etdoriginal, Etd etd, DIAMOND_File file, DIAMOND_LengthBinnedData lengthBinnedData, DIAMOND_SpeedBinnedData speedBinnedData) throws Exception
|
{
|
long millis = System.currentTimeMillis();
|
boolean delete = false;
|
EtdInformation information = etd.getDeviceInformation();
|
|
int periods = file.ltimestamps.size();
|
periods = Math.min(periods, file.lbinnedSpeed.size());
|
periods = Math.min(periods, file.lbinnedLength.size());
|
|
DiamondLengthRelation[] lengthRelations8 = createLengthRelations8();
|
DiamondLengthRelation[] lengthRelations9 = createLengthRelations9();
|
DiamondLengthRelation[] lengthRelations11 = createLengthRelations11();
|
Shared.println(etd.information.name, "1.ANALYSE: #periods: " + periods + " - DIF: " + (System.currentTimeMillis()-millis));
|
|
for (int i=0; i<periods; i++)
|
{
|
try
|
{
|
EtdStatus statusOriginal = etdoriginal.getDeviceStatus();
|
long lastTimestamp = Device.getTimestamp(statusOriginal.getMeasurementTimestamp());
|
long timestampPeriod = file.ltimestamps.get(i).longValue() + (etd.getDeviceInformation().period*1000L);
|
|
if (timestampPeriod > lastTimestamp)
|
{
|
Shared.println(etd.information.name, "2.ANALYSE: period[" + i + "] LAST: " + new Date(lastTimestamp).toString() + " PERIOD: " + new Date(timestampPeriod).toString() + " - DIF: " + (System.currentTimeMillis()-millis));
|
Etd etdData = (Etd)Serialization.clone(etd);
|
EtdStatus status = etdData.getDeviceStatus();
|
status.period = etdData.getDeviceInformation().period;
|
if (status.llane.size() < information.lLane.size())
|
{
|
for (int f=status.llane.size(); f<information.lLane.size(); f++)
|
{
|
EtdStatusLane laneStatus = new EtdStatusLane();
|
laneStatus.number = information.lLane.get(f).number;
|
laneStatus.totalMeasurements = 1;
|
laneStatus.correctMeasurements = 1;
|
laneStatus.lengths = new int[information.lLengthClassification.size()];
|
laneStatus.speeds = new int[information.lSpeedClassification.size()];
|
laneStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
|
status.llane.add(laneStatus);
|
}
|
}
|
else if (status.llane.size() > information.lLane.size())
|
{
|
for (int f=status.llane.size()-1; f>=information.lLane.size(); f--)
|
{
|
status.llane.remove(status.llane.size()-1);
|
}
|
}
|
|
for (int f=0; f<status.llane.size(); f++)
|
{
|
EtdStatusLane laneStatus = status.llane.get(f);
|
laneStatus.totalMeasurements = 1;
|
laneStatus.correctMeasurements = 1;
|
if ((laneStatus.lengths.length != information.lLengthClassification.size()) || (laneStatus.speeds.length != information.lSpeedClassification.size()))
|
laneStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
|
if (laneStatus.lengths.length != information.lLengthClassification.size())
|
laneStatus.lengths = new int[information.lLengthClassification.size()];
|
if (laneStatus.speeds.length != information.lSpeedClassification.size())
|
laneStatus.speeds = new int[information.lSpeedClassification.size()];
|
|
for (int j=0; j<laneStatus.lengths.length; j++)
|
laneStatus.lengths[j] = 0;
|
for (int j=0; j<laneStatus.speeds.length; j++)
|
laneStatus.speeds[j] = 0;
|
for (int j=0; j<laneStatus.speedxlength.length; j++)
|
{
|
for (int k=0; k<laneStatus.speedxlength[j].length; k++)
|
laneStatus.speedxlength[j][k] = 0;
|
}
|
|
laneStatus.counting = 0;
|
laneStatus.unclassified = 0;
|
laneStatus.occupancy = 0;
|
laneStatus.speed = 0;
|
}
|
|
if (status.lsection.size() < information.lSection.size())
|
{
|
for (int f=status.lsection.size(); f<information.lSection.size(); f++)
|
{
|
EtdStatusLane sectionStatus = new EtdStatusLane();
|
sectionStatus.number = information.lSection.get(f).number;
|
sectionStatus.lengths = new int[information.lLengthClassification.size()];
|
sectionStatus.speeds = new int[information.lSpeedClassification.size()];
|
sectionStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
|
status.lsection.add(sectionStatus);
|
}
|
}
|
else if (status.lsection.size() > information.lSection.size())
|
{
|
for (int f=status.lsection.size()-1; f>=information.lSection.size(); f--)
|
{
|
status.lsection.remove(status.lsection.size()-1);
|
}
|
}
|
|
for (int f=0; f<status.lsection.size(); f++)
|
{
|
EtdStatusLane sectionStatus = status.lsection.get(f);
|
if ((sectionStatus.lengths.length != information.lLengthClassification.size()) || (sectionStatus.speeds.length != information.lSpeedClassification.size()))
|
sectionStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
|
if (sectionStatus.lengths.length != information.lLengthClassification.size())
|
sectionStatus.lengths = new int[information.lLengthClassification.size()];
|
if (sectionStatus.speeds.length != information.lSpeedClassification.size())
|
sectionStatus.speeds = new int[information.lSpeedClassification.size()];
|
|
for (int j=0; j<sectionStatus.lengths.length; j++)
|
sectionStatus.lengths[j] = 0;
|
for (int j=0; j<sectionStatus.speeds.length; j++)
|
sectionStatus.speeds[j] = 0;
|
for (int j=0; j<sectionStatus.speedxlength.length; j++)
|
{
|
for (int k=0; k<sectionStatus.speedxlength[j].length; k++)
|
sectionStatus.speedxlength[j][k] = 0;
|
}
|
|
sectionStatus.counting = 0;
|
sectionStatus.unclassified = 0;
|
sectionStatus.occupancy = 0;
|
sectionStatus.speed = 0;
|
}
|
|
status.total = new EtdStatusLane();
|
status.total.number = 0;
|
status.total.totalMeasurements = information.lLane.size();
|
status.total.correctMeasurements = information.lLane.size();
|
status.total.lengths = new int[information.lLengthClassification.size()];
|
status.total.speeds = new int[information.lSpeedClassification.size()];
|
status.total.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
|
for (int j=0; j<status.total.lengths.length; j++)
|
status.total.lengths[j] = 0;
|
for (int j=0; j<status.total.speeds.length; j++)
|
status.total.speeds[j] = 0;
|
for (int j=0; j<status.total.speedxlength.length; j++)
|
{
|
for (int k=0; k<status.total.speedxlength[j].length; k++)
|
status.total.speedxlength[j][k] = 0;
|
}
|
|
status.total.counting = 0;
|
status.total.unclassified = 0;
|
status.total.occupancy = 0;
|
status.total.speed = 0;
|
|
|
status.setMeasurementTimestamp(Device.getDate(timestampPeriod));
|
|
try
|
{
|
int nlanes = etdData.getDeviceInformation().lLane.size();
|
|
if (nlanes == file.llaneConfiguration.size())
|
{
|
// Without directional lanes
|
|
DIAMOND_Binned binnedSpeed = file.lbinnedSpeed.get(i);
|
for (int l=0; l<file.llaneConfiguration.size(); l++)
|
{
|
int[] speeds = binnedSpeed.valores[l];
|
int total = 0;
|
for (int s=0; s<speeds.length; s++)
|
{
|
if (s < status.total.speeds.length)
|
{
|
status.llane.get(l).speeds[s] = speeds[s];
|
total += speeds[s];
|
}
|
}
|
|
float speed = 0f;
|
for (int s=0; s<speeds.length; s++)
|
{
|
speed += ((float)speeds[s]) * speedBinnedData.bins[s].avgSpeed;
|
}
|
|
if (total > 0)
|
{
|
status.llane.get(l).speed = (int)((speed / (float)total) / 10);
|
}
|
}
|
}
|
else if ((nlanes*2) == file.llaneConfiguration.size())
|
{
|
// With directional lanes
|
|
DIAMOND_Binned binnedSpeed = file.lbinnedSpeed.get(i);
|
for (int l=0; l<nlanes; l++)
|
{
|
int[] speeds1 = binnedSpeed.valores[l];
|
int oppositeLane = etd.getDeviceInformation().lLane.get(l).oppositeLane-9+nlanes;
|
int[] speeds2 = new int[speeds1.length];
|
if (oppositeLane >= 0)
|
{
|
speeds2 = binnedSpeed.valores[oppositeLane];
|
}
|
|
int total = 0;
|
for (int s=0; s<speeds1.length; s++)
|
{
|
if (s < status.total.speeds.length)
|
{
|
status.llane.get(l).speeds[s] = speeds1[s] + speeds2[s];
|
total += speeds1[s] + speeds2[s];
|
}
|
}
|
|
float speed = 0f;
|
for (int s=0; s<speeds1.length; s++)
|
{
|
speed += ((float)speeds1[s]) * speedBinnedData.bins[s].avgSpeed;
|
speed += ((float)speeds2[s]) * speedBinnedData.bins[s].avgSpeed;
|
}
|
|
if (total > 0)
|
{
|
status.llane.get(l).speed = (int)((speed / (float)total) / 10);
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
try
|
{
|
int nlanes = etdData.getDeviceInformation().lLane.size();
|
|
if (nlanes == file.llaneConfiguration.size())
|
{
|
// Without directional lanes
|
|
DIAMOND_Binned binnedLength = file.lbinnedLength.get(i);
|
for (int l=0; l<file.llaneConfiguration.size(); l++)
|
{
|
int total = 0;
|
int[] lengths = binnedLength.valores[l];
|
DiamondLengthRelation[] relations = null;
|
if (lengths.length == 8) relations = lengthRelations8;
|
if (lengths.length == 9) relations = lengthRelations9;
|
if (lengths.length == 11) relations = lengthRelations11;
|
for (int s=0; s<lengths.length; s++)
|
{
|
DiamondLengthRelation relation = getRelation(relations, s);
|
if (relation.lublinClassification < status.total.lengths.length)
|
{
|
status.llane.get(l).lengths[relation.lublinClassification] = status.llane.get(l).lengths[relation.lublinClassification] + lengths[s];
|
total += lengths[s];
|
}
|
}
|
|
status.llane.get(l).counting = total;
|
}
|
}
|
else if ((nlanes*2) == file.llaneConfiguration.size())
|
{
|
// With directional lanes
|
|
DIAMOND_Binned binnedLength = file.lbinnedLength.get(i);
|
for (int l=0; l<nlanes; l++)
|
{
|
int total = 0;
|
int[] lengths1 = binnedLength.valores[l];
|
int oppositeLane = etd.getDeviceInformation().lLane.get(l).oppositeLane-9+nlanes;
|
int[] lengths2 = new int[lengths1.length];
|
if (oppositeLane >= 0)
|
{
|
lengths2 = binnedLength.valores[oppositeLane];
|
}
|
|
DiamondLengthRelation[] relations = null;
|
if (lengths1.length == 8) relations = lengthRelations8;
|
if (lengths1.length == 9) relations = lengthRelations9;
|
if (lengths1.length == 11) relations = lengthRelations11;
|
for (int s=0; s<lengths1.length; s++)
|
{
|
DiamondLengthRelation relation = getRelation(relations, s);
|
if (relation.lublinClassification < status.total.lengths.length)
|
{
|
status.llane.get(l).lengths[relation.lublinClassification] = status.llane.get(l).lengths[relation.lublinClassification] + lengths1[s] + lengths2[s];
|
total += lengths1[s] + lengths2[s];
|
}
|
}
|
|
status.llane.get(l).counting = total;
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
try
|
{
|
DIAMOND_Binned binnedError = file.lbinnedError.get(i);
|
}
|
catch (Exception e)
|
{
|
}
|
|
|
// Sections calculation
|
Shared.setSectionsData(etdData);
|
|
// Total calculation
|
Shared.setTotalData(etdData);
|
|
|
if (etdData.alarms.alarm_offline > 0)
|
{
|
String message = art.servers.Shared.getMessage("Etd online");
|
try
|
{
|
art.servers.Shared.println(((ControllerEtd)art.servers.Shared.getDeviceController(etdData.getIdentifier())).getControllerName(), message);
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
}
|
|
etdData.setAlarm("alarm_offline", false);
|
etdData.setAlarm("alarm_invalid", false);
|
|
// if (i == periods-1)
|
{
|
// CHECK
|
// Shared.model.updateDeviceStatus(etdData, etdData.getDeviceStatus().measurementTimestamp);
|
etdData.setLastTimestampStatusUpdate(etdData.getDeviceStatus().measurementTimestamp);
|
Shared.println(etd.information.name, "3.ANALYSE: period[" + i + "] LAST: " + new Date(lastTimestamp).toString() + " PERIOD: " + etdData.getDeviceStatus().getMeasurementTimestamp() + " - DIF: " + (System.currentTimeMillis()-millis));
|
}
|
|
|
// Fill maxSpeed, overspeedCars, heavyTrucks
|
int speedLimit = etdData.getDeviceInformation().speedLimit;
|
if (speedLimit <= 0)
|
{
|
speedLimit = getSpeedLimit(etd.getIdentifier());
|
}
|
|
for (int l=0; l<etdData.getDeviceStatus().llane.size(); l++)
|
{
|
EtdStatusLane laneStatus = etdData.getDeviceStatus().llane.get(l);
|
int totalTrucksLane = 0;
|
int totalVehiclesLane = laneStatus.counting;
|
for (int j=0; j<laneStatus.lengths.length; j++)
|
{
|
if (laneStatus.lengths.length <= 2)
|
{
|
if (j == 1) totalTrucksLane += laneStatus.lengths[j];
|
}
|
else if (laneStatus.lengths.length >= 7)
|
{
|
if ((j == 3) || (j == 4) || (j == 5)) totalTrucksLane += laneStatus.lengths[j];
|
}
|
}
|
|
laneStatus.overspeedCars = 0;
|
for (int k=0; k<laneStatus.speeds.length; k++)
|
{
|
if (laneStatus.speeds[k] > 0)
|
{
|
laneStatus.maxSpeed = (double)((double)etdData.getDeviceInformation().lSpeedClassification.get(k).upperLimit + (double)etdData.getDeviceInformation().lSpeedClassification.get(k).lowerLimit) / 2d;
|
|
if (etdData.getDeviceInformation().lSpeedClassification.get(k).lowerLimit >= speedLimit)
|
{
|
laneStatus.overspeedCars += laneStatus.speeds[k];
|
}
|
}
|
}
|
|
if (totalVehiclesLane > 0)
|
{
|
laneStatus.heavyTrucks = (float)((float)totalTrucksLane / (float)totalVehiclesLane) * 100f;
|
int heavyTrucks = (int)(laneStatus.heavyTrucks*100f);
|
laneStatus.heavyTrucks = (float)((float)heavyTrucks / 100f);
|
}
|
|
if (laneStatus.maxSpeed > 0)
|
{
|
int maxSpeed = (int)(laneStatus.maxSpeed*100d);
|
laneStatus.maxSpeed = (double)((double)maxSpeed / 100d);
|
}
|
}
|
|
for (int s=0; s<etdData.getDeviceStatus().lsection.size(); s++)
|
{
|
EtdStatusLane sectionStatus = etdData.getDeviceStatus().lsection.get(s);
|
int totalTrucksLane = 0;
|
int totalVehiclesLane = sectionStatus.counting;
|
for (int j=0; j<sectionStatus.lengths.length; j++)
|
{
|
if (sectionStatus.lengths.length <= 2)
|
{
|
if (j == 1) totalTrucksLane += sectionStatus.lengths[j];
|
}
|
else if (sectionStatus.lengths.length >= 7)
|
{
|
if ((j == 3) || (j == 4) || (j == 5)) totalTrucksLane += sectionStatus.lengths[j];
|
}
|
}
|
|
sectionStatus.overspeedCars = 0;
|
for (int k=0; k<sectionStatus.speeds.length; k++)
|
{
|
if (sectionStatus.speeds[k] > 0)
|
{
|
sectionStatus.maxSpeed = (double)((double)etdData.getDeviceInformation().lSpeedClassification.get(k).upperLimit + (double)etdData.getDeviceInformation().lSpeedClassification.get(k).lowerLimit) / 2d;
|
|
if (etdData.getDeviceInformation().lSpeedClassification.get(k).lowerLimit >= speedLimit)
|
{
|
sectionStatus.overspeedCars += sectionStatus.speeds[k];
|
}
|
}
|
}
|
|
if (totalVehiclesLane > 0)
|
{
|
sectionStatus.heavyTrucks = (float)((float)totalTrucksLane / (float)totalVehiclesLane) * 100f;
|
int heavyTrucks = (int)(sectionStatus.heavyTrucks*100f);
|
sectionStatus.heavyTrucks = (float)((float)heavyTrucks / 100f);
|
}
|
|
if (sectionStatus.maxSpeed > 0)
|
{
|
int maxSpeed = (int)(sectionStatus.maxSpeed*100d);
|
sectionStatus.maxSpeed = (double)((double)maxSpeed / 100d);
|
}
|
}
|
|
|
EtdStatusLane totalStatus = etdData.getDeviceStatus().total;
|
int totalTrucksLane = 0;
|
int totalVehiclesLane = totalStatus.counting;
|
for (int j=0; j<totalStatus.lengths.length; j++)
|
{
|
if (totalStatus.lengths.length <= 2)
|
{
|
if (j == 1) totalTrucksLane += totalStatus.lengths[j];
|
}
|
else if (totalStatus.lengths.length >= 7)
|
{
|
if ((j == 3) || (j == 4) || (j == 5)) totalTrucksLane += totalStatus.lengths[j];
|
}
|
}
|
|
totalStatus.overspeedCars = 0;
|
for (int k=0; k<totalStatus.speeds.length; k++)
|
{
|
if (totalStatus.speeds[k] > 0)
|
{
|
totalStatus.maxSpeed = (double)((double)etdData.getDeviceInformation().lSpeedClassification.get(k).upperLimit + (double)etdData.getDeviceInformation().lSpeedClassification.get(k).lowerLimit) / 2d;
|
|
if (etdData.getDeviceInformation().lSpeedClassification.get(k).lowerLimit >= speedLimit)
|
{
|
totalStatus.overspeedCars += totalStatus.speeds[k];
|
}
|
}
|
}
|
|
if (totalVehiclesLane > 0)
|
{
|
totalStatus.heavyTrucks = (float)((float)totalTrucksLane / (float)totalVehiclesLane) * 100f;
|
int heavyTrucks = (int)(totalStatus.heavyTrucks*100f);
|
totalStatus.heavyTrucks = (float)((float)heavyTrucks / 100f);
|
}
|
|
if (totalStatus.maxSpeed > 0)
|
{
|
int maxSpeed = (int)(totalStatus.maxSpeed*100d);
|
totalStatus.maxSpeed = (double)((double)maxSpeed / 100d);
|
}
|
|
Shared.println(etd.information.name, "4.ANALYSE: period[" + i + "] LAST: " + new Date(lastTimestamp).toString() + " PERIOD: " + etdData.getDeviceStatus().getMeasurementTimestamp() + " - DIF: " + (System.currentTimeMillis()-millis) + " - " + new Date(etdoriginal.getLastTimestampStatusUpdate()) + " - " + new Date(etdData.getLastTimestampStatusUpdate()));
|
Shared.model.updateDevice(etdoriginal, etdData);
|
Shared.println(etd.information.name, "5.ANALYSE: period[" + i + "] LAST: " + new Date(lastTimestamp).toString() + " PERIOD: " + etdData.getDeviceStatus().getMeasurementTimestamp() + " - DIF: " + (System.currentTimeMillis()-millis) + " - " + new Date(etdoriginal.getLastTimestampStatusUpdate()) + " - " + new Date(etdData.getLastTimestampStatusUpdate()));
|
|
delete = true;
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
}
|
|
if (delete == false)
|
{
|
if (etd.alarms.alarm_offline > 0)
|
{
|
String message = art.servers.Shared.getMessage("Etd online");
|
art.servers.Shared.println(((ControllerEtd)art.servers.Shared.getDeviceController(etd.getIdentifier())).getControllerName(), message);
|
}
|
|
etd.setAlarm("alarm_offline", false);
|
etd.setAlarm("alarm_invalid", false);
|
Shared.model.updateDevice(etdoriginal, etd);
|
}
|
|
try
|
{
|
((ControllerEtd)art.servers.Shared.getDeviceController(etd.getIdentifier())).errorsNumber = 0;
|
String message = "Errors=0";
|
art.servers.Shared.println(((ControllerEtd)art.servers.Shared.getDeviceController(etd.getIdentifier())).getControllerName(), message);
|
}
|
catch (Exception e)
|
{
|
}
|
|
return(delete);
|
}
|
|
|
|
|
|
private static DiamondLengthRelation[] createLengthRelations8()
|
{
|
DiamondLengthRelation[] result = new DiamondLengthRelation[8];
|
for (int i=0; i<result.length; i++)
|
{
|
result[i] = new DiamondLengthRelation();
|
if (i == 0)
|
{
|
result[i].lublinClassification = 0;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 0;
|
}
|
else if (i == 1)
|
{
|
result[i].lublinClassification = 1;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 1;
|
}
|
else if (i == 2)
|
{
|
result[i].lublinClassification = 2;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 2;
|
}
|
else if (i == 3)
|
{
|
result[i].lublinClassification = 3;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 3;
|
}
|
else if (i == 4)
|
{
|
result[i].lublinClassification = 4;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 4;
|
}
|
else if (i == 5)
|
{
|
result[i].lublinClassification = 5;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 5;
|
}
|
else if (i == 6)
|
{
|
result[i].lublinClassification = 6;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 6;
|
result[i].realBins[1] = 7;
|
}
|
}
|
|
return(result);
|
}
|
|
|
|
|
|
private static DiamondLengthRelation[] createLengthRelations9()
|
{
|
DiamondLengthRelation[] result = new DiamondLengthRelation[9];
|
for (int i=0; i<result.length; i++)
|
{
|
result[i] = new DiamondLengthRelation();
|
if (i == 0)
|
{
|
result[i].lublinClassification = 0;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 1;
|
}
|
else if (i == 1)
|
{
|
result[i].lublinClassification = 1;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 0;
|
result[i].realBins[1] = 2;
|
}
|
else if (i == 2)
|
{
|
result[i].lublinClassification = 2;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 3;
|
}
|
else if (i == 3)
|
{
|
result[i].lublinClassification = 3;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 4;
|
}
|
else if (i == 4)
|
{
|
result[i].lublinClassification = 4;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 5;
|
}
|
else if (i == 5)
|
{
|
result[i].lublinClassification = 5;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 6;
|
}
|
else if (i == 6)
|
{
|
result[i].lublinClassification = 6;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 7;
|
result[i].realBins[1] = 8;
|
}
|
}
|
|
return(result);
|
}
|
|
|
|
|
|
private static DiamondLengthRelation[] createLengthRelations11()
|
{
|
DiamondLengthRelation[] result = new DiamondLengthRelation[8];
|
for (int i=0; i<result.length; i++)
|
{
|
result[i] = new DiamondLengthRelation();
|
if (i == 0)
|
{
|
result[i].lublinClassification = 0;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 0;
|
}
|
else if (i == 1)
|
{
|
result[i].lublinClassification = 1;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 1;
|
result[i].realBins[1] = 2;
|
}
|
else if (i == 2)
|
{
|
result[i].lublinClassification = 2;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 3;
|
}
|
else if (i == 3)
|
{
|
result[i].lublinClassification = 3;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 4;
|
result[i].realBins[1] = 5;
|
}
|
else if (i == 4)
|
{
|
result[i].lublinClassification = 4;
|
result[i].realBins = new int[1];
|
result[i].realBins[0] = 6;
|
}
|
else if (i == 5)
|
{
|
result[i].lublinClassification = 5;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 7;
|
result[i].realBins[1] = 8;
|
}
|
else if (i == 6)
|
{
|
result[i].lublinClassification = 6;
|
result[i].realBins = new int[2];
|
result[i].realBins[0] = 9;
|
result[i].realBins[1] = 10;
|
}
|
}
|
|
return(result);
|
}
|
|
|
|
|
|
private static DiamondLengthRelation getRelation(DiamondLengthRelation[] relations, int bin)
|
{
|
for (int i=0; i<relations.length; i++)
|
{
|
for (int j=0; j<relations[i].realBins.length; j++)
|
{
|
if (relations[i].realBins[j] == bin)
|
return(relations[i]);
|
}
|
}
|
|
return(null);
|
}
|
|
|
private static boolean isVehicleDetection(String response)
|
{
|
try
|
{
|
int firstChar = response.charAt(0);
|
if (((firstChar == 42) || ((firstChar >= 0x30) && (firstChar <= 0x39)))
|
&&
|
(response.indexOf(":") > -1))
|
{
|
return(true);
|
}
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
return(false);
|
}
|
|
|
|
|
private static int getSpeedLimit(String etdIdentifier)
|
{
|
try
|
{
|
if (etdIdentifier.equalsIgnoreCase("etd-krzewica-1")) return(90);
|
if (etdIdentifier.equalsIgnoreCase("etd-terespol-1")) return(90);
|
if (etdIdentifier.equalsIgnoreCase("etd-wólkaokopska-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-żyrzyn-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-piaski-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-łopienniknadrzeczny-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-izbica-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-łabuniereforma-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-polanówka-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-hrebenne-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-międzyrzecpodlaski-1")) return(100);
|
if (etdIdentifier.equalsIgnoreCase("etd-radzyńpodlaski-1")) return(90);
|
if (etdIdentifier.equalsIgnoreCase("etd-sobieszyn-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-annopol-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-szczebrzeszyn-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-miączyn-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-łęczna-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-włodawa-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-wisznice-1")) return(70);
|
if (etdIdentifier.equalsIgnoreCase("etd-sławatycze-1")) return(50);
|
if (etdIdentifier.equalsIgnoreCase("etd-staraprawda-1")) return(60);
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
return(70);
|
}
|
|
}
|
