6784 lines
361 KiB
C#
6784 lines
361 KiB
C#
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<Boolean> Task1 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task2 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task3 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task4 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task5 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task6 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task7 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task8 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task9 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> Task1 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task2 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task3 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task4 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task5 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task6 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task7 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task8 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task9 = new Task<Boolean>(() => { return true; });
|
|
Task<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> Task1 = new Task<Boolean>(() => { 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<Boolean> Task2 = new Task<Boolean>(() => { 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<Boolean> Task3 = new Task<Boolean>(() => { 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<Boolean> Task4 = new Task<Boolean>(() => { 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<Boolean> Task5 = new Task<Boolean>(() => { 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<Boolean> Task6 = new Task<Boolean>(() => { 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<Boolean> Task7 = new Task<Boolean>(() => { 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<Boolean> Task8 = new Task<Boolean>(() => { 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<Boolean> Task9 = new Task<Boolean>(() => { 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<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> Task1 = new Task<Boolean>(() => { 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<Boolean> Task2 = new Task<Boolean>(() => { 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<Boolean> Task3 = new Task<Boolean>(() => { 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<Boolean> Task4 = new Task<Boolean>(() => { 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<Boolean> Task5 = new Task<Boolean>(() => { 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<Boolean> Task6 = new Task<Boolean>(() => { 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<Boolean> Task7 = new Task<Boolean>(() => { 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<Boolean> Task8 = new Task<Boolean>(() => { 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<Boolean> Task9 = new Task<Boolean>(() => { 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<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> Task1 = new Task<Boolean>(() => { 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<Boolean> Task2 = new Task<Boolean>(() => { 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<Boolean> Task3 = new Task<Boolean>(() => { 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<Boolean> Task4 = new Task<Boolean>(() => { 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<Boolean> Task5 = new Task<Boolean>(() => { 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<Boolean> Task6 = new Task<Boolean>(() => { 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<Boolean> Task7 = new Task<Boolean>(() => { 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<Boolean> Task8 = new Task<Boolean>(() => { 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<Boolean> Task9 = new Task<Boolean>(() => { 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<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> Task1 = new Task<Boolean>(() => { 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<Boolean> Task2 = new Task<Boolean>(() => { 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<Boolean> Task3 = new Task<Boolean>(() => { 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<Boolean> Task4 = new Task<Boolean>(() => { 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<Boolean> Task5 = new Task<Boolean>(() => { 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<Boolean> Task6 = new Task<Boolean>(() => { 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<Boolean> Task7 = new Task<Boolean>(() => { 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<Boolean> Task8 = new Task<Boolean>(() => { 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<Boolean> Task9 = new Task<Boolean>(() => { 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<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> Task1 = new Task<Boolean>(() => { 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<Boolean> Task2 = new Task<Boolean>(() => { 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<Boolean> Task3 = new Task<Boolean>(() => { 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<Boolean> Task4 = new Task<Boolean>(() => { 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<Boolean> Task5 = new Task<Boolean>(() => { 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<Boolean> Task6 = new Task<Boolean>(() => { 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<Boolean> Task7 = new Task<Boolean>(() => { 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<Boolean> Task8 = new Task<Boolean>(() => { 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<Boolean> Task9 = new Task<Boolean>(() => { 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<Boolean> Task10 = new Task<Boolean>(() => { 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<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> 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<Boolean> 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<Boolean> 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<Boolean> 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<Double>[] TofAvgMeanTotal = new List<Double>[Constants.NumberOfPaths];
|
|
Boolean Ok = false;
|
|
|
|
List<Double>[] AmplitudeValuesPos1 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesPos2 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesPos3 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesPos4 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesNeg1 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesNeg2 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesNeg3 = new List<Double>[Constants.NumberOfPaths];
|
|
List<Double>[] AmplitudeValuesNeg4 = new List<Double>[Constants.NumberOfPaths];
|
|
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
AmplitudeValuesPos1[Path] = new List<Double>();
|
|
AmplitudeValuesPos2[Path] = new List<Double>();
|
|
AmplitudeValuesPos3[Path] = new List<Double>();
|
|
AmplitudeValuesPos4[Path] = new List<Double>();
|
|
AmplitudeValuesNeg1[Path] = new List<Double>();
|
|
AmplitudeValuesNeg2[Path] = new List<Double>();
|
|
AmplitudeValuesNeg3[Path] = new List<Double>();
|
|
AmplitudeValuesNeg4[Path] = new List<Double>();
|
|
TofAvgMeanTotal[Path] = new List<Double>();
|
|
}
|
|
|
|
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<Double> TofAvg, out Double left, out Double right)
|
|
{
|
|
List<Double> ValuesLeft = new List<Double>();
|
|
List<Double> ValuesRight = new List<Double>();
|
|
|
|
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<Double> CalculateNearestDistanceLeft(List<Double> TofAvg, out Double left)
|
|
{
|
|
List<Double> Distance = new List<Double>();
|
|
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<Double> CalculateNearestDistanceRight(List<Double> TofAvg, out Double right)
|
|
{
|
|
List<Double> Distance = new List<Double>();
|
|
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<Boolean> 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<Double>[] amplitudeValuesPositive, List<Double>[] amplitudeValuesNegative, List<Double>[] 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<Boolean> 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<Double>[] DeltaTimeOfFlight = new List<Double>[Constants.NumberOfPaths];
|
|
for (Int32 i = 0; i < Constants.NumberOfPaths; i++)
|
|
DeltaTimeOfFlight[i] = new List<Double>();
|
|
|
|
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<Boolean> 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
|
|
}
|