private GW_DataFile Concat_XmlDataFiles(GW_DataFile[] oDataFiles)
{
if (oDataFiles == null)
{
return(null);
}
//Concatened data file creation
oConcatData = new GW_DataFile();
oConcatData.DataSamplingMode = SamplingMode.MultipleRates;
//Complete channel list creation
foreach (GW_DataFile oFile in oDataFiles)
{
foreach (GW_DataChannel oChan in oFile.Channels)
{
//Create the data channel into the concatenated data file if it does not exist already
if (!(oConcatData.DataChannelExists(oChan.Name)))
{
GW_DataChannel oConcatChan = new GW_DataChannel(oChan.Name, SamplingMode.MultipleRates);
//Copy XML data channel properties
oConcatChan.Description = oChan.Description;
oConcatChan.Unit = oChan.Unit;
oConcatChan.GraphicFormat = oChan.GraphicFormat.Get_Clone();
foreach (GraphReferenceLine oRefLine in oChan.ChannelReferenceLines)
{
oConcatChan.ChannelReferenceLines.Add(oRefLine.Get_Clone());
}
oConcatData.Channels.Add(oConcatChan);
}
}
}
//Append current file channel samples to the concatenated data file channel
foreach (GW_DataChannel oConcatChan in oConcatData.Channels)
{
double Concat_T = 0;
foreach (GW_DataFile oFile in oDataFiles)
{
GW_DataChannel oDataChan = oFile.Get_DataChannel(oConcatChan.Name);
if (!(oDataChan == null))
{
if (oDataChan.Samples.Count > 1)
{
for (int iSample = 0; iSample < oDataChan.Samples.Count; iSample++)
{
if (oConcatChan.Samples.Count > 0)
{
if (iSample > 0)
{
Concat_T += (oDataChan.Samples[iSample].SampleTime - oDataChan.Samples[iSample - 1].SampleTime);
}
else
{
Concat_T += (oDataChan.Samples[1].SampleTime - oDataChan.Samples[0].SampleTime);
}
}
SerieSample sNewSample = new SerieSample();
sNewSample.SampleTime = Concat_T;
sNewSample.SampleValue = oDataChan.Samples[iSample].SampleValue;
oConcatChan.Samples.Add(sNewSample);
if (oConcatChan.Samples.Count == 1)
{
oConcatChan.Min = oDataChan.Samples[iSample].SampleValue;
oConcatChan.Max = oDataChan.Samples[iSample].SampleValue;
}
else
{
if (oDataChan.Samples[iSample].SampleValue < oConcatChan.Min)
{
oConcatChan.Min = oDataChan.Samples[iSample].SampleValue;
}
if (oDataChan.Samples[iSample].SampleValue > oConcatChan.Max)
{
oConcatChan.Max = oDataChan.Samples[iSample].SampleValue;
}
}
}
}
}
}
}
//Virtual channels computations
if (!(VCLibraries == null))
{
VCLibraries.InitLibrariesComputation(); //Virtual channels libraries initialization
foreach (CS_VirtualChannel oVirtChan in VCLibraries.ChannelsComputationList)
{
bool bComputeVirtual = true;
GW_DataChannel oCarrierChannel = null;
foreach (string ChanVar in oVirtChan.ChannelVariables)
{
GW_DataChannel oDataChan = oConcatData.Get_DataChannel(ChanVar);
if (!(oDataChan == null))
{
if (oCarrierChannel == null)
{
oCarrierChannel = oDataChan;
}
else
{
if (oDataChan.Samples.Count > oCarrierChannel.Samples.Count)
{
oCarrierChannel = oDataChan;
}
}
}
else
{
bComputeVirtual = false;
break;
}
}
if (oCarrierChannel != null && bComputeVirtual)
{
GW_DataChannel oVirtualData = new GW_DataChannel(oVirtChan.Name, SamplingMode.MultipleRates);
oVirtualData.Unit = oVirtChan.Unit;
oVirtualData.Description = oVirtChan.Comment;
oVirtualData.GraphicFormat = CANStreamTools.Convert_CSSignalFormatToSerieValueFormat(oVirtChan.ValueFormat);
oVirtualData.ChannelReferenceLines = CANStreamTools.Convert_CSAlarmsToSerieReferenceLines(oVirtChan.Alarms);
foreach (SerieSample sCarrierSample in oCarrierChannel.Samples)
{
SerieSample sVirtSample = new SerieSample();
sVirtSample.SampleTime = sCarrierSample.SampleTime;
foreach (string ChanVar in oVirtChan.ChannelVariables)
{
VCLibraries.UpDateVariableElement(ChanVar, oConcatData.Get_ChannelValueAtTime(ChanVar, sVirtSample.SampleTime));
}
oVirtChan.ComputeChannelValue();
if (oVirtChan.bComputed && oVirtChan.bNewValue)
{
sVirtSample.SampleValue = oVirtChan.Value;
oVirtualData.Samples.Add(sVirtSample);
if (oVirtualData.Samples.Count == 1)
{
oVirtualData.Min = sVirtSample.SampleValue;
oVirtualData.Max = sVirtSample.SampleValue;
}
else
{
if (sVirtSample.SampleValue < oVirtualData.Min)
{
oVirtualData.Min = sVirtSample.SampleValue;
}
if (sVirtSample.SampleValue > oVirtualData.Max)
{
oVirtualData.Max = sVirtSample.SampleValue;
}
}
}
}
if (oVirtualData.Samples.Count > 1)
{
oConcatData.Channels.Add(oVirtualData);
}
}
}
}
oDataFiles = null; //Free up memory
return(oConcatData);
}
/// <summary>
/// Converts the decoded PCAN trace file into a XML data file
/// </summary>
/// <param name="OutputFolder">Output file folder</param>
/// <returns>Converion result (True: OK / False: Error)</returns>
private bool WriteXmlRecordData(string OutputFolder)
{
if (Channels.Count == 0)
{
return(false);
}
GW_DataFile oDataFile = new GW_DataFile();
oDataFile.DataSamplingMode = SamplingMode.MultipleRates;
//Set data file properties
oDataFile.DataStartTime = this.AbsDTStartTime;
oDataFile.UserComment = "Data file created "
+ DateTime.Now.ToShortDateString()
+ " "
+ DateTime.Now.ToShortTimeString();
//Data file custom properties
GW_XmlDataFileCustomProperty oCustProp;
oCustProp = new GW_XmlDataFileCustomProperty();
oCustProp.Name = "Base PCAN Trc file";
oCustProp.PropertyValue = Path.GetFileName(this.BaseTrcFilePath);
oDataFile.XmlDataFileCustomProperties.Add(oCustProp);
oCustProp = new GW_XmlDataFileCustomProperty();
oCustProp.Name = "Data decode CAN Configuration";
oCustProp.PropertyValue = Path.GetFileName(this.oCanConfig.ConfigFilePath);
oDataFile.XmlDataFileCustomProperties.Add(oCustProp);
for (int i = 0; i < this.VCLibraries.Libraries.Count; i++)
{
oCustProp = new GW_XmlDataFileCustomProperty();
oCustProp.Name = "Data decode virtual channels library #" + (i + 1).ToString();
oCustProp.PropertyValue = Path.GetFileName(VCLibraries.Libraries[i].Name);
oDataFile.XmlDataFileCustomProperties.Add(oCustProp);
}
//Set data channels
foreach (RecordDataChannel oRecChan in Channels)
{
GW_DataChannel oDataChan = new GW_DataChannel(oRecChan.Name, SamplingMode.MultipleRates);
//Channel properties
CANParameter oCANSig = this.oCanConfig.GetCANParameter(oRecChan.Name);
if (!(oCANSig == null)) //A CAN parameter has been found, GW_DataChannel properties will be filled using properties of the CAN Parameter
{
oDataChan.Description = oCANSig.Comment;
oDataChan.Unit = oCANSig.Unit;
oDataChan.GraphicFormat = CANStreamTools.Convert_CSSignalFormatToSerieValueFormat(oCANSig.ValueFormat);
oDataChan.ChannelReferenceLines = CANStreamTools.Convert_CSAlarmsToSerieReferenceLines(oCANSig.Alarms);
}
else //No CAN parameter found, search among virtual channels
{
CS_VirtualChannel oVirtual = null;
foreach (CS_VirtualChannelsLibrary oVirtLib in this.VCLibraries.Libraries)
{
oVirtual = oVirtLib.GetVirtualChannel(oRecChan.Name);
if (!(oVirtual == null))
{
break;
}
}
if (!(oVirtual == null)) //A virtual channel has been found, GW_DataChannel properties will be filled using properties of the virtual channel
{
oDataChan.Description = oVirtual.Comment;
oDataChan.Unit = oVirtual.Unit;
oDataChan.GraphicFormat = CANStreamTools.Convert_CSSignalFormatToSerieValueFormat(oVirtual.ValueFormat);
oDataChan.ChannelReferenceLines = CANStreamTools.Convert_CSAlarmsToSerieReferenceLines(oVirtual.Alarms);
}
else //No virtual channel found, GW_DataChannel will keeps its default properties values
{
//Nothing to do
}
}
//Channel samples value
foreach (RecordDataSample oRecSample in oRecChan.Samples)
{
SerieSample sDataSample = new SerieSample();
sDataSample.SampleTime = oRecSample.TimeStamp / 1000;
sDataSample.SampleValue = oRecSample.SampleValue;
oDataChan.Samples.Add(sDataSample);
}
oDataFile.Channels.Add(oDataChan);
}
string OutFilePath = BuildOutputFilePtah(OutputFolder, RecordConversionFormat.Xml);
oDataFile.Write_XmlDataFile(OutFilePath);
return(true);
}