tbf/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeter.cs

///
/// Copyright (c) 2015-2016 Sensus Metering Systems
/// Author: Milan Hanajík
///
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Threading;
using System.Windows.Forms;
using log4net;
using Config.Entities;
using TBF.BenchControl;
using TBF.BenchControl.Generic;

namespace TBF.BenchControl.WaterMeters.iPerl
{
	/// <summary>
	/// This component = instance of this class is a placeholder for a combined main watermeter
	/// </summary>
    public class WaterMeter : ComponentBase, IDevice, GenericDevices.IWaterMeter, GenericDevices.IRegisterReader, IOperation
	{
		private static readonly ILog log = LogManager.GetLogger(typeof(WaterMeter));
        public override string ToString() { return string.Format("iPerl({0})", Cfg.ToString(1)); }


		readonly WaterMeterCfg iPerlCfg;

        public int MuxBoardNr { get { return iPerlCfg.MuxBoardNr; } }
        public int Group { get { return iPerlCfg.Group; } }

		public float PulsesPerLtr { get { return iPerlCfg.ProcParams.PulsesPerLtr; } }

		/// <summary>WaterMeter producer</summary>
		public string Producer { get { return iPerlCfg.ProcParams.Producer; } }

		/// <summary>Nominal water flow in [m3/h]</summary>
		public float Qn { get { return iPerlCfg.ProcParams.Qn; } }

		/// <summary>WaterMeter approval information or signature</summary>
		public string ApprovalInfo { get { return iPerlCfg.ProcParams.ApprovalInfo; } }

		/// <summary>Metrological class</summary>
		public string MetrologicalClass { get { return iPerlCfg.ProcParams.MetrologicalClass; } }

        /// <summary>WM Type ID for Oracle DB</summary>
        public int WMType_ID { get { return iPerlCfg.ProcParams.WMType_ID; } }

        /// <summary>WM Type Revision for Oracle DB</summary>
        public int WMType_Rev { get { return iPerlCfg.ProcParams.WMType_Rev; } }

		/// Properties set by the Begin and the End form
		public string SerialNr
		{
			get
            {
                if (ConfigStruct != null) return configStruct.PCBNumber2String();
                else return string.Empty;
            }
			set { }
		}

		public string EndState
		{
			get { return endState; }
			set { endState = value; }
		}
		string endState;

		public string BeginState
		{
			get { return beginState; }
			set { beginState = value; }
		}
		string beginState;

		public bool Disabled
		{
			get { return disabled; }
			set { disabled = value; }
		}
		bool disabled;

		public bool CommFailed
		{
			get { return commFailed; }
			set { commFailed = value; }
		}
		bool commFailed;

        public bool PositiveCounting;

        /// <summary> ConfigStruct of the water meter obtained or updated by iPerlCommunication </summary>
        public ConfigStruct ConfigStruct
        {
            get { return configStruct; }
            set { configStruct = value; }
        }
        ConfigStruct configStruct;

        /// <summary> CalibrationStruct of the water meter obtained or updated by iPerlCommunication </summary>
        public CalibrationStruct CalibrationStruct
        {
            get { return calibrationStruct; }
            set { calibrationStruct = value; }
        }
        CalibrationStruct calibrationStruct;

        public ushort OriginalCalibFactor;
		public ushort CalibrationFactor { get { return (CalibrationStruct != null) ? CalibrationStruct.Calibration : (ushort)0; } }

        public double Q2ErrorWOCorrection;
        public bool Q2CorrectionDone;
		public double CurrentQ2Correction; 


		/// <summary> Result of the last test used to calculate Q2 correction factors, etc </summary>
		public Results.Entities.MeterTestRslt LastTestResult;
		public double NominalTestFlow;			/// liter per hour


		/// <summary>
		/// New calibration factor calculated from the original factor (argument)
		/// and results of the last test.
		/// </summary>
		/// <param name="originalCalibrationFactor">Original calibration factor</param>
		/// <returns>New calibration factor</returns>
        public UInt16 CalculateNewCalibFactor(UInt16 originalCalibrationFactor, UInt16 FactorLimitLo, UInt16 FactorLimitHi)
        {
            OriginalCalibFactor = originalCalibrationFactor;

            double volumeMeter = Math.Abs(VolumeLtrEnd - VolumeLtrStart);

            if (volumeMeter > 1E-2)
            {
                PositiveCounting = VolumeLtrEnd > VolumeLtrStart;

                UInt16 newFactor = (UInt16)((double)originalCalibrationFactor * VolumeLtrRef / volumeMeter + 0.5);
                log.InfoFormat("Calibration factor: orig={0} new={1} V_1={2} V_2={3} Vdiff={4} Vref={5}",
                               originalCalibrationFactor, newFactor,
                               VolumeLtrStart.ToString("F3"), VolumeLtrEnd.ToString("F3"), volumeMeter.ToString("F3"),
                               VolumeLtrRef.ToString("F3"));

				if (newFactor < FactorLimitLo) newFactor = FactorLimitLo;
				if (newFactor > FactorLimitHi) newFactor = FactorLimitHi;

				return newFactor;
            }
            else
            {
				log.ErrorFormat("Calibration factor: orig={0} new={0} (unchanged!) Vdiff={1}",
                               originalCalibrationFactor, volumeMeter.ToString("F3"));
                return originalCalibrationFactor;   /// Too small volume in the denominator -> no correction at all
            }
        }


		/// <summary>
		/// Q2 correction factor calculated from the last test (Q2).
		/// This factors should be used only for R800 meters.
		/// </summary>
		/// <returns>Q2 correction factor</returns>
		public double Q2CorrectionFactor()
		{
            Q2ErrorWOCorrection = LastTestResult.Error;

            if (Math.Abs(LastTestResult.Error) <= 0.5)
            {
                Q2CorrectionDone = false;
                return 0;      /// No Q2 correction if error < +/-0.5 %
            }

			double A = 16.0 / ScalingFactor();		 /// Raw units per ml: DN15=16, DN20=8, DN25=4, DN32=2, DN40=1
			const double B = 8.0;					 /// Raw units per minute, 8
			const double C = B * 60.0;				 /// Raw units per hour, 480
			double D = C / A;						 /// ml correction per hour
			double F = D / (NominalTestFlow * 10.0); /// Error corrected with 8 Raw Units per minute [%]
			double G = F / B;						 /// Error corrected with 1 Raw Unit per minute [%]

			double errLimitLo = LastTestResult.ErrLimLo() + LastTestResult.Uncertainty();
			double errLimitHi = LastTestResult.ErrLimHi() - LastTestResult.Uncertainty();

			if (LastTestResult.Error < errLimitLo) return 0;	/// No Q2 correction if error too large -> WM failed
			if (LastTestResult.Error > errLimitHi) return 0;	/// No Q2 correction if error too large -> WM failed

			double volumeMeterErrLimLo = LastTestResult.VolumeRef * (100.0 + errLimitLo) / 100.0;
			double volumeMeterErrLimHi = LastTestResult.VolumeRef * (100.0 + errLimitHi) / 100.0;

			double corrFactorHi = (-1) * (errLimitLo / G) * (LastTestResult.VolumeRef / volumeMeterErrLimLo);		/// > 0
			double corrFactorLo = (-1) * (errLimitHi / G) * (LastTestResult.VolumeRef / volumeMeterErrLimHi);		/// < 0

			double corrFactor = (-1) * (LastTestResult.Error / G) * (LastTestResult.VolumeRef / LastTestResult.VolumeMeter);
			double origCalulatedCorrFactor = corrFactor;

			log.WarnFormat("Q2 correction: {0}, corrFactor={4}, error={3}% [Lo={1}%, Hi={2}%]",
							Name,
							errLimitLo.ToString("F1"),
							errLimitHi.ToString("F1"),
							LastTestResult.Error.ToString("F2"),
							corrFactor.ToString("F1"));

            Q2CorrectionDone = true;
			return corrFactor;
		}

        /// <summary> Name set by the test, to be used as a part of the opto-data log file name </summary>
        public string TestName;

        /// <summary> Name set by the test, to be used as a part of the opto-data log file name </summary>
        public string BenchName;

        ///
        /// Volume of water from the opto telegram
        ///
        bool lastVolumeRawValid;            /// true = valid
        private Int32 lastVolumeRaw;        /// Last read raw volume
        private double volumeLtr;           /// 
        private double volumeLtr0;

        public double VolumeLtrStart;       /// Test start volume for metrology
        public double VolumeLtrEnd;         /// Test end volume for metrology
        public double VolumeLtrRef;         /// Reference volume or metrology
        double volumeLtrEnd1;               /// auxiliary buffer1 to keep the end volume before test stops
		double volumeLtrEnd2;               /// auxiliary buffer2 to keep the end volume before test stops
		double volumeLtrEnd3;               /// auxiliary buffer3 to keep the end volume before test stops

		///
        /// Timestamp from the opto telegram
        ///
        bool lastTimestampValid;
        private Int64 lastTimestamp;
        private double timestampSec;
        private double timestampSec0;

        public bool NoSamples { get { return (timestampSecEnd - timestampSecStart) < float.Epsilon; } }
        public double TimestampSecStart { get { return timestampSecStart; } }
        public double TimestampSecEnd { get { return timestampSecEnd; } }
        double timestampSecStart;           
        double timestampSecEnd;
        double timestampSecEnd1;
        double timestampSecEnd2;
		double timestampSecEnd3;

        private int telegramIx;
        public int TestStartTelegramIx;
        public int TestEndTelegramIx;

        private Boxes.IntBox pulses;
        private Boxes.IntBox refPulses;
        private Boxes.DoubleBox timeSec;


		OptoTelegramRaw[] optoData;
		const int MaxOptoDataCount = 40000;
		int optoDataCount;
		string optoDataLogFileName;


		OptoTelegramRaw toBeFlushed;
		int flushedDataCount;
		public int FlushedDataCount
		{
			get { return flushedDataCount; }
			set { flushedDataCount = value; }
		}


        ///
        /// Opto serial port and worker thread related private variables
        ///
        private SerialPort optoSerialPort;


		public WaterMeter()
		{
			ClearData();
		}

		public WaterMeter(WaterMeterCfg cfg)
			: base(cfg)
		{
			ClearData();

			iPerlCfg = cfg;
			log.Debug(this.ToString());
		}

		/// <summary>
		/// Clear data related to a specific water meter
		/// </summary>
		public void ClearData()
		{
			disabled = false;
			commFailed = false;
			endState = string.Empty;
			beginState = string.Empty;

			configStruct = null;
			calibrationStruct = null;

			LastTestResult = null;
			NominalTestFlow = 0;

	        OriginalCalibFactor = 0;
			Q2ErrorWOCorrection = 0;
			Q2CorrectionDone = false;
			CurrentQ2Correction = 0;
			
			optoDataCount = 0;
		}

        public void Initialize()
        {
			ClearData();

			if (DebugLevel == DebugMode.Normal)
            {
				optoSerialPortParsingEnabled = false;

                /// Allocate memory for opto-data from iPerl
				optoData = new OptoTelegramRaw[MaxOptoDataCount];
                for (int i = 0; i < MaxOptoDataCount; i++) optoData[i] = new OptoTelegramRaw();

				toBeFlushed = new OptoTelegramRaw();
				flushedDataCount = 0;

				synchronized = false;
				synchronized2 = false;
				partOfTelegram = string.Empty;

                /// Prepare serial port
                optoSerialPort = new SerialPort(string.Format("COM{0}", iPerlCfg.OptoComPortNr),
                                    9600, Parity.None, 8, StopBits.One);
                optoSerialPort.Handshake = Handshake.None;

				optoSerialPort.Open();
            }
        }

        public void RunDeviceBefore()
        {
			if (DebugLevel == DebugMode.Normal)
			{
				try
				{
					if (optoSerialPortParsingEnabled)
						ReadOptoSerialPort(OptoState.Read);
					else
						ReadOptoSerialPort(OptoState.Flush);
				}
				catch (Exception e)
				{
					DebugLevel = DebugMode.FailureDuringOperation;

					log.FatalFormat("Opto-data serial port failure : {0}", e.Message);
					if (e.InnerException != null)
					{
						log.FatalFormat("InnerMessage : {0}", e.InnerException.Message);
					}
				}
			}
			else if (DebugLevel == DebugMode.FailureDuringOperation)
			{
			}
		}

        public void RunDeviceAfter()
		{
		}

        public void StopDevice()
        {
			if (DebugLevel == DebugMode.Normal && optoSerialPort != null)
            {
				optoSerialPort.Close();
            }
		}

		/// <summary>
		/// Events:  Event.ReadRegisterDone, Event.Error
		/// </summary>
		/// <param name="pulses">Reference to a variable for the water meter pulses</param>
		/// <returns>ReadWaterMeter instance reference casted to IOperaton</returns>
		public IOperation ReadRegisterOp(ref Boxes.IntBox pulses)
		{
			this.pulses = pulses;
			return this;
		}

		/// <summary>
		/// Events:  Event.ReadRegisterDone, Event.Error
		/// </summary>
		/// <param name="pulses">Reference to a variable for the water meter pulses</param>
        /// <param name="refPulses">Reference to a variable for the related reference flowmeter pulses</param>
		/// <returns>Reference to operation object instance</returns>
		public IOperation ReadRegisterOp(ref Boxes.IntBox pulses, ref Boxes.IntBox refPulses)
		{
			this.pulses = pulses;
			this.refPulses = refPulses;
			return this;
		}

        /// <summary>
        /// Events:  Event.ReadRegisterDone, Event.Error
        /// </summary>
        /// <param name="pulses">Reference to a variable for the water meter pulses</param>
        /// <param name="timeSec">Reference to a variable for the related time in seconds</param>
        /// <returns>Reference to operation object instance</returns>
        public IOperation ReadRegisterOp(ref Boxes.IntBox pulses, ref Boxes.DoubleBox timeSec)
        {
            this.pulses = pulses;
            this.timeSec = timeSec;
            return this;
        }

        /// <summary>
        /// Events:  ReadReferenceDone, Error
        /// </summary>
        /// <param name="pulses">Reference to a variable for the water meter pulses</param>
        /// <param name="timeSec">Reference to a variable for the related time in seconds</param>
        /// <param name="refPulses">Reference to a variable for the water meter pulses</param>
        /// <returns>Reference to operation object instance</returns>
        public IOperation ReadRegisterOp(ref Boxes.IntBox pulses, ref Boxes.DoubleBox timeSec, ref Boxes.IntBox refPulses)
        {
            this.pulses = pulses;
            this.timeSec = timeSec;
            this.refPulses = refPulses;
            return this;
        }

		/// <summary>
		/// Events:  ReadReferenceDone, Error
		/// </summary>
		/// <param name="pulses">Reference to a variable for the water meter pulses</param>
        /// <param name="refPulses">Reference to a variable for the water meter pulses</param>
        /// <returns>Reference to operation object instance</returns>
		public IOperation ReadReferenceForRegisterOp(ref Boxes.IntBox pulses, ref Boxes.IntBox refPulses)
		{
			this.pulses = pulses;
			this.refPulses = refPulses;
			return this;
		}


		int sampleNr;		/// This is to determine when the test start sample should be taken

		/// <summary>Start this operation</summary>
		public void Start()
		{
			/// Reset opto data
			optoDataCount = 0;
            TestStartTelegramIx = 0;
            TestEndTelegramIx = 0;

			/// File name is: PCB_AA_BB_HH_MI_SS..txt
			string wmPosition = Name.Substring(5);
			if (wmPosition.Length == 1) wmPosition = "0" + wmPosition;

			string flowNr;
			if (TestName != null && TestName.ToLower().Contains("q1")) flowNr = "01";
            else if (TestName != null && TestName.ToLower().Contains("q2")) flowNr = "02";
            else if (TestName != null && TestName.ToLower().Contains("q3")) flowNr = "03";
            else if (TestName != null && TestName.ToLower().Contains("adj")) flowNr = "00";
			else flowNr = "99";

			optoDataLogFileName = string.Format("{0}_{1}_{2}_{3}.txt",
												(ConfigStruct != null) ? ConfigStruct.PCBNumber2String() : "UnknownPcbNr",
												wmPosition,
												flowNr,
												StateMachine.CycleStartHH_MI_SS);

			sampleNr = 0;

            volumeLtr = 0;
            volumeLtr0 = 0;
            timestampSec = 0;
            timestampSec0 = 0;

			ReadPulses();
			StartParsingOptoSerialPort();
        }

		/// <summary>Run this operation</summary>
		/// <returns>eventDone</returns>
		public Event Run()
		{
            sampleNr++;
			ReadPulses();
            if (sampleNr == 4)
            {
				/// Take the test start sample
                VolumeLtrStart = volumeLtr;
                timestampSecStart = timestampSec;
                TestStartTelegramIx = telegramIx;
            }

            /// Shift data in pipelines
            VolumeLtrEnd = volumeLtrEnd3;
			volumeLtrEnd3 = volumeLtrEnd2;
			volumeLtrEnd2 = volumeLtrEnd1;
            volumeLtrEnd1 = volumeLtr;

            timestampSecEnd = timestampSecEnd3;
			timestampSecEnd3 = timestampSecEnd2;
			timestampSecEnd2 = timestampSecEnd1;
			timestampSecEnd1 = timestampSec;

            TestEndTelegramIx = telegramIx - 3;

			return Event.ReadRegisterDone;
		}

		/// <summary>Stop this operation</summary>
		public void Stop()
		{
            if (TestStartTelegramIx > 0 && TestStartTelegramIx < optoData.Length && optoData[TestStartTelegramIx].Flags == OptoTelegramFlags.OK)
            {
                optoData[TestStartTelegramIx].Flags = OptoTelegramFlags.OK_TestStart;
                OptoTelegramRaw.TestStartTimestampDec = optoData[TestStartTelegramIx].TimestampDec();
            }

            if (TestEndTelegramIx > 0 && TestEndTelegramIx < optoData.Length && optoData[TestEndTelegramIx].Flags == OptoTelegramFlags.OK)
            {
                optoData[TestEndTelegramIx].Flags = OptoTelegramFlags.OK_TestEnd;
            }

            StopParsingOptoSerialPort();
			OptoTelegramRaw.FIRFilterFlow(optoData, optoDataCount);
			SaveOptoData();
        }


		void SaveOptoData()
		{
			string directory = "C:\\TBF\\ProcessData\\";	/// TODO: determine correct relative path
            try
            {
			Directory.CreateDirectory(directory);
			directory += (StateMachine.CycleStartYY + "\\");
			Directory.CreateDirectory(directory);
			directory += (StateMachine.CycleStartMM + "\\");
			Directory.CreateDirectory(directory);
			directory += (StateMachine.CycleStartDD + "\\");
			Directory.CreateDirectory(directory);

			double scalFact = ScalingFactor();

			using (TextWriter optoLogFile = new StreamWriter(directory + optoDataLogFileName))
			{
				optoLogFile.WriteLine(optoData[0].ToString(scalFact, null));
				for (int i = 1; i < optoDataCount; i++) optoLogFile.WriteLine(optoData[i].ToString(scalFact, optoData[i - 1]));
				optoLogFile.Close();
			}
            }
            catch (Exception exc)
            {
                MessageBox.Show(string.Format("Chyba pri zapisovani do suboru:\r\n{0}\\{1}\r\n{2}", directory, optoDataLogFileName, exc.Message),
                    "Chyba", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
		}

		void ReadPulses()
		{
            pulses.Val = (int)((volumeLtr - volumeLtr0) * (double)PulsesPerLtr + 0.5);
            if (timeSec != null) timeSec.Val = timestampSec - timestampSec0;
            if (refPulses != null) refPulses.Val = StateMachine.ControlBoard.EtPulses(0);
		}


        bool optoSerialPortParsingEnabled;

        /// <summary> Flush internal buffers and start parsing the opto serial port data </summary>
        void StartParsingOptoSerialPort()
        {
            optoSerialPortParsingEnabled = true;
        }

        /// <summary> Stop parsig the opto serial port data </summary>
        void StopParsingOptoSerialPort()
        {
            optoSerialPortParsingEnabled = false;
        }

		///
		/// Variables storing the context of serial port data parsing (ReadOptoSerialPort(...))
		///
		bool synchronized;
		bool synchronized2;
		string partOfTelegram;

		/// <summary>
		/// 9600 Bd, 8 data bits, 1 stop bit, no parity
		///
		/// Telegram description:
		/// 
		/// AAAAAA[tab]BBBB[tab]CCCC[tab]DDDDDD[tab]EEEE[tab]FFFFFFFF[tab]GG[cr][lf]  (42 bytes)
		/// 
		/// Example:
		/// FFFFFE	51EA	0000	65324E	0087	F6319DFF	86
		/// FFDD3A	51F9	0000	65324E	0088	F631A60B	45
		/// ...
		/// </summary>
		/// <param name="optoState">OptoState.Read or OptoState.Flush</param>
		void ReadOptoSerialPort(OptoState optoState)
		{
			int nrBytes = optoSerialPort.BytesToRead;
			if (nrBytes > 0)
			{
				char[] buffer = new char[nrBytes];
				optoSerialPort.Read(buffer, 0, nrBytes);
				string received = new string(buffer);

				string allRcvd = partOfTelegram + received;

				while (true)
				{
					int pos = allRcvd.IndexOf("\r\n");

					if (pos < 0)
					{
						/// No CR+LF found, wait for more characters in the next invocation
						partOfTelegram = allRcvd;
						return;
					}
					else
					{
						// CR+LF found
						if (optoState == OptoState.Read)
						{
							if (pos < OptoTelegramRaw.Length - 2)
							{
								/// CR+LF found too early, truncate the beginning incl CR+LF and keep scanning in this loop
								allRcvd = allRcvd.Substring(pos + 2);
								if (synchronized)
								{
									optoData[optoDataCount].Counter = optoDataCount;
									optoData[optoDataCount++].SetFlags(OptoTelegramFlags.SyncError);
								}
								synchronized = true;
							}
							// CR+LF found and (pos >= OptoTelegramRaw.Length - 2)
							else if (optoData[optoDataCount].UpdateFromString(allRcvd.Substring(pos - OptoTelegramRaw.Length + 2), optoDataCount))
							{
								OptoTelegramRreceived(optoDataCount++, synchronized2);
                                synchronized2 = synchronized;
								allRcvd = allRcvd.Substring(pos + 2);
							}
							else
							{
								optoData[optoDataCount].Counter = optoDataCount;
								optoData[optoDataCount++].SetFlags(OptoTelegramFlags.InvalidTelegram);
								allRcvd = allRcvd.Substring(pos + 2);
							}
						}
						else /// optoState == OptoState.Flush
						{
							if (pos < OptoTelegramRaw.Length - 2)
							{
								/// CR+LF found too early, truncate the beginning incl CR+LF and keep scanning in this loop
								allRcvd = allRcvd.Substring(pos + 2);
								synchronized = true;
							}
							// CR+LF found and (pos >= OptoTelegram.Length - 2)
							else if (toBeFlushed.UpdateFromString(allRcvd.Substring(pos - OptoTelegramRaw.Length + 2), 0))
							{
								flushedDataCount++;
								synchronized2 = synchronized;
								allRcvd = allRcvd.Substring(pos + 2);
							}
							else
							{
								allRcvd = allRcvd.Substring(pos + 2);
							}
						}
					}
				}

				//OnOptoReceived(this, new OptoReceivedEventArgs(s));
			}
			else
			{
				//OnOptoReceived(this, new OptoReceivedEventArgs("."));
			}
		}


        void OptoTelegramRreceived(int currentIx, bool async)
		{
            OptoTelegramRaw optoTelegram = optoData[currentIx];
            telegramIx = currentIx;

            Int32 uncorrectedRawVolume = 0;
            if (!lastVolumeRawValid)
            {
                lastVolumeRaw = optoTelegram.VolumeRaw;
                lastVolumeRawValid = true;
            }
            else
            {
                uncorrectedRawVolume = (Int32)((lastVolumeRaw & 0x7F000000) | (optoTelegram.VolumeRaw & 0x00FFFFFF));
                if (Math.Abs(uncorrectedRawVolume - lastVolumeRaw) <= 0x007FFFFF)
                {
                    lastVolumeRaw = uncorrectedRawVolume;
                }
                else if (Math.Abs(uncorrectedRawVolume + 0x01000000 - lastVolumeRaw) <= 0x007FFFFF)
                {
                    lastVolumeRaw = uncorrectedRawVolume + 0x01000000;
                }
                else if (Math.Abs(uncorrectedRawVolume - 0x01000000 - lastVolumeRaw) <= 0x007FFFFF)
                {
                    lastVolumeRaw = uncorrectedRawVolume - 0x01000000;
                }
				else
				{
					lastVolumeRaw = uncorrectedRawVolume;		/// This should never happen
				}
			}


            Int64 uncorrectedTimestamp = 0;
            if (!lastTimestampValid)
            {
                lastTimestamp = optoTelegram.Timestamp;
                lastTimestampValid = true;
            }
            else
            {
                uncorrectedTimestamp = (Int64)((lastTimestamp & 0x7FFFFFFF00000000) | (optoTelegram.Timestamp & 0xFFFFFFFF));
                if (Math.Abs(uncorrectedTimestamp - lastTimestamp) <= 0x7FFFFFFF)
                {
                    lastTimestamp = uncorrectedTimestamp;
                }
                else if (Math.Abs(uncorrectedTimestamp + 0x100000000 - lastTimestamp) <= 0x7FFFFFFF)
                {
                    lastTimestamp = uncorrectedTimestamp + 0x100000000;
                }
                else if (Math.Abs(uncorrectedTimestamp - 0x100000000 - lastTimestamp) <= 0x7FFFFFFF)
                {
                    lastTimestamp = uncorrectedTimestamp - 0x100000000;
                }
                else
                {
					lastTimestamp = uncorrectedTimestamp;		/// This should never happen
                }
            }

            if (volumeLtr == 0 && volumeLtr0 == 0)
            {
                volumeLtr = (double)lastVolumeRaw * ScalingFactor() / 16000.0;
                volumeLtr0 = volumeLtr;
            }
            else
            {
                volumeLtr = (double)lastVolumeRaw * ScalingFactor() / 16000.0;
            }

            if (timestampSec == 0 && timestampSec0 == 0)
            {
                timestampSec = (double)lastTimestamp / 8192.0;
                timestampSec0 = timestampSec;
            }
            else
            {
                timestampSec = (double)lastTimestamp / 8192.0;
            }

            //optoDataLogger.InfoFormat("{0} {1} {2} ltr {3} {4}", optoTelegram, lastTimestamp, lastVolumeRaw.ToString("X8"), timestampSec.ToString("F1"), volumeLtr.ToString("F3"));
        }


        /// <summary>
        /// Called from the state machine when a test is selected and UI needs to be updated.
        /// </summary>
        public void OnOptoReceived(object sender, OptoReceivedEventArgs args)
        {
            if (OptoReceivedHandler == null) return;
            try { OptoReceivedHandler(sender, args); }
            catch (Exception) { }
        }

        public event EventHandler<OptoReceivedEventArgs> OptoReceivedHandler;

        public static double UnitVolume(VolumeUnits units)
        {
            switch (units)
            {
                default:
                case VolumeUnits.m3: return 1000.0;          /// liter
                case VolumeUnits.UK_gallon: return 4.546092; /// liter
                case VolumeUnits.US_gallon: return 3.785412; // liter
            }
        }

        public double ScalingFactor()
        {
            if ((iPerlCfg.MeterType == MeterType.AutoDetect) && (CalibrationStruct != null))
            {
                return WaterMeter.ScalingFactor(CalibrationStruct.MeterType);
            }
            else if (iPerlCfg.MeterType != MeterType.AutoDetect)
            {
                return WaterMeter.ScalingFactor(iPerlCfg.MeterType);
            }
            else
            {
                return WaterMeter.ScalingFactor(MeterType.DN20);
            }
        }

        /// <summary>
        /// Scaling factor:
        ///   0, 1 (DN15, Coax) . . . .  1
        ///   2  (DN20) . . . . . . . .  2
        ///   3  (DN25) . . . . . . . .  4
        ///   4, 5 (DN26, DN32) . . . .  8
        ///   6  (DN40) . . . . . . . . 16
        /// </summary>
        /// <param name="meterType">MeterType (0..6)</param>
        /// <returns>Scaling factor</returns>
        public static double ScalingFactor(MeterType meterType)
        {
            switch (meterType)
            {
                default:
                case MeterType.DN15:
                case MeterType.CoaxManifold: return 1.0;
                case MeterType.DN20: return 2.0;
                case MeterType.DN25: return 4.0;
                case MeterType.DN26:
                case MeterType.DN32: return 8.0;
                case MeterType.DN40: return 16.0;
            }
        }

		int PositionNrFormWMName(string name)
		{
			int len = name.Length;
			if (len < 2) return 0;

			int loNr = (int)name[len - 1] - (int)'0';
			int hiNr = (int)name[len - 2] - (int)'0';
			if (hiNr < 1 || hiNr > 4) hiNr = 0;

			return 10 * hiNr + loNr;
		}
	}
}