782 lines
38 KiB
C#
782 lines
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using GenesisDisplayTool;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
public static class EmptyPipeCheckSequences
|
|
{
|
|
//public static Boolean[] Total(Boolean[] enable, out Boolean aborted)
|
|
//{
|
|
// #region Definitions and initializations
|
|
// const UInt16 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 = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
// SequenceFailed[Meter] = true;
|
|
// return SequenceFailed;
|
|
// }
|
|
// #endregion
|
|
|
|
// for (UInt16 Meter = Constants.Meter1; 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 = Constants.Meter1; 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] = TaskOperations.WaitFor(enable[Constants.Meter1], Task1);
|
|
// TaskCompleted[Constants.Meter2] = TaskOperations.WaitFor(enable[Constants.Meter2], Task2);
|
|
// TaskCompleted[Constants.Meter3] = TaskOperations.WaitFor(enable[Constants.Meter3], Task3);
|
|
// TaskCompleted[Constants.Meter4] = TaskOperations.WaitFor(enable[Constants.Meter4], Task4);
|
|
// TaskCompleted[Constants.Meter5] = TaskOperations.WaitFor(enable[Constants.Meter5], Task5);
|
|
// TaskCompleted[Constants.Meter6] = TaskOperations.WaitFor(enable[Constants.Meter6], Task6);
|
|
// TaskCompleted[Constants.Meter7] = TaskOperations.WaitFor(enable[Constants.Meter7], Task7);
|
|
// TaskCompleted[Constants.Meter8] = TaskOperations.WaitFor(enable[Constants.Meter8], Task8);
|
|
// TaskCompleted[Constants.Meter9] = TaskOperations.WaitFor(enable[Constants.Meter9], Task9);
|
|
// TaskCompleted[Constants.Meter10] = TaskOperations.WaitFor(enable[Constants.Meter10], Task10);
|
|
// Misc.WaitNSeconds(1);
|
|
|
|
// SequenceFailed = TaskOperations.GetResultTotal(enable, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10);
|
|
// for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
// SequenceOk[Meter] = !SequenceFailed[Meter];
|
|
// GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, enable);
|
|
// }
|
|
// GenesisZeroFlow.Display.ShowResultStatus("Sequence OK (while loop) = ", SequenceOk);
|
|
// SequenceFailed = TaskOperations.GetResultTotal(enable, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10);
|
|
// for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
// SequenceOk[Meter] = !SequenceFailed[Meter];
|
|
// GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, enable);
|
|
// // 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
|
|
// TaskOperations.CheckAndDispose(ref Task1);
|
|
// TaskOperations.CheckAndDispose(ref Task2);
|
|
// TaskOperations.CheckAndDispose(ref Task3);
|
|
// TaskOperations.CheckAndDispose(ref Task4);
|
|
// TaskOperations.CheckAndDispose(ref Task5);
|
|
// TaskOperations.CheckAndDispose(ref Task6);
|
|
// TaskOperations.CheckAndDispose(ref Task7);
|
|
// TaskOperations.CheckAndDispose(ref Task8);
|
|
// TaskOperations.CheckAndDispose(ref Task9);
|
|
// TaskOperations.CheckAndDispose(ref Task10);
|
|
// #endregion
|
|
// #region Clear data
|
|
// for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
// GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
|
|
// #endregion
|
|
// }
|
|
// return SequenceFailed;
|
|
//}
|
|
public static Boolean[] Total(Boolean[] allEnable, out Boolean aborted, MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
const UInt16 WaitingTime = 60;
|
|
Boolean[] Aborted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
|
|
MeterSequenceFailed = ArrayInit.Meter(false);
|
|
Boolean[] ThermoAborted = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoSequenceFailed = ArrayInit.Thermo(false);
|
|
Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
|
|
Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);
|
|
aborted = false;
|
|
|
|
#region avoid CA1062
|
|
if (allEnable == null)
|
|
{
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceFailed[Meter] = true;
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
ThermoSequenceFailed[Thermo] = true;
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
}
|
|
#endregion
|
|
|
|
List<EmptyPipeCheck> EmptyPipeChecks = new List<EmptyPipeCheck>();
|
|
List<EmptyPipeCheck> ThermoEmptyPipeChecks = new List<EmptyPipeCheck>();
|
|
|
|
#region METER
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));
|
|
|
|
if (currentMeter != null)
|
|
EmptyPipeChecks.Add(new EmptyPipeCheck(currentMeter, Meter, culture));
|
|
else
|
|
EmptyPipeChecks.Add(new EmptyPipeCheck(Meter, culture));
|
|
}
|
|
#endregion
|
|
#region THERMOMETER
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
{
|
|
var currentMeter = thermoMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Thermo + 11));
|
|
|
|
if (currentMeter != null)
|
|
ThermoEmptyPipeChecks.Add(new EmptyPipeCheck(currentMeter, Thermo, culture));
|
|
else
|
|
ThermoEmptyPipeChecks.Add(new EmptyPipeCheck(Thermo, culture));
|
|
}
|
|
#endregion
|
|
|
|
foreach (var check in EmptyPipeChecks)
|
|
{
|
|
check.AddTask(new Task<Boolean>(() => { return true; }));
|
|
check.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[check.MeterNumber], Constants.Meter, WaitingTime);
|
|
}
|
|
|
|
foreach (var tempcheck in ThermoEmptyPipeChecks)
|
|
{
|
|
tempcheck.AddTask(new Task<Boolean>(() => { return true; }));
|
|
tempcheck.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[tempcheck.MeterNumber], Constants.Thermo, WaitingTime);
|
|
}
|
|
#endregion
|
|
|
|
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
|
|
{
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
|
|
foreach (var metercheck in EmptyPipeChecks)
|
|
{
|
|
if (metercheck.CurrentMeter != null && MeterEnable[metercheck.CurrentMeter.Slot - 1])
|
|
{
|
|
metercheck.MyTask = Task.Run(() =>
|
|
{
|
|
MeterSequenceFailed[metercheck.CurrentMeter.Slot - 1] = metercheck.PerformTest(out Aborted[metercheck.CurrentMeter.Slot - 1], token);
|
|
return MeterSequenceFailed[metercheck.CurrentMeter.Slot - 1];
|
|
});
|
|
}
|
|
}
|
|
foreach (var tempcheck in ThermoEmptyPipeChecks)
|
|
{
|
|
if (tempcheck.CurrentMeter != null && ThermoEnable[tempcheck.CurrentMeter.Slot - 11])
|
|
{
|
|
tempcheck.MyTask = Task.Run(() =>
|
|
{
|
|
ThermoSequenceFailed[tempcheck.CurrentMeter.Slot - 11] = tempcheck.PerformTest(out ThermoAborted[tempcheck.CurrentMeter.Slot - 11], token);
|
|
return ThermoSequenceFailed[tempcheck.CurrentMeter.Slot - 11];
|
|
});
|
|
}
|
|
}
|
|
|
|
#region Wait for tasks
|
|
Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
|
|
MeterSequenceOk = ArrayInit.Meter(false);
|
|
Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoSequenceOk = ArrayInit.Thermo(false);
|
|
|
|
while (!CheckArray(allEnable, MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
cancellationTokenSource.Cancel();
|
|
aborted = true;
|
|
}
|
|
foreach (var waitTask in EmptyPipeChecks)
|
|
MeterTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(MeterEnable[waitTask.MeterNumber], waitTask.MyTask);
|
|
foreach (var waitTask in ThermoEmptyPipeChecks)
|
|
ThermoTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(ThermoEnable[waitTask.MeterNumber], waitTask.MyTask);
|
|
|
|
Misc.WaitNSeconds(1);
|
|
|
|
foreach (var waitTask in EmptyPipeChecks)
|
|
MeterTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(MeterEnable[waitTask.MeterNumber], waitTask.MyTask);
|
|
foreach (var waitTask in ThermoEmptyPipeChecks)
|
|
ThermoTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(ThermoEnable[waitTask.MeterNumber], waitTask.MyTask);
|
|
|
|
foreach (var ResultTask in EmptyPipeChecks)
|
|
MeterSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(MeterEnable[ResultTask.MeterNumber], ResultTask.MyTask);
|
|
foreach (var ResultTask in ThermoEmptyPipeChecks)
|
|
ThermoSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(ThermoEnable[ResultTask.MeterNumber], ResultTask.MyTask);
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
ThermoSequenceOk[Thermo] = !ThermoSequenceFailed[Thermo];
|
|
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterEnable);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoEnable);
|
|
}
|
|
|
|
foreach (var ResultTask in EmptyPipeChecks)
|
|
MeterSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(MeterEnable[ResultTask.MeterNumber], ResultTask.MyTask);
|
|
foreach (var ResultTask in ThermoEmptyPipeChecks)
|
|
ThermoSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(ThermoEnable[ResultTask.MeterNumber], ResultTask.MyTask);
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
ThermoSequenceOk[Thermo] = !ThermoSequenceFailed[Thermo];
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterEnable);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoEnable);
|
|
#endregion
|
|
#region Destroy tasks
|
|
foreach (var TaskToDispose in EmptyPipeChecks)
|
|
TaskOperations.CheckAndDispose(ref TaskToDispose.MyTask);
|
|
foreach (var TaskToDispose in ThermoEmptyPipeChecks)
|
|
TaskOperations.CheckAndDispose(ref TaskToDispose.MyTask);
|
|
#endregion
|
|
#region Clear data
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
|
|
#endregion
|
|
}
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
}
|
|
public static Boolean TotalTempCal(Boolean enable, MeterBatch globalMeterBatch, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
const UInt16 WaitingTime = 60;
|
|
Boolean TaskCompleted = false;
|
|
Boolean SequenceFailed = false;
|
|
List<EmptyPipeCheck> EmptyPipeChecks = new List<EmptyPipeCheck>();
|
|
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Constants.Meter1 + 1));
|
|
if (currentMeter != null)
|
|
EmptyPipeChecks.Add(new EmptyPipeCheck(currentMeter, Constants.Meter1, culture));
|
|
else
|
|
EmptyPipeChecks.Add(new EmptyPipeCheck(Constants.Meter1, culture));
|
|
|
|
foreach (var check in EmptyPipeChecks)
|
|
{
|
|
check.AddTask(new Task<Boolean>(() => { return true; }));
|
|
check.Initialize(String.Empty, Constants.Meter, WaitingTime);
|
|
}
|
|
#endregion
|
|
|
|
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
|
|
{
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
foreach (var check in EmptyPipeChecks)
|
|
{
|
|
if (check.CurrentMeter != null && enable)
|
|
{
|
|
check.MyTask = Task.Run(() =>
|
|
{
|
|
SequenceFailed = check.PerformTestTempCal();
|
|
return SequenceFailed;
|
|
});
|
|
}
|
|
}
|
|
#region Wait for tasks
|
|
Boolean SequenceOk = false;
|
|
|
|
while (!Check(enable, TaskCompleted))
|
|
{
|
|
|
|
foreach (var waitTask in EmptyPipeChecks)
|
|
TaskCompleted = TaskOperations.WaitFor(enable, waitTask.MyTask);
|
|
|
|
Misc.WaitNSeconds(1);
|
|
|
|
foreach (var waitTask in EmptyPipeChecks)
|
|
{
|
|
if (waitTask.CurrentMeter != null)
|
|
{
|
|
//waitTask.CurrentMeter.StartRecordData();
|
|
}
|
|
TaskCompleted = TaskOperations.WaitFor(enable, waitTask.MyTask);
|
|
}
|
|
|
|
|
|
foreach (var ResultTask in EmptyPipeChecks)
|
|
SequenceFailed = TaskOperations.GetResult(enable, ResultTask.MyTask);
|
|
|
|
SequenceOk = !SequenceFailed;
|
|
frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, enable);
|
|
}
|
|
|
|
foreach (var ResultTask in EmptyPipeChecks)
|
|
SequenceFailed = TaskOperations.GetResult(enable, ResultTask.MyTask);
|
|
|
|
SequenceOk = !SequenceFailed;
|
|
frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, enable);
|
|
#endregion
|
|
#region Destroy tasks
|
|
foreach (var TaskToDispose in EmptyPipeChecks)
|
|
TaskOperations.CheckAndDispose(ref TaskToDispose.MyTask);
|
|
#endregion
|
|
#region Clear data
|
|
//for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
// GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
|
|
#endregion
|
|
}
|
|
return SequenceFailed;
|
|
}
|
|
private static Boolean CheckArray(Boolean[] enable, Boolean[] array)
|
|
{
|
|
Boolean Completed = true;
|
|
|
|
for (Int32 i = 0; i < enable.Count(); i++)
|
|
{
|
|
if ((Boolean.Equals(array[i], false)) && (Boolean.Equals(enable[i], true)))
|
|
return false;
|
|
}
|
|
|
|
return Completed;
|
|
}
|
|
|
|
private static Boolean Check(Boolean enable, Boolean array)
|
|
{
|
|
Boolean Completed = true;
|
|
|
|
if ((Boolean.Equals(array, false)) && (Boolean.Equals(enable, true)))
|
|
return false;
|
|
|
|
return Completed;
|
|
}
|
|
}
|
|
public class EmptyPipeCheck
|
|
{
|
|
public ZeroFlowGenesisMeter CurrentMeter;
|
|
public UInt16 MeterNumber { get; set; }
|
|
public String MeterIndex { get; set; }
|
|
public EmptyPipeCheck(UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
this.MeterNumber = meterNumber;
|
|
this.Culture = culture;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
public EmptyPipeCheck(IMeter currentMeter, UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
if (currentMeter is ZeroFlowGenesisMeter)
|
|
{
|
|
this.CurrentMeter = (ZeroFlowGenesisMeter)currentMeter;
|
|
}
|
|
this.MeterNumber = meterNumber;
|
|
this.Culture = culture;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
|
|
String PcbID { get; set; }
|
|
private String Metertype { get; set; }
|
|
private UInt16 WaitingTime { get; set; }
|
|
private CultureInfo Culture { get; set; }
|
|
public void Initialize(String pcbID, String meterType, UInt16 waitingTime)
|
|
{
|
|
this.WaitingTime = waitingTime;
|
|
this.Metertype = meterType;
|
|
this.PcbID = pcbID;
|
|
}
|
|
public Boolean PerformTest(out Boolean aborted, CancellationToken token)
|
|
{
|
|
#region Definitions and initialization
|
|
Boolean SequenceFailed = false;
|
|
Boolean PerformWait = false;
|
|
Double[] Error = new Double[Constants.NumberOfPaths];
|
|
Error = ArrayInit.Path((Double)0.00);
|
|
Int32 Countup = 0;
|
|
Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path(0);
|
|
aborted = false;
|
|
Boolean ActivityOk = false;
|
|
#endregion
|
|
#region Reset counter for activity check/ switch on counting
|
|
if (String.Equals(this.Metertype, Constants.Meter))
|
|
{
|
|
for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLineCounterEmptyPipeTest(0, this.MeterNumber, Path);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorEmptyPipeTest(this.MeterNumber, true);
|
|
}
|
|
else
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLineCounterThermoEmptyPipeTest(0, this.MeterNumber, Path);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoEmptyPipeTest(this.MeterNumber, true);
|
|
}
|
|
#endregion
|
|
#region Cancel
|
|
if (token.IsCancellationRequested)
|
|
return true;
|
|
#endregion
|
|
#region Testsequence
|
|
for (Int32 Countdown = WaitingTime; Countdown >= 0; Countdown--)
|
|
{
|
|
if (Int32.Equals(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
|
|
String Resttime = Countdown.ToString(this.Culture);
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitForEmptyPipe(this.Culture)} {Resttime}s");
|
|
if (String.Equals(this.Metertype, Constants.Meter))
|
|
ActivityOk = this.ActivityCheck(ref LinecounterFollowing, Countup);
|
|
else
|
|
ActivityOk = this.ThermoActivityCheck(ref LinecounterFollowing, Countup);
|
|
if (token.IsCancellationRequested)
|
|
return true;
|
|
#endregion
|
|
#region Time control
|
|
Misc.WaitNSeconds(1);
|
|
Countup++;
|
|
#endregion
|
|
#region Get error status
|
|
if (String.Equals(this.Metertype, Constants.Meter))
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
Error[Constants.PATH0] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[this.MeterNumber][Path].Validation;
|
|
}
|
|
else
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
Error[Constants.PATH0] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllThermometers()[this.MeterNumber][Path].Validation;
|
|
}
|
|
#endregion
|
|
#region Check if wait
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if ((!(Double.Equals(Error[Path], (Double)DataError.NoError))) || (!ActivityOk))
|
|
PerformWait = true;
|
|
}
|
|
#endregion
|
|
#region All OK
|
|
if (Boolean.Equals(PerformWait, false))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Leave EMPTY PIPE mode at {this.Metertype}{this.MeterIndex}\n", this.Culture);
|
|
return false;
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Failed
|
|
SequenceFailed = true;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Leave EMPTY PIPE mode failed at {this.Metertype}{this.MeterIndex}\n", this.Culture);
|
|
if (this.Metertype == Constants.Meter)
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote($"{this.MeterIndex}", this.PcbID, GenesisZeroFlow.PredefinedMessages.EmptyPipeFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
#endregion
|
|
#region Switch off counting
|
|
if (String.Equals(this.Metertype, Constants.Meter))
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorEmptyPipeTest(this.MeterNumber, false);
|
|
else
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoEmptyPipeTest(this.MeterNumber, false);
|
|
#endregion
|
|
|
|
return SequenceFailed;
|
|
}
|
|
|
|
public Boolean PerformTestTempCal()
|
|
{
|
|
#region Definitions and initialization
|
|
Boolean SequenceFailed = false;
|
|
Boolean PerformWait = false;
|
|
Double[] Error = new Double[Constants.NumberOfPaths];
|
|
Error = ArrayInit.Path(0.00);
|
|
Int32 Countup = 0;
|
|
Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path((Int32)0);
|
|
Boolean ActivityOk = false;
|
|
String MeterIndex = (this.MeterNumber + 1).ToString(this.Culture);
|
|
#endregion
|
|
#region Reset counter for activity check/ switch on counting
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
frmTempCalibration._frmTempCalibration.SetLineCounterEmptyPipeTest(0, Path);
|
|
frmTempCalibration._frmTempCalibration.SetEnableIndicatorEmptyPipeTest(true);
|
|
#endregion
|
|
#region Testsequence
|
|
for (Int32 Countdown = WaitingTime; Countdown >= 0; Countdown--)
|
|
{
|
|
if (Int32.Equals(Countup, 0))
|
|
PerformWait = true;
|
|
else
|
|
PerformWait = false;
|
|
#region Abort
|
|
#endregion
|
|
#region Activity check
|
|
frmTempCalibration.DisplayTempCal.StatusLabel($"Wait for leaving EMPTY PIPE mode: {Countdown.ToString(this.Culture)}s");
|
|
ActivityOk = this.ActivityCheckTempCal(ref LinecounterFollowing, Countup);
|
|
#endregion
|
|
#region Time control
|
|
Misc.WaitNSeconds(1);
|
|
Countup++;
|
|
#endregion
|
|
#region Get error status
|
|
for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
if (frmTempCalibration._frmTempCalibration.GetDecodedAllMeters()[Path] != null)
|
|
Error[Path] = frmTempCalibration._frmTempCalibration.GetDecodedAllMeters()[Path].Validation;
|
|
#endregion
|
|
#region Check if wait
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if ((!Double.Equals(Error[Path], (Double)DataError.NoError)) || (!ActivityOk))
|
|
PerformWait = true;
|
|
}
|
|
#endregion
|
|
#region All OK
|
|
if (Boolean.Equals(PerformWait, false))
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"DATA CHANNEL:\t\t Leave EMPTY PIPE mode\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
|
|
return false;
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Failed
|
|
SequenceFailed = true;
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"DATA CHANNEL:\t\t Leave EMPTY PIPE mode failed\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"{Debugmessages.Line}", this.Culture);
|
|
#endregion
|
|
#region Switch off counting
|
|
frmTempCalibration._frmTempCalibration.SetEnableIndicatorEmptyPipeTest(false);
|
|
#endregion
|
|
|
|
return SequenceFailed;
|
|
}
|
|
private Boolean ActivityCheck(ref Int32[] lineCounterFollowing, Int32 seconds)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = true;
|
|
Boolean Error = false;
|
|
#endregion
|
|
#region Check activity
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path] != 0)
|
|
{
|
|
if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
|
|
return false;
|
|
else
|
|
lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path];
|
|
}
|
|
if ((seconds > 0) && (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path], 0)))
|
|
return false;
|
|
|
|
}
|
|
#endregion
|
|
#region Result
|
|
Ok = !Error;
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean ThermoActivityCheck(ref Int32[] lineCounterFollowing, Int32 seconds)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = true;
|
|
Boolean Error = false;
|
|
#endregion
|
|
#region Check activity
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterThermoEmptyPipeTest()[this.MeterNumber][Path] != 0)
|
|
{
|
|
if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterThermoEmptyPipeTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
|
|
return false;
|
|
else
|
|
lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterThermoEmptyPipeTest()[this.MeterNumber][Path];
|
|
}
|
|
if ((seconds > 0) && (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterThermoEmptyPipeTest()[this.MeterNumber][Path], 0)))
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Result
|
|
Ok = !Error;
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean ActivityCheckTempCal(ref Int32[] lineCounterFollowing, Int32 seconds)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = true;
|
|
Boolean Error = false;
|
|
#endregion
|
|
#region Check activity
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (frmTempCalibration._frmTempCalibration.GetLineCounterEmptyPipeTest()[Path] != 0)
|
|
{
|
|
if (frmTempCalibration._frmTempCalibration.GetLineCounterEmptyPipeTest()[Path] == lineCounterFollowing[Path])
|
|
return false;
|
|
else
|
|
lineCounterFollowing[Path] = frmTempCalibration._frmTempCalibration.GetLineCounterEmptyPipeTest()[Path];
|
|
}
|
|
if ((seconds > 0) && (frmTempCalibration._frmTempCalibration.GetLineCounterEmptyPipeTest()[Path] == 0))
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Result
|
|
Ok = !Error;
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
public Task<Boolean> MyTask;
|
|
internal void AddTask(Task<Boolean> task)
|
|
{
|
|
MyTask = task;
|
|
}
|
|
}
|
|
} |