using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Globalization; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Windows.Forms; using System.Drawing.Printing; using System.IO; using System.IO.Ports; namespace GenesisZeroFlow { #region Static classes public partial class GenesisZeroFlow { private Boolean[] DetectionSequence(Boolean[] enable) { #region Definitions and initializations Boolean[] Ok = new Boolean[Constants.NumberOfMeters * 2]; String DebugMessage = String.Empty; Boolean SerialPortClosed = false; for (UInt16 i = 0; i < (Constants.NumberOfMeters * 2); i++) Ok[i] = false; #endregion #region Get serial ports SerialConfigCmdMeter1.Init(Constants.CmdMeter1); SerialConfigCmdMeter2.Init(Constants.CmdMeter2); SerialConfigCmdMeter3.Init(Constants.CmdMeter3); SerialConfigCmdMeter4.Init(Constants.CmdMeter4); SerialConfigCmdMeter5.Init(Constants.CmdMeter5); SerialConfigCmdMeter6.Init(Constants.CmdMeter6); SerialConfigCmdMeter7.Init(Constants.CmdMeter7); SerialConfigCmdMeter8.Init(Constants.CmdMeter8); SerialConfigCmdMeter9.Init(Constants.CmdMeter9); SerialConfigCmdMeter10.Init(Constants.CmdMeter10); SerialConfigDataMeter1.Init(Constants.DataMeter1); SerialConfigDataMeter2.Init(Constants.DataMeter2); SerialConfigDataMeter3.Init(Constants.DataMeter3); SerialConfigDataMeter4.Init(Constants.DataMeter4); SerialConfigDataMeter5.Init(Constants.DataMeter5); SerialConfigDataMeter6.Init(Constants.DataMeter6); SerialConfigDataMeter7.Init(Constants.DataMeter7); SerialConfigDataMeter8.Init(Constants.DataMeter8); SerialConfigDataMeter9.Init(Constants.DataMeter9); SerialConfigDataMeter10.Init(Constants.DataMeter10); #endregion #region Close ports SerialPortClosed = SerialConfigCmdMeter1.ClosePort(serialPortCmdMeter1, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter2.ClosePort(serialPortCmdMeter2, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter3.ClosePort(serialPortCmdMeter3, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter4.ClosePort(serialPortCmdMeter4, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter5.ClosePort(serialPortCmdMeter5, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter6.ClosePort(serialPortCmdMeter6, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter7.ClosePort(serialPortCmdMeter7, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter8.ClosePort(serialPortCmdMeter8, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter9.ClosePort(serialPortCmdMeter9, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter10.ClosePort(serialPortCmdMeter10, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter1.ClosePort(serialPortDataMeter1, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter2.ClosePort(serialPortDataMeter2, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter3.ClosePort(serialPortDataMeter3, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter4.ClosePort(serialPortDataMeter4, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter5.ClosePort(serialPortDataMeter5, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter6.ClosePort(serialPortDataMeter6, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter7.ClosePort(serialPortDataMeter7, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter8.ClosePort(serialPortDataMeter8, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter9.ClosePort(serialPortDataMeter9, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter10.ClosePort(serialPortDataMeter10, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); #endregion #region Get settings from file serialPortCmdMeter1 = SerialConfigCmdMeter1.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter2 = SerialConfigCmdMeter2.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter3 = SerialConfigCmdMeter3.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter4 = SerialConfigCmdMeter4.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter5 = SerialConfigCmdMeter5.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter6 = SerialConfigCmdMeter6.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter7 = SerialConfigCmdMeter7.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter8 = SerialConfigCmdMeter8.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter9 = SerialConfigCmdMeter9.GetParamsFromFile(SerialSettings.Path); serialPortCmdMeter10 = SerialConfigCmdMeter10.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter1 = SerialConfigDataMeter1.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter2 = SerialConfigDataMeter2.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter3 = SerialConfigDataMeter3.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter4 = SerialConfigDataMeter4.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter5 = SerialConfigDataMeter5.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter6 = SerialConfigDataMeter6.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter7 = SerialConfigDataMeter7.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter8 = SerialConfigDataMeter8.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter9 = SerialConfigDataMeter9.GetParamsFromFile(SerialSettings.Path); serialPortDataMeter10 = SerialConfigDataMeter10.GetParamsFromFile(SerialSettings.Path); #endregion #region Open serial port String[] ListOfComports = SerialConfigGetReadSettings.PortNames(); Ok[Constants.CmdMeter1] = SerialConfigCmdMeter1.OpenPort(serialPortCmdMeter1, out DebugMessage, enable[Constants.Meter1], ListOfComports); if (enable[Constants.Meter1]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter2] = SerialConfigCmdMeter2.OpenPort(serialPortCmdMeter2, out DebugMessage, enable[Constants.Meter2], ListOfComports); if (enable[Constants.Meter2]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter3] = SerialConfigCmdMeter3.OpenPort(serialPortCmdMeter3, out DebugMessage, enable[Constants.Meter3], ListOfComports); if (enable[Constants.Meter3]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter4] = SerialConfigCmdMeter4.OpenPort(serialPortCmdMeter4, out DebugMessage, enable[Constants.Meter4], ListOfComports); if (enable[Constants.Meter4]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter5] = SerialConfigCmdMeter5.OpenPort(serialPortCmdMeter5, out DebugMessage, enable[Constants.Meter5], ListOfComports); if (enable[Constants.Meter5]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter6] = SerialConfigCmdMeter6.OpenPort(serialPortCmdMeter6, out DebugMessage, enable[Constants.Meter6], ListOfComports); if (enable[Constants.Meter6]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter7] = SerialConfigCmdMeter7.OpenPort(serialPortCmdMeter7, out DebugMessage, enable[Constants.Meter7], ListOfComports); if (enable[Constants.Meter7]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter8] = SerialConfigCmdMeter8.OpenPort(serialPortCmdMeter8, out DebugMessage, enable[Constants.Meter8], ListOfComports); if (enable[Constants.Meter8]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter9] = SerialConfigCmdMeter9.OpenPort(serialPortCmdMeter9, out DebugMessage, enable[Constants.Meter9], ListOfComports); if (enable[Constants.Meter9]) Display.DebugMessage(DebugMessage); Ok[Constants.CmdMeter10] = SerialConfigCmdMeter10.OpenPort(serialPortCmdMeter10, out DebugMessage, enable[Constants.Meter10], ListOfComports); if (enable[Constants.Meter10]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter1] = SerialConfigDataMeter1.OpenPort(serialPortDataMeter1, out DebugMessage, enable[Constants.Meter1], ListOfComports); if (enable[Constants.Meter1]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter2] = SerialConfigDataMeter2.OpenPort(serialPortDataMeter2, out DebugMessage, enable[Constants.Meter2], ListOfComports); if (enable[Constants.Meter2]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter3] = SerialConfigDataMeter3.OpenPort(serialPortDataMeter3, out DebugMessage, enable[Constants.Meter3], ListOfComports); if (enable[Constants.Meter3]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter4] = SerialConfigDataMeter4.OpenPort(serialPortDataMeter4, out DebugMessage, enable[Constants.Meter4], ListOfComports); if (enable[Constants.Meter4]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter5] = SerialConfigDataMeter5.OpenPort(serialPortDataMeter5, out DebugMessage, enable[Constants.Meter5], ListOfComports); if (enable[Constants.Meter5]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter6] = SerialConfigDataMeter6.OpenPort(serialPortDataMeter6, out DebugMessage, enable[Constants.Meter6], ListOfComports); if (enable[Constants.Meter6]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter7] = SerialConfigDataMeter7.OpenPort(serialPortDataMeter7, out DebugMessage, enable[Constants.Meter7], ListOfComports); if (enable[Constants.Meter7]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter8] = SerialConfigDataMeter8.OpenPort(serialPortDataMeter8, out DebugMessage, enable[Constants.Meter8], ListOfComports); if (enable[Constants.Meter8]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter9] = SerialConfigDataMeter9.OpenPort(serialPortDataMeter9, out DebugMessage, enable[Constants.Meter9], ListOfComports); if (enable[Constants.Meter9]) Display.DebugMessage(DebugMessage); Ok[Constants.DataMeter10] = SerialConfigDataMeter10.OpenPort(serialPortDataMeter10, out DebugMessage, enable[Constants.Meter10], ListOfComports); if (enable[Constants.Meter10]) Display.DebugMessage(DebugMessage); #endregion return Ok; } private void CloseComportsSequence() { #region Definitions and initializations Boolean[] Ok = new Boolean[Constants.NumberOfMeters * 2]; String DebugMessage = String.Empty; Boolean SerialPortClosed = false; for (UInt16 ComportIndex = 0; ComportIndex < (Constants.NumberOfMeters * 2); ComportIndex++) Ok[ComportIndex] = false; #endregion #region Get serial ports SerialConfigCmdMeter1.Init(Constants.CmdMeter1); SerialConfigCmdMeter2.Init(Constants.CmdMeter2); SerialConfigCmdMeter3.Init(Constants.CmdMeter3); SerialConfigCmdMeter4.Init(Constants.CmdMeter4); SerialConfigCmdMeter5.Init(Constants.CmdMeter5); SerialConfigCmdMeter6.Init(Constants.CmdMeter6); SerialConfigCmdMeter7.Init(Constants.CmdMeter7); SerialConfigCmdMeter8.Init(Constants.CmdMeter8); SerialConfigCmdMeter9.Init(Constants.CmdMeter9); SerialConfigCmdMeter10.Init(Constants.CmdMeter10); SerialConfigDataMeter1.Init(Constants.DataMeter1); SerialConfigDataMeter2.Init(Constants.DataMeter2); SerialConfigDataMeter3.Init(Constants.DataMeter3); SerialConfigDataMeter4.Init(Constants.DataMeter4); SerialConfigDataMeter5.Init(Constants.DataMeter5); SerialConfigDataMeter6.Init(Constants.DataMeter6); SerialConfigDataMeter7.Init(Constants.DataMeter7); SerialConfigDataMeter8.Init(Constants.DataMeter8); SerialConfigDataMeter9.Init(Constants.DataMeter9); SerialConfigDataMeter10.Init(Constants.DataMeter10); #endregion #region Open comports SerialPortClosed = SerialConfigCmdMeter1.ClosePort(serialPortCmdMeter1, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter2.ClosePort(serialPortCmdMeter2, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter3.ClosePort(serialPortCmdMeter3, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter4.ClosePort(serialPortCmdMeter4, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter5.ClosePort(serialPortCmdMeter5, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter6.ClosePort(serialPortCmdMeter6, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter7.ClosePort(serialPortCmdMeter7, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter8.ClosePort(serialPortCmdMeter8, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter9.ClosePort(serialPortCmdMeter9, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigCmdMeter10.ClosePort(serialPortCmdMeter10, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter1.ClosePort(serialPortDataMeter1, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter2.ClosePort(serialPortDataMeter2, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter3.ClosePort(serialPortDataMeter3, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter4.ClosePort(serialPortDataMeter4, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter5.ClosePort(serialPortDataMeter5, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter6.ClosePort(serialPortDataMeter6, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter7.ClosePort(serialPortDataMeter7, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter8.ClosePort(serialPortDataMeter8, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter9.ClosePort(serialPortDataMeter9, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); SerialPortClosed = SerialConfigDataMeter10.ClosePort(serialPortDataMeter10, out DebugMessage); if (SerialPortClosed) Display.DebugMessage(DebugMessage); #endregion } } public static partial class Logging { public static void AppendToFile(String data, String path) { Task.Run(() => { using (StreamWriter sw = File.AppendText(path)) { sw.Write(data); } }); } public static void WriteToFile(String data, String path) { String temp = data; Task.Run(() => { using (StreamWriter sw = File.CreateText(path)) { sw.Write(temp); } }); } } public static class PreparationSequences { public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, UInt16 meterSize, out Boolean aborted) { #region Definitions and initializations Int32 NextDelayTime = 0; Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; Boolean[] Ok = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; aborted = false; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceFailed[Meter] = false; Ok[Meter] = false; TaskStarted[Meter] = false; TaskCompleted[Meter] = false; } #region CA1062 if ((enable == null) || (password == null) || (commandInterface == null)) return Ok; #endregion Preparation PreparationMeter1 = new Preparation(); Preparation PreparationMeter2 = new Preparation(); Preparation PreparationMeter3 = new Preparation(); Preparation PreparationMeter4 = new Preparation(); Preparation PreparationMeter5 = new Preparation(); Preparation PreparationMeter6 = new Preparation(); Preparation PreparationMeter7 = new Preparation(); Preparation PreparationMeter8 = new Preparation(); Preparation PreparationMeter9 = new Preparation(); Preparation PreparationMeter10 = new Preparation(); PreparationMeter1.Initialize(commandInterface[Constants.Meter1], Constants.Meter1, numberOfTrials, meterSize); PreparationMeter2.Initialize(commandInterface[Constants.Meter2], Constants.Meter2, numberOfTrials, meterSize); PreparationMeter3.Initialize(commandInterface[Constants.Meter3], Constants.Meter3, numberOfTrials, meterSize); PreparationMeter4.Initialize(commandInterface[Constants.Meter4], Constants.Meter4, numberOfTrials, meterSize); PreparationMeter5.Initialize(commandInterface[Constants.Meter5], Constants.Meter5, numberOfTrials, meterSize); PreparationMeter6.Initialize(commandInterface[Constants.Meter6], Constants.Meter6, numberOfTrials, meterSize); PreparationMeter7.Initialize(commandInterface[Constants.Meter7], Constants.Meter7, numberOfTrials, meterSize); PreparationMeter8.Initialize(commandInterface[Constants.Meter8], Constants.Meter8, numberOfTrials, meterSize); PreparationMeter9.Initialize(commandInterface[Constants.Meter9], Constants.Meter9, numberOfTrials, meterSize); PreparationMeter10.Initialize(commandInterface[Constants.Meter10], Constants.Meter10, numberOfTrials, meterSize); LogOn LogOn1 = new LogOn(); LogOn LogOn2 = new LogOn(); LogOn LogOn3 = new LogOn(); LogOn LogOn4 = new LogOn(); LogOn LogOn5 = new LogOn(); LogOn LogOn6 = new LogOn(); LogOn LogOn7 = new LogOn(); LogOn LogOn8 = new LogOn(); LogOn LogOn9 = new LogOn(); LogOn LogOn10 = new LogOn(); LogOn1.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter1], Constants.Meter1, numberOfTrials); LogOn2.Initialize(commandInterface[Constants.Meter2], password[Constants.Meter2], Constants.Meter2, numberOfTrials); LogOn3.Initialize(commandInterface[Constants.Meter3], password[Constants.Meter3], Constants.Meter3, numberOfTrials); LogOn4.Initialize(commandInterface[Constants.Meter4], password[Constants.Meter4], Constants.Meter4, numberOfTrials); LogOn5.Initialize(commandInterface[Constants.Meter5], password[Constants.Meter5], Constants.Meter5, numberOfTrials); LogOn6.Initialize(commandInterface[Constants.Meter6], password[Constants.Meter6], Constants.Meter6, numberOfTrials); LogOn7.Initialize(commandInterface[Constants.Meter7], password[Constants.Meter7], Constants.Meter7, numberOfTrials); LogOn8.Initialize(commandInterface[Constants.Meter8], password[Constants.Meter8], Constants.Meter8, numberOfTrials); LogOn9.Initialize(commandInterface[Constants.Meter9], password[Constants.Meter9], Constants.Meter9, numberOfTrials); LogOn10.Initialize(commandInterface[Constants.Meter10], password[Constants.Meter10], Constants.Meter10, numberOfTrials); #endregion using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource()) { #region Everything else CancellationToken token = cancellationTokenSource.Token; Task Task1 = new Task(() => { return true; }); Task Task2 = new Task(() => { return true; }); Task Task3 = new Task(() => { return true; }); Task Task4 = new Task(() => { return true; }); Task Task5 = new Task(() => { return true; }); Task Task6 = new Task(() => { return true; }); Task Task7 = new Task(() => { return true; }); Task Task8 = new Task(() => { return true; }); Task Task9 = new Task(() => { return true; }); Task Task10 = new Task(() => { return true; }); PreparationMeter1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, PreparationMeter1, ref NextDelayTime, token); PreparationMeter2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, PreparationMeter2, ref NextDelayTime, token); PreparationMeter3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, PreparationMeter3, ref NextDelayTime, token); PreparationMeter4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, PreparationMeter4, ref NextDelayTime, token); PreparationMeter5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, PreparationMeter5, ref NextDelayTime, token); PreparationMeter6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, PreparationMeter6, ref NextDelayTime, token); PreparationMeter7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, PreparationMeter7, ref NextDelayTime, token); PreparationMeter8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, PreparationMeter8, ref NextDelayTime, token); PreparationMeter9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, PreparationMeter9, ref NextDelayTime, token); PreparationMeter10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, PreparationMeter10, ref NextDelayTime, token); #endregion #region Wait for tasks Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters]; Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceOk[Meter] = false; KeepAuthentifiedCounter[Meter] = 0; } while (!CheckArray(TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { cancellationTokenSource.Cancel(); aborted = true; GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(TaskStarted[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(TaskStarted[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(TaskStarted[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(TaskStarted[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(TaskStarted[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(TaskStarted[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(TaskStarted[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(TaskStarted[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(TaskStarted[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(TaskStarted[Constants.Meter10], Task10); PreparationMeter1.KeepAuthentified(enable[Constants.Meter1], SequenceOk[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1], LogOn1); PreparationMeter2.KeepAuthentified(enable[Constants.Meter2], SequenceOk[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2], LogOn2); PreparationMeter3.KeepAuthentified(enable[Constants.Meter3], SequenceOk[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3], LogOn3); PreparationMeter4.KeepAuthentified(enable[Constants.Meter4], SequenceOk[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4], LogOn4); PreparationMeter5.KeepAuthentified(enable[Constants.Meter5], SequenceOk[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5], LogOn5); PreparationMeter6.KeepAuthentified(enable[Constants.Meter6], SequenceOk[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6], LogOn6); PreparationMeter7.KeepAuthentified(enable[Constants.Meter7], SequenceOk[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7], LogOn7); PreparationMeter8.KeepAuthentified(enable[Constants.Meter8], SequenceOk[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8], LogOn8); PreparationMeter9.KeepAuthentified(enable[Constants.Meter9], SequenceOk[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9], LogOn9); PreparationMeter10.KeepAuthentified(enable[Constants.Meter10], SequenceOk[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10], LogOn10); Misc.WaitNSeconds(1); SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = !SequenceFailed[Meter]; GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted); } SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); #endregion } return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #endregion #region METER1 if (enable[Constants.Meter1]) { if (Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } } #endregion #region METER2 if (enable[Constants.Meter2] && Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } #endregion #region METER3 if (enable[Constants.Meter3] && Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } #endregion #region METER4 if (enable[Constants.Meter4] && Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } #endregion #region METER5 if (enable[Constants.Meter5] && Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } #endregion #region METER6 if (enable[Constants.Meter6] && Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } #endregion #region METER7 if (enable[Constants.Meter7] && Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } #endregion #region METER8 if (enable[Constants.Meter8] && Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } #endregion #region METER9 if (enable[Constants.Meter9] && Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } #endregion #region METER10 if (enable[Constants.Meter10] && Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } #endregion return failed; } private static Boolean CheckArray(Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < array.Count(); i++) { if (array[i] == false) return false; } return Completed; } } public static class EmptyPipeCheckSequences { public static Boolean[] Total(Boolean[] enable, out Boolean aborted) { #region Definitions and initializations const Int32 WaitingTime = 60; CultureInfo Culture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); Boolean[] Aborted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; aborted = false; #region avoid CA1062 if (enable == null) { for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceFailed[Meter] = true; return SequenceFailed; } #endregion for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceFailed[Meter] = false; EmptyPipeCheck EmptyPipeCheck1 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck2 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck3 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck4 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck5 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck6 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck7 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck8 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck9 = new EmptyPipeCheck(); EmptyPipeCheck EmptyPipeCheck10 = new EmptyPipeCheck(); EmptyPipeCheck1.Initialize(WaitingTime, Constants.Meter1, Culture); EmptyPipeCheck2.Initialize(WaitingTime, Constants.Meter2, Culture); EmptyPipeCheck3.Initialize(WaitingTime, Constants.Meter3, Culture); EmptyPipeCheck4.Initialize(WaitingTime, Constants.Meter4, Culture); EmptyPipeCheck5.Initialize(WaitingTime, Constants.Meter5, Culture); EmptyPipeCheck6.Initialize(WaitingTime, Constants.Meter6, Culture); EmptyPipeCheck7.Initialize(WaitingTime, Constants.Meter7, Culture); EmptyPipeCheck8.Initialize(WaitingTime, Constants.Meter8, Culture); EmptyPipeCheck9.Initialize(WaitingTime, Constants.Meter9, Culture); EmptyPipeCheck10.Initialize(WaitingTime, Constants.Meter10, Culture); Task Task1 = new Task(() => { return true; }); Task Task2 = new Task(() => { return true; }); Task Task3 = new Task(() => { return true; }); Task Task4 = new Task(() => { return true; }); Task Task5 = new Task(() => { return true; }); Task Task6 = new Task(() => { return true; }); Task Task7 = new Task(() => { return true; }); Task Task8 = new Task(() => { return true; }); Task Task9 = new Task(() => { return true; }); Task Task10 = new Task(() => { return true; }); #endregion using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource()) { CancellationToken token = cancellationTokenSource.Token; #region METER1 if (enable[Constants.Meter1]) { Task1 = Task.Run(() => { SequenceFailed[Constants.Meter1] = EmptyPipeCheck1.PerformTest(out Aborted[Constants.Meter1], token); return SequenceFailed[Constants.Meter1]; }); } #endregion #region METER2 if (enable[Constants.Meter2]) { Task2 = Task.Run(() => { SequenceFailed[Constants.Meter2] = EmptyPipeCheck2.PerformTest(out Aborted[Constants.Meter2], token); return SequenceFailed[Constants.Meter2]; }); } #endregion #region METER3 if (enable[Constants.Meter3]) { Task3 = Task.Run(() => { SequenceFailed[Constants.Meter3] = EmptyPipeCheck3.PerformTest(out Aborted[Constants.Meter3], token); return SequenceFailed[Constants.Meter3]; }); } #endregion #region METER4 if (enable[Constants.Meter4]) { Task4 = Task.Run(() => { SequenceFailed[Constants.Meter4] = EmptyPipeCheck4.PerformTest(out Aborted[Constants.Meter4], token); return SequenceFailed[Constants.Meter4]; }); } #endregion #region METER5 if (enable[Constants.Meter5]) { Task5 = Task.Run(() => { SequenceFailed[Constants.Meter5] = EmptyPipeCheck5.PerformTest(out Aborted[Constants.Meter5], token); return SequenceFailed[Constants.Meter5]; }); } #endregion #region METER6 if (enable[Constants.Meter6]) { Task6 = Task.Run(() => { SequenceFailed[Constants.Meter6] = EmptyPipeCheck6.PerformTest(out Aborted[Constants.Meter6], token); return SequenceFailed[Constants.Meter6]; }); } #endregion #region METER7 if (enable[Constants.Meter7]) { Task7 = Task.Run(() => { SequenceFailed[Constants.Meter7] = EmptyPipeCheck7.PerformTest(out Aborted[Constants.Meter7], token); return SequenceFailed[Constants.Meter7]; }); } #endregion #region METER8 if (enable[Constants.Meter8]) { Task8 = Task.Run(() => { SequenceFailed[Constants.Meter8] = EmptyPipeCheck8.PerformTest(out Aborted[Constants.Meter8], token); return SequenceFailed[Constants.Meter8]; }); } #endregion #region METER9 if (enable[Constants.Meter9]) { Task9 = Task.Run(() => { SequenceFailed[Constants.Meter9] = EmptyPipeCheck9.PerformTest(out Aborted[Constants.Meter9], token); return SequenceFailed[Constants.Meter9]; }); } #endregion #region METER10 if (enable[Constants.Meter10]) { Task10 = Task.Run(() => { SequenceFailed[Constants.Meter10] = EmptyPipeCheck10.PerformTest(out Aborted[Constants.Meter10], token); return SequenceFailed[Constants.Meter10]; }); } #endregion #region Wait for tasks GenesisZeroFlow.Display.ShowResultStatus("Task started = ", enable); Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = false; while (!CheckArray(enable, TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { cancellationTokenSource.Cancel(); aborted = true; GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(enable[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(enable[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(enable[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(enable[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(enable[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(enable[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(enable[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(enable[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(enable[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(enable[Constants.Meter10], Task10); Misc.WaitNSeconds(1); //TaskFailed = GetTaskResult(enable, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); } for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = !SequenceFailed[Meter]; GenesisZeroFlow.Display.ShowResultStatus("Sequence OK (while loop) = ", SequenceOk); GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, enable); //TaskFailed = GetTaskResult(enable, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); // GenesisZeroFlow.Display.ShowResultStatus("Sequence failed (not while loop) = ", TaskFailed); // GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted); // GenesisZeroFlow.Display.ShowResultStatus("Amplitude total failed: ", TaskFailed); #endregion #region Destroy tasks if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); #endregion #region Clear data for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty); #endregion } return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #region avoid CA1062 if (enable == null) { for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = true; return failed; } #endregion #endregion #region METER1 if (enable[Constants.Meter1]) { if (Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } } #endregion #region METER2 if (enable[Constants.Meter2]) { if (Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } } #endregion #region METER3 if (enable[Constants.Meter3]) { if (Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } } #endregion #region METER4 if (enable[Constants.Meter4]) { if (Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } } #endregion #region METER5 if (enable[Constants.Meter5]) { if (Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } } #endregion #region METER6 if (enable[Constants.Meter6]) { if (Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } } #endregion #region METER7 if (enable[Constants.Meter7]) { if (Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } } #endregion #region METER8 if (enable[Constants.Meter8]) { if (Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } } #endregion #region METER9 if (enable[Constants.Meter9]) { if (Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } } #endregion #region METER10 if (enable[Constants.Meter10]) { if (Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } } #endregion return failed; } private static Boolean CheckArray(Boolean[] enable, Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < array.Count(); i++) { if ((array[i] == false) && (enable[i] == true)) return false; } return Completed; } } public static class AmplitudeSequences { public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, Int32 firstHitLevelPropMin, Int32 firstHitLevelPropMax, Int32 ampTestLowerLimit, Int32 ampTestUpperLimit, Int32 ampTestDistance, out Boolean aborted) { #region Definitions and initializations Int32 FirstHitLevelPropMin = firstHitLevelPropMin; Int32 FirstHitLevelPropMax = firstHitLevelPropMax; const Int32 TofRecordingTime = 2; const Double TriggerValue = 0.5; const Int32 ErrorValue = -123; Int32 NextDelayTime = 0; Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; Boolean[] Ok = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; aborted = false; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceFailed[Meter] = false; Ok[Meter] = false; TaskStarted[Meter] = false; TaskCompleted[Meter] = false; } #region CA1062 if ((enable == null) || (password == null) || (commandInterface == null)) return Ok; #endregion Amplitude AmplitudeMeter1 = new Amplitude(); Amplitude AmplitudeMeter2 = new Amplitude(); Amplitude AmplitudeMeter3 = new Amplitude(); Amplitude AmplitudeMeter4 = new Amplitude(); Amplitude AmplitudeMeter5 = new Amplitude(); Amplitude AmplitudeMeter6 = new Amplitude(); Amplitude AmplitudeMeter7 = new Amplitude(); Amplitude AmplitudeMeter8 = new Amplitude(); Amplitude AmplitudeMeter9 = new Amplitude(); Amplitude AmplitudeMeter10 = new Amplitude(); AmplitudeMeter1.Initialize(commandInterface[Constants.Meter1], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter1); AmplitudeMeter2.Initialize(commandInterface[Constants.Meter2], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter2); AmplitudeMeter3.Initialize(commandInterface[Constants.Meter3], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter3); AmplitudeMeter4.Initialize(commandInterface[Constants.Meter4], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter4); AmplitudeMeter5.Initialize(commandInterface[Constants.Meter5], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter5); AmplitudeMeter6.Initialize(commandInterface[Constants.Meter6], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter6); AmplitudeMeter7.Initialize(commandInterface[Constants.Meter7], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter7); AmplitudeMeter8.Initialize(commandInterface[Constants.Meter8], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter8); AmplitudeMeter9.Initialize(commandInterface[Constants.Meter9], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter9); AmplitudeMeter10.Initialize(commandInterface[Constants.Meter10], ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, numberOfTrials, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, ErrorValue, Constants.Meter10); LogOn LogOn1 = new LogOn(); LogOn LogOn2 = new LogOn(); LogOn LogOn3 = new LogOn(); LogOn LogOn4 = new LogOn(); LogOn LogOn5 = new LogOn(); LogOn LogOn6 = new LogOn(); LogOn LogOn7 = new LogOn(); LogOn LogOn8 = new LogOn(); LogOn LogOn9 = new LogOn(); LogOn LogOn10 = new LogOn(); LogOn1.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter1], Constants.Meter1, numberOfTrials); LogOn2.Initialize(commandInterface[Constants.Meter2], password[Constants.Meter2], Constants.Meter2, numberOfTrials); LogOn3.Initialize(commandInterface[Constants.Meter3], password[Constants.Meter3], Constants.Meter3, numberOfTrials); LogOn4.Initialize(commandInterface[Constants.Meter4], password[Constants.Meter4], Constants.Meter4, numberOfTrials); LogOn5.Initialize(commandInterface[Constants.Meter5], password[Constants.Meter5], Constants.Meter5, numberOfTrials); LogOn6.Initialize(commandInterface[Constants.Meter6], password[Constants.Meter6], Constants.Meter6, numberOfTrials); LogOn7.Initialize(commandInterface[Constants.Meter7], password[Constants.Meter7], Constants.Meter7, numberOfTrials); LogOn8.Initialize(commandInterface[Constants.Meter8], password[Constants.Meter8], Constants.Meter8, numberOfTrials); LogOn9.Initialize(commandInterface[Constants.Meter9], password[Constants.Meter9], Constants.Meter9, numberOfTrials); LogOn10.Initialize(commandInterface[Constants.Meter10], password[Constants.Meter10], Constants.Meter10, numberOfTrials); #endregion #region Perform tests CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken token = cancellationTokenSource.Token; #region METER1 Task Task1 = new Task(() => { return true; }); AmplitudeMeter1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, AmplitudeMeter1, ref NextDelayTime, token); #endregion #region METER2 Task Task2 = new Task(() => { return true; }); AmplitudeMeter2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, AmplitudeMeter2, ref NextDelayTime, token); #endregion #region METER3 Task Task3 = new Task(() => { return true; }); AmplitudeMeter3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, AmplitudeMeter3, ref NextDelayTime, token); #endregion #region METER4 Task Task4 = new Task(() => { return true; }); AmplitudeMeter4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, AmplitudeMeter4, ref NextDelayTime, token); #endregion #region METER5 Task Task5 = new Task(() => { return true; }); AmplitudeMeter5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, AmplitudeMeter5, ref NextDelayTime, token); #endregion #region METER6 Task Task6 = new Task(() => { return true; }); AmplitudeMeter6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, AmplitudeMeter6, ref NextDelayTime, token); #endregion #region METER7 Task Task7 = new Task(() => { return true; }); AmplitudeMeter7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, AmplitudeMeter7, ref NextDelayTime, token); #endregion #region METER8 Task Task8 = new Task(() => { return true; }); AmplitudeMeter8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, AmplitudeMeter8, ref NextDelayTime, token); #endregion #region METER9 Task Task9 = new Task(() => { return true; }); AmplitudeMeter9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, AmplitudeMeter9, ref NextDelayTime, token); #endregion #region METER10 Task Task10 = new Task(() => { return true; }); AmplitudeMeter10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, AmplitudeMeter10, ref NextDelayTime, token); #endregion #endregion #region Wait for tasks GenesisZeroFlow.Display.ShowResultStatus("Task started = ", TaskStarted); Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters]; Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { KeepAuthentifiedCounter[Meter] = 0; SequenceOk[Meter] = false; } while (!CheckArray(TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { cancellationTokenSource.Cancel(); aborted = true; GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(TaskStarted[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(TaskStarted[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(TaskStarted[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(TaskStarted[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(TaskStarted[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(TaskStarted[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(TaskStarted[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(TaskStarted[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(TaskStarted[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(TaskStarted[Constants.Meter10], Task10); AmplitudeMeter1.KeepAuthentified(enable[Constants.Meter1], SequenceOk[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1], LogOn1); AmplitudeMeter2.KeepAuthentified(enable[Constants.Meter2], SequenceOk[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2], LogOn2); AmplitudeMeter3.KeepAuthentified(enable[Constants.Meter3], SequenceOk[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3], LogOn3); AmplitudeMeter4.KeepAuthentified(enable[Constants.Meter4], SequenceOk[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4], LogOn4); AmplitudeMeter5.KeepAuthentified(enable[Constants.Meter5], SequenceOk[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5], LogOn5); AmplitudeMeter6.KeepAuthentified(enable[Constants.Meter6], SequenceOk[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6], LogOn6); AmplitudeMeter7.KeepAuthentified(enable[Constants.Meter7], SequenceOk[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7], LogOn7); AmplitudeMeter8.KeepAuthentified(enable[Constants.Meter8], SequenceOk[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8], LogOn8); AmplitudeMeter9.KeepAuthentified(enable[Constants.Meter9], SequenceOk[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9], LogOn9); AmplitudeMeter10.KeepAuthentified(enable[Constants.Meter10], SequenceOk[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10], LogOn10); Misc.WaitNSeconds(1); SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = !SequenceFailed[Meter]; GenesisZeroFlow.Display.ShowResultStatus("Sequence OK (while loop) = ", SequenceOk); GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted); } SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); GenesisZeroFlow.Display.ShowResultStatus("Sequence failed (not while loop) = ", SequenceFailed); GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted); #endregion #region Destroy tasks GenesisZeroFlow.Display.ShowResultStatus("Amplitude total failed: ", SequenceFailed); if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); #endregion #region Clear data for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty); #endregion return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #endregion #region METER1 if (enable[Constants.Meter1] && Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } #endregion #region METER2 if (enable[Constants.Meter2] && Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } #endregion #region METER3 if (enable[Constants.Meter3] && Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } #endregion #region METER4 if (enable[Constants.Meter4] && Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } #endregion #region METER5 if (enable[Constants.Meter5] && Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } #endregion #region METER6 if (enable[Constants.Meter6] && Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } #endregion #region METER7 if (enable[Constants.Meter7] && Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } #endregion #region METER8 if (enable[Constants.Meter8] && Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } #endregion #region METER9 if (enable[Constants.Meter9] && Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } #endregion #region METER10 if (enable[Constants.Meter10] && Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } #endregion return failed; } private static Boolean CheckArray(Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < array.Count(); i++) { if (array[i] == false) return false; } return Completed; } } public static class ZeroOffsetSequences { public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, Int32 settlingTime, Int16 lowerLimit, Int16 upperLimit, Int32 offsetLimit, Int32 numberOfLines, out Boolean aborted) { #region Definitions and initializations Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; Int32 NextDelayTime = 0; aborted = false; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceFailed[Meter] = false; TaskStarted[Meter] = false; TaskCompleted[Meter] = false; } #region Avoid warning CA1062 if ((enable == null) || (password == null) || (commandInterface == null)) return SequenceFailed; #endregion ZeroFlowOffsetTest ZeroFlowOffsetMeter1 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter2 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter3 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter4 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter5 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter6 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter7 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter8 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter9 = new ZeroFlowOffsetTest(); ZeroFlowOffsetTest ZeroFlowOffsetMeter10 = new ZeroFlowOffsetTest(); ZeroFlowOffsetMeter1.Initialize(commandInterface[Constants.Meter1], Constants.Meter1, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter2.Initialize(commandInterface[Constants.Meter2], Constants.Meter2, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter3.Initialize(commandInterface[Constants.Meter3], Constants.Meter3, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter4.Initialize(commandInterface[Constants.Meter4], Constants.Meter4, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter5.Initialize(commandInterface[Constants.Meter5], Constants.Meter5, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter6.Initialize(commandInterface[Constants.Meter6], Constants.Meter6, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter7.Initialize(commandInterface[Constants.Meter7], Constants.Meter7, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter8.Initialize(commandInterface[Constants.Meter8], Constants.Meter8, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter9.Initialize(commandInterface[Constants.Meter9], Constants.Meter9, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); ZeroFlowOffsetMeter10.Initialize(commandInterface[Constants.Meter10], Constants.Meter10, lowerLimit, upperLimit, offsetLimit, numberOfLines, numberOfTrials); LogOn LogOn1 = new LogOn(); LogOn LogOn2 = new LogOn(); LogOn LogOn3 = new LogOn(); LogOn LogOn4 = new LogOn(); LogOn LogOn5 = new LogOn(); LogOn LogOn6 = new LogOn(); LogOn LogOn7 = new LogOn(); LogOn LogOn8 = new LogOn(); LogOn LogOn9 = new LogOn(); LogOn LogOn10 = new LogOn(); LogOn1.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter1], Constants.Meter1, numberOfTrials); LogOn2.Initialize(commandInterface[Constants.Meter2], password[Constants.Meter2], Constants.Meter2, numberOfTrials); LogOn3.Initialize(commandInterface[Constants.Meter3], password[Constants.Meter3], Constants.Meter3, numberOfTrials); LogOn4.Initialize(commandInterface[Constants.Meter4], password[Constants.Meter4], Constants.Meter4, numberOfTrials); LogOn5.Initialize(commandInterface[Constants.Meter5], password[Constants.Meter5], Constants.Meter5, numberOfTrials); LogOn6.Initialize(commandInterface[Constants.Meter6], password[Constants.Meter6], Constants.Meter6, numberOfTrials); LogOn7.Initialize(commandInterface[Constants.Meter7], password[Constants.Meter7], Constants.Meter7, numberOfTrials); LogOn8.Initialize(commandInterface[Constants.Meter8], password[Constants.Meter8], Constants.Meter8, numberOfTrials); LogOn9.Initialize(commandInterface[Constants.Meter9], password[Constants.Meter9], Constants.Meter9, numberOfTrials); LogOn10.Initialize(commandInterface[Constants.Meter10], password[Constants.Meter10], Constants.Meter10, numberOfTrials); #endregion #region Perform test CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken token = cancellationTokenSource.Token; #region METER1 Task Task1 = new Task(() => { return true; }); ZeroFlowOffsetMeter1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, ZeroFlowOffsetMeter1, ref NextDelayTime, settlingTime, token); #endregion #region METER2 Task Task2 = new Task(() => { return true; }); ZeroFlowOffsetMeter2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, ZeroFlowOffsetMeter2, ref NextDelayTime, settlingTime, token); #endregion #region METER3 Task Task3 = new Task(() => { return true; }); ZeroFlowOffsetMeter3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, ZeroFlowOffsetMeter3, ref NextDelayTime, settlingTime, token); #endregion #region METER4 Task Task4 = new Task(() => { return true; }); ZeroFlowOffsetMeter4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, ZeroFlowOffsetMeter4, ref NextDelayTime, settlingTime, token); #endregion #region METER5 Task Task5 = new Task(() => { return true; }); ZeroFlowOffsetMeter5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, ZeroFlowOffsetMeter5, ref NextDelayTime, settlingTime, token); #endregion #region METER6 Task Task6 = new Task(() => { return true; }); ZeroFlowOffsetMeter6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, ZeroFlowOffsetMeter6, ref NextDelayTime, settlingTime, token); #endregion #region METER7 Task Task7 = new Task(() => { return true; }); ZeroFlowOffsetMeter7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, ZeroFlowOffsetMeter7, ref NextDelayTime, settlingTime, token); #endregion #region METER8 Task Task8 = new Task(() => { return true; }); ZeroFlowOffsetMeter8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, ZeroFlowOffsetMeter8, ref NextDelayTime, settlingTime, token); #endregion #region METER9 Task Task9 = new Task(() => { return true; }); ZeroFlowOffsetMeter9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, ZeroFlowOffsetMeter9, ref NextDelayTime, settlingTime, token); #endregion #region METER10 Task Task10 = new Task(() => { return true; }); ZeroFlowOffsetMeter10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, ZeroFlowOffsetMeter10, ref NextDelayTime, settlingTime, token); #endregion #endregion #region Wait for tasks Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters]; Boolean[] SequenceOK = new Boolean[Constants.NumberOfMeters]; for (Int32 i = 0; i < Constants.NumberOfMeters; i++) { KeepAuthentifiedCounter[i] = 0; SequenceOK[i] = false; } while (!CheckArray(TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { aborted = true; cancellationTokenSource.Cancel(); GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(TaskStarted[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(TaskStarted[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(TaskStarted[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(TaskStarted[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(TaskStarted[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(TaskStarted[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(TaskStarted[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(TaskStarted[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(TaskStarted[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(TaskStarted[Constants.Meter10], Task10); ZeroFlowOffsetMeter1.KeepAuthentified(enable[Constants.Meter1], SequenceOK[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1], LogOn1); ZeroFlowOffsetMeter2.KeepAuthentified(enable[Constants.Meter2], SequenceOK[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2], LogOn2); ZeroFlowOffsetMeter3.KeepAuthentified(enable[Constants.Meter3], SequenceOK[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3], LogOn3); ZeroFlowOffsetMeter4.KeepAuthentified(enable[Constants.Meter4], SequenceOK[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4], LogOn4); ZeroFlowOffsetMeter5.KeepAuthentified(enable[Constants.Meter5], SequenceOK[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5], LogOn5); ZeroFlowOffsetMeter6.KeepAuthentified(enable[Constants.Meter6], SequenceOK[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6], LogOn6); ZeroFlowOffsetMeter7.KeepAuthentified(enable[Constants.Meter7], SequenceOK[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7], LogOn7); ZeroFlowOffsetMeter8.KeepAuthentified(enable[Constants.Meter8], SequenceOK[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8], LogOn8); ZeroFlowOffsetMeter9.KeepAuthentified(enable[Constants.Meter9], SequenceOK[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9], LogOn9); ZeroFlowOffsetMeter10.KeepAuthentified(enable[Constants.Meter10], SequenceOK[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10], LogOn10); Misc.WaitNSeconds(1); SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10); for (Int32 i = 0; i < Constants.NumberOfMeters; i++) SequenceOK[i] = !SequenceFailed[i]; GenesisZeroFlow.Display.ShowResultStatus("Zero offset test sequence OK (while loop) = ", SequenceOK); GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOK, TaskStarted); } #endregion #region Destroy tasks SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10); GenesisZeroFlow.Display.ShowResultStatus("Zero offset test sequence failed = ", SequenceFailed); GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted); if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty); #endregion return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #endregion #region METER1 if (enable[Constants.Meter1]) { if (Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } } #endregion #region METER2 if (enable[Constants.Meter2]) { if (Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } } #endregion #region METER3 if (enable[Constants.Meter3]) { if (Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } } #endregion #region METER4 if (enable[Constants.Meter4]) { if (Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } } #endregion #region METER5 if (enable[Constants.Meter5]) { if (Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } } #endregion #region METER6 if (enable[Constants.Meter6]) { if (Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } } #endregion #region METER7 if (enable[Constants.Meter7]) { if (Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } } #endregion #region METER8 if (enable[Constants.Meter8]) { if (Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } } #endregion #region METER9 if (enable[Constants.Meter9]) { if (Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } } #endregion #region METER10 if (enable[Constants.Meter10]) { if (Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } } #endregion return failed; } private static Boolean CheckArray(Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < array.Count(); i++) { if (array[i] == false) return false; } return Completed; } } public static class TempCalibrationSequences { public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, out Boolean aborted) { #region Definitions and initializations Int32 NextDelayTime = 0; Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; Boolean[] Ok = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; Double[] RefTemperature = new Double[Constants.NumberOfMeters]; aborted = false; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceFailed[Meter] = false; Ok[Meter] = false; TaskStarted[Meter] = false; TaskCompleted[Meter] = false; } #region Avoid warning CA1062 if ((enable == null) || (password == null) || (commandInterface == null)) return Ok; #endregion TempCalibration TempCal1 = new TempCalibration(); TempCalibration TempCal2 = new TempCalibration(); TempCalibration TempCal3 = new TempCalibration(); TempCalibration TempCal4 = new TempCalibration(); TempCalibration TempCal5 = new TempCalibration(); TempCalibration TempCal6 = new TempCalibration(); TempCalibration TempCal7 = new TempCalibration(); TempCalibration TempCal8 = new TempCalibration(); TempCalibration TempCal9 = new TempCalibration(); TempCalibration TempCal10 = new TempCalibration(); TempCal1.Initialize(commandInterface[Constants.CmdMeter1], Constants.Meter1, numberOfTrials, RefTemperature[Constants.Meter1]); TempCal2.Initialize(commandInterface[Constants.CmdMeter2], Constants.Meter2, numberOfTrials, RefTemperature[Constants.Meter2]); TempCal3.Initialize(commandInterface[Constants.CmdMeter3], Constants.Meter3, numberOfTrials, RefTemperature[Constants.Meter3]); TempCal4.Initialize(commandInterface[Constants.CmdMeter4], Constants.Meter4, numberOfTrials, RefTemperature[Constants.Meter4]); TempCal5.Initialize(commandInterface[Constants.CmdMeter5], Constants.Meter5, numberOfTrials, RefTemperature[Constants.Meter5]); TempCal6.Initialize(commandInterface[Constants.CmdMeter6], Constants.Meter6, numberOfTrials, RefTemperature[Constants.Meter6]); TempCal7.Initialize(commandInterface[Constants.CmdMeter7], Constants.Meter7, numberOfTrials, RefTemperature[Constants.Meter7]); TempCal8.Initialize(commandInterface[Constants.CmdMeter8], Constants.Meter8, numberOfTrials, RefTemperature[Constants.Meter8]); TempCal9.Initialize(commandInterface[Constants.CmdMeter9], Constants.Meter9, numberOfTrials, RefTemperature[Constants.Meter9]); TempCal10.Initialize(commandInterface[Constants.CmdMeter10], Constants.Meter10, numberOfTrials, RefTemperature[Constants.Meter10]); LogOn LogOn1 = new LogOn(); LogOn LogOn2 = new LogOn(); LogOn LogOn3 = new LogOn(); LogOn LogOn4 = new LogOn(); LogOn LogOn5 = new LogOn(); LogOn LogOn6 = new LogOn(); LogOn LogOn7 = new LogOn(); LogOn LogOn8 = new LogOn(); LogOn LogOn9 = new LogOn(); LogOn LogOn10 = new LogOn(); LogOn1.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter1], Constants.Meter1, numberOfTrials); LogOn2.Initialize(commandInterface[Constants.Meter2], password[Constants.Meter2], Constants.Meter2, numberOfTrials); LogOn3.Initialize(commandInterface[Constants.Meter3], password[Constants.Meter3], Constants.Meter3, numberOfTrials); LogOn4.Initialize(commandInterface[Constants.Meter4], password[Constants.Meter4], Constants.Meter4, numberOfTrials); LogOn5.Initialize(commandInterface[Constants.Meter5], password[Constants.Meter5], Constants.Meter5, numberOfTrials); LogOn6.Initialize(commandInterface[Constants.Meter6], password[Constants.Meter6], Constants.Meter6, numberOfTrials); LogOn7.Initialize(commandInterface[Constants.Meter7], password[Constants.Meter7], Constants.Meter7, numberOfTrials); LogOn8.Initialize(commandInterface[Constants.Meter8], password[Constants.Meter8], Constants.Meter8, numberOfTrials); LogOn9.Initialize(commandInterface[Constants.Meter9], password[Constants.Meter9], Constants.Meter9, numberOfTrials); LogOn10.Initialize(commandInterface[Constants.Meter10], password[Constants.Meter10], Constants.Meter10, numberOfTrials); #endregion #region Perform tests CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken token = cancellationTokenSource.Token; #region Get manually measured temperatures Int32 NumberOfTextboxes = 0; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { if (enable[Meter]) NumberOfTextboxes++; } if (NumberOfTextboxes == 0) return SequenceFailed; #endregion #region METER1 Task Task1 = new Task(() => { return true; }); TempCal1.SetTemperature(TemperatureField._TemperatureField.GetValueMeter1()); TempCal1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, TempCal1, ref NextDelayTime, token); #endregion #region METER2 Task Task2 = new Task(() => { return true; }); TempCal2.SetTemperature(TemperatureField._TemperatureField.GetValueMeter2()); TempCal2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, TempCal2, ref NextDelayTime, token); #endregion #region METER3 Task Task3 = new Task(() => { return true; }); TempCal3.SetTemperature(TemperatureField._TemperatureField.GetValueMeter3()); TempCal3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, TempCal3, ref NextDelayTime, token); #endregion #region METER4 Task Task4 = new Task(() => { return true; }); TempCal4.SetTemperature(TemperatureField._TemperatureField.GetValueMeter4()); TempCal4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, TempCal4, ref NextDelayTime, token); #endregion #region METER5 Task Task5 = new Task(() => { return true; }); TempCal5.SetTemperature(TemperatureField._TemperatureField.GetValueMeter5()); TempCal5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, TempCal5, ref NextDelayTime, token); #endregion #region METER6 Task Task6 = new Task(() => { return true; }); TempCal6.SetTemperature(TemperatureField._TemperatureField.GetValueMeter6()); TempCal6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, TempCal6, ref NextDelayTime, token); Task6.ContinueWith((s) => { s.Dispose(); }); #endregion #region METER7 Task Task7 = new Task(() => { return true; }); TempCal7.SetTemperature(TemperatureField._TemperatureField.GetValueMeter7()); TempCal7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, TempCal7, ref NextDelayTime, token); #endregion #region METER8 Task Task8 = new Task(() => { return true; }); TempCal8.SetTemperature(TemperatureField._TemperatureField.GetValueMeter8()); TempCal8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, TempCal8, ref NextDelayTime, token); #endregion #region METER9 Task Task9 = new Task(() => { return true; }); TempCal9.SetTemperature(TemperatureField._TemperatureField.GetValueMeter9()); TempCal9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, TempCal9, ref NextDelayTime, token); #endregion #region METER10 Task Task10 = new Task(() => { return true; }); TempCal10.SetTemperature(TemperatureField._TemperatureField.GetValueMeter10()); TempCal10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, TempCal10, ref NextDelayTime, token); #endregion #endregion #region Wait for tasks GenesisZeroFlow.Display.ShowResultStatus("Task started = ", TaskStarted); Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters]; Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { KeepAuthentifiedCounter[Meter] = 0; SequenceOk[Meter] = false; } while (!CheckArray(TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { cancellationTokenSource.Cancel(); aborted = true; GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(TaskStarted[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(TaskStarted[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(TaskStarted[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(TaskStarted[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(TaskStarted[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(TaskStarted[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(TaskStarted[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(TaskStarted[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(TaskStarted[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(TaskStarted[Constants.Meter10], Task10); TempCal1.KeepAuthentified(enable[Constants.Meter1], SequenceOk[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1], LogOn1); TempCal2.KeepAuthentified(enable[Constants.Meter2], SequenceOk[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2], LogOn2); TempCal3.KeepAuthentified(enable[Constants.Meter3], SequenceOk[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3], LogOn3); TempCal4.KeepAuthentified(enable[Constants.Meter4], SequenceOk[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4], LogOn4); TempCal5.KeepAuthentified(enable[Constants.Meter5], SequenceOk[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5], LogOn5); TempCal6.KeepAuthentified(enable[Constants.Meter6], SequenceOk[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6], LogOn6); TempCal7.KeepAuthentified(enable[Constants.Meter7], SequenceOk[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7], LogOn7); TempCal8.KeepAuthentified(enable[Constants.Meter8], SequenceOk[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8], LogOn8); TempCal9.KeepAuthentified(enable[Constants.Meter9], SequenceOk[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9], LogOn9); TempCal10.KeepAuthentified(enable[Constants.Meter10], SequenceOk[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10], LogOn10); Misc.WaitNSeconds(1); SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = !SequenceFailed[Meter]; GenesisZeroFlow.Display.ShowResultStatus("Sequence OK (while loop) = ", SequenceOk); GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted); } SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); GenesisZeroFlow.Display.ShowResultStatus("Sequence failed (not while loop) = ", SequenceFailed); GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted); #endregion #region Destroj tasks GenesisZeroFlow.Display.ShowResultStatus("Temperature calibration failed: ", SequenceFailed); if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); if (Task1.Status == TaskStatus.Created) { Task1 = Task.Run(() => { return true; }); while (Task1.Status != TaskStatus.RanToCompletion) { }; Task1.Dispose(); } if (Task2.Status == TaskStatus.Created) { Task2 = Task.Run(() => { return true; }); while (Task2.Status != TaskStatus.RanToCompletion) { }; Task2.Dispose(); } if (Task3.Status == TaskStatus.Created) { Task3 = Task.Run(() => { return true; }); while (Task3.Status != TaskStatus.RanToCompletion) { }; Task3.Dispose(); } if (Task4.Status == TaskStatus.Created) { Task4 = Task.Run(() => { return true; }); while (Task4.Status != TaskStatus.RanToCompletion) { }; Task4.Dispose(); } if (Task5.Status == TaskStatus.Created) { Task5 = Task.Run(() => { return true; }); while (Task5.Status != TaskStatus.RanToCompletion) { }; Task5.Dispose(); } if (Task6.Status == TaskStatus.Created) { Task6 = Task.Run(() => { return true; }); while (Task6.Status != TaskStatus.RanToCompletion) { }; Task6.Dispose(); } if (Task7.Status == TaskStatus.Created) { Task7 = Task.Run(() => { return true; }); while (Task7.Status != TaskStatus.RanToCompletion) { }; Task7.Dispose(); } if (Task8.Status == TaskStatus.Created) { Task8 = Task.Run(() => { return true; }); while (Task8.Status != TaskStatus.RanToCompletion) { }; Task8.Dispose(); } if (Task9.Status == TaskStatus.Created) { Task9 = Task.Run(() => { return true; }); while (Task9.Status != TaskStatus.RanToCompletion) { }; Task3.Dispose(); } if (Task10.Status == TaskStatus.Created) { Task10 = Task.Run(() => { return true; }); while (Task10.Status != TaskStatus.RanToCompletion) { }; Task10.Dispose(); } #endregion #region Clear data for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty); #endregion return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #endregion #region METER1 if (enable[Constants.Meter1]) { if (Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } } #endregion #region METER2 if (enable[Constants.Meter2]) { if (Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } } #endregion #region METER3 if (enable[Constants.Meter3]) { if (Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } } #endregion #region METER4 if (enable[Constants.Meter4]) { if (Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } } #endregion #region METER5 if (enable[Constants.Meter5]) { if (Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } } #endregion #region METER6 if (enable[Constants.Meter6]) { if (Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } } #endregion #region METER7 if (enable[Constants.Meter7]) { if (Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } } #endregion #region METER8 if (enable[Constants.Meter8]) { if (Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } } #endregion #region METER9 if (enable[Constants.Meter9]) { if (Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } } #endregion #region METER10 if (enable[Constants.Meter10]) { if (Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } } #endregion return failed; } private static Boolean CheckArray(Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < array.Count(); i++) { if (array[i] == false) return false; } return Completed; } } public static class LogOnSequences { public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, out Boolean aborted) { #region Definitions and initializations Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; Int32 NextDelayTime = 0; aborted = false; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceFailed[Meter] = false; TaskStarted[Meter] = false; TaskCompleted[Meter] = false; } #region CA1062 if ((enable == null) || (password == null) || (commandInterface == null)) return SequenceFailed; #endregion LogOn LogOn1 = new LogOn(); LogOn LogOn2 = new LogOn(); LogOn LogOn3 = new LogOn(); LogOn LogOn4 = new LogOn(); LogOn LogOn5 = new LogOn(); LogOn LogOn6 = new LogOn(); LogOn LogOn7 = new LogOn(); LogOn LogOn8 = new LogOn(); LogOn LogOn9 = new LogOn(); LogOn LogOn10 = new LogOn(); LogOn1.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter1], Constants.Meter1, numberOfTrials); LogOn2.Initialize(commandInterface[Constants.Meter2], password[Constants.Meter2], Constants.Meter2, numberOfTrials); LogOn3.Initialize(commandInterface[Constants.Meter3], password[Constants.Meter3], Constants.Meter3, numberOfTrials); LogOn4.Initialize(commandInterface[Constants.Meter4], password[Constants.Meter4], Constants.Meter4, numberOfTrials); LogOn5.Initialize(commandInterface[Constants.Meter5], password[Constants.Meter5], Constants.Meter5, numberOfTrials); LogOn6.Initialize(commandInterface[Constants.Meter6], password[Constants.Meter6], Constants.Meter6, numberOfTrials); LogOn7.Initialize(commandInterface[Constants.Meter7], password[Constants.Meter7], Constants.Meter7, numberOfTrials); LogOn8.Initialize(commandInterface[Constants.Meter8], password[Constants.Meter8], Constants.Meter8, numberOfTrials); LogOn9.Initialize(commandInterface[Constants.Meter9], password[Constants.Meter9], Constants.Meter9, numberOfTrials); LogOn10.Initialize(commandInterface[Constants.Meter10], password[Constants.Meter10], Constants.Meter10, numberOfTrials); #endregion #region Perform test CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken token = cancellationTokenSource.Token; #region METER1 Task Task1 = new Task(() => { return true; }); LogOn1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, ref NextDelayTime, token); #endregion #region METER2 Task Task2 = new Task(() => { return true; }); LogOn2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, ref NextDelayTime, token); #endregion #region METER3 Task Task3 = new Task(() => { return true; }); LogOn3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, ref NextDelayTime, token); #endregion #region METER4 Task Task4 = new Task(() => { return true; }); LogOn4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, ref NextDelayTime, token); #endregion #region METER5 Task Task5 = new Task(() => { return true; }); LogOn5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, ref NextDelayTime, token); #endregion #region METER6 Task Task6 = new Task(() => { return true; }); LogOn6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, ref NextDelayTime, token); #endregion #region METER7 Task Task7 = new Task(() => { return true; }); LogOn7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, ref NextDelayTime, token); #endregion #region METER8 Task Task8 = new Task(() => { return true; }); LogOn8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, ref NextDelayTime, token); #endregion #region METER9 Task Task9 = new Task(() => { return true; }); LogOn9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, ref NextDelayTime, token); #endregion #region METER10 Task Task10 = new Task(() => { return true; }); LogOn10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, ref NextDelayTime, token); #endregion #endregion #region Wait for tasks GenesisZeroFlow.Display.ShowResultStatus("Login, task started = ", TaskStarted); Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters]; Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { KeepAuthentifiedCounter[Meter] = 0; SequenceOk[Meter] = false; } while (!CheckArray(TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { aborted = true; cancellationTokenSource.Cancel(); GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(TaskStarted[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(TaskStarted[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(TaskStarted[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(TaskStarted[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(TaskStarted[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(TaskStarted[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(TaskStarted[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(TaskStarted[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(TaskStarted[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(TaskStarted[Constants.Meter10], Task10); LogOn1.KeepAuthentified(enable[Constants.Meter1], SequenceOk[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1]); LogOn2.KeepAuthentified(enable[Constants.Meter2], SequenceOk[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2]); LogOn3.KeepAuthentified(enable[Constants.Meter3], SequenceOk[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3]); LogOn4.KeepAuthentified(enable[Constants.Meter4], SequenceOk[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4]); LogOn5.KeepAuthentified(enable[Constants.Meter5], SequenceOk[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5]); LogOn6.KeepAuthentified(enable[Constants.Meter6], SequenceOk[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6]); LogOn7.KeepAuthentified(enable[Constants.Meter7], SequenceOk[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7]); LogOn8.KeepAuthentified(enable[Constants.Meter8], SequenceOk[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8]); LogOn9.KeepAuthentified(enable[Constants.Meter9], SequenceOk[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9]); LogOn10.KeepAuthentified(enable[Constants.Meter10], SequenceOk[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10]); Misc.WaitNSeconds(1); SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10); for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = !SequenceFailed[Meter]; GenesisZeroFlow.Display.ShowResultStatus("Login sequence OK (while loop) = ", SequenceOk); GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted); } #endregion #region Destroy tasks SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10); GenesisZeroFlow.Display.ShowResultStatus("Login sequence failed = ", SequenceFailed); GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted); if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); #endregion return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #endregion #region METER1 if (enable[Constants.Meter1]) { if (Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } } #endregion #region METER2 if (enable[Constants.Meter2]) { if (Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } } #endregion #region METER3 if (enable[Constants.Meter3]) { if (Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } } #endregion #region METER4 if (enable[Constants.Meter4]) { if (Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } } #endregion #region METER5 if (enable[Constants.Meter5]) { if (Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } } #endregion #region METER6 if (enable[Constants.Meter6]) { if (Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } } #endregion #region METER7 if (enable[Constants.Meter7]) { if (Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } } #endregion #region METER8 if (enable[Constants.Meter8]) { if (Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } } #endregion #region METER9 if (enable[Constants.Meter9]) { if (Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } } #endregion #region METER10 if (enable[Constants.Meter10]) { if (Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } } #endregion return failed; } private static Boolean CheckArray(Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < array.Count(); i++) { if (array[i] == false) return false; } return Completed; } public static Boolean CheckIfNoMeterSelected(Boolean[] meterSelected) { Boolean noMeterSelected = true; #region CA1062 if (meterSelected == null) return noMeterSelected; #endregion for (Int32 i = 0; i < meterSelected.Count(); i++) { if (meterSelected[i]) noMeterSelected = false; } return noMeterSelected; } public static Boolean CheckIfPortIndicatorsValid(Boolean[] meterSelected, Boolean[] serialPortOpenIndicator) { Boolean portIndicatorsValid = true; #region CA1062 if ((meterSelected == null) || (serialPortOpenIndicator == null)) return portIndicatorsValid = false; ; #endregion GenesisZeroFlow.Display.ShowResultStatus("METER selected", meterSelected); GenesisZeroFlow.Display.ShowResultStatus("serialPortOpenFlag", serialPortOpenIndicator); for (Int32 i = 0; i < meterSelected.Count(); i++) { if (meterSelected[i] != (serialPortOpenIndicator[i] & serialPortOpenIndicator[Constants.NumberOfMeters + i])) portIndicatorsValid = false; } return portIndicatorsValid; } } public static class CompletionSequences { public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, out Boolean aborted) { #region Definitions and initializations Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters]; Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters]; Int32 NextDelayTime = 0; aborted = false; const Int16 LedMode = 0; const Int16 StoreCalibration = 1; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { SequenceFailed[Meter] = false; TaskStarted[Meter] = false; TaskCompleted[Meter] = false; } #region CA1062 if ((enable == null) || (password == null) || (commandInterface == null)) { SequenceFailed = enable; return SequenceFailed; } #endregion Completion Completion1 = new Completion(); Completion Completion2 = new Completion(); Completion Completion3 = new Completion(); Completion Completion4 = new Completion(); Completion Completion5 = new Completion(); Completion Completion6 = new Completion(); Completion Completion7 = new Completion(); Completion Completion8 = new Completion(); Completion Completion9 = new Completion(); Completion Completion10 = new Completion(); Completion1.Initialize(commandInterface[Constants.Meter1], Constants.Meter1, numberOfTrials, LedMode, StoreCalibration); Completion2.Initialize(commandInterface[Constants.Meter2], Constants.Meter2, numberOfTrials, LedMode, StoreCalibration); Completion3.Initialize(commandInterface[Constants.Meter3], Constants.Meter3, numberOfTrials, LedMode, StoreCalibration); Completion4.Initialize(commandInterface[Constants.Meter4], Constants.Meter4, numberOfTrials, LedMode, StoreCalibration); Completion5.Initialize(commandInterface[Constants.Meter5], Constants.Meter5, numberOfTrials, LedMode, StoreCalibration); Completion6.Initialize(commandInterface[Constants.Meter6], Constants.Meter6, numberOfTrials, LedMode, StoreCalibration); Completion7.Initialize(commandInterface[Constants.Meter7], Constants.Meter7, numberOfTrials, LedMode, StoreCalibration); Completion8.Initialize(commandInterface[Constants.Meter8], Constants.Meter8, numberOfTrials, LedMode, StoreCalibration); Completion9.Initialize(commandInterface[Constants.Meter9], Constants.Meter9, numberOfTrials, LedMode, StoreCalibration); Completion10.Initialize(commandInterface[Constants.Meter10], Constants.Meter10, numberOfTrials, LedMode, StoreCalibration); LogOn LogOn1 = new LogOn(); LogOn LogOn2 = new LogOn(); LogOn LogOn3 = new LogOn(); LogOn LogOn4 = new LogOn(); LogOn LogOn5 = new LogOn(); LogOn LogOn6 = new LogOn(); LogOn LogOn7 = new LogOn(); LogOn LogOn8 = new LogOn(); LogOn LogOn9 = new LogOn(); LogOn LogOn10 = new LogOn(); LogOn1.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter1], Constants.Meter1, numberOfTrials); LogOn2.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter2], Constants.Meter2, numberOfTrials); LogOn3.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter3], Constants.Meter3, numberOfTrials); LogOn4.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter4], Constants.Meter4, numberOfTrials); LogOn5.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter5], Constants.Meter5, numberOfTrials); LogOn6.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter6], Constants.Meter6, numberOfTrials); LogOn7.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter7], Constants.Meter7, numberOfTrials); LogOn8.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter8], Constants.Meter8, numberOfTrials); LogOn9.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter9], Constants.Meter9, numberOfTrials); LogOn10.Initialize(commandInterface[Constants.Meter1], password[Constants.Meter10], Constants.Meter10, numberOfTrials); #endregion #region Perform test CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken token = cancellationTokenSource.Token; #region METER1 Task Task1 = new Task(() => { return true; }); Completion1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, Completion1, ref NextDelayTime, token); #endregion #region METER2 Task Task2 = new Task(() => { return true; }); Completion2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, Completion2, ref NextDelayTime, token); #endregion #region METER3 Task Task3 = new Task(() => { return true; }); Completion3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, Completion3, ref NextDelayTime, token); #endregion #region METER4 Task Task4 = new Task(() => { return true; }); Completion4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, Completion4, ref NextDelayTime, token); #endregion #region METER5 Task Task5 = new Task(() => { return true; }); Completion5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, Completion5, ref NextDelayTime, token); #endregion #region METER6 Task Task6 = new Task(() => { return true; }); Completion6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, Completion6, ref NextDelayTime, token); #endregion #region METER7 Task Task7 = new Task(() => { return true; }); Completion7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, Completion7, ref NextDelayTime, token); #endregion #region METER8 Task Task8 = new Task(() => { return true; }); Completion8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, Completion8, ref NextDelayTime, token); #endregion #region METER9 Task Task9 = new Task(() => { return true; }); Completion9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, Completion9, ref NextDelayTime, token); #endregion #region METER10 Task Task10 = new Task(() => { return true; }); Completion10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, Completion10, ref NextDelayTime, token); #endregion #endregion #region Wait for tasks Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters]; Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) { KeepAuthentifiedCounter[Meter] = 0; SequenceOk[Meter] = false; } while (!CheckArray(TaskCompleted)) { if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { aborted = true; cancellationTokenSource.Cancel(); GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false); } TaskCompleted[Constants.Meter1] = Misc.WaitForTask(TaskStarted[Constants.Meter1], Task1); TaskCompleted[Constants.Meter2] = Misc.WaitForTask(TaskStarted[Constants.Meter2], Task2); TaskCompleted[Constants.Meter3] = Misc.WaitForTask(TaskStarted[Constants.Meter3], Task3); TaskCompleted[Constants.Meter4] = Misc.WaitForTask(TaskStarted[Constants.Meter4], Task4); TaskCompleted[Constants.Meter5] = Misc.WaitForTask(TaskStarted[Constants.Meter5], Task5); TaskCompleted[Constants.Meter6] = Misc.WaitForTask(TaskStarted[Constants.Meter6], Task6); TaskCompleted[Constants.Meter7] = Misc.WaitForTask(TaskStarted[Constants.Meter7], Task7); TaskCompleted[Constants.Meter8] = Misc.WaitForTask(TaskStarted[Constants.Meter8], Task8); TaskCompleted[Constants.Meter9] = Misc.WaitForTask(TaskStarted[Constants.Meter9], Task9); TaskCompleted[Constants.Meter10] = Misc.WaitForTask(TaskStarted[Constants.Meter10], Task10); Completion1.KeepAuthentified(enable[Constants.Meter1], SequenceOk[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1], LogOn1); Completion2.KeepAuthentified(enable[Constants.Meter2], SequenceOk[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2], LogOn2); Completion3.KeepAuthentified(enable[Constants.Meter3], SequenceOk[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3], LogOn3); Completion4.KeepAuthentified(enable[Constants.Meter4], SequenceOk[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4], LogOn4); Completion5.KeepAuthentified(enable[Constants.Meter5], SequenceOk[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5], LogOn5); Completion6.KeepAuthentified(enable[Constants.Meter6], SequenceOk[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6], LogOn6); Completion7.KeepAuthentified(enable[Constants.Meter7], SequenceOk[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7], LogOn7); Completion8.KeepAuthentified(enable[Constants.Meter8], SequenceOk[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8], LogOn8); Completion9.KeepAuthentified(enable[Constants.Meter9], SequenceOk[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9], LogOn9); Completion10.KeepAuthentified(enable[Constants.Meter10], SequenceOk[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10], LogOn10); Misc.WaitNSeconds(1); //SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) SequenceOk[Meter] = !SequenceFailed[Meter]; GenesisZeroFlow.Display.ShowResultStatus("Completion sequence OK (while loop) = ", SequenceOk); GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted); } #endregion #region Destroy tasks SequenceFailed = GetTaskResult(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10); GenesisZeroFlow.Display.ShowResultStatus("Completion sequence failed = ", SequenceFailed); GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted); if ((Task1.Status == TaskStatus.RanToCompletion) || (Task1.Status == TaskStatus.Canceled) || (Task1.Status == TaskStatus.Faulted)) Task1.Dispose(); if ((Task2.Status == TaskStatus.RanToCompletion) || (Task2.Status == TaskStatus.Canceled) || (Task2.Status == TaskStatus.Faulted)) Task2.Dispose(); if ((Task3.Status == TaskStatus.RanToCompletion) || (Task3.Status == TaskStatus.Canceled) || (Task3.Status == TaskStatus.Faulted)) Task3.Dispose(); if ((Task4.Status == TaskStatus.RanToCompletion) || (Task4.Status == TaskStatus.Canceled) || (Task4.Status == TaskStatus.Faulted)) Task4.Dispose(); if ((Task5.Status == TaskStatus.RanToCompletion) || (Task5.Status == TaskStatus.Canceled) || (Task5.Status == TaskStatus.Faulted)) Task5.Dispose(); if ((Task6.Status == TaskStatus.RanToCompletion) || (Task6.Status == TaskStatus.Canceled) || (Task6.Status == TaskStatus.Faulted)) Task6.Dispose(); if ((Task7.Status == TaskStatus.RanToCompletion) || (Task7.Status == TaskStatus.Canceled) || (Task7.Status == TaskStatus.Faulted)) Task7.Dispose(); if ((Task8.Status == TaskStatus.RanToCompletion) || (Task8.Status == TaskStatus.Canceled) || (Task8.Status == TaskStatus.Faulted)) Task8.Dispose(); if ((Task9.Status == TaskStatus.RanToCompletion) || (Task9.Status == TaskStatus.Canceled) || (Task9.Status == TaskStatus.Faulted)) Task9.Dispose(); if ((Task10.Status == TaskStatus.RanToCompletion) || (Task10.Status == TaskStatus.Canceled) || (Task10.Status == TaskStatus.Faulted)) Task10.Dispose(); #endregion return SequenceFailed; } private static Boolean[] GetTaskResult(Boolean[] enable, Task Task1, Task Task2, Task Task3, Task Task4, Task Task5, Task Task6, Task Task7, Task Task8, Task Task9, Task Task10) { #region Definitions and initializations Boolean[] failed = new Boolean[Constants.NumberOfMeters]; for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++) failed[Meter] = false; #endregion #region METER1 if (enable[Constants.Meter1]) { if (Task1.Status != TaskStatus.Running) { if (Task1.Status == TaskStatus.RanToCompletion) failed[Constants.Meter1] = Task1.Result; if (Task1.Status == TaskStatus.Faulted) failed[Constants.Meter1] = true; if (Task1.Status == TaskStatus.Canceled) failed[Constants.Meter1] = true; } } #endregion #region METER2 if (enable[Constants.Meter2]) { if (Task2.Status != TaskStatus.Running) { if (Task2.Status == TaskStatus.RanToCompletion) failed[Constants.Meter2] = Task2.Result; if (Task2.Status == TaskStatus.Faulted) failed[Constants.Meter2] = true; if (Task2.Status == TaskStatus.Canceled) failed[Constants.Meter2] = true; } } #endregion #region METER3 if (enable[Constants.Meter3]) { if (Task3.Status != TaskStatus.Running) { if (Task3.Status == TaskStatus.RanToCompletion) failed[Constants.Meter3] = Task3.Result; if (Task3.Status == TaskStatus.Faulted) failed[Constants.Meter3] = true; if (Task3.Status == TaskStatus.Canceled) failed[Constants.Meter3] = true; } } #endregion #region METER4 if (enable[Constants.Meter4]) { if (Task4.Status != TaskStatus.Running) { if (Task4.Status == TaskStatus.RanToCompletion) failed[Constants.Meter4] = Task4.Result; if (Task4.Status == TaskStatus.Faulted) failed[Constants.Meter4] = true; if (Task4.Status == TaskStatus.Canceled) failed[Constants.Meter4] = true; } } #endregion #region METER5 if (enable[Constants.Meter5]) { if (Task5.Status != TaskStatus.Running) { if (Task5.Status == TaskStatus.RanToCompletion) failed[Constants.Meter5] = Task5.Result; if (Task5.Status == TaskStatus.Faulted) failed[Constants.Meter5] = true; if (Task5.Status == TaskStatus.Canceled) failed[Constants.Meter5] = true; } } #endregion #region METER6 if (enable[Constants.Meter6]) { if (Task6.Status != TaskStatus.Running) { if (Task6.Status == TaskStatus.RanToCompletion) failed[Constants.Meter6] = Task6.Result; if (Task6.Status == TaskStatus.Faulted) failed[Constants.Meter6] = true; if (Task6.Status == TaskStatus.Canceled) failed[Constants.Meter6] = true; } } #endregion #region METER7 if (enable[Constants.Meter7]) { if (Task7.Status != TaskStatus.Running) { if (Task7.Status == TaskStatus.RanToCompletion) failed[Constants.Meter7] = Task7.Result; if (Task7.Status == TaskStatus.Faulted) failed[Constants.Meter7] = true; if (Task7.Status == TaskStatus.Canceled) failed[Constants.Meter7] = true; } } #endregion #region METER8 if (enable[Constants.Meter8]) { if (Task8.Status != TaskStatus.Running) { if (Task8.Status == TaskStatus.RanToCompletion) failed[Constants.Meter8] = Task8.Result; if (Task8.Status == TaskStatus.Faulted) failed[Constants.Meter8] = true; if (Task8.Status == TaskStatus.Canceled) failed[Constants.Meter8] = true; } } #endregion #region METER9 if (enable[Constants.Meter9]) { if (Task9.Status != TaskStatus.Running) { if (Task9.Status == TaskStatus.RanToCompletion) failed[Constants.Meter9] = Task9.Result; if (Task9.Status == TaskStatus.Faulted) failed[Constants.Meter9] = true; if (Task9.Status == TaskStatus.Canceled) failed[Constants.Meter9] = true; } } #endregion #region METER10 if (enable[Constants.Meter10]) { if (Task10.Status != TaskStatus.Running) { if (Task10.Status == TaskStatus.RanToCompletion) failed[Constants.Meter10] = Task10.Result; if (Task10.Status == TaskStatus.Faulted) failed[Constants.Meter10] = true; if (Task10.Status == TaskStatus.Canceled) failed[Constants.Meter10] = true; } } #endregion return failed; } private static Boolean CheckArray(Boolean[] array) { Boolean Completed = true; for (Int32 i = 0; i < (Int32)array.Count(); i++) { if (array[i] == false) return false; } return Completed; } } #endregion #region Non static classes public class LogOn { private String Password { get; set; } private UInt16 MeterNumber { get; set; } private UInt16 NumberOfTrials { get; set; } private CultureInfo GlobalCulture { get; set; } private SerialPort SerialPort { get; set; } private CmdInterface CommandInterface { get; set; } public void Initialize(CmdInterface commandInterface, String password, UInt16 meterNumber, UInt16 numberOfTrials) { this.Password = password; this.MeterNumber = meterNumber; this.NumberOfTrials = numberOfTrials; this.GlobalCulture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); this.CommandInterface = commandInterface; } public Boolean PerformLogOn(CancellationToken token, out String debugMessage) { #region Definitions and initializations Boolean reAuthentication = false; Boolean Ok = false; UInt16 Trials = 0; Byte[] Password = new Byte[12] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); String DebugMessage = String.Empty; #endregion #region Get password debugMessage = String.Empty; if (this.Password.Count() != 12) { debugMessage = "COMMAND CHANNEL:\t Password length wrong at METER" + MeterIndex + "\n"; return Ok; } Boolean OnlyHex = Misc.OnlyHexInString(this.Password); if (!OnlyHex) { if (String.IsNullOrEmpty(this.Password)) debugMessage = "COMMAND CHANNEL:\t Missing password at METER" + MeterIndex + "\n"; else debugMessage = "COMMAND CHANNEL:\t Password contains invalid characters at METER" + MeterIndex + "\n"; return Ok; } Password = Encoding.ASCII.GetBytes(this.Password); #endregion #region Send data to privilege register Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing '8' to 'Privilege'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetPrivilegeRegister(8, out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing '8' to 'Privilege'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing '8' to 'Privilege'-register failed at METER" + MeterIndex + "\n"); if ((this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)|| (this.CommandInterface.Subreason == GP30ConfigExErrors.LockedOut)) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Send data to password register Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Password'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetPasswordRegister(Password, out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Password'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Password'-register failed at METER" + MeterIndex + "\n"); if ((this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)||(this.CommandInterface.Subreason == GP30ConfigExErrors.LockedOut)) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Command memory this.CommandInterface.GP30LastCommand = GP30Commands.MultipleWritedata; this.CommandInterface.SetGP30LastRegister(GP30Registers.Password()); #endregion return Ok; } public void Meter(Boolean enable, ref Task task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, ref Int32 nextDelayTime, CancellationToken token) { #region Definitions and initializations Int32 DelayTime = 0; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); const Int32 DeltaDelay = 5; DialogResult AskForActions = DialogResult.None; var _sequenceFailed = sequenceFailed; var _logOn = logOn; String DebugMessage = String.Empty; Int32 temp = DelayTime; Boolean Ok = false; #endregion #region Avoid CA1062 if (task == null) return; #endregion #region Everything else if ((enable) && (task.Status != TaskStatus.Running) && (!task.IsCompleted)) { DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); task = Task.Run(() => { while ((AskForActions == DialogResult.Retry) || (AskForActions == DialogResult.None)) { #region Login procedure if (AskForActions == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t LOGIN started at METER" + MeterIndex + "\n"); Ok = _logOn.PerformLogOn(token, out DebugMessage); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t LOGIN aborted at METER" + MeterIndex + "\n"); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t LOGIN successful at METER" + MeterIndex + "\n"); _sequenceFailed = false; AskForActions = DialogResult.OK; } else { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t LOGIN failed at METER" + MeterIndex + "\n"); _sequenceFailed = true; AskForActions = AskHowToProceedSequence("LOGIN"); } #endregion } return _sequenceFailed; }); } #endregion } private DialogResult AskHowToProceedSequence(String sequenceName) { DialogResult AskForActions; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(sequenceName + " failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (AskForActions) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); break; default: break; } GenesisZeroFlow.Display.AbortButtonEnabled(true); return AskForActions; } public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter) { const Int32 CounterValue = 30; if (enable && taskCompleted && sequenceOk && (counter >= CounterValue)) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Keep authentified at METER" + (this.MeterNumber + 1).ToString(this.GlobalCulture) + "\n"); String DebugMessage = String.Empty; this.GetLedModeRegister(out DebugMessage); counter = 0; } else counter++; } private Boolean SetPrivilegeRegister(Int32 value, out String debugMessage) { #region Definitions and initializations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.Privilege(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetPasswordRegister(Byte[] password, out String debugMessage) { #region Definitions and initializations Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register ErrCode = this.CommandInterface.MultipleWriteRegister(GP30Registers.Password(), password, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.MultipleWrite); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean GetLedModeRegister(out String debugMessage) { #region Definitions and initialisations Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Read register ErrCode = this.CommandInterface.ReadRegister(GP30Registers.LedMode()); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.ReadRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } } public class Preparation { private CultureInfo GlobalCulture { get; set; } private Int32 CalibrationFactor1 { get; set; } private Int32 CalibrationFactor2 { get; set; } private Int32 CalibrationFactor3 { get; set; } private UInt16 NumberOfTrials { get; set; } private Int32 ZeroOffset1 { get; set; } private Int32 ZeroOffset2 { get; set; } private Int32 ZeroOffset3 { get; set; } private Int32 SampleRate { get; set; } private UInt16 MeterSize { get; set; } private Int32 LedMode { get; set; } private UInt16 MeterNumber { get; set; } private CmdInterface CommandInterface { get; set; } public void Initialize(CmdInterface commandInterface, UInt16 meterNumber, UInt16 trials, UInt16 meterSize) { this.CalibrationFactor1 = PreparationValues.CalFactor1; this.CalibrationFactor2 = PreparationValues.CalFactor2; this.CalibrationFactor3 = PreparationValues.CalFactor3; this.ZeroOffset1 = PreparationValues.ZeroOffset1; this.ZeroOffset2 = PreparationValues.ZeroOffset2; this.ZeroOffset3 = PreparationValues.ZeroOffset3; this.SampleRate = PreparationValues.Samplerate; this.MeterSize = meterSize; this.LedMode = PreparationValues.LedMode; this.NumberOfTrials = trials; this.MeterNumber = meterNumber; this.GlobalCulture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); this.CommandInterface = commandInterface; } private Boolean PerformPreparation(out Boolean reAuthentication, CancellationToken token) { #region Definitions and initialisations const Int32 WaitingTime = 100; Boolean Ok = false; Int32 Trials = 0; String DebugMessage = String.Empty; String MeterIndex = (this.MeterNumber + 1).ToString(GlobalCulture); reAuthentication = false; #endregion #region Calibration factor1 while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetCalFactor1Register(this.CalibrationFactor1, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor1'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor1'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Calibration factor2 Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetCalFactor2Register(this.CalibrationFactor2, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor2'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } #endregion #region Calibration factor3 Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetCalFactor3Register(this.CalibrationFactor3, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor3'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Calibration factor3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Zeroflow Offset1 Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetZeroFlowOffset1Register(this.ZeroOffset1, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Zeroflow Offset2 Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetZeroFlowOffset2Register(this.ZeroOffset2, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Zeroflow Offset3 Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetZeroFlowOffset3Register(this.ZeroOffset3, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Sample rate Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetSamplerateRegister(this.SampleRate, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region MeterSize Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Metersize'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetMetersizeRegister(this.MeterSize, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Metersize'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Metersize'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region LedMode Misc.WaitNMilliseconds(WaitingTime); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetLedModeRegister(this.LedMode, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion return Ok; } public void Meter(Boolean enable, ref Task task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, Preparation preparation, ref Int32 nextDelayTime, CancellationToken token) { #region Definitions and initializations Boolean Ok = false; String DebugMessage = String.Empty; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); DialogResult AskForActions = DialogResult.None; Int32 DelayTime = 0; const Int32 DeltaDelay = 5; #endregion if (enable) { DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; Int32 temp = DelayTime; taskStarted = true; var _sequenceFailed = sequenceFailed; var _logOn = logOn; Boolean ReAuthentication = false; task = Task.Run(() => { Misc.WaitNSeconds(temp); while ((AskForActions == DialogResult.Retry) || (AskForActions == DialogResult.None)) { #region Cancelation token if (!token.IsCancellationRequested) GenesisZeroFlow.Display.AbortButtonEnabled(true); #endregion #region Optional reauthentication _sequenceFailed = ReauthenticationProcedure(_logOn, token, ref ReAuthentication); #endregion #region Testprocedure if (AskForActions == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t PREPARATION started at METER" + MeterIndex + "\n"); Ok = preparation.PerformPreparation(out ReAuthentication, token); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t PREPARATION aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t PREPARATION successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); _sequenceFailed = false; AskForActions = DialogResult.OK; } else { if (ReAuthentication == false) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t " + DebugMessage + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t PREPARATION failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = AskHowToProceedSequence("PREPARATION"); } _sequenceFailed = true; } #endregion } AskForActions = DialogResult.None; return _sequenceFailed; }); } } private DialogResult AskHowToProceedSequence(String sequenceName) { DialogResult AskForActions; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(sequenceName + " failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (AskForActions) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); break; default: break; } return AskForActions; } private Boolean ReauthenticationProcedure(LogOn logOn, CancellationToken token, ref Boolean reAuthentication) { #region Definitions and initialization Boolean Ok = false; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); String DebugMessage = String.Empty; Boolean SequenceFailed = false; DialogResult askForActionsAuth = DialogResult.None; #endregion #region Optional reauthentification if (reAuthentication) { while ((askForActionsAuth == DialogResult.Retry) || (askForActionsAuth == DialogResult.None)) { if (askForActionsAuth == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication started at METER" + MeterIndex + "\n"); Ok = logOn.PerformLogOn(token, out DebugMessage); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = false; reAuthentication = false; askForActionsAuth = DialogResult.OK; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t " + DebugMessage + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); SequenceFailed = true; askForActionsAuth = MessageBox.Show("Reauthentication failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (askForActionsAuth) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = true; return SequenceFailed; //break; default: break; } } } } #endregion return SequenceFailed; } public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter, LogOn logOn) { logOn.KeepAuthentified(enable, sequenceOk, taskCompleted, ref counter); } private Boolean SetCalFactor1Register(Int32 value, out String debugMessage) { #region Definitions and initializations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.CalFactor1(), Payload, true); #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion #endregion return Ok; } private Boolean SetCalFactor2Register(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.CalFactor2(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetCalFactor3Register(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.CalFactor3(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetZeroFlowOffset1Register(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ZeroOffset1(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetZeroFlowOffset2Register(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ZeroOffset2(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetZeroFlowOffset3Register(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ZeroOffset3(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetSamplerateRegister(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.Samplerate(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetMetersizeRegister(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.MeterSize(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetLedModeRegister(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.LedMode(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } } public class EmptyPipeCheck { private Int32 WaitingTime { get; set; } private UInt16 MeterNumber { get; set; } private CultureInfo Culture { get; set; } public void Initialize(Int32 waitingTime, UInt16 meterNumber, CultureInfo culture) { this.WaitingTime = waitingTime; this.MeterNumber = meterNumber; this.Culture = culture; } public Boolean PerformTest(out Boolean aborted, CancellationToken token) { #region Definitions and initialization Boolean SequenceFailed = false; Boolean PerformWait = false; Double[] Error = new Double[Constants.NumberOfPaths]; Int32 Countup = 0; Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths] { 0, 0, 0 }; aborted = false; Boolean ActivityOk = false; String MeterIndex = (this.MeterNumber + 1).ToString(this.Culture); #endregion #region Reset counter for activity check/ switch on counting GenesisZeroFlow._GenesisZeroFlow.SetLineCounterEmptyPipeTest(0, this.MeterNumber, Constants.PATH0); GenesisZeroFlow._GenesisZeroFlow.SetLineCounterEmptyPipeTest(0, this.MeterNumber, Constants.PATH1); GenesisZeroFlow._GenesisZeroFlow.SetLineCounterEmptyPipeTest(0, this.MeterNumber, Constants.PATH2); GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorEmptyPipeTest(this.MeterNumber, true); #endregion #region Cancel if (token.IsCancellationRequested) return true; #endregion #region Testsequence for (Int32 Countdown = WaitingTime; Countdown >= 0; Countdown--) { if (Countup == 0) PerformWait = true; else PerformWait = false; #region Abort if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator) { aborted = true; return true; // all enabled meters get sequence failed } #endregion #region Activity check GenesisZeroFlow.Display.StatusLabel("Wait for leaving EMPTY PIPE mode: " + Countdown.ToString(this.Culture) + "s"); ActivityOk = this.PollNumberOfLines(ref LinecounterFollowing, Countup); if (token.IsCancellationRequested) return true; #endregion #region Time control Misc.WaitNSeconds(1); Countup++; #endregion #region Get error status Error[Constants.PATH0] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[MeterNumber][Constants.PATH0].Error; Error[Constants.PATH1] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[MeterNumber][Constants.PATH1].Error; Error[Constants.PATH2] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[MeterNumber][Constants.PATH2].Error; #endregion #region Check if wait for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if ((Error[Path] != DataError.NoError)||(!ActivityOk)) PerformWait = true; } #endregion #region All OK if (PerformWait == false) { GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Leave EMPTY PIPE mode at METER" + MeterIndex + "\n"); return false; } #endregion } #endregion #region Failed SequenceFailed = true; GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Leave EMPTY PIPE mode failed at METER" + MeterIndex + "\n"); #endregion #region Switch off counting GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorEmptyPipeTest(this.MeterNumber, false); #endregion return SequenceFailed; } private Boolean PollNumberOfLines(ref Int32[] lineCounterFollowing, Int32 seconds) { #region Definitions and initializations Boolean Ok = true; Boolean Error = false; #endregion #region Check activity for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path] != 0) { if (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path] == lineCounterFollowing[Path]) return false; else lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path]; } if ((seconds > 0) && (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path] == 0)) return false; } #endregion #region Result Ok = !Error; #endregion return Ok; } } public class Amplitude { private CmdInterface CommandInterface { get; set; } private UInt16 MeterNumber { get; set; } private UInt16 NumberOfTrials { get; set; } private Int32 FirstHitLevelPercMin { get; set; } private Int32 FirstHitLevelPercMax { get; set; } private Int32 TofRecordingTime { get; set; } private Double TriggerValue { get; set; } private Int32 ErrorValue { get; set; } private Int32 OptimumMinValue { get; set; } private Int32 OptimumMaxValue { get; set; } private Double OptimumMinDistance { get; set; } private CultureInfo GlobalCulture { get; set; } public void Initialize(CmdInterface commandInterface, Int32 optimumMinValue, Int32 optimumMaxValue, Int32 optimumMinDistance, UInt16 numberOfTrials, Int32 firstHitLevelPropMin, Int32 firstHitLevelPropMax, Int32 tofRecordingTime, Double triggerValue, Int32 errorValue, UInt16 meterNumber) { this.NumberOfTrials = numberOfTrials; this.TofRecordingTime = tofRecordingTime; this.FirstHitLevelPercMin = firstHitLevelPropMin; this.FirstHitLevelPercMax = firstHitLevelPropMax; this.TriggerValue = triggerValue; this.ErrorValue = errorValue; this.OptimumMinValue = optimumMinValue; this.OptimumMaxValue = optimumMaxValue; this.OptimumMinDistance = optimumMinDistance; this.MeterNumber = meterNumber; this.GlobalCulture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); this.CommandInterface = commandInterface; } public void Meter(Boolean enable, ref Task task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, Amplitude amplitude, ref Int32 nextDelayTime, CancellationToken token) { #region avoid CA1062 if ((task == null) || (amplitude == null)) return; #endregion #region Definitions and initializations Int32 DelayTime = 0; String MeterIndex = (amplitude.CommandInterface.MeterNumber + 1).ToString(this.GlobalCulture); const Int32 DeltaDelay = 30; DialogResult AskForActions = DialogResult.None; Boolean ReAuthentication = false; var _sequenceFailed = sequenceFailed; var _logOn = logOn; var _amplitude = amplitude; Int32 temp = DelayTime; Boolean Ok = false; #endregion #region Everything else if ((enable) && (task.Status != TaskStatus.Running) && (!task.IsCompleted)) { DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); task = Task.Run(() => { while ((AskForActions == DialogResult.Retry) || (AskForActions == DialogResult.None) && (!token.IsCancellationRequested)) { #region Abort if (!token.IsCancellationRequested) GenesisZeroFlow.Display.AbortButtonEnabled(true); #endregion #region Optional reauthentication _sequenceFailed = ReauthenticationProcedure(_logOn, token, ref ReAuthentication); #endregion #region Testprocedure if (AskForActions == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t AMPLITUDE TEST started at METER" + MeterIndex + "\n"); Ok = _amplitude.PerformTest(token, out ReAuthentication); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t AMPLITUDE TEST aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; // sequence failed } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t AMPLITUDE TEST successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); _sequenceFailed = false; AskForActions = DialogResult.OK; } else { if (!ReAuthentication) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t AMPLITUDE TEST failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = this.AskHowToProceedSequence("AMPLITUDE TEST"); } _sequenceFailed = true; } #endregion } return _sequenceFailed; }, token); } #endregion } private Boolean PerformTest(CancellationToken token, out Boolean reAuthentication) { this.ClearData(); #region Definitions and initializations UInt16 Trials = 0; const Int32 FirstHitShiftValue = 4; const Int32 FirstHitShiftValueEnd = 4; const Int32 FirstHitUpdatePeriodeValue = 1; const Int32 FirstHitUpdatePeriodeValueEnd = 10; const Int32 WaitBeforeLogging = 1; UInt16 MeterNumber = this.CommandInterface.MeterNumber; String DebugMessage = String.Empty; String MeterIndex = (this.CommandInterface.MeterNumber + 1).ToString(this.GlobalCulture); Boolean[] dummy = new Boolean[Constants.NumberOfMeters]; reAuthentication = false; List[] TofAvgMeanTotal = new List[Constants.NumberOfPaths]; Boolean Ok = false; List[] AmplitudeValuesPos1 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesPos2 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesPos3 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesPos4 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesNeg1 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesNeg2 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesNeg3 = new List[Constants.NumberOfPaths]; List[] AmplitudeValuesNeg4 = new List[Constants.NumberOfPaths]; for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { AmplitudeValuesPos1[Path] = new List(); AmplitudeValuesPos2[Path] = new List(); AmplitudeValuesPos3[Path] = new List(); AmplitudeValuesPos4[Path] = new List(); AmplitudeValuesNeg1[Path] = new List(); AmplitudeValuesNeg2[Path] = new List(); AmplitudeValuesNeg3[Path] = new List(); AmplitudeValuesNeg4[Path] = new List(); TofAvgMeanTotal[Path] = new List(); } Double[] TofAvgMean = new Double[Constants.NumberOfPaths] { 0, 0, 0 }; Int32[] OptimalPoint = new Int32[Constants.NumberOfPaths] { 0, 0, 0 }; #endregion #region Test sequence #region Set first hit update period GenesisZeroFlow.Display.StatusLabel("Wait until register write has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitUpdatePeriodeValue.ToString(this.GlobalCulture) + " to 'First hit update period'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetFirstHitUpdatePeriod(FirstHitUpdatePeriodeValue, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitUpdatePeriodeValue.ToString(this.GlobalCulture) + " to 'First hit update period'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitUpdatePeriodeValue.ToString(this.GlobalCulture) + " to 'First hit update period'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Set first hit shift to 4 GenesisZeroFlow.Display.StatusLabel("Wait until register write has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitShiftValue.ToString(this.GlobalCulture) + " to 'First hit shift'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetFirstHitShift(FirstHitShiftValue, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitShiftValue.ToString(this.GlobalCulture) + " to 'First hit shift'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitShiftValue.ToString(this.GlobalCulture) + " to 'First hit shift'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Set first hit level percentage from 5 to 40 ClearData(); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Start first hit level percentage sweep at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); for (Int32 FirstHitLevelPercentage = (Int32)(this.FirstHitLevelPercMin); FirstHitLevelPercentage <= (this.FirstHitLevelPercMax); FirstHitLevelPercentage++) { if (token.IsCancellationRequested) { this.ClearData(); return false; } GenesisZeroFlow.Display.StatusLabel("Wait for percentage sweep to end: " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + "/" + FirstHitLevelPercMax.ToString(this.GlobalCulture)); #region Write to percentage register PATH0 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) { this.ClearData(); return false; } GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register at METER" + MeterIndex + "; PATH1; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetPercentageRegisterPath0(FirstHitLevelPercentage, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register successful at METER" + MeterIndex + "; PATH1\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register failed at METER" + MeterIndex + "; PATH1\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) { this.ClearData(); return false; } #endregion #region Write to percentage register PATH1 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) { this.ClearData(); return false; } GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register at METER" + MeterIndex + "; PATH2; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetPercentageRegisterPath1(FirstHitLevelPercentage, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register successful at METER" + MeterIndex + "; PATH2\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register failed at METER" + MeterIndex + "; PATH2\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) { this.ClearData(); return false; } #endregion #region Write to percentage register PATH2 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) { this.ClearData(); return false; } GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register at METER" + MeterIndex + "; PATH3; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetPercentageRegisterPath2(FirstHitLevelPercentage, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register successful at METER" + MeterIndex + "; PATH3\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + " to 'Percentage'-register failed at METER" + MeterIndex + "; PATH3\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) { this.ClearData(); return false; } #endregion #region Wait for 1 second for (Int32 i = 0; i < WaitBeforeLogging; i++) { if (token.IsCancellationRequested) { this.ClearData(); return false; } GenesisZeroFlow.Display.StatusLabel("Wait for percentage sweep to end: " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + "/" + FirstHitLevelPercMax.ToString(this.GlobalCulture) + "; " + (this.TofRecordingTime + WaitBeforeLogging - i).ToString(this.GlobalCulture) + "s"); Misc.WaitNSeconds(1); } #endregion #region Record TOF GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(MeterNumber, true); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Start collecting data at METER" + MeterIndex + "\n"); Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths] { 0, 0, 0 }; for (Int32 Seconds = 0; Seconds < this.TofRecordingTime; Seconds++) // eight seconds { if (token.IsCancellationRequested) { this.ClearData(); return false; } Ok = this.PollNumberOfLines(ref LinecounterFollowing, Seconds); if (Ok) { GenesisZeroFlow.Display.StatusLabel("Wait for percentage sweep to end: " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + "/" + FirstHitLevelPercMax.ToString(this.GlobalCulture) + "; " + (this.TofRecordingTime - Seconds).ToString(this.GlobalCulture) + "s"); Misc.WaitNSeconds(1); } else { GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Activity check failed at METER" + MeterIndex + "\n"); GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(MeterNumber, false); this.ClearData(); return false; } } GenesisZeroFlow.Display.StatusLabel("Wait for percentage sweep to end: " + FirstHitLevelPercentage.ToString(this.GlobalCulture) + "/" + FirstHitLevelPercMax.ToString(this.GlobalCulture) + "; 0s"); GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(MeterNumber, false); Ok = true; #endregion #region Write raw data to files String temp = GenesisZeroFlow._GenesisZeroFlow.GetDataToLog()[MeterNumber]; GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Write data to files at METER" + MeterIndex + "\n"); Logging.WriteToFile(temp, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathAmplitudeTest()[MeterNumber]); GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(MeterNumber, String.Empty); #endregion #region Calculate mean value for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Calculate mean value at METER" + MeterIndex + "; PATH" + (Path + 1).ToString(this.GlobalCulture) + "\n"); TofAvgMean[Path] = GenesisZeroFlow._GenesisZeroFlow.GetTotalTimeOfFlightAverage()[MeterNumber][Path].Mean(); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Mean value at METER" + MeterIndex + "; PATH" + (Path + 1).ToString(this.GlobalCulture) + "; Value = " + Math.Round(TofAvgMean[Path], 4).ToString(this.GlobalCulture) + "\n"); TofAvgMeanTotal[Path].Add(TofAvgMean[Path]); GenesisZeroFlow._GenesisZeroFlow.SetNumbersToLog(MeterNumber, Path, GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Path] + Math.Round(TofAvgMean[Path], 4).ToString(this.GlobalCulture) + "\n"); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(MeterNumber, Path); } #endregion } #endregion #region Write log data to file String DateTime = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.GlobalCulture); if (GenesisZeroFlow._GenesisZeroFlow.GetCBMeanAmplitudeFiles()) { Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH0], @"..\GenesisZeroFlowTest_MeanAmplitude_METER" + MeterIndex + "_PATH0_" + DateTime + ".csv"); Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH1], @"..\GenesisZeroFlowTest_MeanAmplitude_METER" + MeterIndex + "_PATH1_" + DateTime + ".csv"); Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH2], @"..\GenesisZeroFlowTest_MeanAmplitude_METER" + MeterIndex + "_PATH2_" + DateTime + ".csv"); } GenesisZeroFlow.Display.ShowResultStatus("NumbersToLog.Count() = " + GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[Constants.PATH0].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("NumbersToLog.Count() = " + GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[Constants.PATH1].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("NumbersToLog.Count() = " + GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[Constants.PATH2].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("TotalTimeOfFlightAvg.Count() = " + GenesisZeroFlow._GenesisZeroFlow.GetTotalTimeOfFlightAverage()[MeterNumber][Constants.PATH0].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("TotalTimeOfFlightAvg.Count() = " + GenesisZeroFlow._GenesisZeroFlow.GetTotalTimeOfFlightAverage()[MeterNumber][Constants.PATH1].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("TotalTimeOfFlightAvg.Count() = " + GenesisZeroFlow._GenesisZeroFlow.GetTotalTimeOfFlightAverage()[MeterNumber][Constants.PATH2].Count().ToString(this.GlobalCulture), dummy); this.ClearData(); #endregion #region Calculate optimal point Double[] DistanceLeft = new Double[Constants.NumberOfPaths]; Double[] DistanceRight = new Double[Constants.NumberOfPaths]; GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Start calculating optimal points at METER" + MeterIndex + "\n"); OptimalPoint[Constants.PATH0] = CalculateOptimalPoint(TofAvgMeanTotal[Constants.PATH0], out DistanceLeft[Constants.PATH0], out DistanceRight[Constants.PATH0]); OptimalPoint[Constants.PATH1] = CalculateOptimalPoint(TofAvgMeanTotal[Constants.PATH1], out DistanceLeft[Constants.PATH1], out DistanceRight[Constants.PATH1]); OptimalPoint[Constants.PATH2] = CalculateOptimalPoint(TofAvgMeanTotal[Constants.PATH2], out DistanceLeft[Constants.PATH2], out DistanceRight[Constants.PATH2]); if (OptimalPoint[Constants.PATH0] != this.ErrorValue) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Optimal point calculation successful at METER" + MeterIndex + ", PATH1; Value = " + OptimalPoint[Constants.PATH0].ToString(this.GlobalCulture) + "\n"); else GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Optimal point calculation failed at METER" + MeterIndex + ", PATH1\n"); if (OptimalPoint[Constants.PATH1] != this.ErrorValue) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Optimal point calculation successful at METER" + MeterIndex + ", PATH2; Value = " + OptimalPoint[Constants.PATH1].ToString(this.GlobalCulture) + "\n"); else GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Optimal point calculation failed at METER" + MeterIndex + ", PATH2\n"); if (OptimalPoint[Constants.PATH2] != this.ErrorValue) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Optimal point calculation successful at METER" + MeterIndex + ", PATH3; Value = " + OptimalPoint[Constants.PATH2].ToString(this.GlobalCulture) + "\n"); else GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Optimal point calculation failed at METER" + MeterIndex + ", PATH3\n"); if ((OptimalPoint[Constants.PATH0] == this.ErrorValue) || (OptimalPoint[Constants.PATH1] == this.ErrorValue) || (OptimalPoint[Constants.PATH2] == this.ErrorValue)) return false; #endregion #region Check value GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Start optimal point values check at METER" + MeterIndex + "\n"); Boolean OptimalPointOkPath0 = this.CheckOptimalPoint(OptimalPoint[Constants.PATH0], out DebugMessage); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t " + DebugMessage + ", PATH1\n"); Boolean OptimalPointOkPath1 = this.CheckOptimalPoint(OptimalPoint[Constants.PATH1], out DebugMessage); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t " + DebugMessage + ", PATH2\n"); Boolean OptimalPointOkPath2 = this.CheckOptimalPoint(OptimalPoint[Constants.PATH2], out DebugMessage); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t " + DebugMessage + ", PATH3\n"); if ((OptimalPointOkPath0 == false) || (OptimalPointOkPath1 == false) || (OptimalPointOkPath2 == false)) return false; #endregion #region Check distance Boolean CheckDistanceOkPath0 = this.CheckDistance(DistanceLeft[Constants.PATH0], DistanceRight[Constants.PATH0], out DebugMessage); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t " + DebugMessage + ", PATH1\n"); Boolean CheckDistanceOkPath1 = this.CheckDistance(DistanceLeft[Constants.PATH1], DistanceRight[Constants.PATH1], out DebugMessage); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t " + DebugMessage + ", PATH2\n"); Boolean CheckDistanceOkPath2 = this.CheckDistance(DistanceLeft[Constants.PATH2], DistanceRight[Constants.PATH2], out DebugMessage); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t " + DebugMessage + ", PATH3\n"); if ((CheckDistanceOkPath0 == false) || (CheckDistanceOkPath1 == false) || (CheckDistanceOkPath2 == false)) return false; #endregion #region Set first hit level percentage registers GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Start writing to percentage registers at METER" + MeterIndex + "\n"); #region Write to percentage register PATH0 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; String OptimalPointPath0 = OptimalPoint[Constants.PATH0].ToString(this.GlobalCulture); GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath0 + " to 'Percentage'-register at METER" + MeterIndex + "; PATH1; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetPercentageRegisterPath0(OptimalPoint[Constants.PATH0], out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath0 + " to 'Percentage'-register successful at METER" + MeterIndex + "; PATH1\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath0 + " to 'Percentage'-register failed at METER" + MeterIndex + "; PATH1\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Write to percentage register PATH1 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; String OptimalPointPath1 = OptimalPoint[Constants.PATH1].ToString(this.GlobalCulture); GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath1 + " to 'Percentage'-register at METER" + MeterIndex + "; PATH2; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetPercentageRegisterPath1(OptimalPoint[Constants.PATH1], out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath1 + " to 'Percentage'-register successful at METER" + MeterIndex + "; PATH2\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath1 + " to 'Percentage'-register failed at METER" + MeterIndex + "; PATH2\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Write to percentage register PATH2 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; String OptimalPointPath2 = OptimalPoint[Constants.PATH2].ToString(this.GlobalCulture); GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath2 + " to 'Percentage'-register at METER" + MeterIndex + "; PATH3; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetPercentageRegisterPath2(OptimalPoint[Constants.PATH2], out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath2 + " to 'Percentage'-register successful at METER" + MeterIndex + "; PATH3\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + OptimalPointPath2 + " to 'Percentage'-register failed at METER" + MeterIndex + "; PATH3\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #endregion #region Set first hit update period to 10 GenesisZeroFlow.Display.StatusLabel("Wait until register write has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitUpdatePeriodeValueEnd.ToString(this.GlobalCulture) + " to first hit update period register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetFirstHitUpdatePeriod(FirstHitUpdatePeriodeValueEnd, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitUpdatePeriodeValueEnd.ToString(this.GlobalCulture) + " to first hit update period register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitUpdatePeriodeValueEnd.ToString(this.GlobalCulture) + " to first hit update period register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) { //MessageBox.Show(cmdInterface.Subreason.ToString("X")); return false; } // JumpOverFirstHitUpdatePeriodEnd: #endregion #region Set first hit shift to 4 GenesisZeroFlow.Display.StatusLabel("Wait until register write has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitShiftValueEnd.ToString(this.GlobalCulture) + " to 'First hit shift'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetFirstHitShift(FirstHitShiftValueEnd, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitShiftValueEnd.ToString(this.GlobalCulture) + " to 'First hit shift'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing " + FirstHitShiftValueEnd.ToString(this.GlobalCulture) + " to 'First hit shift'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #endregion return Ok; } public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter, LogOn logOn) { logOn.KeepAuthentified(enable, sequenceOk, taskCompleted, ref counter); } private Boolean ReauthenticationProcedure(LogOn logOn, CancellationToken token, ref Boolean reAuthentication) { #region Definitions and initialization Boolean Ok = false; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); String DebugMessage = String.Empty; Boolean SequenceFailed = false; DialogResult askForActionsAuth = DialogResult.None; #endregion #region Optional reauthentification if (reAuthentication) { while ((askForActionsAuth == DialogResult.Retry) || (askForActionsAuth == DialogResult.None)) { if (askForActionsAuth == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication started at METER" + MeterIndex + "\n"); Ok = logOn.PerformLogOn(token, out DebugMessage); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = false; reAuthentication = false; askForActionsAuth = DialogResult.OK; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t " + DebugMessage + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); SequenceFailed = true; askForActionsAuth = MessageBox.Show("Reauthentication failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (askForActionsAuth) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = true; return SequenceFailed; //break; default: break; } } } } #endregion return SequenceFailed; } private DialogResult AskHowToProceedSequence(String sequenceName) { DialogResult AskForActions; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(sequenceName + " failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (AskForActions) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); break; default: break; } return AskForActions; } private Int32 CalculateOptimalPoint(List TofAvg, out Double left, out Double right) { List ValuesLeft = new List(); List ValuesRight = new List(); Int32 XatOptimalPoint = this.ErrorValue; left = 0; right = 0; ValuesLeft = this.CalculateNearestDistanceLeft(TofAvg, out left); ValuesRight = this.CalculateNearestDistanceRight(TofAvg, out right); for (Int32 i = 0; i < TofAvg.Count(); i++) { if ((i != 0) && (i != TofAvg.Count() - 1)) { if ((ValuesLeft.ElementAt(i - 1) > ValuesRight.ElementAt(i - 1)) && (ValuesRight.ElementAt(i + 1) > ValuesLeft.ElementAt(i + 1))) { XatOptimalPoint = i + this.FirstHitLevelPercMin; } } } return XatOptimalPoint; } private List CalculateNearestDistanceLeft(List TofAvg, out Double left) { List Distance = new List(); Double NearestDistance = 0; Boolean Detected = false; left = 0; for (Int32 Percentage = this.FirstHitLevelPercMin; Percentage <= (this.FirstHitLevelPercMax); Percentage++) { for (Int32 PercentageFollowing = Percentage; PercentageFollowing <= this.FirstHitLevelPercMax; PercentageFollowing++) { if ((TofAvg.ElementAt(PercentageFollowing - this.FirstHitLevelPercMin) - TofAvg.ElementAt(Percentage - FirstHitLevelPercMin)) > this.TriggerValue) { NearestDistance = PercentageFollowing - Percentage; Detected = true; break; } } if (Detected) { Distance.Add(NearestDistance); } else { Distance.Add(this.ErrorValue); } } for (Int32 i = 0; i < Distance.Count(); i++) { if (Distance.ElementAt(i) >= left) { left = Distance.ElementAt(i); } } return Distance; } private List CalculateNearestDistanceRight(List TofAvg, out Double right) { List Distance = new List(); Double NearestDistance = 0; Boolean Detected = false; right = 0; for (Int32 Proportion = this.FirstHitLevelPercMax; Proportion >= (this.FirstHitLevelPercMin); Proportion--) { for (Int32 ProportionFollowing = Proportion; ProportionFollowing >= this.FirstHitLevelPercMin; ProportionFollowing--) { if ((TofAvg.ElementAt(ProportionFollowing - FirstHitLevelPercMin)) - (TofAvg.ElementAt(Proportion - FirstHitLevelPercMin)) < -this.TriggerValue) { NearestDistance = Proportion - ProportionFollowing; Detected = true; break; } } if (Detected) { Distance.Add(NearestDistance); } else { Distance.Add(this.ErrorValue); } } Distance.Reverse(); for (Int32 i = 0; i < Distance.Count(); i++) { if (Distance.ElementAt(i) >= right) { right = Distance.ElementAt(i); } } return Distance; } private Boolean SetFirstHitUpdatePeriod(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes(value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.FirstHitUpdatePeriod(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetFirstHitShift(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean OK = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload = BitConverter.GetBytes(value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.FirstHitShift(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out OK); #endregion return OK; } private Boolean SetPercentageRegisterPath0(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register PATH0 Payload = BitConverter.GetBytes(value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.FirstHitLevelPercentagePath0(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetPercentageRegisterPath1(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register PATH1 Payload = BitConverter.GetBytes(value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.FirstHitLevelPercentagePath1(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean SetPercentageRegisterPath2(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register PATH2 Payload = BitConverter.GetBytes(value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.FirstHitLevelPercentagePath2(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean CheckOptimalPoint(Int32 optimalPoint, out String debugMessage) { Boolean Ok = true; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); debugMessage = "Optimal point check successful at METER" + MeterIndex; if (optimalPoint == this.ErrorValue) { debugMessage = "Optimal point check failed at METER" + MeterIndex; Ok = false; return Ok; } if (optimalPoint > this.OptimumMaxValue) { debugMessage = "Optimal point maximum check failed at METER" + MeterIndex; Ok = false; return Ok; } if (optimalPoint < this.OptimumMinValue) { debugMessage = "Optimal point minimum check failed at METER" + MeterIndex; Ok = false; return Ok; } return Ok; } private Boolean CheckDistance(Double left, Double right, out String debugMessage) { Boolean OK = true; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); debugMessage = "Distance check successful at METER" + MeterIndex; if (left < this.OptimumMinDistance) { OK = false; debugMessage = "Distance check failed at METER" + MeterIndex; return OK; } if (right < this.OptimumMinDistance) { OK = false; debugMessage = "Distance check failed at METER" + MeterIndex; return OK; } return OK; } private Boolean PollNumberOfLines(ref Int32[] lineCounterFollowing, Int32 seconds) { #region Definitions and initializations Boolean Ok = true; Boolean Error = false; #endregion #region Check activity for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path] != 0) { if (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path] == lineCounterFollowing[Path]) return false; else lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path]; } if ((seconds > 0) && (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path] == 0)) return false; } #endregion #region Result Ok = !Error; #endregion return Ok; } private void ClearData() { GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Constants.PATH0); GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Constants.PATH1); GenesisZeroFlow.Display.EraseAmplitudeData(MeterNumber, Constants.PATH2); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Constants.PATH0); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Constants.PATH1); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Constants.PATH2); } } public class ZeroFlowOffsetTest { private CultureInfo GlobalCulture { get; set; } private Double RangeLow { get; set; } private Double RangeHigh { get; set; } private UInt16 NumberOfCheckingTrials { get; set; } private UInt16 MeterNumber { get; set; } private Int32 OffsetValuePath0 { get; set; } private Int32 OffsetValuePath1 { get; set; } private Int32 OffsetValuePath2 { get; set; } private Int32 OffsetLimit { get; set; } private Int32 NumberOfLines { get; set; } private CmdInterface CommandInterface { get; set; } public void Initialize(CmdInterface commandInterface, UInt16 meterNumber, Int16 rangeLow, Int16 rangeHigh, Int32 offsetLimit, Int32 numberOfLines, UInt16 numberOfCheckingTrials) { this.MeterNumber = meterNumber; this.NumberOfCheckingTrials = numberOfCheckingTrials; this.OffsetValuePath0 = 0; this.OffsetValuePath1 = 0; this.OffsetValuePath2 = 0; this.RangeHigh = rangeHigh; this.RangeLow = rangeLow; this.OffsetLimit = offsetLimit; this.NumberOfLines = numberOfLines; this.GlobalCulture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); this.CommandInterface = commandInterface; } public void Meter(Boolean enable, ref Task task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, ZeroFlowOffsetTest zeroFlowOffsetTest, ref Int32 nextDelayTime, Int32 settlingTime, CancellationToken token) { #region Definitions and initializations Int32 DelayTime = 0; String MeterIndex = (this.MeterNumber + 1).ToString(GlobalCulture); const Int32 DeltaDelay = 5; DialogResult AskForActions = DialogResult.None; DialogResult AskForActionsFinalization = DialogResult.None; Boolean ReAuthentication = false; var _sequenceFailed = sequenceFailed; var _logOn = logOn; var _zeroFlowOffsetTest = zeroFlowOffsetTest; Int32 temp = DelayTime; Boolean Ok = false; UInt16 MeterNumber = this.MeterNumber; #endregion #region Avoid CA1062 if (task == null) { sequenceFailed = true; taskStarted = false; return; } #endregion #region Everything else if ((enable) && (task.Status != TaskStatus.Running)) { #region Start delay DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); #endregion #region Testprocedure DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); task = Task.Run(() => { while ((AskForActions == DialogResult.Retry) || (AskForActions == DialogResult.None)) { #region Abort if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; // sequence failed } else GenesisZeroFlow.Display.AbortButtonEnabled(true); #endregion #region Start logging GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST started at METER" + MeterIndex + "\n"); _zeroFlowOffsetTest.StartTest(); GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(true, this.MeterNumber); #endregion #region Wait for settling time (60s) for (Int32 i = settlingTime; i >= 0; i--) { if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST aborted at METER" + MeterIndex + "\n"); return true; // sequence failed } GenesisZeroFlow.Display.StatusLabel("Wait for settling time: " + i.ToString(this.GlobalCulture)); Misc.WaitNSeconds(1); } #endregion #region Start collecting data for calculation GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(true, MeterNumber); #endregion #region Polling for number of data lines/ activity check Boolean PollOk = true; for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if (enable && PollOk && ((AskForActions == DialogResult.None) || (AskForActions == DialogResult.Retry))) PollOk = _zeroFlowOffsetTest.PollNumberOfLines(Path, token); } #endregion #region Stop logging ==> is done by the 'MainloopMeterX'-Functions GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Stop logging at METER" + MeterIndex + "\n"); #endregion #region Write raw data to files String LogData = GenesisZeroFlow._GenesisZeroFlow.GetDataToLog()[MeterNumber]; GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Write data to files at METER" + MeterIndex + "\n"); Logging.WriteToFile(LogData, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathZeroFlowTest()[MeterNumber]); GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(MeterNumber, String.Empty); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; // sequence failed } #endregion #region Summary if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; // sequence failed } if (PollOk) { while ((AskForActionsFinalization == DialogResult.Retry) || (AskForActionsFinalization == DialogResult.None)) { #region Abort if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; // sequence failed } else GenesisZeroFlow.Display.AbortButtonEnabled(true); #endregion #region Optional re-authentication _sequenceFailed = ReauthenticationProcedure(_logOn, token, ref ReAuthentication); #endregion #region Finalize test GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Finalize ZEROFLOW OFFSET TEST at METER" + MeterIndex + "\n"); Ok = _zeroFlowOffsetTest.FinalizeTest(GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeValuesPositive(MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeValuesNegative(MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetDeltaTimeOfFlightAverage(MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetBadDataCounter(MeterNumber), out ReAuthentication, token); if (Ok == true) { AskForActionsFinalization = DialogResult.OK; _sequenceFailed = false;//? } else { if (!ReAuthentication) AskForActionsFinalization = this.AskHowToProceedSequence("ZEROFLOW OFFSET TEST"); _sequenceFailed = true; //? } #endregion } } else Ok = false; if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); _sequenceFailed = false; AskForActions = DialogResult.OK; ReAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); _sequenceFailed = true; AskForActions = AskHowToProceedSequence("ZEROFLOW OFFSET TEST"); } #endregion } return _sequenceFailed; }); #endregion } #endregion } private Boolean StartTest() { #region Definitions and initializations Boolean Ok = false; String time = DateTime.Now.ToString(Formats.LogFileDateTimeString, this.GlobalCulture); String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); #endregion #region Start logging GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty); GenesisZeroFlow._GenesisZeroFlow.ClearAmplitudeValuesPositive(this.MeterNumber); GenesisZeroFlow._GenesisZeroFlow.ClearAmplitudeValuesNegative(this.MeterNumber); GenesisZeroFlow._GenesisZeroFlow.ClearDeltaTimeOfFlightAverage(this.MeterNumber); GenesisZeroFlow._GenesisZeroFlow.ClearBadDataCounter(this.MeterNumber); GenesisZeroFlow._GenesisZeroFlow.ClearLineCounterZeroFlow(this.MeterNumber); GenesisZeroFlow._GenesisZeroFlow.SetLoggingPathZeroFlowTest(this.MeterNumber, DataLogging.DefaultPath + "GenesisZeroflowTest_RawData_METER" + MeterIndex + "_" + time + ".txt"); GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Start logging at METER" + MeterIndex + "\n"); #endregion return Ok; } public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter, LogOn logOn) { logOn.KeepAuthentified(enable, sequenceOk, taskCompleted, ref counter); } private Boolean ReauthenticationProcedure(LogOn logOn, CancellationToken token, ref Boolean reAuthentication) { #region Definitions and initialization Boolean Ok = false; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); String DebugMessage = String.Empty; Boolean SequenceFailed = false; DialogResult askForActionsAuth = DialogResult.None; #endregion #region Optional reauthentification if (reAuthentication) { while ((askForActionsAuth == DialogResult.Retry) || (askForActionsAuth == DialogResult.None)) { if (askForActionsAuth == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication started at METER" + MeterIndex + "\n"); Ok = logOn.PerformLogOn(token, out DebugMessage); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = false; reAuthentication = false; askForActionsAuth = DialogResult.OK; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t " + DebugMessage + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); SequenceFailed = true; askForActionsAuth = MessageBox.Show("Reauthentication failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (askForActionsAuth) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = true; return SequenceFailed; //break; default: break; } } } } #endregion return SequenceFailed; } private DialogResult AskHowToProceedSequence(String sequenceName) { DialogResult AskForActions; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(sequenceName + " failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (AskForActions) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); break; default: break; } return AskForActions; } private Boolean PollNumberOfLines(Int32 path, CancellationToken token) { #region Definitions and initializations Boolean Ok = true; Boolean Error = false; Int32 LineCounterFollowing = 0; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); #endregion #region Check activity while (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterZeroFlow(this.MeterNumber)[path] < this.NumberOfLines - 1) { if (token.IsCancellationRequested) return false; LineCounterFollowing = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterZeroFlow(this.MeterNumber)[path]; GenesisZeroFlow.Display.StatusLabel("Wait until data aquisition has finished: " + LineCounterFollowing.ToString(this.GlobalCulture) + "/" + this.NumberOfLines.ToString(this.GlobalCulture)); Misc.WaitNSeconds(10); if ((LineCounterFollowing == GenesisZeroFlow._GenesisZeroFlow.GetLineCounterZeroFlow(this.MeterNumber)[path])) { Error = false; GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Data activity check failed at METER" + MeterIndex + "\n"); MessageBox.Show("DATA CHANNEL:\t\t Data activity check failed at METER" + MeterIndex + "\n keep going"); break; } } #endregion #region Result Ok = !Error; #endregion return Ok; } private Boolean CheckForBadData(Int32[] badData) { #region Definitions and initializations const Int32 BadDataLimit = ZeroOffsetTestConstants.BadDataLimit; Boolean Ok = true; #endregion #region Result for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if (badData[Path] >= BadDataLimit) Ok = false; } #endregion return Ok; } private Boolean CheckOffset(Double[] deltaTimeOfFlightAvg) { #region Definitions and initializations Boolean Ok = true; #endregion #region Result for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if (deltaTimeOfFlightAvg[Path] > this.OffsetLimit) Ok = false; if (deltaTimeOfFlightAvg[Path] < -this.OffsetLimit) Ok = false; } #endregion return Ok; } private Boolean CheckAmplitudes(Double[] AmplitudeValuesPos, Double[] AmplitudeValuesNeg) { #region Definitions and initializations Boolean Ok = true; Double AmplitudeLimitHigh = this.RangeHigh; Double AmplitudeLimitLow = this.RangeLow; #endregion #region Result for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { if (AmplitudeValuesPos[Path] > AmplitudeLimitHigh) Ok = false; if (AmplitudeValuesNeg[Path] < AmplitudeLimitLow) Ok = false; } #endregion return Ok; } private Boolean FinalizeTest(List[] amplitudeValuesPositive, List[] amplitudeValuesNegative, List[] deltaTimeOfFlightAverage, Int32[] badData, out Boolean reAuthentication, CancellationToken token) { #region Definitions and initializations Boolean Ok = false; String debugMessage = String.Empty; String meterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); UInt16 Trials = 0; Double[] amplitudeValuesMeanPositive = new Double[Constants.NumberOfPaths]; Double[] amplitudeValuesMeanNegative = new Double[Constants.NumberOfPaths]; Double[] DeltaTimeOfFlightAverage = new Double[Constants.NumberOfPaths]; Boolean[] dummy = new Boolean[Constants.NumberOfMeters]; for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { amplitudeValuesMeanPositive[Path] = 0; amplitudeValuesMeanNegative[Path] = 0; DeltaTimeOfFlightAverage[Path] = 0; } reAuthentication = false; #endregion #region Avoid CA1062 if ((amplitudeValuesPositive == null) || (amplitudeValuesNegative == null) || (badData == null) || (deltaTimeOfFlightAverage == null)) return false; #endregion #region Calculating mean values GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Calculating mean values at METER" + meterIndex + "\n"); GenesisZeroFlow.Display.ShowResultStatus("AmplitudeValuesMeanPos[PATH0] = " + amplitudeValuesPositive[Constants.PATH0].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("AmplitudeValuesMeanPos[PATH1] = " + amplitudeValuesPositive[Constants.PATH1].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("AmplitudeValuesMeanPos[PATH2] = " + amplitudeValuesPositive[Constants.PATH2].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("AmplitudeValuesMeanNeg[PATH0] = " + amplitudeValuesNegative[Constants.PATH0].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("AmplitudeValuesMeanNeg[PATH1] = " + amplitudeValuesNegative[Constants.PATH1].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("AmplitudeValuesMeanneg[PATH2] = " + amplitudeValuesNegative[Constants.PATH2].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("DeltaTimeOfFlightAvg[PATH0] = " + deltaTimeOfFlightAverage[Constants.PATH0].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("DeltaTimeOfFlightAvg[PATH1] = " + deltaTimeOfFlightAverage[Constants.PATH1].Count().ToString(this.GlobalCulture), dummy); GenesisZeroFlow.Display.ShowResultStatus("DeltaTimeOfFlightAvg[PATH2] = " + deltaTimeOfFlightAverage[Constants.PATH2].Count().ToString(this.GlobalCulture), dummy); for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) { amplitudeValuesMeanPositive[Path] = amplitudeValuesPositive[Path].Mean(); amplitudeValuesMeanNegative[Path] = amplitudeValuesNegative[Path].Mean(); DeltaTimeOfFlightAverage[Path] = deltaTimeOfFlightAverage[Path].Mean(); } #endregion #region Display values for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Bad data at METER" + meterIndex + ", PATH" + (Path + 1).ToString(this.GlobalCulture) + ": " + badData[Path].ToString(this.GlobalCulture) + "\n"); for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Average positive amplitude value at METER" + meterIndex + ", PATH" + (Path + 1).ToString(this.GlobalCulture) + ": " + Math.Round(amplitudeValuesMeanPositive[Path], 2).ToString(this.GlobalCulture) + "mV\n"); for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Average negative amplitude value at METER" + meterIndex + ", PATH" + (Path + 1).ToString(this.GlobalCulture) + ": " + Math.Round(amplitudeValuesMeanNegative[Path], 2).ToString(this.GlobalCulture) + "mV\n"); for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++) GenesisZeroFlow.Display.DebugMessage("DATA CHANNEL:\t\t Average time of flight value at METER" + meterIndex + ", PATH" + (Path + 1).ToString(this.GlobalCulture) + ": " + Math.Round(DeltaTimeOfFlightAverage[Path], 2).ToString(this.GlobalCulture) + "ps\n"); #endregion #region Check for bad data Boolean BadDataCheckOK = false; BadDataCheckOK = CheckForBadData(badData); if (BadDataCheckOK == true) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Bad data check successful at METER" + meterIndex + "\n"); else GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Bad data check failed at METER" + meterIndex + "\n"); #endregion #region Check amplitudes Boolean AmplitudeCheckOK = false; AmplitudeCheckOK = CheckAmplitudes(amplitudeValuesMeanPositive, amplitudeValuesMeanNegative); if (AmplitudeCheckOK == true) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Amplitude check successful at METER" + meterIndex + "\n"); else GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Amplitude check failed at METER" + meterIndex + "\n"); #endregion #region Check offsets Boolean OffsetCheckOK = false; OffsetCheckOK = CheckOffset(DeltaTimeOfFlightAverage); if (OffsetCheckOK == true) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Delta time of flight check successful at METER" + meterIndex + "\n"); else GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Delta time of flight check failed at METER" + meterIndex + "\n"); #endregion #region Abort if checks failed if ((BadDataCheckOK == false) || (AmplitudeCheckOK == false) || (OffsetCheckOK == false)) return false; #endregion #region Write new values to register #region Write to register PATH0 Trials = 0; this.OffsetValuePath0 = (Int32)Math.Round(4 * ((DeltaTimeOfFlightAverage[Constants.PATH0] / ZeroOffsetTestConstants.DeltaTofAverageFactor))); GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zero flow offset'-register PATH1 started at METER" + meterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfCheckingTrials.ToString(this.GlobalCulture) + "; Value = " + this.OffsetValuePath0.ToString(this.GlobalCulture) + "\n"); while ((Trials < this.NumberOfCheckingTrials) && (Ok == false) && (reAuthentication == false)) { #region Check if abort if (token.IsCancellationRequested) return false; #endregion #region Write to register Ok = SetZeroFlowOffsetRegister(this.OffsetValuePath0, Constants.PATH0, out debugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zero flow offset'-register successful at METER" + meterIndex + "; PATH1\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zero flow offset'-register failed at METER" + meterIndex + "; PATH1\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; #endregion } if (Ok == false) return false; #endregion #region Write to register PATH1 Trials = 0; Ok = false; this.OffsetValuePath1 = (Int32)Math.Round(4 * ((DeltaTimeOfFlightAverage[Constants.PATH1] / ZeroOffsetTestConstants.DeltaTofAverageFactor))); GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zero flow offset'-register PATH2 started at METER" + meterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfCheckingTrials.ToString(this.GlobalCulture) + "; Value = " + this.OffsetValuePath1.ToString(this.GlobalCulture) + "\n"); while ((Trials < this.NumberOfCheckingTrials) && (Ok == false) && (reAuthentication == false)) { #region Check if abort if (token.IsCancellationRequested) return false; #endregion #region Write to register Ok = SetZeroFlowOffsetRegister(this.OffsetValuePath1, Constants.PATH1, out debugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zero flow offset'-register successful at METER" + meterIndex + "; PATH2\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zero flow offset'-register failed at METER" + meterIndex + "; PATH2\n"); if (CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; #endregion } if (Ok == false) return false; #endregion #region Write to register PATH2 Trials = 0; Ok = false; this.OffsetValuePath2 = (Int32)Math.Round(4 * ((DeltaTimeOfFlightAverage[Constants.PATH2] / ZeroOffsetTestConstants.DeltaTofAverageFactor))); GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset'-register PATH3 started at METER" + meterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfCheckingTrials.ToString(this.GlobalCulture) + "; Value = " + this.OffsetValuePath2.ToString(this.GlobalCulture) + "\n"); while ((Trials < this.NumberOfCheckingTrials) && (Ok == false) && (reAuthentication == false)) { #region Check if abort if (token.IsCancellationRequested) return false; #endregion #region Write to register Ok = SetZeroFlowOffsetRegister(this.OffsetValuePath2, Constants.PATH2, out debugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset'-register successful at METER" + meterIndex + "; PATH3\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Zeroflow offset'-register failed at METER" + meterIndex + "; PATH3\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; #endregion } #endregion #endregion return Ok; } private Boolean SetZeroFlowOffsetRegister(Int32 value, Int32 path, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; // tbd Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Peak detection register #region Write register Payload = BitConverter.GetBytes(value); switch (path) { case Constants.PATH0: ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ZeroOffset1(), Payload, true); break; case Constants.PATH1: ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ZeroOffset2(), Payload, true); break; case Constants.PATH2: ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ZeroOffset3(), Payload, true); break; } #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion #endregion return Ok; } } public class TempCalibration { private CultureInfo GlobalCulture { get; set; } private UInt16 NumberOfTrials { get; set; } private UInt16 MeterNumber { get; set; } private Double RefTemperature { get; set; } private CmdInterface CommandInterface { get; set; } public void Initialize(CmdInterface commandInterface, UInt16 meterNumber, UInt16 numberOfTrials, Double refTemperature) { this.MeterNumber = meterNumber; this.NumberOfTrials = numberOfTrials; this.RefTemperature = refTemperature; this.GlobalCulture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); this.CommandInterface = commandInterface; } public void SetTemperature(Double temperature) { this.RefTemperature = temperature; } public void Meter(Boolean enable, ref Task task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, TempCalibration tempCal, ref Int32 nextDelayTime, CancellationToken token) { #region Definitions and initializations Int32 DelayTime = 0; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); const Int32 DeltaDelay = 30; DialogResult AskForActions = DialogResult.None; Boolean ReAuthentication = false; var _sequenceFailed = sequenceFailed; var _logOn = logOn; var _tempCal = tempCal; Int32 temp = DelayTime; Boolean Ok = false; #endregion #region Avoid CA1062 if (task == null) return; #endregion #region Everything else if ((enable) && (task.Status != TaskStatus.Running) && (!task.IsCompleted)) { DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); task = Task.Run(() => { while ((AskForActions == DialogResult.Retry) || (AskForActions == DialogResult.None) && (!token.IsCancellationRequested)) { #region Abort if (!token.IsCancellationRequested) GenesisZeroFlow.Display.AbortButtonEnabled(true); #endregion #region Optional reauthentication _sequenceFailed = ReauthenticationProcedure(_logOn, token, ref ReAuthentication); #endregion #region Testprocedure if (AskForActions == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t TEMPERATURE CALIBRATION started at METER" + MeterIndex + "\n"); Ok = _tempCal.PerformTest(_tempCal, out ReAuthentication, token); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t TEMPERATURE CALIBRATION aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; // sequence failed } if (Ok == true) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t TEMPERATURE CALIBRATION successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); _sequenceFailed = false; AskForActions = DialogResult.OK; } else { if (ReAuthentication == false) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t TEMPERATURE CALIBRATION failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = this.AskHowToProceedSequence("TEMPERATURE CALIBRATION"); } _sequenceFailed = true; } #endregion } return _sequenceFailed; }, token); } /* else { DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); task = Task.Run(() => { }, token); }*/ #endregion } private Boolean PerformTest(TempCalibration tempCal, out Boolean reAuthentication, CancellationToken token) { ClearData(); #region Definitions and initializations UInt16 Trials = 0; Boolean Ok = false; String DebugMessage = String.Empty; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); reAuthentication = false; #endregion #region Avoid warning CA1062 if (tempCal == null) return Ok; Int32 TemperatureToRegister = (Int32)(tempCal.RefTemperature * 4096); #endregion #region Set temperature calibration register GenesisZeroFlow.Display.StatusLabel("Wait until register write has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing 0x" + TemperatureToRegister.ToString("X", this.GlobalCulture) + " to Temperature calibration'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetTofTempCalibrate(TemperatureToRegister, out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing 0x" + TemperatureToRegister.ToString("X", this.GlobalCulture) + " to 'Temperature calibration'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing 0x" + TemperatureToRegister.ToString("X", this.GlobalCulture) + " to 'Temperature calibration'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (!Ok) return false; #endregion #region Wait for some seconds const UInt16 WaitingTime = 5; for (UInt16 i = 0; i < WaitingTime; i++) { GenesisZeroFlow.Display.StatusLabel("Wait " + (WaitingTime - i).ToString(this.GlobalCulture) + " seconds"); if (token.IsCancellationRequested) return false; Misc.WaitNSeconds(1); } #endregion #region Check temperature Ok = CheckTemperature(tempCal.RefTemperature, out DebugMessage); if (Ok == true) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Temperature check OK at METER" + MeterIndex + "\n"); else GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Temperature check failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Temperatures at METER" + MeterIndex + ": " + DebugMessage); #endregion #region Get 'TOF offset1' register GenesisZeroFlow.Display.StatusLabel("Wait until register read has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetTofOffset1(out DebugMessage); if (Ok == true) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset1'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset1'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Get 'TOF offset2' register GenesisZeroFlow.Display.StatusLabel("Wait until register read has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetTofOffset2(out DebugMessage); if (Ok == true) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset2'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return false; #endregion #region Get 'TOF offset3' register GenesisZeroFlow.Display.StatusLabel("Wait until register read has finished"); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetTofOffset3(out DebugMessage); if (Ok) { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset3'-register successful at METER" + MeterIndex + "\n"); reAuthentication = false; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'TOF offset3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (!Ok) return false; #endregion #region Write logdata to file /* System.DateTime Timestamp= new System.DateTime(); Timestamp = System.DateTime.Now; if (GenesisZeroFlow._GenesisZeroFlow.cB_TempCalFiles.Checked) { String LoggingText = "GENESISFLOW_ZeroOffset\t0x"+ "GENESISFLOW_ToFTempOffset\t0x" + GenesisZeroFlow._GenesisZeroFlow.ToFTempOffset[MeterNumber][Constants.PATH0].ToString("X4") + "\t0x" + GenesisZeroFlow._GenesisZeroFlow.ToFTempOffset[MeterNumber][Constants.PATH1].ToString("X4") + "\t0x" + GenesisZeroFlow._GenesisZeroFlow.ToFTempOffset[MeterNumber][Constants.PATH2].ToString("X4") + "\n" + "GENESISFLOW_CalFactor\t0x"; Logging.WriteToFile(LoggingText, @"..\GenesisZeroFlowTest_ToFTempOffset_METER" + MeterIndex + ".txt"); } */ ClearData(); #endregion return Ok; } private DialogResult AskHowToProceedSequence(String sequenceName) { DialogResult AskForActions; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(sequenceName + " failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (AskForActions) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); break; default: break; } return AskForActions; } public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter, LogOn logOn) { logOn.KeepAuthentified(enable, sequenceOk, taskCompleted, ref counter); } private Boolean ReauthenticationProcedure(LogOn logOn, CancellationToken token, ref Boolean reAuthentication) { #region Definitions and initialization Boolean Ok = false; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); String DebugMessage = String.Empty; Boolean SequenceFailed = false; DialogResult askForActionsAuth = DialogResult.None; #endregion #region Optional reauthentification if (reAuthentication) { while ((askForActionsAuth == DialogResult.Retry) || (askForActionsAuth == DialogResult.None)) { if (askForActionsAuth == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication started at METER" + MeterIndex + "\n"); Ok = logOn.PerformLogOn(token, out DebugMessage); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = false; reAuthentication = false; askForActionsAuth = DialogResult.OK; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t " + DebugMessage + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); SequenceFailed = true; askForActionsAuth = MessageBox.Show("Reauthentication failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (askForActionsAuth) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = true; return SequenceFailed; //break; default: break; } } } } #endregion return SequenceFailed; } private Boolean SetTofTempCalibrate(Int32 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register PATH0 Payload = BitConverter.GetBytes(value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.ToFTempCalibrate(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean GetTofOffset1(out String debugMessage) { #region Definitions and initialisations Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Read register ErrCode = this.CommandInterface.ReadRegister(GP30Registers.ToFTempOffset1()); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.ReadRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean GetTofOffset2(out String debugMessage) { #region Definitions and initialisations Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Read register ErrCode = this.CommandInterface.ReadRegister(GP30Registers.ToFTempOffset2()); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.ReadRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean GetTofOffset3(out String debugMessage) { #region Definitions and initialisations Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Read register ErrCode = this.CommandInterface.ReadRegister(GP30Registers.ToFTempOffset3()); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.ReadRegister); #endregion #region Debug message debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean CheckTemperature(Double refTemperature, out String debugMessage) { #region Definitions and initializations const Double AllowedDeviation = 0.5; Double[] MeasTemperature = new Double[Constants.NumberOfPaths]; debugMessage = String.Empty; String Meterindex = (MeterNumber + 1).ToString(this.GlobalCulture); Boolean TemperatureOk = true; #endregion MeasTemperature[Constants.PATH0] = ((Double)GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[Constants.PATH0][MeterNumber].Temperature / (Math.Pow(2, GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[Constants.PATH0][MeterNumber].TemperatureScale))); MeasTemperature[Constants.PATH1] = ((Double)GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[Constants.PATH1][MeterNumber].Temperature / (Math.Pow(2, GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[Constants.PATH1][MeterNumber].TemperatureScale))); MeasTemperature[Constants.PATH2] = ((Double)GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[Constants.PATH2][MeterNumber].Temperature / (Math.Pow(2, GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[Constants.PATH2][MeterNumber].TemperatureScale))); if (Math.Abs(refTemperature - MeasTemperature[Constants.PATH0]) > AllowedDeviation) TemperatureOk = false; if (Math.Abs(refTemperature - MeasTemperature[Constants.PATH1]) > AllowedDeviation) TemperatureOk = false; if (Math.Abs(refTemperature - MeasTemperature[Constants.PATH2]) > AllowedDeviation) TemperatureOk = false; debugMessage = "ref. temperature = " + refTemperature.ToString(this.GlobalCulture) + "°C ; meas. temperature PATH" + Meterindex + " = " + Math.Round(MeasTemperature[Constants.PATH0], 2).ToString(this.GlobalCulture) + "°C; PATH2 = " + Math.Round(MeasTemperature[Constants.PATH1], 2).ToString(this.GlobalCulture) + "°C; PATH3 = " + Math.Round(MeasTemperature[Constants.PATH2], 2).ToString(this.GlobalCulture) + "°C\n"; return TemperatureOk; } private void ClearData() { GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Constants.PATH0); GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Constants.PATH1); GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Constants.PATH2); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Constants.PATH0); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Constants.PATH1); GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Constants.PATH2); GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH0, 0); GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH1, 0); GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH2, 0); } } public class Completion { private CultureInfo GlobalCulture { get; set; } private UInt16 MeterNumber { get; set; } private UInt16 NumberOfTrials { get; set; } private Int16 LedMode { get; set; } private Int16 StoreCalibration { get; set; } private SerialPort SerialPort { get; set; } private CmdInterface CommandInterface { get; set; } public void Initialize(CmdInterface commandInterface, UInt16 meterNumber, UInt16 numberOfTrials, Int16 ledMode, Int16 storeCalibration) { this.MeterNumber = meterNumber; this.NumberOfTrials = numberOfTrials; this.LedMode = ledMode; this.StoreCalibration = storeCalibration; this.GlobalCulture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture(); this.CommandInterface = commandInterface; } private Boolean PerformCompletion(CancellationToken token, out Boolean reAuthentication) { #region Definitions and initializations List[] DeltaTimeOfFlight = new List[Constants.NumberOfPaths]; for (Int32 i = 0; i < Constants.NumberOfPaths; i++) DeltaTimeOfFlight[i] = new List(); Int32 Trials = 0; Boolean Ok = false; String DebugMessage = String.Empty; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); reAuthentication = false; #endregion #region Completion sequence GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Start COMPLETION at METER" + MeterIndex + "\n"); #region Write samplerate register Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.SetSampleRateRegister(0, out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Write led mode register Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetLedMode(this.LedMode, out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Write store completion register Misc.WaitNSeconds(1); Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Store calibration'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.SetStoreCalibration(out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Store calibration'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Writing to 'Store calibration'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } #endregion #endregion #region Get registers GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Read registers at METER" + MeterIndex + "\n"); #region Read zero offset register PATH0 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.GetRegister(GP30Registers.ZeroOffset1(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset1'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset1'-register failed at METER" + MeterIndex + "\n"); if (CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read zero offset register PATH1 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n"); Ok = this.GetRegister(GP30Registers.ZeroOffset2(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset2'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read zero offset register PATH2 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.ZeroOffset3(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset3'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read first hit percentage register PATH0 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath0(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage1'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage1'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read first hit percentage register PATH1 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath1(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage2'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read first hit percentage register PATH2 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath2(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage3'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read tof temp offset register PATH0 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.ToFTempOffset1(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset1'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset1'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read tof temp offset register PATH1 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.ToFTempOffset2(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset2'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read tof temp offset register PATH2 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.ToFTempOffset3(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset3'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read calfactor register PATH0 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.CalFactor1(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor1'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor1'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read calfactor register PATH1 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.CalFactor2(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor2'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor2'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } if (Ok == false) return Ok; #endregion #region Read calfactor register PATH2 Trials = 0; Ok = false; while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false)) { if (token.IsCancellationRequested) return false; GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n"); Ok = this.GetRegister(GP30Registers.CalFactor3(), out DebugMessage); if (Ok) GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor3'-register successful at METER" + MeterIndex + "\n"); else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor3'-register failed at METER" + MeterIndex + "\n"); if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied) reAuthentication = true; } Trials++; } System.Diagnostics.Debug.WriteLine(Ok.ToString()); if (Ok == false) { System.Diagnostics.Debug.WriteLine("Returning"); return Ok; } System.Diagnostics.Debug.WriteLine("Write data to file"); #endregion #region Write to file DateTime Timestamp = new DateTime(); Timestamp = DateTime.Now; String TimestampFileName = Timestamp.ToString(Formats.LogFileDateTimeString, this.GlobalCulture); String LoggingText = "GENESISFLOW_ZeroOffset;0x" + GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" + "GENESISFLOW_FirstHitPercent;0x" + GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" + "GENESISFLOW_ToFTempOffset;0x" + GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" + "GENESISFLOW_Calfactor;0x" + GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" + GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n"; Logging.WriteToFile(LoggingText, @"..\GenesisZeroflowTest_Registers_METER" + MeterIndex + "_" + TimestampFileName + ".csv"); ClearData(); #endregion #endregion return Ok; } public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter, LogOn logOn) { logOn.KeepAuthentified(enable, sequenceOk, taskCompleted, ref counter); } private Boolean ReauthenticationProcedure(LogOn logOn, CancellationToken token, ref Boolean reAuthentication) { #region Definitions and initialization Boolean Ok = false; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); String DebugMessage = String.Empty; Boolean SequenceFailed = false; DialogResult askForActionsAuth = DialogResult.None; #endregion #region Optional reauthentification if (reAuthentication) { while ((askForActionsAuth == DialogResult.Retry) || (askForActionsAuth == DialogResult.None)) { if (askForActionsAuth == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication started at METER" + MeterIndex + "\n"); Ok = logOn.PerformLogOn(token, out DebugMessage); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication aborted at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.AbortButtonEnabled(false); return true; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = false; reAuthentication = false; askForActionsAuth = DialogResult.OK; } else { GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t " + DebugMessage + "\n"); GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); GenesisZeroFlow.Display.AbortButtonEnabled(false); SequenceFailed = true; askForActionsAuth = MessageBox.Show("Reauthentication failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (askForActionsAuth) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t Reauthentication canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); SequenceFailed = true; return SequenceFailed; //break; default: break; } } } } #endregion return SequenceFailed; } private DialogResult AskHowToProceedSequence(String sequenceName) { DialogResult AskForActions; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); GenesisZeroFlow.Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(sequenceName + " failed at METER" + MeterIndex, "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question); switch (AskForActions) { case DialogResult.Retry: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " restarted at METER" + MeterIndex + "\n"); break; case DialogResult.Cancel: GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t " + sequenceName + " canceled at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); break; default: break; } GenesisZeroFlow.Display.AbortButtonEnabled(true); return AskForActions; } public void Meter(Boolean enable, ref Task task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, Completion completion, ref Int32 nextDelayTime, CancellationToken token) { #region Avoid CA1062 if (task == null) return; #endregion #region Definitions and initializations Int32 DelayTime = 0; String MeterIndex = (this.MeterNumber + 1).ToString(this.GlobalCulture); const Int32 DeltaDelay = 5; DialogResult AskForActions = DialogResult.None; Boolean ReAuthentication = false; var _sequenceFailed = sequenceFailed; var _logOn = logOn; var _completion = completion; Int32 temp = DelayTime; Boolean Ok = false; #endregion #region Everything else if ((enable) && (task.Status != TaskStatus.Running) && (!task.IsCompleted)) { DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); #region Testprocedure DelayTime = nextDelayTime; nextDelayTime = nextDelayTime + DeltaDelay; taskStarted = true; Misc.WaitNSeconds(temp); task = Task.Run(() => { while ((AskForActions == DialogResult.Retry) || (AskForActions == DialogResult.None)) { #region Cancellation token if (AskForActions == DialogResult.None) GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t COMPLETION started at METER" + MeterIndex + "\n"); #endregion #region Optional re-authentication _sequenceFailed = ReauthenticationProcedure(_logOn, token, ref ReAuthentication); #endregion #region Sequence Ok = _completion.PerformCompletion(token, out ReAuthentication); if (token.IsCancellationRequested) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t COMPLETION aborted at METER" + MeterIndex + "\n"); return false; } if (Ok) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t COMPLETION successful at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); _sequenceFailed = false; AskForActions = DialogResult.OK; } else { if (ReAuthentication == false) { GenesisZeroFlow.Display.DebugMessage("APPLICATION:\t\t COMPLETION failed at METER" + MeterIndex + "\n"); GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line); AskForActions = AskHowToProceedSequence("COMPLETION"); } _sequenceFailed = true; } #endregion } return _sequenceFailed; }); #endregion } #endregion } private Boolean SetSampleRateRegister(Int16 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Peak detection register #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = this.CommandInterface.WriteRegister(GP30Registers.Samplerate(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion #endregion return Ok; } private Boolean SetLedMode(Int16 value, out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; // tbd Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Peak detection register #region Write register Payload = BitConverter.GetBytes((Int32)value); ErrCode = CommandInterface.WriteRegister(GP30Registers.LedMode(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion #endregion return Ok; } private Boolean SetStoreCalibration(out String debugMessage) { #region Definitions and initialisations Byte[] Payload = new Byte[4] { 0, 0, 0, 0 }; // tbd Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Write register Payload[0] = 1; ErrCode = CommandInterface.WriteRegister(GP30Registers.StoreCalibration(), Payload, true); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = CommandInterface.RXProcessor(GP30RequestType.WriteRegister); #endregion #region Debug message debugMessage = CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private Boolean GetRegister(Byte[] register, out String debugMessage) { #region Definitions and initialisations Boolean Ok = false; Int32 ErrCode = GP30LowLevelErrors.NoError; #endregion #region Read register ErrCode = CommandInterface.ReadRegister(register); #endregion #region Wait for answer if (ErrCode == GP30LowLevelErrors.NoError) ErrCode = CommandInterface.RXProcessor(GP30RequestType.ReadRegister); #endregion #region Debug message debugMessage = CommandInterface.LowLevelMessages(ErrCode, out Ok); #endregion return Ok; } private void ClearData() { GenesisZeroFlow._GenesisZeroFlow.SetZeroFlowOffset(this.MeterNumber, Constants.PATH0, 0); GenesisZeroFlow._GenesisZeroFlow.SetZeroFlowOffset(this.MeterNumber, Constants.PATH1, 0); GenesisZeroFlow._GenesisZeroFlow.SetZeroFlowOffset(this.MeterNumber, Constants.PATH2, 0); GenesisZeroFlow._GenesisZeroFlow.SetFirstHitPercentage(this.MeterNumber, Constants.PATH0, 0); GenesisZeroFlow._GenesisZeroFlow.SetFirstHitPercentage(this.MeterNumber, Constants.PATH1, 0); GenesisZeroFlow._GenesisZeroFlow.SetFirstHitPercentage(this.MeterNumber, Constants.PATH2, 0); GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH0, 0); GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH1, 0); GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH2, 0); GenesisZeroFlow._GenesisZeroFlow.SetCalFactor(this.MeterNumber, Constants.PATH0, 0); GenesisZeroFlow._GenesisZeroFlow.SetCalFactor(this.MeterNumber, Constants.PATH1, 0); GenesisZeroFlow._GenesisZeroFlow.SetCalFactor(this.MeterNumber, Constants.PATH2, 0); } } #endregion }