package art.servers.etdserver.protocols.dgt;
|
|
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.information.EtdClassification;
|
import art.library.model.devices.etd.information.EtdInformationLane;
|
import art.library.model.devices.etd.information.EtdInformationSection;
|
import art.library.model.devices.etd.status.EtdStatusLane;
|
|
import art.library.utils.common.NumberUtils;
|
import art.library.utils.common.TimeUtils;
|
import art.servers.Shared;
|
|
|
public class EtdDgtProtocolAnalyser
|
{
|
public EtdDgtProtocolAnalyser ()
|
{
|
}
|
|
|
public void analyseResponseEyA (Etd device, int[] information) throws Exception
|
{
|
if (device.status == null)
|
{
|
device.status = createEtdStatus(device);
|
}
|
|
if ((device.getDeviceStatus().llane.size() != device.getDeviceInformation().lLane.size()) ||
|
(device.getDeviceStatus().lsection.size() != device.getDeviceInformation().lSection.size()))
|
{
|
device.status = createEtdStatus(device);
|
}
|
|
int status = information[0];
|
int alarms = information[1];
|
int numberOfSensors = information[2];
|
int[] sensorsType = new int[numberOfSensors];
|
int[] sensorsAlarms = new int[numberOfSensors];
|
int pointer = 3;
|
EtdStatus etdStatus = device.getDeviceStatus();
|
boolean existSensorAlarm = false;
|
for (int i=0; i<numberOfSensors; i++)
|
{
|
try
|
{
|
sensorsType[i] = information[pointer++];
|
sensorsAlarms[i] = information[pointer++];
|
|
EtdStatusLane laneStatus = etdStatus.getLane(i+1);
|
if (sensorsAlarms[i] == EtdDgtConstants.ETD_SENSOR_FAILURE)
|
{
|
existSensorAlarm = true;
|
laneStatus.status = DeviceStatus.STATUS_OFFLINE;
|
}
|
else if (sensorsAlarms[i] == EtdDgtConstants.ETD_SENSOR_OK)
|
{
|
laneStatus.status = DeviceStatus.STATUS_ONLINE;
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
System.out.println(device.getIdentifier() + " - EyA EX: " + e.toString());
|
}
|
}
|
|
|
if ((status & 0x01) != 0)
|
{
|
// AN
|
device.setAlarm("alarm_offline", false);
|
device.setAlarm("alarm_abnormal_state", false);
|
}
|
|
if ((status & 0x02) != 0)
|
{
|
// NC
|
if (device.getAlarm("alarm_offline") <= 0)
|
{
|
device.getDeviceAlarms().clear();
|
}
|
device.setAlarm("alarm_offline", true);
|
device.setAlarm("alarm_abnormal_state", false);
|
}
|
|
if ((status & 0x04) != 0)
|
{
|
// EA
|
device.setAlarm("alarm_offline", false);
|
device.setAlarm("alarm_abnormal_state", true);
|
}
|
|
device.setAlarm("alarm_terminal", ((alarms & 0x01) != 0));
|
device.setAlarm("alarm_open_door", ((alarms & 0x02) != 0));
|
device.setAlarm("alarm_mains_voltage_error", ((alarms & 0x04) != 0));
|
device.setAlarm("alarm_batteries_low", ((alarms & 0x08) != 0));
|
device.setAlarm("alarm_power_stopped", ((alarms & 0x10) != 0));
|
device.setAlarm("alarm_batteries_disconnected", ((alarms & 0x20) != 0));
|
device.setAlarm("alarm_clock_failure", ((alarms & 0x40) != 0));
|
|
device.setAlarm("alarm_lanes", existSensorAlarm);
|
}
|
|
|
public void analyseResponseDUP (Etd device, int[] information) throws Exception
|
{
|
// if (device.status == null)
|
// {
|
// device.status = createEtdStatus(device);
|
// }
|
//
|
// if ((device.getDeviceStatus().llane.size() != device.getDeviceInformation().lLane.size()) ||
|
// (device.getDeviceStatus().lsection.size() != device.getDeviceInformation().lSection.size()))
|
// {
|
// device.status = createEtdStatus(device);
|
// }
|
|
int available = information[0];
|
|
// clearEtdStatus(device);
|
// EtdStatus etdStatus = device.getDeviceStatus();
|
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - Avail: " + available);
|
}
|
if (available == EtdDgtConstants.ETD_DUP_NOT_AVAILABLE)
|
{
|
// TODO
|
// When there is not current data
|
return;
|
}
|
|
int pointer = 1;
|
int day = information[pointer++];
|
int month = information[pointer++];
|
int year = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
pointer += 2;
|
int hour = information[pointer++];
|
int minutes = information[pointer++];
|
int seconds = information[pointer++];
|
int period = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
pointer += 2;
|
int relativeError = information[pointer++];
|
|
long measurementTimestamp = TimeUtils.toTimestamp(day, month, year, hour, minutes, seconds);
|
int numberOfSensorsClasses = information[pointer++];
|
|
initialiseStatus(device, measurementTimestamp);
|
EtdStatus etdStatus = device.getDeviceStatus();
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - TS: " + Device.getDate(measurementTimestamp) + " - #Classes: " + numberOfSensorsClasses);
|
}
|
// etdStatus.setMeasurementTimestamp(Device.getDate(measurementTimestamp));
|
|
for (int i=0; i<numberOfSensorsClasses; i++)
|
{
|
try
|
{
|
int sensorClass = information[pointer++];
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - TS: " + Device.getDate(measurementTimestamp) + " - #SensorClass: " + sensorClass);
|
}
|
if (sensorClass == EtdDgtConstants.ETD_SENSOR_TYPE_DOUBLE)
|
{
|
pointer = fillDoubleDetectors(device, etdStatus, information, pointer);
|
}
|
else if (sensorClass == EtdDgtConstants.ETD_SENSOR_TYPE_SIMPLE)
|
{
|
pointer = fillSimpleDetectors(device, etdStatus, information, pointer);
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
}
|
|
|
// Adjust Total and Sections values
|
if (etdStatus.total.counting > 0)
|
{
|
etdStatus.total.speed = (int)(etdStatus.total.speed / etdStatus.total.counting);
|
etdStatus.total.length = (etdStatus.total.length / etdStatus.total.counting);
|
etdStatus.total.distance = (etdStatus.total.speed / etdStatus.total.counting);
|
etdStatus.total.occupancy = (etdStatus.total.occupancy / etdStatus.total.counting);
|
etdStatus.total.occupancy = NumberUtils.ajustarDecimales(etdStatus.total.occupancy, 1);
|
etdStatus.total.length = NumberUtils.ajustarDecimales((float)(etdStatus.total.length/10d), 1);
|
etdStatus.total.distance = NumberUtils.ajustarDecimales((float)etdStatus.total.distance, 1);
|
if (etdStatus.total.occupancy > 100) etdStatus.total.occupancy = 100;
|
if (etdStatus.total.occupancy < 0) etdStatus.total.occupancy = 0;
|
if (etdStatus.total.length < 0) etdStatus.total.length = 0;
|
if (etdStatus.total.distance < 0) etdStatus.total.distance = 0;
|
if (etdStatus.total.speed < 0) etdStatus.total.speed = 0;
|
}
|
|
for (EtdStatusLane sectionStatus : etdStatus.lsection)
|
{
|
sectionStatus.speed = (int)(sectionStatus.speed / sectionStatus.counting);
|
sectionStatus.length = (sectionStatus.length / sectionStatus.counting);
|
sectionStatus.distance = (sectionStatus.speed / sectionStatus.counting);
|
sectionStatus.occupancy = (sectionStatus.occupancy / sectionStatus.counting);
|
sectionStatus.occupancy = NumberUtils.ajustarDecimales(sectionStatus.occupancy, 1);
|
sectionStatus.length = NumberUtils.ajustarDecimales((float)(sectionStatus.length/10d), 1);
|
sectionStatus.distance = NumberUtils.ajustarDecimales((float)sectionStatus.distance, 1);
|
if (sectionStatus.occupancy > 100) sectionStatus.occupancy = 100;
|
if (sectionStatus.occupancy < 0) sectionStatus.occupancy = 0;
|
if (sectionStatus.length < 0) sectionStatus.length = 0;
|
if (sectionStatus.distance < 0) sectionStatus.distance = 0;
|
if (sectionStatus.speed < 0) sectionStatus.speed = 0;
|
}
|
}
|
|
|
private int fillDoubleDetectors (Etd device, EtdStatus etdStatus, int[] information, int index) throws Exception
|
{
|
int pointer = index;
|
|
try
|
{
|
int numberOfSensors = information[pointer++];
|
|
for (int j=0; j<numberOfSensors; j++)
|
{
|
int detectorNumber = information[pointer++];
|
EtdStatusLane laneStatus = etdStatus.getLane(detectorNumber);
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Detector: " + detectorNumber);
|
}
|
laneStatus.correctMeasurements = 1;
|
laneStatus.counting = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
pointer += 2;
|
laneStatus.occupancy = information[pointer++];
|
laneStatus.congestionDetection = (information[pointer++]==0x01);
|
laneStatus.wrongWayVehicleDetection = (information[pointer++]==0x01);
|
laneStatus.direction = information[pointer++];
|
laneStatus.speed = information[pointer++];
|
laneStatus.length = information[pointer++];
|
laneStatus.distance = information[pointer++];
|
if (laneStatus.occupancy > 100) laneStatus.occupancy = 100;
|
if (laneStatus.occupancy < 0) laneStatus.occupancy = 0;
|
if (laneStatus.length < 0) laneStatus.length = 0;
|
if (laneStatus.distance < 0) laneStatus.distance = 0;
|
if (laneStatus.speed < 0) laneStatus.speed = 0;
|
|
int numberOfClassifications = information[pointer++];
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Classif: " + detectorNumber);
|
}
|
for (int k=0; k<numberOfClassifications; k++)
|
{
|
int classificationType = information[pointer++];
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #ClassifType: " + classificationType);
|
}
|
if (classificationType == EtdDgtConstants.ETD_LENGHT_CLASSIFICATION)
|
{
|
pointer = readLengthClassification(device, laneStatus, information, pointer);
|
}
|
else if (classificationType == EtdDgtConstants.ETD_SPEED_CLASSIFICATION)
|
{
|
pointer = readSpeedClassification(device, laneStatus, information, pointer);
|
}
|
else if (classificationType == EtdDgtConstants.ETD_SPEED_X_LENGTH_CLASSIFICATION)
|
{
|
pointer = readSpeedxLengthClassification(laneStatus, information, pointer);
|
}
|
}
|
|
int classified = 0;
|
for (int i=0; i<laneStatus.lengths.length; i++)
|
{
|
classified += laneStatus.lengths[i];
|
}
|
|
laneStatus.unclassified = laneStatus.counting - classified;
|
laneStatus.correctMeasurements = 1;
|
laneStatus.totalMeasurements = 1;
|
laneStatus.status = DeviceStatus.STATUS_ONLINE;
|
|
addLaneToTotal(device, laneStatus, etdStatus);
|
EtdInformationSection sectionInformation = getSectionInformationLane(device.getDeviceInformation(), laneStatus.number);
|
if (sectionInformation != null)
|
{
|
EtdStatusLane sectionStatus = etdStatus.getSection(sectionInformation.number);
|
addLaneToSection(device, laneStatus, sectionStatus);
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
System.out.println(device.getIdentifier() + " 1.EX: " + e.toString());
|
}
|
|
return(pointer);
|
}
|
|
|
private EtdInformationSection getSectionInformationLane (EtdInformation etdInformation, int lane)
|
{
|
for (EtdInformationSection sectionInformation : etdInformation.lSection)
|
{
|
for (Integer number : sectionInformation.llane)
|
{
|
if ((number.intValue()) == lane) return(sectionInformation);
|
}
|
}
|
|
return(null);
|
}
|
|
|
private int fillSimpleDetectors (Etd device, EtdStatus etdStatus, int[] information, int index) throws Exception
|
{
|
int pointer = index;
|
|
try
|
{
|
int numberOfSensors = information[pointer++];
|
|
for (int j=0; j<numberOfSensors; j++)
|
{
|
int detectorNumber = information[pointer++];
|
EtdStatusLane laneStatus = etdStatus.getLane(detectorNumber);
|
laneStatus.counting = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
pointer += 2;
|
laneStatus.occupancy = information[pointer++];
|
if (laneStatus.occupancy > 100) laneStatus.occupancy = 100;
|
if (laneStatus.occupancy < 0) laneStatus.occupancy = 0;
|
laneStatus.congestionDetection = (information[pointer++]==0x01);
|
|
addLaneToTotal(device, laneStatus, etdStatus);
|
EtdInformationSection sectionInformation = getSectionInformationLane(device.getDeviceInformation(), laneStatus.number);
|
if (sectionInformation != null)
|
{
|
EtdStatusLane sectionStatus = etdStatus.getSection(sectionInformation.number);
|
addLaneToSection(device, laneStatus, sectionStatus);
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
return(pointer);
|
}
|
|
|
private void addLaneToTotal (Etd device, EtdStatusLane laneStatus, EtdStatus etdStatus)
|
{
|
etdStatus.total.status = DeviceStatus.STATUS_ONLINE;
|
etdStatus.total.correctMeasurements += 1;
|
etdStatus.total.counting += laneStatus.counting;
|
etdStatus.total.speed += (laneStatus.counting*laneStatus.speed);
|
etdStatus.total.occupancy += (laneStatus.counting*laneStatus.occupancy);
|
etdStatus.total.length += (laneStatus.counting*laneStatus.length);
|
etdStatus.total.distance += (laneStatus.counting*laneStatus.distance);
|
etdStatus.total.unclassified += laneStatus.unclassified;
|
for (int i=0; i<etdStatus.total.lengths.length; i++) etdStatus.total.lengths[i] += laneStatus.lengths[i];
|
for (int i=0; i<etdStatus.total.speeds.length; i++) etdStatus.total.speeds[i] += laneStatus.speeds[i];
|
for (int i=0; i<etdStatus.total.speedxlength.length; i++)
|
{
|
for (int j=0; j<etdStatus.total.speedxlength[i].length; j++)
|
etdStatus.total.speedxlength[i][j] += laneStatus.speedxlength[i][j];
|
}
|
|
if (laneStatus.congestionDetection == true)
|
etdStatus.total.congestionDetection = true;
|
if (laneStatus.wrongWayVehicleDetection == true)
|
etdStatus.total.wrongWayVehicleDetection = true;
|
}
|
|
|
private void addLaneToSection (Etd device, EtdStatusLane laneStatus, EtdStatusLane sectionStatus)
|
{
|
sectionStatus.status = DeviceStatus.STATUS_ONLINE;
|
sectionStatus.correctMeasurements += 1;
|
sectionStatus.counting += laneStatus.counting;
|
sectionStatus.speed += (laneStatus.counting*laneStatus.speed);
|
sectionStatus.occupancy += (laneStatus.counting*laneStatus.occupancy);
|
sectionStatus.length += (laneStatus.counting*laneStatus.length);
|
sectionStatus.distance += (laneStatus.counting*laneStatus.distance);
|
sectionStatus.unclassified += laneStatus.unclassified;
|
for (int i=0; i<sectionStatus.lengths.length; i++) sectionStatus.lengths[i] += laneStatus.lengths[i];
|
for (int i=0; i<sectionStatus.speeds.length; i++) sectionStatus.speeds[i] += laneStatus.speeds[i];
|
for (int i=0; i<sectionStatus.speedxlength.length; i++)
|
{
|
for (int j=0; j<sectionStatus.speedxlength[i].length; j++)
|
sectionStatus.speedxlength[i][j] += laneStatus.speedxlength[i][j];
|
}
|
|
if (laneStatus.congestionDetection == true)
|
sectionStatus.congestionDetection = true;
|
if (laneStatus.wrongWayVehicleDetection == true)
|
sectionStatus.wrongWayVehicleDetection = true;
|
}
|
|
|
private int readLengthClassification (Etd device, EtdStatusLane laneStatus, int[] information, int index) throws Exception
|
{
|
int pointer = index;
|
|
try
|
{
|
int numberOfValues = information[pointer++];
|
laneStatus.lengths = new int[numberOfValues];
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Lengths: " + numberOfValues);
|
}
|
|
if (device.getDeviceInformation().lLengthClassification.size() == 0)
|
{
|
EtdInformation etdInformation = device.getDeviceInformation();
|
for (int i=0; i<numberOfValues; i++)
|
{
|
EtdClassification classification = new EtdClassification();
|
classification.identifier = (i+1);
|
|
if (numberOfValues == 2)
|
{
|
if (i == 0)
|
{
|
classification.lowerLimit = 0;
|
classification.upperLimit = 70;
|
classification.description = "Lleugers";
|
}
|
else if (i == 1)
|
{
|
classification.lowerLimit = 70;
|
classification.upperLimit = 255;
|
classification.description = "Pessats";
|
}
|
}
|
|
etdInformation.lLengthClassification.add(classification);
|
}
|
}
|
|
for (int j=0; j<numberOfValues; j++)
|
{
|
laneStatus.lengths[j] = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Lengths[" + j + "]: " + laneStatus.lengths[j]);
|
}
|
pointer += 2;
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
return(pointer);
|
}
|
|
|
private int readSpeedClassification (Etd device, EtdStatusLane laneStatus, int[] information, int index) throws Exception
|
{
|
int pointer = index;
|
|
try
|
{
|
int numberOfValues = information[pointer++];
|
laneStatus.speeds = new int[numberOfValues];
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Speeds: " + numberOfValues + " - " + device.getDeviceInformation().lSpeedClassification.size());
|
}
|
|
if (device.getDeviceInformation().lSpeedClassification.size() == 0)
|
{
|
EtdInformation etdInformation = device.getDeviceInformation();
|
for (int i=0; i<numberOfValues; i++)
|
{
|
EtdClassification classification = new EtdClassification();
|
classification.identifier = (i+1);
|
|
if (numberOfValues == 10)
|
{
|
if (i == 0)
|
{
|
classification.lowerLimit = 0;
|
classification.upperLimit = 40;
|
classification.description = "<40";
|
}
|
else if (i == 1)
|
{
|
classification.lowerLimit = 40;
|
classification.upperLimit = 50;
|
classification.description = "40-50";
|
}
|
else if (i == 2)
|
{
|
classification.lowerLimit = 50;
|
classification.upperLimit = 60;
|
classification.description = "50-60";
|
}
|
else if (i == 3)
|
{
|
classification.lowerLimit = 60;
|
classification.upperLimit = 70;
|
classification.description = "60-70";
|
}
|
else if (i == 4)
|
{
|
classification.lowerLimit = 70;
|
classification.upperLimit = 80;
|
classification.description = "70-80";
|
}
|
else if (i == 5)
|
{
|
classification.lowerLimit = 80;
|
classification.upperLimit = 90;
|
classification.description = "80-90";
|
}
|
else if (i == 6)
|
{
|
classification.lowerLimit = 90;
|
classification.upperLimit = 100;
|
classification.description = "90-100";
|
}
|
else if (i == 7)
|
{
|
classification.lowerLimit = 100;
|
classification.upperLimit = 110;
|
classification.description = "100-110";
|
}
|
else if (i == 8)
|
{
|
classification.lowerLimit = 110;
|
classification.upperLimit = 120;
|
classification.description = "110-120";
|
}
|
else if (i == 9)
|
{
|
classification.lowerLimit = 120;
|
classification.upperLimit = 255;
|
classification.description = ">120";
|
}
|
}
|
|
etdInformation.lSpeedClassification.add(classification);
|
}
|
|
device.getDeviceStatus().total.speeds = new int[device.getDeviceInformation().lSpeedClassification.size()];
|
for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
|
device.getDeviceStatus().total.speeds[s] = 0;
|
device.getDeviceStatus().total.speedxlength = new int[device.getDeviceInformation().lSpeedClassification.size()][device.getDeviceInformation().lLengthClassification.size()];
|
for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
|
{
|
for (int l=0; l<device.getDeviceStatus().total.lengths.length; l++)
|
{
|
device.getDeviceStatus().total.speedxlength[s][l] = 0;
|
}
|
}
|
}
|
else if ((device.getDeviceInformation().lSpeedClassification.size() > 0) && (device.getDeviceInformation().lSpeedClassification.size() > numberOfValues))
|
{
|
EtdInformation etdInformation = device.getDeviceInformation();
|
etdInformation.lSpeedClassification.clear();
|
|
for (int i=0; i<numberOfValues; i++)
|
{
|
EtdClassification classification = new EtdClassification();
|
classification.identifier = (i+1);
|
|
if (numberOfValues == 10)
|
{
|
if (i == 0)
|
{
|
classification.lowerLimit = 0;
|
classification.upperLimit = 40;
|
classification.description = "<40";
|
}
|
else if (i == 1)
|
{
|
classification.lowerLimit = 40;
|
classification.upperLimit = 50;
|
classification.description = "40-50";
|
}
|
else if (i == 2)
|
{
|
classification.lowerLimit = 50;
|
classification.upperLimit = 60;
|
classification.description = "50-60";
|
}
|
else if (i == 3)
|
{
|
classification.lowerLimit = 60;
|
classification.upperLimit = 70;
|
classification.description = "60-70";
|
}
|
else if (i == 4)
|
{
|
classification.lowerLimit = 70;
|
classification.upperLimit = 80;
|
classification.description = "70-80";
|
}
|
else if (i == 5)
|
{
|
classification.lowerLimit = 80;
|
classification.upperLimit = 90;
|
classification.description = "80-90";
|
}
|
else if (i == 6)
|
{
|
classification.lowerLimit = 90;
|
classification.upperLimit = 100;
|
classification.description = "90-100";
|
}
|
else if (i == 7)
|
{
|
classification.lowerLimit = 100;
|
classification.upperLimit = 110;
|
classification.description = "100-110";
|
}
|
else if (i == 8)
|
{
|
classification.lowerLimit = 110;
|
classification.upperLimit = 120;
|
classification.description = "110-120";
|
}
|
else if (i == 9)
|
{
|
classification.lowerLimit = 120;
|
classification.upperLimit = 255;
|
classification.description = ">120";
|
}
|
}
|
else if (numberOfValues == 3)
|
{
|
if (i == 0)
|
{
|
classification.lowerLimit = 0;
|
classification.upperLimit = 50;
|
classification.description = "<50";
|
}
|
else if (i == 1)
|
{
|
classification.lowerLimit = 50;
|
classification.upperLimit = 100;
|
classification.description = "50-100";
|
}
|
else if (i == 9)
|
{
|
classification.lowerLimit = 100;
|
classification.upperLimit = 255;
|
classification.description = ">100";
|
}
|
}
|
|
etdInformation.lSpeedClassification.add(classification);
|
}
|
|
device.getDeviceStatus().total.speeds = new int[device.getDeviceInformation().lSpeedClassification.size()];
|
for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
|
device.getDeviceStatus().total.speeds[s] = 0;
|
device.getDeviceStatus().total.speedxlength = new int[device.getDeviceInformation().lSpeedClassification.size()][device.getDeviceInformation().lLengthClassification.size()];
|
for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
|
{
|
for (int l=0; l<device.getDeviceStatus().total.lengths.length; l++)
|
{
|
device.getDeviceStatus().total.speedxlength[s][l] = 0;
|
}
|
}
|
}
|
|
for (int j=0; j<numberOfValues; j++)
|
{
|
laneStatus.speeds[j] = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
|
{
|
System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Speeds[" + j + "]: " + laneStatus.speeds[j]);
|
}
|
pointer += 2;
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
return(pointer);
|
}
|
|
|
private int readSpeedxLengthClassification (EtdStatusLane laneStatus, int[] information, int index) throws Exception
|
{
|
int pointer = index;
|
|
try
|
{
|
int numberOfValues = information[pointer++];
|
if (numberOfValues != (laneStatus.lengths.length*laneStatus.speeds.length))
|
{
|
throw new Exception(Shared.getMessage("Number of Speed x Length categories not correct: ") + numberOfValues + " - " + laneStatus.lengths.length + " * " + laneStatus.speeds.length);
|
}
|
|
laneStatus.speedxlength = new int[laneStatus.speeds.length][];
|
for (int j=0; j<laneStatus.speeds.length; j++)
|
{
|
laneStatus.speedxlength[j] = new int[laneStatus.lengths.length];
|
for (int k=0; k<laneStatus.lengths.length; k++)
|
{
|
laneStatus.speedxlength[j][k] = NumberUtils.getInt(information[pointer+1], information[pointer]);
|
pointer += 2;
|
}
|
}
|
|
|
// Read Average speed by length
|
int numberOfSpeeds = information[pointer++];
|
for (int i=0; i<numberOfSpeeds; i++)
|
{
|
int value = information[pointer++];
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
return(pointer);
|
}
|
|
|
private void initialiseStatus (Etd deviceclone, long tsperiod)
|
{
|
if (deviceclone.getDeviceStatus() == null)
|
{
|
deviceclone.status = new EtdStatus();
|
for (EtdInformationLane laneInformation : deviceclone.getDeviceInformation().lLane)
|
{
|
EtdStatusLane laneStatus = new EtdStatusLane();
|
laneStatus.number = laneInformation.number;
|
laneStatus.correctMeasurements = 1;
|
laneStatus.totalMeasurements = 1;
|
deviceclone.getDeviceStatus().llane.add(laneStatus);
|
}
|
|
for (EtdInformationSection sectionInformation : deviceclone.getDeviceInformation().lSection)
|
{
|
EtdStatusLane sectionStatus = new EtdStatusLane();
|
sectionStatus.number = sectionInformation.number;
|
sectionStatus.correctMeasurements = 0;
|
sectionStatus.totalMeasurements = 0;
|
deviceclone.getDeviceStatus().lsection.add(sectionStatus);
|
}
|
|
deviceclone.getDeviceStatus().total = new EtdStatusLane();
|
}
|
|
if (deviceclone.getDeviceStatus().total == null)
|
{
|
deviceclone.getDeviceStatus().total = new EtdStatusLane();
|
}
|
|
deviceclone.getDeviceStatus().llane.clear();
|
deviceclone.getDeviceStatus().lsection.clear();
|
for (EtdInformationLane laneInformation : deviceclone.getDeviceInformation().lLane)
|
{
|
EtdStatusLane laneStatus = new EtdStatusLane();
|
laneStatus.number = laneInformation.number;
|
laneStatus.status = DeviceStatus.STATUS_OFFLINE;
|
laneStatus.totalMeasurements = 0;
|
laneStatus.correctMeasurements = 0;
|
laneStatus.lengths = new int[deviceclone.getDeviceInformation().lLengthClassification.size()];
|
for (int l=0; l<laneStatus.lengths.length; l++)
|
laneStatus.lengths[l] = 0;
|
laneStatus.speeds = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()];
|
for (int s=0; s<laneStatus.speeds.length; s++)
|
laneStatus.speeds[s] = 0;
|
laneStatus.speedxlength = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()][deviceclone.getDeviceInformation().lLengthClassification.size()];
|
for (int s=0; s<laneStatus.speeds.length; s++)
|
{
|
for (int l=0; l<laneStatus.lengths.length; l++)
|
{
|
laneStatus.speedxlength[s][l] = 0;
|
}
|
}
|
deviceclone.getDeviceStatus().llane.add(laneStatus);
|
}
|
|
for (EtdInformationSection sectionInformation : deviceclone.getDeviceInformation().lSection)
|
{
|
EtdStatusLane sectionStatus = new EtdStatusLane();
|
sectionStatus.number = sectionInformation.number;
|
sectionStatus.status = DeviceStatus.STATUS_OFFLINE;
|
sectionStatus.totalMeasurements = sectionInformation.llane.size();
|
sectionStatus.correctMeasurements = 0;
|
sectionStatus.lengths = new int[deviceclone.getDeviceInformation().lLengthClassification.size()];
|
for (int l=0; l<sectionStatus.lengths.length; l++)
|
sectionStatus.lengths[l] = 0;
|
sectionStatus.speeds = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()];
|
for (int s=0; s<sectionStatus.speeds.length; s++)
|
sectionStatus.speeds[s] = 0;
|
sectionStatus.speedxlength = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()][deviceclone.getDeviceInformation().lLengthClassification.size()];
|
for (int s=0; s<sectionStatus.speeds.length; s++)
|
{
|
for (int l=0; l<sectionStatus.lengths.length; l++)
|
{
|
sectionStatus.speedxlength[s][l] = 0;
|
}
|
}
|
deviceclone.getDeviceStatus().lsection.add(sectionStatus);
|
}
|
|
deviceclone.getDeviceStatus().total.status = DeviceStatus.STATUS_OFFLINE;
|
deviceclone.getDeviceStatus().total.correctMeasurements = 0;
|
deviceclone.getDeviceStatus().total.totalMeasurements = deviceclone.getDeviceInformation().lLane.size();
|
deviceclone.getDeviceStatus().total.counting = 0;
|
deviceclone.getDeviceStatus().total.distance = 0;
|
deviceclone.getDeviceStatus().total.length = 0;
|
deviceclone.getDeviceStatus().total.occupancy = 0;
|
deviceclone.getDeviceStatus().total.speed = 0;
|
deviceclone.getDeviceStatus().total.unclassified = 0;
|
deviceclone.getDeviceStatus().total.wrongWayVehicleDetection = false;
|
deviceclone.getDeviceStatus().total.congestionDetection = false;
|
deviceclone.getDeviceStatus().total.lengths = new int[deviceclone.getDeviceInformation().lLengthClassification.size()];
|
for (int l=0; l<deviceclone.getDeviceStatus().total.lengths.length; l++)
|
deviceclone.getDeviceStatus().total.lengths[l] = 0;
|
deviceclone.getDeviceStatus().total.speeds = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()];
|
for (int s=0; s<deviceclone.getDeviceStatus().total.speeds.length; s++)
|
deviceclone.getDeviceStatus().total.speeds[s] = 0;
|
deviceclone.getDeviceStatus().total.speedxlength = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()][deviceclone.getDeviceInformation().lLengthClassification.size()];
|
for (int s=0; s<deviceclone.getDeviceStatus().total.speeds.length; s++)
|
{
|
for (int l=0; l<deviceclone.getDeviceStatus().total.lengths.length; l++)
|
{
|
deviceclone.getDeviceStatus().total.speedxlength[s][l] = 0;
|
}
|
}
|
|
deviceclone.getDeviceStatus().period = deviceclone.getDeviceInformation().period;
|
deviceclone.getDeviceStatus().setMeasurementTimestamp(Device.getDate(tsperiod));
|
}
|
|
|
private EtdStatus createEtdStatus (Etd device) throws Exception
|
{
|
try
|
{
|
EtdStatus status = new EtdStatus();
|
status.period = device.getDeviceInformation().period;
|
status.setMeasurementTimestamp(Device.getDate(TimeUtils.thisperiod(device.getDeviceInformation().period)));
|
status.total = new EtdStatusLane();
|
for (EtdInformationLane laneInformation : device.getDeviceInformation().lLane)
|
{
|
EtdStatusLane laneStatus = new EtdStatusLane();
|
laneStatus.number = laneInformation.number;
|
status.llane.add(laneStatus);
|
}
|
|
for (EtdInformationSection sectionInformation : device.getDeviceInformation().lSection)
|
{
|
EtdStatusLane laneStatus = new EtdStatusLane();
|
laneStatus.number = sectionInformation.number;
|
status.lsection.add(laneStatus);
|
}
|
|
return(status);
|
}
|
catch (Exception e)
|
{
|
throw e;
|
}
|
}
|
|
|
private void clearEtdStatus (Etd device) throws Exception
|
{
|
try
|
{
|
EtdStatus etdStatus = device.getDeviceStatus();
|
etdStatus.period = device.getDeviceInformation().period;
|
etdStatus.setMeasurementTimestamp(Device.getDate(TimeUtils.thisperiod(device.getDeviceInformation().period)));
|
|
clearEtdStatusLane(device, etdStatus.total);
|
etdStatus.total.totalMeasurements = device.getDeviceInformation().lLane.size();
|
|
for (EtdStatusLane laneStatus : device.getDeviceStatus().llane)
|
{
|
clearEtdStatusLane(device, laneStatus);
|
laneStatus.totalMeasurements = 1;
|
}
|
|
for (EtdStatusLane sectionStatus : device.getDeviceStatus().lsection)
|
{
|
clearEtdStatusLane(device, sectionStatus);
|
sectionStatus.totalMeasurements = device.getDeviceInformation().getSection(sectionStatus.number).llane.size();
|
}
|
}
|
catch (Exception e)
|
{
|
throw e;
|
}
|
}
|
|
|
private void clearEtdStatusLane (Etd device, EtdStatusLane laneStatus)
|
{
|
laneStatus.congestionDetection = false;
|
laneStatus.correctMeasurements = 0;
|
laneStatus.counting = 0;
|
laneStatus.direction = EtdStatusLane.ETD_STATUS_DIRECTION_UNKNOWN;
|
laneStatus.distance = 0;
|
laneStatus.length = 0;
|
laneStatus.lengths = new int[device.getDeviceInformation().lLengthClassification.size()];
|
laneStatus.occupancy = 0;
|
laneStatus.speed = 0;
|
laneStatus.speeds = new int[device.getDeviceInformation().lSpeedClassification.size()];
|
laneStatus.speedxlength = new int[device.getDeviceInformation().lSpeedClassification.size()][];
|
for (int i=0; i<laneStatus.speedxlength.length; i++)
|
{
|
laneStatus.speedxlength[i] = new int[device.getDeviceInformation().lLengthClassification.size()];
|
}
|
|
laneStatus.totalMeasurements = 0;
|
laneStatus.unclassified = 0;
|
laneStatus.wrongWayVehicleDetection = false;
|
}
|
|
}
|
