package art.servers.etdserver.protocols.diamond.file;
|
|
import art.library.utils.common.TimeUtils;
|
import java.io.*;
|
import java.text.DecimalFormat;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
|
public final class DIAMOND_File
|
{
|
public DIAMOND_Header header;
|
public DIAMOND_BinnedSetup binnedSetup;
|
public DIAMOND_SerialNumber serialNumber;
|
public DIAMOND_RecordInterval recordInterval;
|
public DIAMOND_EndOfFile endOfFile;
|
|
// One per lane
|
public List<DIAMOND_LaneConfiguration> llaneConfiguration = new ArrayList<DIAMOND_LaneConfiguration>();
|
|
|
// Tables
|
public int[] minAxleBinTable;
|
public int[] maxAxleBinTable;
|
|
public int[] minSpeedBinTable;
|
public int[] maxSpeedBinTable;
|
|
public int[] minLengthBinTable;
|
public int[] maxLengthBinTable;
|
|
|
// Raw data
|
public Vector raw = new Vector();
|
|
|
// One per period
|
// Todos deberían ser de la misma longitud (excepto si no es de longitud cero)
|
|
public List<Long> ltimestamps = new ArrayList<Long>();
|
public List<DIAMOND_Binned> lbinnedAxle = new ArrayList<DIAMOND_Binned>();
|
public List<DIAMOND_Binned> lbinnedLength = new ArrayList<DIAMOND_Binned>();
|
public List<DIAMOND_Binned> lbinnedSpeed = new ArrayList<DIAMOND_Binned>();
|
public List<DIAMOND_Binned> lbinnedSpeedxLenght = new ArrayList<DIAMOND_Binned>();
|
public List<DIAMOND_Binned> lbinnedSpeedxAxle = new ArrayList<DIAMOND_Binned>();
|
public List<DIAMOND_Binned> lbinnedError = new ArrayList<DIAMOND_Binned>();
|
public List<DIAMOND_Count> lcount = new ArrayList<DIAMOND_Count>();
|
|
|
|
|
|
// Funciones
|
|
|
public DIAMOND_File ()
|
{
|
}
|
|
|
public DIAMOND_File (int[] receive)
|
{
|
retrieveFile(receive);
|
}
|
|
|
|
|
private void retrieveFile (int[] receive)
|
{
|
try
|
{
|
int apuntador = 0;
|
|
while(true)
|
{
|
int flag = receive[apuntador];
|
if (flag < 0) flag += 256;
|
|
switch (flag)
|
{
|
case 0x01 : header(this, receive, apuntador); apuntador += 80; break;
|
case 0x02 : binnedDataSetup(this, receive, apuntador); apuntador += 66; break;
|
case 0x03 : counterSerialNumber(this, receive, apuntador); apuntador += 32; break;
|
case 0x10 :
|
case 0x20 :
|
case 0x30 :
|
case 0x40 :
|
case 0x50 :
|
case 0x60 :
|
case 0x70 :
|
case 0x80 :
|
laneConfiguration(this, receive, apuntador, flag); apuntador += 25; break;
|
case 0x11 :
|
case 0x21 :
|
case 0x31 :
|
case 0x41 :
|
case 0x51 :
|
case 0x61 :
|
case 0x71 :
|
case 0x81 :
|
apuntador += 7; break;
|
case 0x12 :
|
case 0x22 :
|
case 0x32 :
|
case 0x42 :
|
case 0x52 :
|
case 0x62 :
|
case 0x72 :
|
case 0x82 : apuntador += 9; break;
|
case 0x13 :
|
case 0x23 :
|
case 0x33 :
|
case 0x43 :
|
case 0x53 :
|
case 0x63 :
|
case 0x73 :
|
case 0x83 : apuntador += 12; break;
|
case 0x14 :
|
case 0x24 :
|
case 0x34 :
|
case 0x44 :
|
case 0x54 :
|
case 0x64 :
|
case 0x74 :
|
case 0x84 :
|
apuntador += 14; break;
|
case 0x90 : countData(this, receive, apuntador+1); apuntador += (1 + (2 * this.header.activelanes)); break;
|
case 0x91 : binnedAxleData(this, receive, apuntador+1); apuntador += (1 + (2 * (this.header.activelanes * this.binnedSetup.numberaxle))); break;
|
case 0x92 : binnedSpeedData(this, receive, apuntador+1); apuntador += (1 + (2 * (this.header.activelanes * this.binnedSetup.numberspeed))); break;
|
case 0x93 : binnedLengthData(this, receive, apuntador+1); apuntador += (1 + (2 * (this.header.activelanes * this.binnedSetup.numberlength))); break;
|
case 0x94 : apuntador += (1 + 2 * (this.header.activelanes + this.binnedSetup.numbergap)); break;
|
case 0x95 : apuntador += (1 + 2 * (this.header.activelanes + this.binnedSetup.numberheadway)); break;
|
case 0x96 : apuntador = binnedSpeedxLengthData(this, receive, apuntador+1); break;
|
case 0x97 :
|
apuntador = binnedSpeedxAxleData(this, receive, apuntador+1); break;
|
|
case 0x9F : errorBininfo(this, receive, apuntador+1); apuntador += (1 + 8 * (this.header.activelanes)); break;
|
case 0xF0 : apuntador += 6; break;
|
case 0xF1 : recordInterval(this, receive, apuntador+1); apuntador += 3; break;
|
case 0xFF :
|
enfOfFile(this, receive, apuntador); apuntador += 6;
|
return;
|
|
case 0x2F : // System.out.println("No implemented yet : flag " + flag + ", byte " + apuntador); apuntador += 5; break;
|
case 0x4F : // System.out.println("No implemented yet : flag " + flag + ", byte " + apuntador); apuntador += 5; break;
|
case 0x5F : // System.out.println("No implemented yet : flag " + flag + ", byte " + apuntador); apuntador += 5; break;
|
case 0x6F : // System.out.println("No implemented yet : flag " + flag + ", byte " + apuntador); apuntador += 5; break;
|
case 0x7F : // System.out.println("No implemented yet : flag " + flag + ", byte " + apuntador); apuntador += 5; break;
|
case 0x8F : // System.out.println("No implemented yet : flag " + flag + ", byte " + apuntador); apuntador += 5; break;
|
|
// Apollo raw format
|
case 0x1A : apuntador = rawData(0, receive, apuntador); header.activelanes = Math.max(header.activelanes, 1); break;
|
case 0x3A : apuntador = rawData(1, receive, apuntador); header.activelanes = Math.max(header.activelanes, 2); break;
|
case 0x1F : apuntador = rawDataError(0, receive, apuntador); header.activelanes = Math.max(header.activelanes, 1); break;
|
case 0x3F : apuntador = rawDataError(1, receive, apuntador); header.activelanes = Math.max(header.activelanes, 2); break;
|
|
default :
|
// System.out.println("No implemented yet : flag " + Integer.toHexString(flag).toUpperCase() + ", byte " + apuntador);
|
return;
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
}
|
|
if (ltimestamps.size() == 0)
|
{
|
// EndOfFile Flag not received
|
// ltimestamps calculation with header and recordInterval flags information
|
DIAMOND_Header h = header;
|
|
int periodoMs = recordInterval.minutes * 60 * 1000;
|
|
Calendar calendarStart = Calendar.getInstance();
|
calendarStart.set(Calendar.DATE, h.startday);
|
calendarStart.set(Calendar.MONTH, h.startmonth - 1);
|
calendarStart.set(Calendar.YEAR, h.startyear + 2000);
|
calendarStart.set(Calendar.HOUR_OF_DAY, h.starthour);
|
calendarStart.set(Calendar.MINUTE, h.startminute);
|
calendarStart.set(Calendar.SECOND, 0);
|
calendarStart.set(Calendar.MILLISECOND, 0);
|
|
Calendar calendarStop = Calendar.getInstance();
|
calendarStop.set(Calendar.DATE, h.stopday);
|
calendarStop.set(Calendar.MONTH, h.stopmonth - 1);
|
calendarStop.set(Calendar.YEAR, h.stopyear + 2000);
|
calendarStop.set(Calendar.HOUR_OF_DAY, h.stophour);
|
calendarStop.set(Calendar.MINUTE, h.stopminute);
|
calendarStop.set(Calendar.SECOND, 0);
|
calendarStop.set(Calendar.MILLISECOND, 0);
|
|
while (calendarStart.before(calendarStop))
|
{
|
long ts = new Long(calendarStart.getTimeInMillis());
|
ts = TimeUtils.thisperiod(recordInterval.minutes*60, ts);
|
ltimestamps.add(ts);
|
calendarStart.setTimeInMillis(calendarStart.getTimeInMillis() + periodoMs);
|
}
|
}
|
}
|
|
|
|
|
|
|
|
|
|
private void header(DIAMOND_File file, int[] receive, int apuntador)
|
{
|
|
byte in[] = new byte[80];
|
for (int i=0; i<80; i++)
|
in[i] = (byte)receive[apuntador+i];
|
|
|
DIAMOND_Header header = new DIAMOND_Header();
|
header.site = S(in, 1, 10);
|
header.lanedirection = S(in, 11, 15);
|
header.location = S(in, 26, 15);
|
|
header.startyear = DIAMOND_SubCharSet((byte)in[41],7,7);
|
header.startmonth = DIAMOND_SubWordSet(in[41],in[42],8,4);
|
header.startday = DIAMOND_SubCharSet(in[42],4,5);
|
header.starthour = DIAMOND_SubCharSet(in[43],4,5);
|
header.startminute = DIAMOND_SubCharSet(in[44],5,6);
|
header.stopyear = DIAMOND_SubCharSet(in[45],7,7);
|
header.stopmonth = DIAMOND_SubWordSet(in[45],in[46],8,4);
|
header.stopday = DIAMOND_SubCharSet(in[46],4,5);
|
header.stophour = DIAMOND_SubCharSet(in[47],4,5);
|
header.stopminute = DIAMOND_SubCharSet(in[48],5,6);
|
header.storagemode = DIAMOND_SubCharSet(in[49],7,3);
|
header.dateformat = DIAMOND_SubCharSet(in[49],4,2);
|
header.numberformat = DIAMOND_SubCharSet(in[49],2,2);
|
header.activelanes = DIAMOND_SubCharSet(in[50],7,8);
|
header.unittype = DIAMOND_SubCharSet(in[51],7,8);
|
header.unitversion = DIAMOND_Word(in[52],in[53]);
|
header.retrieved = true;
|
|
|
header.start = F(header.startday,2)+"/"+F(header.stopmonth,2)+"/"+F(header.stopyear,2)+" ";
|
header.stop = F(header.stopday,2)+"/"+F(header.stopmonth,2)+"/"+F(header.stopyear,2)+" ";
|
file.header = header;
|
|
|
}
|
|
|
|
|
private void binnedDataSetup(DIAMOND_File file, int[] receive, int apuntador)
|
{
|
byte in[] = new byte[66];
|
for (int i=0; i<66; i++)
|
in[i] = (byte)receive[apuntador+i];
|
|
|
DIAMOND_BinnedSetup binnedSetup = new DIAMOND_BinnedSetup();
|
file.binnedSetup = binnedSetup;
|
binnedSetup.numberspeed = in[1];
|
binnedSetup.numberaxle = in[14];
|
binnedSetup.numberlength = in[27];
|
binnedSetup.numbergap = in[40];
|
binnedSetup.numberheadway = in[53];
|
binnedSetup.namespeed = S(in, 2, 12);
|
binnedSetup.nameaxle = S(in, 15, 12);
|
binnedSetup.namelength = S(in, 28, 12);
|
binnedSetup.namegap = S(in, 41, 12);
|
binnedSetup.nameheadway = S(in, 54, 12);
|
binnedSetup.retrieved = true;
|
|
file.minAxleBinTable = new int[binnedSetup.numberaxle];
|
file.minSpeedBinTable = new int[binnedSetup.numberspeed];
|
file.minLengthBinTable = new int[binnedSetup.numberlength];
|
file.maxAxleBinTable = new int[binnedSetup.numberaxle];
|
file.maxSpeedBinTable = new int[binnedSetup.numberspeed];
|
file.maxLengthBinTable = new int[binnedSetup.numberlength];
|
|
}
|
|
|
|
|
|
private void counterSerialNumber(DIAMOND_File file, int[] receive, int apuntador)
|
{
|
byte in[] = new byte[32];
|
for (int i=0; i<32; i++)
|
in[i] = (byte)receive[apuntador+i];
|
|
DIAMOND_SerialNumber serialNumber = new DIAMOND_SerialNumber();
|
serialNumber.serialnumber = S(in, 1, 31);
|
serialNumber.retrieved = true;
|
file.serialNumber = serialNumber;
|
}
|
|
|
|
|
private void laneConfiguration(DIAMOND_File file, int[] receive, int apuntador, int flag)
|
{
|
byte in[] = new byte[25];
|
for (int i=0; i<25; i++)
|
in[i] = (byte)receive[apuntador+i];
|
|
|
|
// Si existe el flag es que es un carril direccional, sumar 0x80 al flag
|
|
for (int i=0; i<file.llaneConfiguration.size(); i++)
|
{
|
DIAMOND_LaneConfiguration laneConfiguration = (DIAMOND_LaneConfiguration)file.llaneConfiguration.get(i);
|
if (laneConfiguration.lane == (flag / 0x10))
|
{
|
flag = flag + 0x80;
|
}
|
}
|
|
|
|
|
DIAMOND_LaneConfiguration laneConfiguration = new DIAMOND_LaneConfiguration();
|
laneConfiguration.information = S(in, 1, 15);
|
laneConfiguration.mode = in[16];
|
laneConfiguration.sensor = in[17];
|
laneConfiguration.countonly = DIAMOND_SubCharSet(in[18],7,1);
|
laneConfiguration.numbergroups = DIAMOND_SubCharSet(in[18],6,3);
|
laneConfiguration.group = DIAMOND_SubCharSet(in[18],3,3);
|
laneConfiguration.sensordspacing = DIAMOND_Word(in[19],in[20]);
|
laneConfiguration.secondlooplength = in[21];
|
laneConfiguration.operatornumber = DIAMOND_Word(in[22],in[23]);
|
laneConfiguration.lane = flag / 0x10;
|
file.llaneConfiguration.add(laneConfiguration);
|
}
|
|
|
|
|
|
|
private void countData(DIAMOND_File file, int[] in, int apuntador)
|
{
|
DIAMOND_Count count = new DIAMOND_Count();
|
count.valores = new int[file.header.activelanes];
|
file.lcount.add(count);
|
|
for (int i=0; i<file.header.activelanes; i++)
|
{
|
count.valores[i] = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
|
if (count.valores[i] == 65535)
|
count.valores[i] = 0;
|
|
apuntador = apuntador + 2;
|
}
|
|
|
}
|
|
|
|
|
|
private void binnedAxleData(DIAMOND_File file, int[] in, int apuntador)
|
{
|
DIAMOND_Binned binned = new DIAMOND_Binned();
|
binned.valores = new int[file.header.activelanes][file.binnedSetup.numberaxle];
|
file.lbinnedAxle.add(binned);
|
|
for (int i=0; i<file.header.activelanes; i++)
|
{
|
for (int j=0; j<file.binnedSetup.numberaxle; j++)
|
{
|
binned.valores[i][j] = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
if (binned.valores[i][j] == 65535)binned.valores[i][j] = 0;
|
apuntador = apuntador + 2;
|
}
|
}
|
}
|
|
|
|
|
|
private void binnedSpeedData (DIAMOND_File file, int[] in, int apuntador)
|
{
|
DIAMOND_Binned binned = new DIAMOND_Binned();
|
binned.valores = new int[file.header.activelanes][file.binnedSetup.numberspeed];
|
file.lbinnedSpeed.add(binned);
|
|
for (int i = 0; i<file.header.activelanes; i++)
|
{
|
for (int j=0; j<file.binnedSetup.numberspeed; j++)
|
{
|
binned.valores[i][j] = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
if (binned.valores[i][j] == 65535) binned.valores[i][j] = 0;
|
apuntador = apuntador + 2;
|
}
|
}
|
}
|
|
|
|
|
|
private void binnedLengthData (DIAMOND_File file, int[] in, int apuntador)
|
{
|
DIAMOND_Binned binned = new DIAMOND_Binned();
|
binned.valores = new int[file.header.activelanes][file.binnedSetup.numberlength];
|
file.lbinnedLength.add(binned);
|
|
for (int i=0; i<file.header.activelanes; i++)
|
{
|
for (int j=0; j<file.binnedSetup.numberlength; j++)
|
{
|
binned.valores[i][j] = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
if (binned.valores[i][j] == 65535) binned.valores[i][j] = 0;
|
apuntador = apuntador + 2;
|
}
|
|
}
|
}
|
|
|
|
|
private int binnedSpeedxLengthData (DIAMOND_File file, int[] in, int apuntador) throws Exception
|
{
|
int flag = 0x96;
|
|
DIAMOND_Binned binned = new DIAMOND_Binned();
|
binned.valores2 = new int[file.header.activelanes][file.binnedSetup.numberlength][file.binnedSetup.numberspeed];
|
file.lbinnedSpeedxLenght.add(binned);
|
|
for (int i=0; i<file.binnedSetup.numberlength; i++)
|
{
|
if (flag != 0x96) throw new Exception();
|
|
int lengthbin = (int)in[apuntador];
|
|
apuntador = apuntador + 1;
|
|
for (int j=0; j<file.header.activelanes; j++)
|
{
|
|
for (int k=0; k<file.binnedSetup.numberspeed; k++)
|
{
|
int valor = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
binned.valores2[j][i][k] = valor;
|
if (binned.valores2[j][i][k] == 65535) binned.valores2[j][i][k] = 0;
|
apuntador = apuntador + 2;
|
}
|
}
|
|
flag = (int)in[apuntador] & 0xFF;
|
apuntador = apuntador + 1;
|
}
|
|
return (apuntador - 1);
|
}
|
|
|
|
|
private int binnedSpeedxAxleData (DIAMOND_File file, int[] in, int apuntador) throws Exception
|
{
|
int flag = 0x97;
|
|
DIAMOND_Binned binned = new DIAMOND_Binned();
|
binned.valores2 = new int[file.header.activelanes][file.binnedSetup.numberaxle][file.binnedSetup.numberspeed];
|
file.lbinnedSpeedxAxle.add(binned);
|
|
for (int i=0; i<file.binnedSetup.numberaxle; i++)
|
{
|
if (flag != 0x97) throw new Exception();
|
|
int axlebin = (int)in[apuntador];
|
|
apuntador = apuntador + 1;
|
|
for (int j=0; j<file.header.activelanes; j++)
|
{
|
|
for (int k=0; k<file.binnedSetup.numberspeed; k++)
|
{
|
int valor = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
binned.valores2[j][i][k] = valor;
|
if (binned.valores2[j][i][k] == 65535) binned.valores2[j][i][k] = 0;
|
apuntador = apuntador + 2;
|
}
|
}
|
|
flag = (int)in[apuntador] & 0xFF;
|
apuntador = apuntador + 1;
|
}
|
|
return (apuntador - 1);
|
}
|
|
|
|
private int rawData (int carril, int[] in, int apuntador) throws Exception
|
{
|
|
DIAMOND_RawData rawData = new DIAMOND_RawData();
|
rawData.carril = carril;
|
|
apuntador = apuntador + 1;
|
|
String data = "";
|
|
for (int i=0; i<4; i++)
|
{
|
String bin = Integer.toBinaryString(in[apuntador] & 0xFF);
|
for (int j=bin.length(); j<8; j++) data = data + "0";
|
data = data + bin;
|
apuntador = apuntador + 1;
|
}
|
|
int horas = Integer.parseInt(data.substring(0, 5), 2);
|
int minutos = Integer.parseInt(data.substring(5, 11), 2);
|
int segundos = Integer.parseInt(data.substring(11, 17), 2);
|
|
|
SimpleDateFormat formato1 = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
|
DecimalFormat formato2 = new DecimalFormat("00");
|
rawData.timestamp = formato1.parse(formato2.format(header.startday) + "/" + formato2.format(header.startmonth) + "/" + formato2.format(header.startyear) + " " + formato2.format(horas) + ":" + formato2.format(minutos) + ":" + formato2.format(segundos)).getTime();
|
rawData.ejes = Integer.parseInt(data.substring(17,21), 2) + 1;
|
rawData.velocidad = ((float)Integer.parseInt(data.substring(21,32), 2)) / 10.0f;
|
rawData.longitudejes = new int[rawData.ejes-1];
|
|
|
|
// Longitudes
|
|
for (int i=0; i< rawData.longitudejes.length; i++)
|
{
|
int longitud1 = in[apuntador] & 0xFF; apuntador = apuntador + 1;
|
int longitud2 = in[apuntador] & 0xFF; apuntador = apuntador + 1;
|
rawData.longitudejes[i] = longitud1 + (longitud2 * 256);
|
rawData.longitud = rawData.longitud + rawData.longitudejes[i];
|
}
|
|
raw.add(rawData);
|
|
return apuntador;
|
|
}
|
|
|
|
|
|
private int rawDataError (int carril, int[] in, int apuntador) throws Exception
|
{
|
|
DIAMOND_RawData rawData = new DIAMOND_RawData();
|
rawData.carril = carril;
|
|
apuntador = apuntador + 1;
|
|
String data = "";
|
|
for (int i=0; i<4; i++)
|
{
|
String bin = Integer.toBinaryString(in[apuntador] & 0xFF);
|
for (int j=bin.length(); j<8; j++) data = data + "0";
|
data = data + bin;
|
apuntador = apuntador + 1;
|
}
|
|
SimpleDateFormat formato1 = new SimpleDateFormat("dd/MM/yy HH:mm:ss");
|
DecimalFormat formato2 = new DecimalFormat("00");
|
|
int horas = Integer.parseInt(data.substring(0, 5), 2);
|
int minutos = Integer.parseInt(data.substring(5, 11), 2);
|
int segundos = Integer.parseInt(data.substring(11, 17), 2);
|
rawData.velocidad = -1;
|
rawData.longitud = -1;
|
rawData.timestamp = formato1.parse(formato2.format(header.startday) + "/" + formato2.format(header.startmonth) + "/" + formato2.format(header.startyear) + " " + formato2.format(horas) + ":" + formato2.format(minutos) + ":" + formato2.format(segundos)).getTime();
|
raw.add(rawData);
|
|
return apuntador;
|
|
}
|
|
|
|
|
|
private void errorBininfo (DIAMOND_File file, int[] in, int apuntador)
|
{
|
DIAMOND_Binned binned = new DIAMOND_Binned();
|
binned.valores = new int[file.header.activelanes][4];
|
file.lbinnedError.add(binned);
|
|
for (int i=0; i<file.header.activelanes; i++)
|
{
|
for (int j=0; j<4; j++)
|
{
|
binned.valores[i][j] = DIAMOND_Word((byte)in[apuntador], (byte)in[apuntador+1]);
|
if (binned.valores[i][j] == 65535) binned.valores[i][j] = 0;
|
apuntador = apuntador + 2;
|
}
|
}
|
|
|
}
|
|
|
|
|
private void recordInterval (DIAMOND_File file, int[] in, int apuntador)
|
{
|
file.recordInterval = new DIAMOND_RecordInterval();
|
file.recordInterval.minutes = DIAMOND_Word((byte)in[apuntador],(byte)in[apuntador+1]);
|
file.recordInterval.retrieved = true;
|
}
|
|
|
|
|
private void enfOfFile (DIAMOND_File file, int[] receive, int apuntador)
|
{
|
|
byte in[] = new byte[6];
|
for (int i=0; i<6; i++)
|
in[i] = (byte)receive[apuntador+i];
|
|
DIAMOND_EndOfFile endOfFile = new DIAMOND_EndOfFile();
|
endOfFile.year = DIAMOND_SubCharSet(in[1],7,7);
|
endOfFile.month = DIAMOND_SubWordSet(in[1],in[2],8,4);
|
endOfFile.day = DIAMOND_SubCharSet (in[2],4,5);
|
endOfFile.hour = DIAMOND_SubCharSet (in[3],7,5);
|
endOfFile.minute = DIAMOND_SubWordSet (in[3],in[4],10,6);
|
endOfFile.second = DIAMOND_SubWordSet (in[4],in[5],12,6);
|
endOfFile.hundredseconds = DIAMOND_SubCharSet (in[5],6,7);
|
endOfFile.retrieved = true;
|
file.endOfFile = endOfFile;
|
|
|
// Timestamp a los periodos
|
|
DIAMOND_Header h = file.header;
|
|
int periodoMs = file.recordInterval.minutes * 60 * 1000;
|
|
Calendar calendarStart = Calendar.getInstance();
|
calendarStart.set(Calendar.DATE, h.startday);
|
calendarStart.set(Calendar.MONTH, h.startmonth - 1);
|
calendarStart.set(Calendar.YEAR, h.startyear + 2000);
|
calendarStart.set(Calendar.HOUR_OF_DAY, h.starthour);
|
calendarStart.set(Calendar.MINUTE, h.startminute);
|
calendarStart.set(Calendar.SECOND, 0);
|
calendarStart.set(Calendar.MILLISECOND, 0);
|
|
Calendar calendarStop = Calendar.getInstance();
|
calendarStop.set(Calendar.DATE, h.stopday);
|
calendarStop.set(Calendar.MONTH, h.stopmonth - 1);
|
calendarStop.set(Calendar.YEAR, h.stopyear + 2000);
|
calendarStop.set(Calendar.HOUR_OF_DAY, h.stophour);
|
calendarStop.set(Calendar.MINUTE, h.stopminute);
|
calendarStop.set(Calendar.SECOND, 0);
|
calendarStop.set(Calendar.MILLISECOND, 0);
|
|
while (calendarStart.before(calendarStop))
|
{
|
file.ltimestamps.add(new Long(calendarStart.getTimeInMillis()));
|
calendarStart.setTimeInMillis(calendarStart.getTimeInMillis() + periodoMs);
|
}
|
|
|
// Print de los datos
|
|
|
if ((file.lbinnedAxle.size() > 0) && (file.lbinnedAxle.size() != file.ltimestamps.size()))
|
{
|
return;
|
}
|
|
if ((file.lbinnedSpeed.size() > 0) && (file.lbinnedSpeed.size() != file.ltimestamps.size()))
|
{
|
return;
|
}
|
|
if ((file.lbinnedLength.size() > 0) && (file.lbinnedLength.size() != file.ltimestamps.size()))
|
{
|
return;
|
}
|
|
|
if ((file.lbinnedError.size() > 0) && (file.lbinnedError.size() != file.ltimestamps.size()))
|
{
|
return;
|
}
|
|
if ((file.lcount.size() > 0) && (file.lcount.size() != file.ltimestamps.size()))
|
{
|
return;
|
}
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
private int V (byte[] trama)
|
{
|
return (Integer.parseInt(new String(trama), 16));
|
}
|
|
|
|
|
private int V (int[] trama, int apuntador, int longitud)
|
{
|
byte[] aux = new byte[longitud];
|
for (int i=apuntador; i<(apuntador+longitud); i++)
|
aux[i-apuntador] = (byte)trama[i];
|
return (Integer.parseInt(new String(aux), 16));
|
}
|
|
|
|
private String S (int[] trama, int apuntador, int longitud)
|
{
|
byte[] cadena = new byte[longitud];
|
for (int i=apuntador; i<(apuntador+longitud); i++)
|
cadena[i-apuntador] = (byte)trama[i];
|
|
return ((new String(cadena)).trim());
|
}
|
|
|
|
|
private String S (byte[] trama, int apuntador, int longitud)
|
{
|
byte[] cadena = new byte[longitud];
|
|
for (int i=apuntador; i<(apuntador+longitud); i++)
|
cadena[i-apuntador] = (byte)trama[i];
|
|
return ((new String(cadena)).trim());
|
}
|
|
|
|
|
private int DIAMOND_SubCharSet(byte in, int bit, int length)
|
{
|
int out = 0;
|
for (int i=bit-length+1; i<=bit; i++)
|
out += 0x01<<i;
|
out = (int)(out & in);
|
out = (int)(out>>(bit-length+1));
|
return(out);
|
}
|
|
|
private int DIAMOND_SubWordSet(byte high, byte low, int bit, int length)
|
{
|
int out = 0;
|
int h = (int)high;
|
int l = (int)low;
|
if (h<0) h += 256;
|
if (l<0) l += 256;
|
|
int in =(int)(((h)<<8) + l);
|
|
for (int i=bit-length+1; i<=bit; i++)
|
out += 0x01<<i;
|
out = (int)(out & in);
|
out = (int)(out>>(bit-length+1));
|
return(out);
|
}
|
|
|
private int DIAMOND_Word (byte low, byte high)
|
{
|
int h = (int)high;
|
int l = (int)low;
|
if (h<0) h += 256;
|
if (l<0) l += 256;
|
int valor = (int)((h<<8) + l);
|
return (valor);
|
}
|
|
|
|
private String F(int numero, int longitud)
|
{
|
String s = ""+numero;
|
for (int i=0; i<(longitud-s.length()); i++)
|
s = "0" + s;
|
return s;
|
}
|
|
|
private String FS(int numero, int longitud)
|
{
|
String s = ""+numero;
|
for (int i=0; i<(longitud-s.length()); i++)
|
s = " " + s;
|
return s;
|
}
|
|
|
private String IntToString(int valor, int digitos)
|
{
|
try
|
{
|
String res = "";
|
if (valor < 1000) res = res + "0";
|
if (valor < 100) res = res + "0";
|
if (valor < 10) res = res + "0";
|
res = res + valor;
|
return res;
|
}
|
catch (Exception e)
|
{
|
}
|
|
return "" + valor;
|
}
|
|
}
|
