983 lines
56 KiB
C#
983 lines
56 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using GenesisDisplayTool;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
public static class ZeroOffsetSequences
|
|
{
|
|
public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, Int16 settlingTime, Int16 lowerVoltLimit, Int16 upperVoltLimit, Double offsetTimeLimit, Int32 numberOfLines, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, out Boolean aborted, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
|
|
Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);
|
|
|
|
Boolean[] MeterTaskStarted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
|
|
|
|
Boolean[] ThermoTaskStarted = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
|
|
|
|
MeterTaskStarted = ArrayInit.Meter(false);
|
|
MeterTaskCompleted = ArrayInit.Meter(false);
|
|
MeterSequenceOk = ArrayInit.Meter(false);
|
|
MeterSequenceFailed = ArrayInit.Meter(false);
|
|
|
|
ThermoTaskStarted = ArrayInit.Thermo(false);
|
|
ThermoTaskCompleted = ArrayInit.Thermo(false);
|
|
ThermoSequenceOk = ArrayInit.Thermo(false);
|
|
ThermoSequenceFailed = ArrayInit.Thermo(false);
|
|
|
|
Boolean GenerateLogFiles = GenesisZeroFlow._GenesisZeroFlow.GetCBOffsetTestLogFiles();
|
|
Int32 NextDelayTime = 0;
|
|
aborted = false;
|
|
|
|
List<ZeroFlowOffsetTest> ListZeroFlowOffsetMeter = new List<ZeroFlowOffsetTest>();
|
|
List<ZeroFlowOffsetTest> ThermoListZeroFlowOffsetTest = new List<ZeroFlowOffsetTest>();
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = false;
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));
|
|
|
|
if (currentMeter != null)
|
|
ListZeroFlowOffsetMeter.Add(new ZeroFlowOffsetTest(Meter, culture, currentMeter));
|
|
else
|
|
ListZeroFlowOffsetMeter.Add(new ZeroFlowOffsetTest(Meter, culture));
|
|
}
|
|
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
{
|
|
var currentMeter = thermoMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Thermo + 11));
|
|
|
|
if (currentMeter != null)
|
|
ThermoListZeroFlowOffsetTest.Add(new ZeroFlowOffsetTest(Thermo, culture, currentMeter));
|
|
else
|
|
ThermoListZeroFlowOffsetTest.Add(new ZeroFlowOffsetTest(Thermo, culture));
|
|
}
|
|
#region Initialize
|
|
foreach (var zft in ListZeroFlowOffsetMeter)
|
|
{
|
|
zft.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[zft.MeterNumber], Constants.Meter, lowerVoltLimit, upperVoltLimit, offsetTimeLimit, numberOfLines, 0, 0, 0, GenerateLogFiles);
|
|
zft.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
{
|
|
zft.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[zft.MeterNumber], Constants.Thermo, 0, 0, 0, numberOfLines, upperTempLimit, lowerTempLimit, tempDeviationLimit, GenerateLogFiles);
|
|
zft.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region Perform test
|
|
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
// Zeroflow Offset test
|
|
foreach (var zft in ListZeroFlowOffsetMeter)
|
|
zft.Meter(MeterEnable[zft.MeterNumber], ref MeterTaskStarted[zft.MeterNumber], ref MeterSequenceFailed[zft.MeterNumber], ref NextDelayTime, settlingTime, token);
|
|
// Temperature test
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
{
|
|
if (ThermoEnable[zft.MeterNumber])
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(zft.MeterNumber, true);
|
|
GenesisZeroFlow.Display.DebugMessage($"{zft.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING started at {zft.MeterType}{zft.MeterIndex}\n", zft.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(zft.MeterNumber, true);
|
|
}
|
|
Misc.WaitNMilliseconds(300);
|
|
zft.Thermometer(ThermoEnable[zft.MeterNumber], ref ThermoTaskStarted[zft.MeterNumber], ref ThermoSequenceFailed[zft.MeterNumber], ref NextDelayTime, token);
|
|
}
|
|
#endregion
|
|
#region Wait for tasks
|
|
while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
|
|
{
|
|
#region Temperature check
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
{
|
|
if (CheckArray(MeterTaskCompleted) && (ThermoEnable[zft.MeterNumber])) // If all METERs finished, not THERMOMETERs
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(zft.MeterNumber, false);
|
|
GenesisZeroFlow.Display.DebugMessage($"{zft.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {zft.MeterType}{zft.MeterIndex}\n", zft.Culture);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Abort check
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
cancellationTokenSource.Cancel();
|
|
aborted = true;
|
|
}
|
|
#endregion
|
|
#region Check result
|
|
Misc.WaitNSeconds(1);
|
|
#region Meter
|
|
foreach (var zft in ListZeroFlowOffsetMeter)
|
|
{
|
|
MeterTaskCompleted[zft.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[zft.MeterNumber], zft.MyTask);
|
|
// Stop temperature check
|
|
var tmp = !MeterTaskCompleted[zft.MeterNumber];
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(zft.MeterNumber, tmp);
|
|
}
|
|
foreach (var zft in ListZeroFlowOffsetMeter)
|
|
MeterSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[zft.MeterNumber], zft.MyTask);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
#endregion
|
|
#region Thermometer
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
{
|
|
ThermoTaskCompleted[zft.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[zft.MeterNumber], zft.MyTask);
|
|
// Stop temperature check
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(zft.MeterNumber, !MeterTaskCompleted[zft.MeterNumber]);
|
|
}
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
ThermoSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[zft.MeterNumber], zft.MyTask);
|
|
for (UInt16 Thermometer = Constants.Thermo1; Thermometer < Constants.NumberOfThermometers; Thermometer++)
|
|
ThermoSequenceOk[Thermometer] = !ThermoSequenceFailed[Thermometer];
|
|
#endregion
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
|
|
#endregion
|
|
}
|
|
#region Sequence failed
|
|
foreach (var zft in ListZeroFlowOffsetMeter)
|
|
MeterSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[zft.MeterNumber], zft.MyTask);
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
ThermoSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[zft.MeterNumber], zft.MyTask);
|
|
#endregion
|
|
#region SequenceOk/ ThermoSequenceOk
|
|
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, MeterTaskStarted);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
|
|
#endregion
|
|
#endregion
|
|
#region Destroy tasks
|
|
foreach (var zft in ListZeroFlowOffsetMeter)
|
|
TaskOperations.CheckAndDispose(zft.MyTask);
|
|
foreach (var zft in ThermoListZeroFlowOffsetTest)
|
|
TaskOperations.CheckAndDispose(zft.MyTask);
|
|
#endregion
|
|
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
}
|
|
private static Boolean CheckArray(Boolean[] array)
|
|
{
|
|
Boolean Completed = true;
|
|
|
|
for (Int32 i = 0; i < array.Count(); i++)
|
|
{
|
|
if (Boolean.Equals(array[i], false))
|
|
return false;
|
|
}
|
|
|
|
return Completed;
|
|
}
|
|
}
|
|
public class ZeroFlowOffsetTest
|
|
{
|
|
private readonly ZeroFlowGenesisMeter GenesisMeter;
|
|
public Task<Boolean> MyTask { get; internal set; }
|
|
public ZeroFlowOffsetTest(UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
this.Culture = culture;
|
|
this.MeterNumber = meterNumber;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
public ZeroFlowOffsetTest(UInt16 meterNumber, CultureInfo culture, IMeter meter)
|
|
{
|
|
if (meter is ZeroFlowGenesisMeter)
|
|
{
|
|
GenesisMeter = meter as ZeroFlowGenesisMeter;
|
|
}
|
|
|
|
this.Culture = culture;
|
|
this.MeterNumber = meterNumber;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
internal void Meter(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, Int16 settlingTime, CancellationToken token)
|
|
{
|
|
#region Avoid CA1062
|
|
if (Task.Equals(MyTask, null))
|
|
{
|
|
sequenceFailed = true;
|
|
taskStarted = false;
|
|
return;
|
|
}
|
|
#endregion
|
|
#region Definitions and initializations
|
|
Int32 DelayTime = 0;
|
|
const Int32 DeltaDelay = 5;
|
|
DialogResult AskForActionsTask = DialogResult.None;
|
|
DialogResult AskForActionsFinalization = DialogResult.None;
|
|
var _sequenceFailed = sequenceFailed;
|
|
Int32 temp = DelayTime;
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!Task.Equals(MyTask.Status, TaskStatus.Running)))
|
|
{
|
|
#region Start delay
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(temp);
|
|
#endregion
|
|
#region Run task
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
while ((DialogResult.Equals(AskForActionsTask, DialogResult.Retry)) || (DialogResult.Equals(AskForActionsTask, DialogResult.None)))
|
|
{
|
|
#region Abort
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true; // sequence failed
|
|
}
|
|
else
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Start logging
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
this.StartTest();
|
|
#endregion
|
|
#region Wait for settling time (60s)
|
|
for (Int16 Time = settlingTime; Time >= 0; Time--)
|
|
{
|
|
if ((token.IsCancellationRequested) || (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
this.LeaveSequence();
|
|
return true; // sequence failed
|
|
}
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetWaitForSettling(this.Culture)}{Time.ToString(this.Culture)}");
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
#endregion
|
|
#region Start collecting data for calculation
|
|
GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(true, this.MeterNumber);
|
|
#endregion
|
|
#region Activity check
|
|
Boolean ActivityOk = true;
|
|
if (enable && ActivityOk && ((DialogResult.Equals(AskForActionsTask, DialogResult.None)) || (DialogResult.Equals(AskForActionsTask, DialogResult.Retry))))
|
|
ActivityOk = ActivityCheck(token);
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = !ActivityOk;
|
|
#endregion
|
|
#region Stop logging and stop calculating ==> is also done by the 'MainloopMeterX'-Functions
|
|
GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(false, this.MeterNumber);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(false, this.MeterNumber);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Stop logging at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#region Write raw data to files
|
|
String LogData = GenesisZeroFlow._GenesisZeroFlow.GetDataToLog()[this.MeterNumber];
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Write data to files at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Logging.WriteToFile(LogData, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathZeroFlowTest()[this.MeterNumber]);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty);
|
|
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true; // sequence failed
|
|
}
|
|
#endregion
|
|
#region Summary
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true; // sequence failed
|
|
}
|
|
|
|
if (ActivityOk)
|
|
{
|
|
while ((DialogResult.Equals(AskForActionsFinalization, DialogResult.Retry)) || (DialogResult.Equals(AskForActionsFinalization, DialogResult.None)))
|
|
{
|
|
#region Abort
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetTestStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true; // sequence failed
|
|
}
|
|
else
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Finalize test
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Finalize ZEROFLOW OFFSET TEST at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = FinalizeTest(GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeValuesUp(this.MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeValuesDown(this.MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetDeltaTimeOfFlightAverage(this.MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetBadDataCounter(this.MeterNumber), token, GenesisZeroFlow._GenesisZeroFlow.GetDeltaTimeOfFlightAverageRaw(this.MeterNumber));
|
|
|
|
if (Boolean.Equals(Ok, true))
|
|
{
|
|
AskForActionsFinalization = DialogResult.OK;
|
|
_sequenceFailed = false;//?
|
|
}
|
|
else
|
|
{
|
|
// AskForActionsFinalization = this.AskHowToProceedSequence("ZEROFLOW OFFSET TEST");
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetTestFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
AskForActionsFinalization = DialogResult.Cancel;
|
|
_sequenceFailed = true; //?
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
else
|
|
Ok = false;
|
|
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
_sequenceFailed = false;
|
|
AskForActionsTask = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetTestFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
_sequenceFailed = true;
|
|
AskForActionsTask = DialogResult.Cancel;
|
|
}
|
|
#endregion
|
|
}
|
|
return _sequenceFailed;
|
|
});
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
|
|
|
|
internal void Thermometer(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
|
|
{
|
|
#region Avoid CA1062
|
|
if ((MyTask == null))
|
|
return;
|
|
#endregion
|
|
#region Definitions and initializations
|
|
Int32 DelayTime = 0;
|
|
const Int32 DeltaDelay = 30;
|
|
const Int32 Interval = 4;
|
|
var _sequenceFailed = sequenceFailed;
|
|
Boolean Ok = true;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
{
|
|
#region Start delay
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(DelayTime);
|
|
#endregion
|
|
#region Run task
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
Boolean LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
|
|
Int32 BadCycles = 0;
|
|
const Int32 AllowedBadCycles = 1;
|
|
|
|
Boolean StatusOk = true;
|
|
|
|
while (LoggingIndicator && (StatusOk))
|
|
{
|
|
|
|
#region Abort
|
|
if (!token.IsCancellationRequested)
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Testprocedure
|
|
Ok = PerformTempMonitoring(token);
|
|
|
|
|
|
Misc.WaitNSeconds(Interval);
|
|
|
|
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true; // sequence failed
|
|
}
|
|
|
|
|
|
if (Ok)
|
|
{
|
|
BadCycles = 0;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
_sequenceFailed = false;
|
|
}
|
|
else
|
|
{
|
|
BadCycles++;
|
|
if (BadCycles > AllowedBadCycles)
|
|
StatusOk = false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
_sequenceFailed = true;
|
|
}
|
|
#endregion
|
|
LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
|
|
}
|
|
return _sequenceFailed;
|
|
|
|
}, token);
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|
|
private Boolean StartTest()
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String time = DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
|
|
String TempPcbID = this.PcbID.Replace(" ", String.Empty);
|
|
#endregion
|
|
#region Generate Header
|
|
String Header = $"Genesis ZeroFlowOffsetTest {this.MeterType}{this.MeterIndex}; PCB ID = {TempPcbID}; Date = {time}; Operator = {Environment.UserName}\n";
|
|
#endregion
|
|
#region Start logging
|
|
this.ClearData();
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingPathZeroFlowTest(this.MeterNumber, $"{DataLogging.DefaultPath}ZeroflowOffsetTest_RawData_{TempPcbID}_{time}.txt");
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(true, this.MeterNumber); // Start logging data
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start logging at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
|
|
|
|
private Boolean FinalizeTest(List<Double>[] amplitudeValuesUp, List<Double>[] amplitudeValuesDown, List<Double>[] deltaTimeOfFlightAverage, Int32[] badData, CancellationToken token, List<Int32>[] deltaTimeOfFlightAverageRAW)
|
|
{
|
|
|
|
#region Avoid CA1062
|
|
if ((amplitudeValuesUp == null) || (amplitudeValuesDown == null) || (badData == null) || (deltaTimeOfFlightAverage == null) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
#endregion
|
|
#region Definitions and initializations
|
|
|
|
Boolean Ok = false;
|
|
Double[] amplitudeValuesMeanUp = new Double[Constants.NumberOfPaths];
|
|
Double[] amplitudeValuesMeanDown = new Double[Constants.NumberOfPaths];
|
|
Double[] DeltaTimeOfFlightAverage = new Double[Constants.NumberOfPaths];
|
|
amplitudeValuesMeanUp = ArrayInit.Path((Double)0);
|
|
amplitudeValuesMeanDown = ArrayInit.Path((Double)0);
|
|
DeltaTimeOfFlightAverage = ArrayInit.Path((Double)0);
|
|
#endregion
|
|
#region Calculating mean values
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Calculating mean values at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
amplitudeValuesMeanUp[Path] = amplitudeValuesUp[Path].Mean();
|
|
amplitudeValuesMeanDown[Path] = amplitudeValuesDown[Path].Mean();
|
|
DeltaTimeOfFlightAverage[Path] = deltaTimeOfFlightAverage[Path].Mean();
|
|
|
|
if((amplitudeValuesMeanUp[Path] == 0)|| (amplitudeValuesMeanDown[Path] == 0)||(DeltaTimeOfFlightAverage[Path] == 0))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Mean value is zero at {this.MeterType}{this.MeterIndex}; PATH{(Path + 1).ToString(this.Culture)}\n", this.Culture);
|
|
this.ClearData();
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Display calculated values
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Bad data at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}: {badData[Path].ToString(this.Culture)}\n", this.Culture);
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Average positive amplitude value at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}: {Math.Round(amplitudeValuesMeanUp[Path], 2).ToString("000.00", this.Culture)}mV\n", this.Culture);
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Average negative amplitude value at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}: {Math.Round(amplitudeValuesMeanDown[Path], 2).ToString("000.00", this.Culture)}mV\n", this.Culture);
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Average delta time of flight value at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}: { Math.Round(DeltaTimeOfFlightAverage[Path] * (Math.Pow(2, 38)), 2).ToString("000.00", this.Culture)}ps\n", this.Culture);
|
|
#endregion
|
|
#region Check for bad data
|
|
Boolean BadDataCheckOK = false;
|
|
BadDataCheckOK = this.CheckForBadData(badData);
|
|
if (BadDataCheckOK)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Bad data check successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Bad data check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#region Check amplitude values
|
|
this.ClearData();
|
|
Boolean AmplitudeCheckOK = false;
|
|
AmplitudeCheckOK = CheckAmplitudes(amplitudeValuesMeanUp, amplitudeValuesMeanDown);
|
|
if (AmplitudeCheckOK)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Amplitude check successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Amplitude check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#region Check if offsets are within ranges
|
|
Boolean OffsetCheckOK = false;
|
|
OffsetCheckOK = CheckOffset(DeltaTimeOfFlightAverage);
|
|
if (OffsetCheckOK)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Delta time of flight check successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Delta time of flight check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#region Abort if checks failed
|
|
if ((Boolean.Equals(BadDataCheckOK, false)) || (Boolean.Equals(AmplitudeCheckOK, false)) || (Boolean.Equals(OffsetCheckOK, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
|
|
{
|
|
this.ClearData();
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
GenesisMeter.Login();
|
|
|
|
#region Write new values to offset registers
|
|
#region Write to 'ZeroOffset' register PATH0
|
|
|
|
|
|
this.OffsetValuePath0 = (Int32)((DeltaTimeOfFlightAverage[Constants.PATH0] * Math.Pow(2, 40))); // ZeroOffsetTestConstants.DeltaTofAverageFactor)));
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath0.ToString(this.Culture)} to 'Zero flow offset'-register PATH1 started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#region Write to register
|
|
Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset1, OffsetValuePath0);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath0.ToString(this.Culture)} to 'Zero flow offset'-register successful at {this.MeterType}{this.MeterIndex}; PATH1\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath0.ToString(this.Culture)} to 'Zero flow offset'-register failed at {this.MeterType}{this.MeterIndex}; PATH1\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
#endregion
|
|
#endregion
|
|
#region Write to 'ZeroOffset' register PATH1
|
|
if (Constants.NumberOfPaths > 1)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t calculating offset PATH2 {DeltaTimeOfFlightAverage[Constants.PATH1]} * {Math.Pow(2, 40)} started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
var p2AVG = deltaTimeOfFlightAverageRAW[Constants.PATH1].Average();
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID} AVG RAW Value is {p2AVG}", this.Culture);
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID} Value in S is {DeltaTimeOfFlightAverage[Constants.PATH1]}", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage(
|
|
$"{this.PcbID} Calculation RAW {DeltaTimeOfFlightAverage[Constants.PATH1] / (1.0 / 0x4000000000)} | RAW {DeltaTimeOfFlightAverage} in Seconds", this.Culture);
|
|
|
|
GenesisZeroFlow.Display.DebugMessage(
|
|
$"{this.PcbID} Raw x4 calc {DeltaTimeOfFlightAverage[Constants.PATH1] / (1.0 / 0x4000000000) * 4} = offset", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage(
|
|
$"{this.PcbID} Current calc DeltaTimeOfFlightAverage * 2^40 {(Int32)((DeltaTimeOfFlightAverage[Constants.PATH1] * Math.Pow(2, 40)))} = offset", this.Culture);
|
|
|
|
|
|
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture)}");
|
|
this.OffsetValuePath1 = (Int32)((DeltaTimeOfFlightAverage[Constants.PATH1] * Math.Pow(2, 40))); // ZeroOffsetTestConstants.DeltaTofAverageFactor)));
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath1.ToString(this.Culture)} to 'Zero flow offset'-register PATH2 started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#region Write to register
|
|
Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset2, OffsetValuePath1);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath1.ToString(this.Culture)} to 'Zero flow offset'-register successful at {this.MeterType}{this.MeterIndex}; PATH2\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath1.ToString(this.Culture)} to 'Zero flow offset'-register failed at {this.MeterType}{this.MeterIndex}; PATH2\n", this.Culture);
|
|
#endregion
|
|
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Write to 'ZeroOffset' register PATH2
|
|
if (Constants.NumberOfPaths > 2)
|
|
{
|
|
this.OffsetValuePath2 = (Int32)((DeltaTimeOfFlightAverage[Constants.PATH2] * Math.Pow(2, 40)));// ZeroOffsetTestConstants.DeltaTofAverageFactor)));
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath2.ToString(this.Culture)} to 'Zero flow offset'-register PATH3 started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#region Write to register
|
|
Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset3, OffsetValuePath2);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath2.ToString(this.Culture)} to 'Zero flow offset'-register successful at {this.MeterType}{this.MeterIndex}; PATH3\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath2.ToString(this.Culture)} to 'Zero flow offset'-register failed at {this.MeterType}{this.MeterIndex}; PATH3\n", this.Culture);
|
|
#endregion
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean PerformTempMonitoring(CancellationToken token)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32[] LinecounterFollowing = new Int32[1];
|
|
|
|
|
|
//Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
Boolean Ok = true;
|
|
Int32 ActivityCheckInterval = GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeActivityCheckInterval();
|
|
Ok = this.ThermoActivityCheck(ref LinecounterFollowing, 0);
|
|
#endregion
|
|
#region Test sequence
|
|
#region Check upper temp value
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
Double temp = 0;
|
|
|
|
try
|
|
{
|
|
temp = GenesisZeroFlow._GenesisZeroFlow.GetTemperatures(this.MeterNumber, Path);
|
|
String Temperature = $"{Math.Round(temp, 2).ToString("00.00", this.Culture)}°C";
|
|
|
|
switch (this.MeterNumber)
|
|
{
|
|
case Constants.Meter1:
|
|
GenesisZeroFlow.Display.SetThermoLabel1($"{Temperature}");
|
|
break;
|
|
case Constants.Meter2:
|
|
GenesisZeroFlow.Display.SetThermoLabel2($"{Temperature}");
|
|
break;
|
|
default:
|
|
GenesisZeroFlow.Display.SetThermoLabel1($"n/a");
|
|
break;
|
|
}
|
|
|
|
#region Upper value
|
|
if (temp > this.UpperTempLimit)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value check failed at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value check values (actual/ limit) = {Temperature}/ {Math.Round(this.UpperTempLimit, 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value successful at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Temperature}\n", this.Culture);
|
|
#endregion
|
|
#region Lower value
|
|
if (temp < this.LowerTempLimit)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value check failed at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value check values (actual/ limit) = {Temperature}/ {Math.Round(this.LowerTempLimit, 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value successful at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Temperature}\t\n", this.Culture);
|
|
#endregion
|
|
#region Deviation check
|
|
// Lower value check
|
|
if (this.GetTempDeviationMin()[Path] == 0)
|
|
this.TempDeviationMin[Path] = temp;
|
|
else
|
|
{
|
|
if (temp < this.GetTempDeviationMin()[Path])
|
|
this.TempDeviationMin[Path] = temp;
|
|
}
|
|
// Upper value check
|
|
if (this.GetTempDeviationMax()[Path] == 0)
|
|
this.TempDeviationMax[Path] = temp;
|
|
else
|
|
{
|
|
if (temp > this.GetTempDeviationMax()[Path])
|
|
this.TempDeviationMax[Path] = temp;
|
|
}
|
|
// Deviation check
|
|
|
|
Double DeviationValue = this.GetTempDeviationMax()[Path] - this.GetTempDeviationMin()[Path];
|
|
String Deviation = $"{Math.Round(DeviationValue, 3).ToString("00.000", this.Culture)}°C";
|
|
|
|
if (DeviationValue > this.TempDeviationLimit)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING deviation check failed at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Deviation}\n", this.Culture);
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING deviation check successful at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Deviation}\n", this.Culture);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
ErrorLog.Log(LogErrReason.Exeption, "ZeroFlowOffsetTest.PerformTemperatureMonitoring() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
return Ok;
|
|
}
|
|
private Boolean ActivityCheck(CancellationToken token)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = true;
|
|
Int32[] LineCounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LineCounterFollowing = ArrayInit.Path((Int32)0);
|
|
Int32[] LineCounter = new Int32[Constants.NumberOfPaths];
|
|
LineCounter = ArrayInit.Path((Int32)0);
|
|
Int32[] LineCounterFailed = new Int32[Constants.NumberOfPaths];
|
|
LineCounterFailed = ArrayInit.Path((Int32)0);
|
|
const Int32 maxLineCounterFailed = 500;
|
|
Boolean PerformCheck = true;
|
|
|
|
for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (!(LineCounter[Path] < this.NumberOfLines - 1))
|
|
PerformCheck = false;
|
|
if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
PerformCheck = false;
|
|
}
|
|
|
|
#endregion
|
|
#region Check activity
|
|
while (PerformCheck)
|
|
//while ((LineCounter[Constants.PATH0] < this.NumberOfLines - 1) && (LineCounter[Constants.PATH1] < this.NumberOfLines - 1) && (LineCounter[Constants.PATH2] < this.NumberOfLines) && (!GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
|
|
{
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
LineCounterFollowing = (Int32[])LineCounter.Clone();
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetAqqFinished(this.Culture)} {LineCounterFollowing[Constants.PATH0].ToString(this.Culture)}/{this.NumberOfLines.ToString(this.Culture)}"); // "Wait until data aquisition has finished:"
|
|
Misc.WaitNSeconds(2);
|
|
LineCounter = (Int32[])GenesisZeroFlow._GenesisZeroFlow.GetLineCounterZeroFlow(this.MeterNumber).Clone();
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (Int32.Equals(LineCounterFollowing[Path], LineCounter[Path]) && (Int32.Equals((LineCounter[Path] % 3), 0)))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Data activity check failed at {this.MeterType}{this.MeterIndex}; PATH{Path + 1}; Linecounter = {LineCounter[Path].ToString(this.Culture)}\n", this.Culture);
|
|
LineCounterFailed[Path] = LineCounterFailed[Path] + 1;
|
|
}
|
|
}
|
|
|
|
bool testDone = true;
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
|
|
if (LineCounterFailed[Path] > maxLineCounterFailed)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t To many bad data Packages {this.MeterType}{this.MeterIndex}; PATH{Path + 1}; Linecounter = {LineCounter[Path].ToString(this.Culture)}\n", this.Culture);
|
|
|
|
Ok = false;
|
|
break;
|
|
}
|
|
if (LineCounter[Path] < this.NumberOfLines)
|
|
{
|
|
testDone = false;
|
|
}
|
|
}
|
|
|
|
if (testDone)
|
|
{
|
|
Ok = true;
|
|
PerformCheck = false;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
#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 (!Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], 0))
|
|
{
|
|
if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
|
|
return false;
|
|
else
|
|
lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path];
|
|
}
|
|
if ((seconds > 0) && (Boolean.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], 0)))
|
|
return false;
|
|
}
|
|
#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 = Constants.PATH0; 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 = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (deltaTimeOfFlightAvg[Path] > this.OffsetTimeLimit)
|
|
Ok = false;
|
|
if (deltaTimeOfFlightAvg[Path] < -this.OffsetTimeLimit)
|
|
Ok = false;
|
|
}
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean CheckAmplitudes(Double[] amplitudeValuesUp, Double[] amplitudeValuesDown)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = true;
|
|
|
|
#endregion
|
|
#region Result
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (amplitudeValuesUp[Path] > this.UpperVoltLimit)
|
|
return false;
|
|
if (amplitudeValuesUp[Path] < this.LowerVoltLimit)
|
|
return false;
|
|
if (amplitudeValuesDown[Path] < this.LowerVoltLimit)
|
|
return false;
|
|
if (amplitudeValuesDown[Path] > this.UpperVoltLimit)
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private DialogResult AskHowToProceedSequence(String sequenceName)
|
|
{
|
|
DialogResult AskForActions;
|
|
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
AskForActions = MessageBox.Show(GenesisZeroFlow.PredefinedMessages.MeterSequenceFailed(sequenceName, this.MeterIndex, this.Culture), "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
|
|
switch (AskForActions)
|
|
{
|
|
case DialogResult.Retry:
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {sequenceName} restarted at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
break;
|
|
case DialogResult.Cancel:
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {sequenceName} canceled at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
break;
|
|
default: break;
|
|
}
|
|
|
|
return AskForActions;
|
|
}
|
|
|
|
private void LeaveSequence()
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(false, this.MeterNumber);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(false, this.MeterNumber);
|
|
|
|
#region Write raw data to files
|
|
if (this.GenerateLogFiles)
|
|
{
|
|
String temp = GenesisZeroFlow._GenesisZeroFlow.GetDataToLog()[this.MeterNumber];
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Write data to files at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Logging.WriteToFile(temp, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathZeroFlowTest()[this.MeterNumber]);
|
|
}
|
|
this.ClearData();
|
|
#endregion
|
|
}
|
|
|
|
private void ClearData()
|
|
{
|
|
try
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(false, this.MeterNumber);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(false, this.MeterNumber);
|
|
Misc.WaitNMilliseconds(100);
|
|
|
|
GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty);
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearAmplitudeValuesUp(this.MeterNumber);
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearAmplitudeValuesDown(this.MeterNumber);
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearLineCounterZeroFlow(this.MeterNumber);
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearBadDataCounter(this.MeterNumber);
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exeption, "ZeroFlowOffsetTest.ClearData() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
|
|
}
|
|
}
|
|
|
|
public void Initialize(String pcbID, String meterType, Int16 lowerVoltLimit, Int16 upperVoltLimit, Double offsetTimeLimit, Int32 numberOfLines, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, Boolean generateLogFiles)
|
|
{
|
|
this.OffsetValuePath0 = 0;
|
|
this.OffsetValuePath1 = 0;
|
|
this.OffsetValuePath2 = 0;
|
|
this.UpperVoltLimit = upperVoltLimit;
|
|
this.LowerVoltLimit = lowerVoltLimit;
|
|
this.OffsetTimeLimit = offsetTimeLimit;
|
|
this.NumberOfLines = numberOfLines;
|
|
this.UpperTempLimit = upperTempLimit;
|
|
this.LowerTempLimit = lowerTempLimit;
|
|
this.TempDeviationLimit = tempDeviationLimit;
|
|
this.TempDeviationMin = new Double[Constants.NumberOfPaths];
|
|
this.TempDeviationMax = new Double[Constants.NumberOfPaths];
|
|
this.TempDeviationMin = ArrayInit.Path((Double)0);
|
|
this.TempDeviationMax = ArrayInit.Path((Double)0);
|
|
this.MeterType = meterType;
|
|
this.ActivityInterval = GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowActivityCheckInterval();
|
|
this.PcbID = pcbID;
|
|
this.GenerateLogFiles = generateLogFiles;
|
|
}
|
|
private Boolean GenerateLogFiles { get; set; }
|
|
public UInt16 MeterNumber { get; private set; }
|
|
public String MeterIndex { get; private set; }
|
|
public String MeterType { get; private set; }
|
|
public String PcbID { get; private set; }
|
|
public CultureInfo Culture { get; private set; }
|
|
private Double LowerVoltLimit { get; set; }
|
|
private Double UpperVoltLimit { get; set; }
|
|
private Int32 OffsetValuePath0 { get; set; }
|
|
private Int32 OffsetValuePath1 { get; set; }
|
|
private Int32 OffsetValuePath2 { get; set; }
|
|
private Double OffsetTimeLimit { get; set; }
|
|
private Int32 NumberOfLines { get; set; }
|
|
private Int32 ActivityInterval { get; set; }
|
|
private Double LowerTempLimit { get; set; } // usually 10.0°C
|
|
private Double UpperTempLimit { get; set; } // usually 35.0°C
|
|
private Double TempDeviationLimit { get; set; } // usually 0.5°C
|
|
internal Double[] TempDeviationMin { get; set; } // to store min. measure temperature value
|
|
private Double[] GetTempDeviationMin()
|
|
{
|
|
return (Double[])TempDeviationMin.Clone();
|
|
}
|
|
private Double[] TempDeviationMax { get; set; } // to store max. measure temperature value
|
|
private Double[] GetTempDeviationMax()
|
|
{
|
|
return (Double[])TempDeviationMax.Clone();
|
|
}
|
|
|
|
}
|
|
} |