2696 lines
150 KiB
C#
2696 lines
150 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Globalization;
|
|
using System.Windows.Forms;
|
|
|
|
namespace GenesisDisplayTool
|
|
{
|
|
public static partial class DecodeTelegram
|
|
{
|
|
private static CultureInfo culture = GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture();
|
|
public static DecodedData[] DecodedDataDecodeTelegram(String rxString, Boolean cB_StdDevEnable_Checked, Boolean cB_MeanValuesEnable_Checked, DecodedData[] decodedData, Double crystalFrequency)
|
|
{
|
|
|
|
#region Definitions and initializations
|
|
DecodedData[] DecodingResult = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
|
|
DecodingResult[Constants.PATH0] = ((DecodedData)(decodedData[Constants.PATH0].Clone()));
|
|
DecodingResult[Constants.PATH1] = ((DecodedData)(decodedData[Constants.PATH1].Clone()));
|
|
DecodingResult[Constants.PATH2] = ((DecodedData)(decodedData[Constants.PATH2].Clone()));
|
|
|
|
#endregion
|
|
#region Prepare RX data
|
|
String[] HexValues = rxString.Split(' ');
|
|
#endregion
|
|
#region Call decoder
|
|
#region Decode protocol A and B
|
|
//DecodingResult = DecodeTelegram.DecodeProtocolAandB(HexValues, decodedData, crystalFrequency);
|
|
#endregion
|
|
#region Decode protocol D
|
|
//DecodingResult = DecodeTelegram.DecodeProtocolD(HexValues, DecodingResult, crystalFrequency);
|
|
#endregion
|
|
#region Decode protocol E
|
|
//DecodingResult = DecodeTelegram.DecodeProtocolE(HexValues, DecodingResult, crystalFrequency);
|
|
#endregion
|
|
#region Decode protocol G
|
|
DecodingResult = DecodeTelegram.DecodeProtocolG(HexValues, DecodingResult);
|
|
#endregion
|
|
#region Decode protocol F
|
|
DecodingResult = DecodeTelegram.DecodeProtocolF(HexValues, DecodingResult);
|
|
#endregion
|
|
#region Decode protocol H
|
|
DecodingResult = DecodeTelegram.DecodeProtocolH(HexValues, DecodingResult);
|
|
#endregion
|
|
#region Decode protocol I
|
|
DecodingResult = DecodeTelegram.DecodeProtocolI(HexValues, DecodingResult, crystalFrequency);
|
|
#endregion
|
|
#endregion
|
|
#region Return data
|
|
return DecodingResult;
|
|
#endregion
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolAandB(String[] HexValues, DecodedData[] inputDecodedData, Double crystalFrequency)
|
|
{
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
ReturnData = inputDecodedData;
|
|
String ProtocolVersion = String.Empty;
|
|
String MessageType = String.Empty;
|
|
Double temp = 0;
|
|
UInt16 Path = 0;
|
|
UInt16 DatIndex = 0;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Decode TDC data ("DATA CHANNEL")
|
|
if (HexValues[0].Contains("a") ||
|
|
(HexValues[0].Contains("b") && (!(HexValues[1].Contains(Message.Temperature)))))
|
|
{
|
|
#region Reset parameters
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode and display
|
|
foreach (String HexValue in HexValues)
|
|
{
|
|
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode and display telegram
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 1:
|
|
Path = UInt16.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
break;
|
|
#endregion
|
|
#region Decode HCC-Value
|
|
case 2:
|
|
#region Calculate Value
|
|
UInt32 HccValTemp = UInt32.Parse(HexValue, NumberStyles.HexNumber);
|
|
ReturnData[Path].HccVal = (Double)HccValTemp;
|
|
ReturnData[Path].HccCorrectionFactor = (4 * Constants.NominalFrequency * 1000000) / ((HccValTemp >> 16) * 32768);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF sum of all up
|
|
case 3:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofSumOfAllUp = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Pulse width up
|
|
case 4:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].PulsewidthUp = (Double)Math.Round((((Double)temp / 128)), 2);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude up
|
|
case 5:
|
|
#region Calculate value and assign
|
|
ReturnData[Path].AmpUpRaw = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude calibrate value high
|
|
case 6:
|
|
#region Calculate value and assign
|
|
ReturnData[Path].AmpCalHigh = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF sum of all down
|
|
case 7:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofSumOfAllDown = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8); // From Acam datasheet vol.2, 5-1
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Pulse width down
|
|
case 8:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].PulsewidthDown = (Double)Math.Round((((Double)temp / 128)), 2);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude down
|
|
case 9:
|
|
#region Calculate value and assign
|
|
ReturnData[Path].AmpDownRaw = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude calibrate value low
|
|
case 10:
|
|
#region Calculate value and assign
|
|
ReturnData[Path].AmpCalLow = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].AmpGradient = Constants.Vcal / (ReturnData[Path].AmpCalHigh - ReturnData[Path].AmpCalLow);
|
|
ReturnData[Path].AmpOffset = ((2 * ReturnData[Path].AmpCalLow) - ReturnData[Path].AmpCalHigh) * ReturnData[Path].AmpGradient;
|
|
ReturnData[Path].AmpUpCalculated = ReturnData[Path].AmpGradient * ReturnData[Path].AmpUpRaw - ReturnData[Path].AmpOffset;
|
|
ReturnData[Path].AmpDownCalculated = ReturnData[Path].AmpGradient * ReturnData[Path].AmpDownRaw - ReturnData[Path].AmpOffset;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF0 up
|
|
case 11:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT0] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF1 up
|
|
case 12:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT1] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF2 up
|
|
case 13:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT2] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF3 up
|
|
case 14:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT3] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF4 up
|
|
case 15:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT4] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF5 up
|
|
case 16:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT5] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF6 up
|
|
case 17:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT6] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF7 up
|
|
case 18:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofUp[Constants.HIT7] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF0 down/ DIF-TOF0
|
|
case 19:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT0] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT0] = (ReturnData[Path].TofDown[Constants.HIT0] - ReturnData[Path].TofUp[Constants.HIT0]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF1 down/ DIF-TOF1
|
|
case 20:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT1] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT1] = (ReturnData[Path].TofDown[Constants.HIT1] - ReturnData[Path].TofUp[Constants.HIT1]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF2 down/ DIF-TOF2
|
|
case 21:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT2] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT2] = (ReturnData[Path].TofDown[Constants.HIT2] - ReturnData[Path].TofUp[Constants.HIT2]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF3 down/ DIF-TOF3
|
|
case 22:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT3] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT3] = (ReturnData[Path].TofDown[Constants.HIT3] - ReturnData[Path].TofUp[Constants.HIT3]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF4 down/ DIF-TOF4
|
|
case 23:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT4] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT4] = (ReturnData[Path].TofDown[Constants.HIT4] - ReturnData[Path].TofUp[Constants.HIT4]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF5 down/ DIF-TOF5
|
|
case 24:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT5] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT5] = (ReturnData[Path].TofDown[Constants.HIT5] - ReturnData[Path].TofUp[Constants.HIT5]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF6 down/ DIF-TOF6
|
|
case 25:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT6] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT6] = (ReturnData[Path].TofDown[Constants.HIT6] - ReturnData[Path].TofUp[Constants.HIT6]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF7 down/ DIF-TOF7
|
|
case 26:
|
|
#region Calculate value and assign
|
|
temp = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].TofDown[Constants.HIT7] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT7] = (ReturnData[Path].TofDown[Constants.HIT7] - ReturnData[Path].TofUp[Constants.HIT7]) * 1000;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
default: break;
|
|
#endregion
|
|
}
|
|
|
|
if (DatIndex == 26) // last position of telegram
|
|
{
|
|
#region Decoding finished
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
ReturnData[Path].MessageType = Message.Data;
|
|
DatIndex = 0;
|
|
#endregion
|
|
|
|
}
|
|
else
|
|
DatIndex++;
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
#region Decode temperature data ("DATA CHANNEL")
|
|
if (HexValues[0].Contains("b") && (HexValues[1].Contains(Message.Temperature)))
|
|
{
|
|
#region Decode
|
|
foreach (String HexValue in HexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram (DATA CHANNEL)
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 1:
|
|
MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 2:
|
|
Path = UInt16.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
break;
|
|
#endregion
|
|
#region Schmitt trigger delay compensation value (not used)
|
|
case 3:
|
|
#region Calculate value and assign
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT reference impedance value (not used)
|
|
case 4:
|
|
#region Calculate value and assign
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT cold impedance value (not used)
|
|
case 5:
|
|
#region Calculate Value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Pt hot impedance value (not used)
|
|
case 6:
|
|
#region Calculate value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT reference 1st (on) correction value (not used)
|
|
case 7:
|
|
#region Calculate Value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Schmitt trigger delay compensation value (not used)
|
|
case 8:
|
|
#region Calculate Value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT reference impedance value (not used)
|
|
case 9:
|
|
#region Calculate Value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT cold impedance value (not used)
|
|
case 10:
|
|
#region Calculate Value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT hot impedance value (not used)
|
|
case 11:
|
|
#region Calculate value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region PT reference 1st (on) correction value (not used)
|
|
case 12:
|
|
#region Calculate Value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Temperature (cold)
|
|
case 13:
|
|
#region Calculate Value
|
|
ReturnData[Path].TemperatureCold = Double.Parse(HexValue);
|
|
ReturnData[Path].TemperatureHot = 0; // Dummy data
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
default: break;
|
|
#endregion
|
|
}
|
|
if (DatIndex == 13)
|
|
{
|
|
#region Decoding finished
|
|
DatIndex = 0;
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
ReturnData[Path].MessageType = MessageType;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeProtocolAandB() failed", $"0x{ex.HResult.ToString("X", culture)}", String.Empty);
|
|
}
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolD(String[] hexValues, DecodedData[] inputDecodedData, Double crystalFrequency)
|
|
{
|
|
|
|
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
|
|
ReturnData[Constants.PATH0] = ((DecodedData)(inputDecodedData[Constants.PATH0].Clone()));
|
|
ReturnData[Constants.PATH1] = ((DecodedData)(inputDecodedData[Constants.PATH1].Clone()));
|
|
ReturnData[Constants.PATH2] = ((DecodedData)(inputDecodedData[Constants.PATH2].Clone()));
|
|
|
|
|
|
|
|
UInt32 temp = 0;
|
|
UInt16 DatIndex = 0;
|
|
String DecodedMessageType = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Decode TDC-data ("DATA CHANNEL")
|
|
if ((hexValues[0] == "d") && (hexValues[1] == Message.Data) && (hexValues.Count()== 29))
|
|
{
|
|
|
|
DecodedMessageType = Message.Data;
|
|
|
|
#region Definitions
|
|
UInt16 Path = Constants.PATH0;
|
|
String ProtocolVersion = String.Empty;
|
|
String MessageType = String.Empty;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
|
|
#endregion
|
|
#region Decode and display
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode and display telegram
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 2:
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out Path))
|
|
{
|
|
Path--;
|
|
ReturnData[Constants.PATH0].Path = Path;
|
|
ReturnData[Constants.PATH1].Path = Path;
|
|
ReturnData[Constants.PATH2].Path = Path;
|
|
}
|
|
|
|
break;
|
|
#endregion
|
|
#region Data valid
|
|
case 3:
|
|
ReturnData[Path].DataValid = HexValue;
|
|
break;
|
|
#endregion
|
|
#region TOF sum of all up
|
|
case 4:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofSumOfAllUp = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Pulse width up
|
|
case 5:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].PulsewidthUp = (Double)Math.Round((((Double)temp / 128)), 2);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude up
|
|
case 6:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].AmpUpRaw = temp;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude calibrate value high
|
|
case 7:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].AmpCalHigh = temp;
|
|
#endregion
|
|
|
|
break;
|
|
#endregion
|
|
#region TOF sum of all down
|
|
case 8:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofSumOfAllDown = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8); // From Acam datasheet vol.2, 5-1
|
|
#endregion
|
|
|
|
break;
|
|
#endregion
|
|
#region Pulse width down
|
|
case 9:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].PulsewidthDown = (Double)Math.Round((((Double)temp / 128)), 2);
|
|
#endregion
|
|
|
|
break;
|
|
#endregion
|
|
#region Amplitude down
|
|
case 10:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].AmpDownRaw = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude calibrate value low
|
|
case 11:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].AmpCalLow = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].AmpGradient = Constants.Vcal / (ReturnData[Path].AmpCalHigh - ReturnData[Path].AmpCalLow);
|
|
ReturnData[Path].AmpOffset = ((2 * ReturnData[Path].AmpCalLow) - ReturnData[Path].AmpCalHigh) * ReturnData[Path].AmpGradient;
|
|
ReturnData[Path].AmpUpCalculated = ReturnData[Path].AmpGradient * ReturnData[Path].AmpUpRaw - ReturnData[Path].AmpOffset;
|
|
ReturnData[Path].AmpDownCalculated = ReturnData[Path].AmpGradient * ReturnData[Path].AmpDownRaw - ReturnData[Path].AmpOffset;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF0 up
|
|
case 12:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT0] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF1 up
|
|
case 13:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT1] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF2 up
|
|
case 14:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT2] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF3 up
|
|
case 15:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT3] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF4 up
|
|
case 16:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT4] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF5 up
|
|
case 17:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT5] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF6 up
|
|
case 18:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT6] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF7 up
|
|
case 19:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].TofUp[Constants.HIT7] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF0 down/ DIF-TOF0
|
|
case 20:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT0] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT0] = (ReturnData[Path].TofDown[Constants.HIT0] - ReturnData[Path].TofUp[Constants.HIT0]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF1 down/ DIF-TOF1
|
|
case 21:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT1] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT1] = (ReturnData[Path].TofDown[Constants.HIT1] - ReturnData[Path].TofUp[Constants.HIT1]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF2 down/ DIF-TOF2
|
|
case 22:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT2] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT2] = (ReturnData[Path].TofDown[Constants.HIT2] - ReturnData[Path].TofUp[Constants.HIT2]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF3 down/ DIF-TOF3
|
|
case 23:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT3] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT3] = (ReturnData[Path].TofDown[Constants.HIT3] - ReturnData[Path].TofUp[Constants.HIT3]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF4 down/ DIF-TOF4
|
|
case 24:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT4] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT4] = (ReturnData[Path].TofDown[Constants.HIT4] - ReturnData[Path].TofUp[Constants.HIT4]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF5 down/ DIF-TOF5
|
|
case 25:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT5] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT5] = (ReturnData[Path].TofDown[Constants.HIT5] - ReturnData[Path].TofUp[Constants.HIT5]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF6 down/ DIF-TOF6
|
|
case 26:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT6] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT6] = (ReturnData[Path].TofDown[Constants.HIT6] - ReturnData[Path].TofUp[Constants.HIT6]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF7 down/ DIF-TOF7
|
|
case 27:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].TofDown[Constants.HIT7] = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].DifTof[Constants.HIT7] = (ReturnData[Path].TofDown[Constants.HIT7] - ReturnData[Path].TofUp[Constants.HIT7]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|
|
if (DatIndex == 27) // last position of telegram
|
|
{
|
|
#region Decoding finished
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
ReturnData[Path].MessageType = MessageType;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++;
|
|
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
|
|
#endregion
|
|
#region Decode Temperature data ("DATA CHANNEL")
|
|
if ((hexValues[0] == "d") && (hexValues[1] == Message.Temperature)&&(hexValues.Count() == 15))
|
|
{
|
|
DecodedMessageType = Message.Temperature;
|
|
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ReturnData[Constants.PATH0].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH1].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH2].ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
ReturnData[Constants.PATH0].MessageType = HexValue;
|
|
ReturnData[Constants.PATH1].MessageType = HexValue;
|
|
ReturnData[Constants.PATH2].MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Data valid
|
|
case 2:
|
|
ReturnData[Constants.PATH0].DataValid = HexValue;
|
|
ReturnData[Constants.PATH1].DataValid = HexValue;
|
|
ReturnData[Constants.PATH2].DataValid = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 3:
|
|
#region Schmitt trigger delay compensation values
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 4:
|
|
#region PT reference impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 5:
|
|
#region PT cold impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 6:
|
|
#region PT hot impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 7:
|
|
#region PT reference 1st correction value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 8:
|
|
#region Schmitt trigger delay compensation value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 9:
|
|
#region PT reference impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 10:
|
|
#region PT cold impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 11:
|
|
#region PT hot impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 12:
|
|
#region PT reference 1st rds(on) correction value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Get temperature value
|
|
case 13:
|
|
#region Temperature value
|
|
Double Temperature;
|
|
|
|
if (Double.TryParse(HexValue, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out Temperature))
|
|
{
|
|
ReturnData[Constants.PATH0].TemperatureCold = Temperature;
|
|
ReturnData[Constants.PATH0].TemperatureHot = 0; // Dummy data
|
|
ReturnData[Constants.PATH1].TemperatureCold = Temperature;
|
|
ReturnData[Constants.PATH1].TemperatureHot = 0; // Dummy data
|
|
ReturnData[Constants.PATH2].TemperatureCold = Temperature;
|
|
ReturnData[Constants.PATH2].TemperatureHot = 0; // Dummy data
|
|
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|
|
#region Decoding finished
|
|
if (DatIndex == 13)
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
ReturnData[Constants.PATH0].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH1].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH2].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
#region Decode HCC-value ("DATA CHANNEL")
|
|
if ((hexValues[0] == "d") && (hexValues[1] == Message.Hcc) && (hexValues.Count() == 5))
|
|
{
|
|
DecodedMessageType = Message.Hcc;
|
|
|
|
#region Definitions
|
|
UInt16 Path = Constants.PATH0;
|
|
String ProtocolVersion = String.Empty;
|
|
String MessageType = String.Empty;
|
|
#endregion
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Get PATH
|
|
case 2:
|
|
UInt16 PathTemp = 0;
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out PathTemp))
|
|
Path = (UInt16)(PathTemp - 1);
|
|
break;
|
|
#endregion
|
|
#region HCC-value
|
|
case 3:
|
|
#region Calculate value
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].HccVal = (Double)temp;
|
|
ReturnData[Path].HccCorrectionFactor = (Double)(4 * Constants.NominalFrequency * 1000000) / ((temp >> 16) * 32768);
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|
|
#region Decoding finished
|
|
if (DatIndex == 3)
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
ReturnData[Path].MessageType = MessageType;
|
|
ReturnData[Constants.PATH0].Path = Path;
|
|
ReturnData[Constants.PATH1].Path = Path;
|
|
ReturnData[Constants.PATH2].Path = Path;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
#region Decode comment ("DATA CHANNEL")
|
|
if ((hexValues[0] == "d") && (hexValues[1] == Message.Comment))
|
|
{
|
|
DecodedMessageType = Message.Comment;
|
|
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ReturnData[Constants.PATH0].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH1].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH2].ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
ReturnData[Constants.PATH0].MessageType = HexValue;
|
|
ReturnData[Constants.PATH1].MessageType = HexValue;
|
|
ReturnData[Constants.PATH2].MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Comment0
|
|
case 2:
|
|
#region Comment0
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = HexValue;
|
|
ReturnData[Constants.PATH1].Comment = HexValue;
|
|
ReturnData[Constants.PATH2].Comment = HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment1
|
|
case 3:
|
|
#region Comment1
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = ReturnData[Constants.PATH0].Comment + HexValue;
|
|
ReturnData[Constants.PATH1].Comment = ReturnData[Constants.PATH1].Comment + HexValue;
|
|
ReturnData[Constants.PATH2].Comment = ReturnData[Constants.PATH2].Comment + HexValue;
|
|
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment2
|
|
case 4:
|
|
#region Comment2
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = ReturnData[Constants.PATH0].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH1].Comment = ReturnData[Constants.PATH1].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH2].Comment = ReturnData[Constants.PATH2].Comment + " " + HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment3
|
|
case 5:
|
|
#region Comment3
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = ReturnData[Constants.PATH0].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH1].Comment = ReturnData[Constants.PATH1].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH2].Comment = ReturnData[Constants.PATH2].Comment + " " + HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment4
|
|
case 6:
|
|
#region Comment4
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = ReturnData[Constants.PATH0].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH1].Comment = ReturnData[Constants.PATH1].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH2].Comment = ReturnData[Constants.PATH2].Comment + " " + HexValue;
|
|
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment5
|
|
case 7:
|
|
#region Comment5
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = ReturnData[Constants.PATH0].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH1].Comment = ReturnData[Constants.PATH1].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH2].Comment = ReturnData[Constants.PATH2].Comment + " " + HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment6
|
|
case 8:
|
|
#region Comment6
|
|
if (HexValue != String.Empty)
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = ReturnData[Constants.PATH0].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH1].Comment = ReturnData[Constants.PATH1].Comment + " " + HexValue;
|
|
ReturnData[Constants.PATH2].Comment = ReturnData[Constants.PATH2].Comment + " " + HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#region Decoding finished
|
|
if (DatIndex == hexValues.Count()-1)
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Constants.PATH0].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH1].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH2].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeTelegram.DecodeProtocolD() failed", "0x" + ex.HResult.ToString("X", culture), DecodedMessageType+DatIndex.ToString());
|
|
#endregion
|
|
}
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolE(String[] hexValues, DecodedData[] inputDecodedData, Double crystalFrequency)
|
|
{
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
ReturnData = inputDecodedData;
|
|
UInt16 DatIndex = 0;
|
|
UInt16 DecodedPath = Constants.PATH0;
|
|
Int32 temp = 0;
|
|
String ProtocolVersion = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Decode comment ("DATA CHANNEL")
|
|
if ((hexValues[0] == "e")&&(hexValues.Count() == 8))
|
|
{
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 1:
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out DecodedPath))
|
|
{
|
|
DecodedPath--;
|
|
ReturnData[Constants.PATH0].Path = DecodedPath;
|
|
ReturnData[Constants.PATH1].Path = DecodedPath;
|
|
ReturnData[Constants.PATH2].Path = DecodedPath;
|
|
|
|
}
|
|
ReturnData[DecodedPath].ProtocolVersion = ProtocolVersion;
|
|
break;
|
|
#endregion
|
|
#region Data valid
|
|
case 2:
|
|
ReturnData[DecodedPath].DataValid = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Delta time of flight
|
|
case 3:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].DeltaTimeOfFlight = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[DecodedPath].HccCorrectionFactor, 8);
|
|
/*
|
|
Double temp = (Double)Int32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[DecodedPath].DeltaTimeOfFlight = (Double)Math.Round((((Double)temp / 65536) * (1000 / (crystalFrequency))) * ReturnData[DecodedPath].HccCorrectionFactor, 8);
|
|
*/
|
|
break;
|
|
#endregion
|
|
#region Raw delta volume
|
|
case 4:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].RawDeltaVolume = (Double)temp;
|
|
/*
|
|
Int32 temp2 = Int32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[DecodedPath].RawDeltaVolume = (Double)temp2*/;
|
|
break;
|
|
#endregion
|
|
#region Raw delta volume scaling
|
|
case 5:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].RawDeltaVolumeScaling = (Double)temp;
|
|
|
|
//ReturnData[DecodedPath].RawDeltaVolumeScaling = (Double)Int32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
break;
|
|
#endregion
|
|
#region Sample interval
|
|
case 6:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].SampleInterval = (Double)temp;
|
|
|
|
|
|
//ReturnData[DecodedPath].SampleInterval = (Double)Int32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#region Decoding finished
|
|
if (DatIndex == 6)
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[DecodedPath].MessageType = Message.Data;
|
|
ReturnData[DecodedPath].Flow = ((ReturnData[DecodedPath].RawDeltaVolume / ReturnData[DecodedPath].RawDeltaVolumeScaling) / (ReturnData[DecodedPath].SampleInterval/65536))*Constants.FlowFactor;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeTelegram.DecodeProtocolE() failed", "0x" + ex.HResult.ToString("X", culture), String.Empty);
|
|
}
|
|
|
|
return ReturnData;
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolF(String[] hexValues, DecodedData[] inputDecodedData)
|
|
{
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
ReturnData[Constants.PATH0] = ((DecodedData)(inputDecodedData[Constants.PATH0].Clone()));
|
|
ReturnData[Constants.PATH1] = ((DecodedData)(inputDecodedData[Constants.PATH1].Clone()));
|
|
ReturnData[Constants.PATH2] = ((DecodedData)(inputDecodedData[Constants.PATH2].Clone()));
|
|
UInt16 DatIndex = 0;
|
|
String ProtocolVersion = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
if (!String.Equals(hexValues[0], "@f"))
|
|
{
|
|
ReturnData[Constants.PATH0].ProtocolVersion = hexValues[0];
|
|
ReturnData[Constants.PATH1].ProtocolVersion = hexValues[0];
|
|
ReturnData[Constants.PATH2].ProtocolVersion = hexValues[0];
|
|
return ReturnData;
|
|
}
|
|
|
|
#region Decode comment ("DATA CHANNEL")
|
|
if ((String.Equals(hexValues[0], "@f")) && (UInt16.Equals((UInt16)hexValues.Count(), (UInt16)4)))
|
|
{
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ReturnData[Constants.PATH0].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH1].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH2].ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode "Display Volume"
|
|
case 1:
|
|
Int32 temp = 0;
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Constants.PATH0].FProt_DisplayVol = temp;
|
|
ReturnData[Constants.PATH1].FProt_DisplayVol = temp;
|
|
ReturnData[Constants.PATH2].FProt_DisplayVol = temp;
|
|
}
|
|
else
|
|
{
|
|
ReturnData[Constants.PATH0].FProt_DisplayVol = 0;
|
|
ReturnData[Constants.PATH1].FProt_DisplayVol = 0;
|
|
ReturnData[Constants.PATH2].FProt_DisplayVol = 0;
|
|
}
|
|
break;
|
|
#endregion
|
|
#region Time
|
|
case 2:
|
|
Int32 itemp = 0;
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out itemp))
|
|
{
|
|
ReturnData[Constants.PATH0].FProt_Time = itemp;
|
|
ReturnData[Constants.PATH1].FProt_Time = itemp;
|
|
ReturnData[Constants.PATH2].FProt_Time = itemp;
|
|
}
|
|
else
|
|
{
|
|
ReturnData[Constants.PATH0].FProt_Time = 0;
|
|
ReturnData[Constants.PATH1].FProt_Time = 0;
|
|
ReturnData[Constants.PATH2].FProt_Time = 0;
|
|
}
|
|
break;
|
|
#endregion
|
|
#region CRC
|
|
case 3:
|
|
ReturnData[Constants.PATH0].CRC = HexValue;
|
|
ReturnData[Constants.PATH1].CRC = HexValue;
|
|
ReturnData[Constants.PATH2].CRC = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#region Decoding finished
|
|
if (UInt16.Equals(DatIndex, 3))
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH0].DataForGraph = true;
|
|
ReturnData[Constants.PATH1].DataForGraph = true;
|
|
ReturnData[Constants.PATH2].DataForGraph = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeTelegram.DecodeProtocolF() failed", $"0x{ex.HResult.ToString("X", culture)}", String.Empty);
|
|
}
|
|
|
|
return ReturnData;
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolG(String[] hexValues, DecodedData[] inputDecodedData)
|
|
{
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
ReturnData[Constants.PATH0] = ((DecodedData)(inputDecodedData[Constants.PATH0].Clone()));
|
|
ReturnData[Constants.PATH1] = ((DecodedData)(inputDecodedData[Constants.PATH1].Clone()));
|
|
ReturnData[Constants.PATH2] = ((DecodedData)(inputDecodedData[Constants.PATH2].Clone()));
|
|
|
|
Int32 temp = 0;
|
|
UInt16 DatIndex = 0;
|
|
UInt16 DecodedPath = Constants.PATH0;
|
|
String DecodedMessageType = String.Empty;
|
|
String ProtocolVersion = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Decode comment ("DATA CHANNEL")
|
|
if (!String.Equals(hexValues[0], "@g"))
|
|
{
|
|
ProtocolVersion = hexValues[0];
|
|
return ReturnData;
|
|
}
|
|
|
|
if ((String.Equals(hexValues[0], "@g")) && (UInt16.Equals(hexValues.Count(), 17)))
|
|
{
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 1:
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out DecodedPath))
|
|
{
|
|
DecodedPath--;
|
|
ReturnData[Constants.PATH0].Path = DecodedPath;
|
|
ReturnData[Constants.PATH1].Path = DecodedPath;
|
|
ReturnData[Constants.PATH2].Path = DecodedPath;
|
|
|
|
}
|
|
ReturnData[DecodedPath].ProtocolVersion = ProtocolVersion;
|
|
break;
|
|
#endregion
|
|
#region Data valid
|
|
case 2:
|
|
ReturnData[DecodedPath].DataValid = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Delta time of flight
|
|
case 3:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].DeltaTimeOfFlight = temp * 3.637978;
|
|
break;
|
|
#endregion
|
|
#region Raw delta volume
|
|
case 4:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].RawDeltaVolume = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Raw accumulated volume
|
|
case 5:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].RawDeltaVolumeAccu = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Raw delta volume scaling
|
|
case 6:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].RawDeltaVolumeScaling = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Sample interval
|
|
case 7:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].SampleInterval = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Amplitude up
|
|
case 8:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[DecodedPath].GProt_AmplitudeUp = (Double)(temp >> 22);
|
|
}
|
|
break;
|
|
#endregion
|
|
#region Amplitude down
|
|
case 9:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].GProt_AmplitudeDown = (Double)(temp >> 22);
|
|
|
|
break;
|
|
#endregion
|
|
#region Pulsewidth ratio up
|
|
case 10:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].GProt_PulsewidthRatioUp = (Double)temp;
|
|
|
|
//ReturnData[DecodedPath].SampleInterval = (Double)Int32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
break;
|
|
#endregion
|
|
#region Pulsewidth ratio down
|
|
case 11:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].GProt_PulsewidthRatioDown = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Temperature
|
|
case 12:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].HProt_RawTemperature = temp;
|
|
break;
|
|
#endregion
|
|
#region Temperatur scale
|
|
case 13:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[DecodedPath].HProt_TemperatureScale = temp;
|
|
|
|
|
|
}
|
|
break;
|
|
#endregion
|
|
#region Time
|
|
case 14:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[DecodedPath].GProt_Time = temp;
|
|
break;
|
|
#endregion
|
|
#region CRC
|
|
case 15:
|
|
ReturnData[Constants.PATH0].CRC = HexValue;
|
|
ReturnData[Constants.PATH1].CRC = HexValue;
|
|
ReturnData[Constants.PATH2].CRC = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#region Decoding finished
|
|
if (DatIndex == 15)
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[DecodedPath].MessageType = Message.Data;
|
|
ReturnData[DecodedPath].Flow = ((ReturnData[DecodedPath].RawDeltaVolume / ReturnData[DecodedPath].RawDeltaVolumeScaling) / (ReturnData[DecodedPath].SampleInterval / 65536)) * Constants.FlowFactor;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeTelegram.DecodeProtocolG() failed", $"0x{ex.HResult.ToString("X", culture)}", String.Empty);
|
|
}
|
|
return ReturnData;
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolH(String[] hexValues, DecodedData[] inputDecodedData)
|
|
{
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
ReturnData[Constants.PATH0] = ((DecodedData)(inputDecodedData[Constants.PATH0].Clone()));
|
|
ReturnData[Constants.PATH1] = ((DecodedData)(inputDecodedData[Constants.PATH1].Clone()));
|
|
ReturnData[Constants.PATH2] = ((DecodedData)(inputDecodedData[Constants.PATH2].Clone()));
|
|
|
|
Int32 temp = 0;
|
|
UInt16 DatIndex = 0;
|
|
UInt16 Path = Constants.PATH0;
|
|
String DecodedMessageType = String.Empty;
|
|
String ProtocolVersion = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
if (!String.Equals(hexValues[0], "@h"))
|
|
{
|
|
ReturnData[Constants.PATH0].ProtocolVersion = hexValues[0];
|
|
ReturnData[Constants.PATH1].ProtocolVersion = hexValues[0];
|
|
ReturnData[Constants.PATH2].ProtocolVersion = hexValues[0];
|
|
return ReturnData;
|
|
}
|
|
|
|
#region Decode comment ("DATA CHANNEL")
|
|
if ((String.Equals(hexValues[0], "@h")) && (UInt16.Equals((UInt16)hexValues.Count(), (UInt16)15)))
|
|
{
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 1:
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out Path))
|
|
{
|
|
Path--;
|
|
ReturnData[Constants.PATH0].Path = Path;
|
|
ReturnData[Constants.PATH1].Path = Path;
|
|
ReturnData[Constants.PATH2].Path = Path;
|
|
|
|
}
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
break;
|
|
#endregion
|
|
#region ERROR
|
|
case 2:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_Error = temp;
|
|
else
|
|
ReturnData[Path].HProt_Error = DataError.Unknown;
|
|
break;
|
|
#endregion
|
|
#region Total time of flight
|
|
case 3:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_TotalTimeOfFlightAvg = temp * ZeroOffsetTestConstants.DeltaTofAverageFactor / 1000000; // value in µs
|
|
break;
|
|
#endregion
|
|
#region Delta time of flight
|
|
case 4:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_DeltaTimeOfFlight = temp * ZeroOffsetTestConstants.DeltaTofAverageFactor;
|
|
break;
|
|
#endregion
|
|
#region Raw delta volume
|
|
case 5:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_RawDeltaVolume = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Raw accumulated volume
|
|
case 6:
|
|
Int32 AccuVolumeRaw = 0;
|
|
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out AccuVolumeRaw))
|
|
ReturnData[Path].HProt_RawDeltaVolumeAccu = (Double)AccuVolumeRaw;
|
|
|
|
break;
|
|
#endregion
|
|
#region Raw delta volume scaling
|
|
case 7:
|
|
Int32 RawDeltaVolumeScaling = 0;
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out RawDeltaVolumeScaling))
|
|
ReturnData[Path].HProt_RawDeltaVolumeScaling = (Double)RawDeltaVolumeScaling;
|
|
|
|
const Double MilliliterToQmFactor = 1.0E-6;
|
|
Double VolumeScaleRawMl = 1024;
|
|
|
|
if (ReturnData[Path].HProt_RawDeltaVolumeScaling != 0)
|
|
VolumeScaleRawMl = ReturnData[Path].HProt_RawDeltaVolumeScaling;
|
|
Double VolumeFactorRawToQm = MilliliterToQmFactor / VolumeScaleRawMl;
|
|
ReturnData[Path].HProt_DeltaVolumeQm = ReturnData[Path].HProt_RawDeltaVolume * VolumeFactorRawToQm;
|
|
ReturnData[Path].HProt_AccuVolumeQm = ReturnData[Path].HProt_RawDeltaVolumeAccu * VolumeFactorRawToQm;
|
|
break;
|
|
#endregion
|
|
#region Sample interval
|
|
case 8:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_SampleInterval = (Double)temp;
|
|
break;
|
|
#endregion
|
|
#region Amplitude up
|
|
case 9:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_AmplitudeUp = (Double)(temp / Math.Pow(2, 22));
|
|
break;
|
|
#endregion
|
|
#region Amplitude down
|
|
case 10:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_AmplitudeDown = (Double)(temp / Math.Pow(2, 22));
|
|
break;
|
|
#endregion
|
|
#region Temperature
|
|
case 11:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].HProt_RawTemperature = temp;
|
|
break;
|
|
#endregion
|
|
#region Temperature scale/ calculate temperature
|
|
case 12:
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].HProt_TemperatureScale = temp;
|
|
ReturnData[Path].HProt_CalculatedTemperature = ((Double)ReturnData[Path].HProt_RawTemperature / Math.Pow(2, ((Double)temp)));
|
|
}
|
|
break;
|
|
#endregion
|
|
#region Time
|
|
case 13:
|
|
UInt32 time = 0;
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out time))
|
|
ReturnData[Path].HProt_Time = (UInt32)time / (UInt32)0x10000;
|
|
break;
|
|
#endregion
|
|
#region CRC
|
|
case 14:
|
|
ReturnData[Constants.PATH0].CRC = HexValue;
|
|
ReturnData[Constants.PATH1].CRC = HexValue;
|
|
ReturnData[Constants.PATH2].CRC = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#region Decoding finished
|
|
if (UInt16.Equals(DatIndex, (UInt16)14))
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Path].MessageType = Message.Data;
|
|
SetIProtocolToZero(ref ReturnData[Constants.PATH0]);
|
|
SetIProtocolToZero(ref ReturnData[Constants.PATH1]);
|
|
SetIProtocolToZero(ref ReturnData[Constants.PATH2]);
|
|
ReturnData[Path].Flow = ((ReturnData[Path].RawDeltaVolume / ReturnData[Path].RawDeltaVolumeScaling) / (ReturnData[Path].SampleInterval / 65536)) * Constants.FlowFactor;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH0].DataForGraph = true;
|
|
ReturnData[Constants.PATH1].DataForGraph = true;
|
|
ReturnData[Constants.PATH2].DataForGraph = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeTelegram.DecodeProtocolH() failed", $"0x{ex.HResult.ToString("X", culture)}", $"Index = {DatIndex.ToString(culture)}");
|
|
}
|
|
|
|
return ReturnData;
|
|
}
|
|
|
|
public static DecodedData[] DecodeProtocolI(String[] hexValues, DecodedData[] inputDecodedData, Double crystalFrequency)
|
|
{
|
|
#region Definitions and initializations
|
|
DecodedData[] ReturnData = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths);
|
|
String Where = "Beginning";
|
|
String ProtocolVersion = String.Empty;
|
|
|
|
ReturnData[Constants.PATH0] = ((DecodedData)(inputDecodedData[Constants.PATH0].Clone()));
|
|
ReturnData[Constants.PATH1] = ((DecodedData)(inputDecodedData[Constants.PATH1].Clone()));
|
|
ReturnData[Constants.PATH2] = ((DecodedData)(inputDecodedData[Constants.PATH2].Clone()));
|
|
|
|
UInt32 temp = 0;
|
|
UInt16 DatIndex = 0;
|
|
String DecodedMessageType = String.Empty;
|
|
#endregion
|
|
|
|
|
|
try
|
|
{
|
|
Where = "Data values";
|
|
|
|
|
|
#region Decode TDC-data ("DATA CHANNEL")
|
|
if (!String.Equals(hexValues[0], "@i"))
|
|
{
|
|
|
|
ReturnData[Constants.PATH0].ProtocolVersion = hexValues[0];
|
|
ReturnData[Constants.PATH1].ProtocolVersion = hexValues[0];
|
|
ReturnData[Constants.PATH2].ProtocolVersion = hexValues[0];
|
|
return ReturnData;
|
|
}
|
|
|
|
if ((String.Equals(hexValues[0], "@i") && (String.Equals(hexValues[1], Message.Data)) && (UInt16.Equals((UInt16)hexValues.Count(), (UInt16)29))))
|
|
{
|
|
|
|
#region Definitions and initializations
|
|
DecodedMessageType = Message.Data;
|
|
UInt16 Path = Constants.PATH0;
|
|
String MessageType = String.Empty;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
#endregion
|
|
#region Decode and display
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode and display telegram
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Decode PATH
|
|
case 2:
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out Path))
|
|
{
|
|
Path--;
|
|
ReturnData[Constants.PATH0].Path = Path;
|
|
ReturnData[Constants.PATH1].Path = Path;
|
|
ReturnData[Constants.PATH2].Path = Path;
|
|
}
|
|
break;
|
|
#endregion
|
|
#region Data valid
|
|
case 3:
|
|
Int32 valid = 0;
|
|
if (Int32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out valid))
|
|
{
|
|
ReturnData[Path].IProt_Valid = valid;
|
|
}
|
|
break;
|
|
#endregion
|
|
#region TOF sum of all up
|
|
case 4:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_SumOfAllUp = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Pulse width up
|
|
case 5:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_PwUp = (Double)Math.Round((((Double)temp / 128)), 2);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude up
|
|
case 6:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_AmpUp = temp;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude calibrate value high
|
|
case 7:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_AmpCalHigh = temp;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF sum of all down
|
|
case 8:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_SumOfAllDown = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8); // From Acam datasheet vol.2, 5-1
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Pulse width down
|
|
case 9:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_PwDown = (Double)Math.Round((((Double)temp / 128)), 2);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude down
|
|
case 10:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_AmpDown = temp;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Amplitude calibrate value low
|
|
case 11:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_AmpCalLow = (Double)UInt32.Parse(HexValue, NumberStyles.AllowHexSpecifier);
|
|
ReturnData[Path].IProt_AmpGradient = Constants.Vcal / (ReturnData[Path].IProt_AmpCalHigh - ReturnData[Path].IProt_AmpCalLow);
|
|
ReturnData[Path].IProt_AmpOffset = ((2 * ReturnData[Path].IProt_AmpCalLow) - ReturnData[Path].IProt_AmpCalHigh) * ReturnData[Path].IProt_AmpGradient;
|
|
ReturnData[Path].IProt_AmpUpCalculated = ReturnData[Path].IProt_AmpGradient * ReturnData[Path].IProt_AmpUp - ReturnData[Path].IProt_AmpOffset;
|
|
ReturnData[Path].IProt_AmpDownCalculated = ReturnData[Path].IProt_AmpGradient * ReturnData[Path].IProt_AmpDown - ReturnData[Path].IProt_AmpOffset;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF0 up
|
|
case 12:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT0] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF1 up
|
|
case 13:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT1] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF2 up
|
|
case 14:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT2] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF3 up
|
|
case 15:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT3] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF4 up
|
|
case 16:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT4] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF5 up
|
|
case 17:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT5] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF6 up
|
|
case 18:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT6] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF7 up
|
|
case 19:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
ReturnData[Path].IProt_TofUp[Constants.HIT7] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF0 down/ DIF-TOF0
|
|
case 20:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT0] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT0] = (ReturnData[Path].IProt_TofDown[Constants.HIT0] - ReturnData[Path].IProt_TofUp[Constants.HIT0]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF1 down/ DIF-TOF1
|
|
case 21:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT1] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT1] = (ReturnData[Path].IProt_TofDown[Constants.HIT1] - ReturnData[Path].IProt_TofUp[Constants.HIT1]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF2 down/ DIF-TOF2
|
|
case 22:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT2] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT2] = (ReturnData[Path].IProt_TofDown[Constants.HIT2] - ReturnData[Path].IProt_TofUp[Constants.HIT2]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF3 down/ DIF-TOF3
|
|
case 23:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT3] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT3] = (ReturnData[Path].IProt_TofDown[Constants.HIT3] - ReturnData[Path].IProt_TofUp[Constants.HIT3]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF4 down/ DIF-TOF4
|
|
case 24:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT4] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT4] = (ReturnData[Path].IProt_TofDown[Constants.HIT4] - ReturnData[Path].IProt_TofUp[Constants.HIT4]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF5 down/ DIF-TOF5
|
|
case 25:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT5] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT5] = (ReturnData[Path].IProt_TofDown[Constants.HIT5] - ReturnData[Path].IProt_TofUp[Constants.HIT5]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF6 down/ DIF-TOF6
|
|
case 26:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT6] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT6] = (ReturnData[Path].IProt_TofDown[Constants.HIT6] - ReturnData[Path].IProt_TofUp[Constants.HIT6]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region TOF7 down/ DIF-TOF7
|
|
case 27:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_TofDown[Constants.HIT7] = (Double)Math.Round((((Double)temp / 65536) * ((crystalFrequency))) * ReturnData[Path].HccCorrectionFactor, 8);
|
|
ReturnData[Path].IProt_DifTof[Constants.HIT7] = (ReturnData[Path].IProt_TofDown[Constants.HIT7] - ReturnData[Path].IProt_TofUp[Constants.HIT7]) * 1000;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region CRC
|
|
case 28:
|
|
#region Calculate value and assign
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].IProt_Crc = HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|
|
if (UInt16.Equals(DatIndex, (UInt16)28)) // last position of telegram
|
|
{
|
|
#region Decoding finished
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH0]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH1]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH2]);
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
ReturnData[Path].MessageType = MessageType;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH0].DataForGraph = true;
|
|
ReturnData[Constants.PATH1].DataForGraph = true;
|
|
ReturnData[Constants.PATH2].DataForGraph = true;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++;
|
|
|
|
}
|
|
#endregion
|
|
return ReturnData;
|
|
}
|
|
|
|
#endregion
|
|
#region Decode Temperature data ("DATA CHANNEL")
|
|
Where = "Temperature";
|
|
if ((String.Equals(hexValues[0], "@i") && (String.Equals(hexValues[1], Message.Temperature)) && (UInt16.Equals((UInt16)hexValues.Count(), (UInt16)15))))
|
|
{
|
|
DecodedMessageType = Message.Temperature;
|
|
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ReturnData[Constants.PATH0].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH1].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH2].ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
ReturnData[Constants.PATH0].MessageType = HexValue;
|
|
ReturnData[Constants.PATH1].MessageType = HexValue;
|
|
ReturnData[Constants.PATH2].MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Data valid
|
|
case 2:
|
|
ReturnData[Constants.PATH0].DataValid = HexValue;
|
|
ReturnData[Constants.PATH1].DataValid = HexValue;
|
|
ReturnData[Constants.PATH2].DataValid = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 3:
|
|
#region Schmitt trigger delay compensation values
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 4:
|
|
#region PT reference impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 5:
|
|
#region PT cold impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 6:
|
|
#region PT hot impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 7:
|
|
#region PT reference 1st correction value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 8:
|
|
#region Schmitt trigger delay compensation value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 9:
|
|
#region PT reference impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 10:
|
|
#region PT cold impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 11:
|
|
#region PT hot impedance value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Not used
|
|
case 12:
|
|
#region PT reference 1st rds(on) correction value
|
|
// [tbd]
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Get temperature value
|
|
case 13:
|
|
#region Temperature value
|
|
Double Temperature;
|
|
|
|
if (Double.TryParse(HexValue, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out Temperature))
|
|
{
|
|
ReturnData[Constants.PATH0].IProt_Temperature = Temperature;
|
|
ReturnData[Constants.PATH1].IProt_Temperature = Temperature;
|
|
ReturnData[Constants.PATH2].IProt_Temperature = Temperature;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 14:
|
|
ReturnData[Constants.PATH0].CRC = HexValue;
|
|
ReturnData[Constants.PATH1].CRC = HexValue;
|
|
ReturnData[Constants.PATH2].CRC = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|
|
#region Decoding finished
|
|
if (UInt16.Equals(DatIndex, (UInt16)14))
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
ReturnData[Constants.PATH0].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH1].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH2].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH0].DataForGraph = false;
|
|
ReturnData[Constants.PATH1].DataForGraph = false;
|
|
ReturnData[Constants.PATH2].DataForGraph = false;
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH0]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH1]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH2]);
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
#region Decode HCC-value ("DATA CHANNEL")
|
|
Where = "HCC-Value";
|
|
if ((String.Equals(hexValues[0], "@i") && (String.Equals(hexValues[1], Message.Hcc)) && (UInt16.Equals((UInt16)hexValues.Count(), (UInt16)5))))
|
|
{
|
|
|
|
DecodedMessageType = Message.Hcc;
|
|
|
|
#region Definitions
|
|
UInt16 Path = Constants.PATH0;
|
|
String MessageType = String.Empty;
|
|
#endregion
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Get PATH
|
|
case 2:
|
|
UInt16 PathTemp = 0;
|
|
if (UInt16.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out PathTemp))
|
|
Path = (UInt16)(PathTemp - 1);
|
|
break;
|
|
#endregion
|
|
#region HCC-value
|
|
case 3:
|
|
#region Calculate value
|
|
/*
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].HccVal = (Double)temp;
|
|
ReturnData[Path].HccCorrectionFactor = (Double)(4 * Constants.NominalFrequency * 1000000) / ((temp >> 16) * 32768);
|
|
}*/
|
|
#endregion
|
|
if (UInt32.TryParse(HexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out temp))
|
|
{
|
|
ReturnData[Path].HccVal = (Double)temp;
|
|
ReturnData[Path].HccCorrectionFactor = (Double)(4 * Constants.NominalFrequency * 1000000) / ((temp >> 16) * 32768);
|
|
}
|
|
break;
|
|
#endregion
|
|
#region CRC
|
|
case 4:
|
|
#region Calculate value
|
|
ReturnData[Path].CRC = HexValue;
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|
|
#region Decoding finished
|
|
if (UInt16.Equals(DatIndex, (UInt16)4))
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Path].ProtocolVersion = ProtocolVersion;
|
|
ReturnData[Path].MessageType = MessageType;
|
|
ReturnData[Constants.PATH0].Path = Path;
|
|
ReturnData[Constants.PATH1].Path = Path;
|
|
ReturnData[Constants.PATH2].Path = Path;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH0]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH1]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH2]);
|
|
ReturnData[Path].DataForGraph = false;
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
#region Decode comment ("DATA CHANNEL")
|
|
Where = "Comment";
|
|
if ((String.Equals(hexValues[0], "@i") && (String.Equals(hexValues[1], Message.Comment))))
|
|
{
|
|
DecodedMessageType = Message.Comment;
|
|
|
|
|
|
#region Reset data
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = false;
|
|
ReturnData[Constants.PATH0].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH1].MessageType = String.Empty;
|
|
ReturnData[Constants.PATH2].MessageType = String.Empty;
|
|
#endregion
|
|
#region Decode
|
|
foreach (String HexValue in hexValues)
|
|
{
|
|
switch (DatIndex)
|
|
{
|
|
#region Decode telegram ("DATA CHANNEL")
|
|
#region Protocol version
|
|
case 0:
|
|
ReturnData[Constants.PATH0].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH1].ProtocolVersion = HexValue;
|
|
ReturnData[Constants.PATH2].ProtocolVersion = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Message type
|
|
case 1:
|
|
ReturnData[Constants.PATH0].MessageType = HexValue;
|
|
ReturnData[Constants.PATH1].MessageType = HexValue;
|
|
ReturnData[Constants.PATH2].MessageType = HexValue;
|
|
break;
|
|
#endregion
|
|
#region Comment0
|
|
case 2:
|
|
#region Comment0
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = HexValue;
|
|
ReturnData[Constants.PATH1].Comment = HexValue;
|
|
ReturnData[Constants.PATH2].Comment = HexValue;
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment1
|
|
case 3:
|
|
#region Comment1
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = $"{ReturnData[Constants.PATH0].Comment}{HexValue}";
|
|
ReturnData[Constants.PATH1].Comment = $"{ReturnData[Constants.PATH1].Comment}{HexValue}";
|
|
ReturnData[Constants.PATH2].Comment = $"{ReturnData[Constants.PATH2].Comment}{HexValue}";
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment2
|
|
case 4:
|
|
#region Comment2
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = $"{ReturnData[Constants.PATH0].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH1].Comment = $"{ReturnData[Constants.PATH1].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH2].Comment = $"{ReturnData[Constants.PATH2].Comment} {HexValue}";
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment3
|
|
case 5:
|
|
#region Comment3
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = $"{ReturnData[Constants.PATH0].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH1].Comment = $"{ReturnData[Constants.PATH1].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH2].Comment = $"{ReturnData[Constants.PATH2].Comment} {HexValue}";
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment4
|
|
case 6:
|
|
#region Comment4
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = $"{ReturnData[Constants.PATH0].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH1].Comment = $"{ReturnData[Constants.PATH1].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH2].Comment = $"{ReturnData[Constants.PATH2].Comment} {HexValue}";
|
|
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment5
|
|
case 7:
|
|
#region Comment5
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = $"{ReturnData[Constants.PATH0].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH1].Comment = $"{ReturnData[Constants.PATH1].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH2].Comment = $"{ReturnData[Constants.PATH2].Comment} {HexValue}";
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Comment6
|
|
case 8:
|
|
#region Comment6
|
|
if (!String.IsNullOrEmpty(HexValue))
|
|
{
|
|
ReturnData[Constants.PATH0].Comment = $"{ReturnData[Constants.PATH0].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH1].Comment = $"{ReturnData[Constants.PATH1].Comment} {HexValue}";
|
|
ReturnData[Constants.PATH2].Comment = $"{ReturnData[Constants.PATH2].Comment} {HexValue}";
|
|
}
|
|
#endregion
|
|
break;
|
|
#endregion
|
|
#region Default
|
|
default: break;
|
|
#endregion
|
|
#endregion
|
|
}
|
|
#region Decoding finished
|
|
if (UInt16.Equals(DatIndex, (UInt16)(hexValues.Count() - 1)))
|
|
{
|
|
#region Reset index
|
|
DatIndex = 0;
|
|
#endregion
|
|
#region Set data
|
|
ReturnData[Constants.PATH0].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH1].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH2].Path = Constants.PATH0;
|
|
ReturnData[Constants.PATH0].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH1].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH2].DecodingSuceeded = true;
|
|
ReturnData[Constants.PATH0].DataForGraph = false;
|
|
ReturnData[Constants.PATH1].DataForGraph = false;
|
|
ReturnData[Constants.PATH2].DataForGraph = false;
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH0]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH1]);
|
|
SetHProtocolToZero(ref ReturnData[Constants.PATH2]);
|
|
#endregion
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
else
|
|
DatIndex++; // switch to next position of data
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
return ReturnData;
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "DecodeTelegram.DecodeProtocolI() failed", $"0x{ex.HResult.ToString("X", culture)}", Where);
|
|
#endregion
|
|
}
|
|
#region Return data
|
|
return ReturnData;
|
|
#endregion
|
|
}
|
|
|
|
public static void SetIProtocolToZero(ref DecodedData input)
|
|
{
|
|
input.IProt_SumOfAllUp = 0;
|
|
input.IProt_PwUp = 0;
|
|
input.IProt_AmpUp = 0;
|
|
input.IProt_AmpCalHigh = 0;
|
|
input.IProt_SumOfAllDown = 0;
|
|
input.IProt_PwDown = 0;
|
|
input.IProt_AmpDown = 0;
|
|
input.IProt_AmpCalLow = 0;
|
|
input.IProt_AmpGradient = 0;
|
|
input.IProt_AmpOffset = 0;
|
|
input.IProt_AmpUpCalculated = 0;
|
|
input.IProt_AmpDownCalculated = 0;
|
|
|
|
|
|
for (UInt16 k = 0; k < 8; k++)
|
|
{
|
|
input.IProt_TofUp[k] = 0;
|
|
input.IProt_TofDown[k] = 0;
|
|
input.IProt_DifTof[k] = 0;
|
|
}
|
|
input.IProt_Temperature = 0;
|
|
}
|
|
|
|
public static void SetHProtocolToZero(ref DecodedData input)
|
|
{
|
|
input.HProt_AmplitudeUp = 0;
|
|
input.HProt_AmplitudeDown = 0;
|
|
input.HProt_CalculatedTemperature = 0;
|
|
input.HProt_DeltaTimeOfFlight = 0;
|
|
input.HProt_TotalTimeOfFlightAvg = 0;
|
|
input.HProt_AccuVolumeQm = 0;
|
|
input.HProt_DeltaVolumeQm = 0;
|
|
input.HProt_Error = DataError.NoError;
|
|
|
|
}
|
|
public static DecodedData[] Reset()
|
|
{
|
|
DecodedData[] data = DecodedDataHelper.getDefaultDecodedDataArray(3);
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
data[Path] = DecodedDataHelper.getDefaultDecodedData();
|
|
return data;
|
|
}
|
|
}
|
|
|
|
}
|
|
|