1098 lines
58 KiB
C#
1098 lines
58 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.WaterMeterCore;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
public static class AmplitudeSequences
|
|
{
|
|
public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, Int32 firstHitLevelPropMin, Int32 firstHitLevelPropMax, Int32 ampTestLowerLimit, Int32 ampTestUpperLimit, Int32 ampTestDistance, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, out Boolean aborted, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 FirstHitLevelPropMin = firstHitLevelPropMin;
|
|
Int32 FirstHitLevelPropMax = firstHitLevelPropMax;
|
|
Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
|
|
Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);
|
|
Boolean GenerateMeanFiles = GenesisZeroFlow._GenesisZeroFlow.GetCBMeanAmplitudeFiles();
|
|
Boolean GenerateLogFiles = GenesisZeroFlow._GenesisZeroFlow.GetCBAmpLogFiles();
|
|
const Int32 TofRecordingTime = 2;
|
|
const Double TriggerValue = 0.5;
|
|
Int32 NextDelayTime = 0;
|
|
|
|
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];
|
|
|
|
List<Amplitude> listAmpTest = new List<Amplitude>();
|
|
List<Amplitude> thermoAmpTest = new List<Amplitude>();
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = false;
|
|
|
|
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);
|
|
|
|
aborted = false;
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));
|
|
|
|
if (currentMeter != null)
|
|
listAmpTest.Add(new Amplitude(Meter, currentMeter, culture));
|
|
else
|
|
listAmpTest.Add(new Amplitude(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)
|
|
thermoAmpTest.Add(new Amplitude(Thermo, currentMeter, culture));
|
|
else
|
|
thermoAmpTest.Add(new Amplitude(Thermo, culture));
|
|
}
|
|
#region Initialize
|
|
foreach (var meteramp in listAmpTest)
|
|
{
|
|
meteramp.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[meteramp.MeterNumber], Constants.Meter, ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, upperTempLimit, lowerTempLimit, tempDeviationLimit, GenerateMeanFiles, GenerateLogFiles);
|
|
meteramp.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
foreach (var thermoamp in thermoAmpTest)
|
|
{
|
|
thermoamp.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermoamp.MeterNumber], Constants.Thermo, 0, 0, 0, 0, 0, TofRecordingTime, TriggerValue, upperTempLimit, lowerTempLimit, tempDeviationLimit, GenerateMeanFiles, GenerateLogFiles);
|
|
thermoamp.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region Perform tests
|
|
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
// Amplitude test
|
|
foreach (var meteramp in listAmpTest)
|
|
meteramp.Meter(MeterEnable[meteramp.MeterNumber], ref MeterTaskStarted[meteramp.MeterNumber], ref MeterSequenceFailed[meteramp.MeterNumber], ref NextDelayTime, token);
|
|
// Temperature Monitoring
|
|
foreach (var thermoamp in thermoAmpTest)
|
|
{
|
|
if (ThermoEnable[thermoamp.MeterNumber])
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(thermoamp.MeterNumber, true);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\tTEMPERATURE MONITORING started at {thermoamp.MeterType}{thermoamp.MeterIndex}\n", thermoamp.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(thermoamp.MeterNumber, true);
|
|
}
|
|
Misc.WaitNMilliseconds(300);
|
|
thermoamp.Thermometer(ThermoEnable[thermoamp.MeterNumber], ref ThermoTaskStarted[thermoamp.MeterNumber], ref ThermoSequenceFailed[thermoamp.MeterNumber], ref NextDelayTime, token);
|
|
}
|
|
#endregion
|
|
#region Wait for tasks
|
|
while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
|
|
{
|
|
#region Temperature check
|
|
foreach (var thermoamp in thermoAmpTest)
|
|
{
|
|
if (CheckArray(MeterTaskCompleted) && (ThermoEnable[thermoamp.MeterNumber])) // If all METERs finished, not THERMOMETERs
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(thermoamp.MeterNumber, false);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {thermoamp.MeterType}{thermoamp.MeterIndex}\n", thermoamp.Culture);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Abort check
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
cancellationTokenSource.Cancel();
|
|
aborted = true;
|
|
}
|
|
#endregion
|
|
#region Check result
|
|
Misc.WaitNSeconds(1);
|
|
#region Meter
|
|
foreach (var amp in listAmpTest)
|
|
{
|
|
MeterTaskCompleted[amp.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[amp.MeterNumber], amp.MyTask);
|
|
// Stop temperature check
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(amp.MeterNumber, !MeterTaskCompleted[amp.MeterNumber]);
|
|
}
|
|
foreach (var amp in listAmpTest)
|
|
MeterSequenceFailed[amp.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[amp.MeterNumber], amp.MyTask);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
#endregion
|
|
#region Thermometer
|
|
foreach (var amp in thermoAmpTest)
|
|
{
|
|
ThermoTaskCompleted[amp.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[amp.MeterNumber], amp.MyTask);
|
|
// Stop temperature check
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(amp.MeterNumber, !MeterTaskCompleted[amp.MeterNumber]);
|
|
}
|
|
foreach (var amp in thermoAmpTest)
|
|
ThermoSequenceFailed[amp.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[amp.MeterNumber], amp.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 meteramp in listAmpTest)
|
|
MeterSequenceFailed[meteramp.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[meteramp.MeterNumber], meteramp.MyTask);
|
|
foreach (var thermoamp in thermoAmpTest)
|
|
ThermoSequenceFailed[thermoamp.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermoamp.MeterNumber], thermoamp.MyTask);
|
|
#endregion
|
|
#region Sequence Ok
|
|
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 meteramp in listAmpTest)
|
|
TaskOperations.CheckAndDispose(meteramp.MyTask);
|
|
foreach (var thermoamp in thermoAmpTest)
|
|
TaskOperations.CheckAndDispose(thermoamp.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 Amplitude
|
|
{
|
|
private readonly ZeroFlowGenesisMeter GenesisMeter;
|
|
public Task<Boolean> MyTask { get; set; }
|
|
public Amplitude(UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
MeterNumber = meterNumber;
|
|
Culture = culture;
|
|
MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
public Amplitude(UInt16 meterNumber, IMeter meter, CultureInfo culture)
|
|
{
|
|
if (meter is ZeroFlowGenesisMeter)
|
|
{
|
|
GenesisMeter = meter as ZeroFlowGenesisMeter;
|
|
}
|
|
MeterNumber = meterNumber;
|
|
Culture = culture;
|
|
MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
internal void Meter(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 = 1;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
Boolean _sequenceFailed = sequenceFailed;
|
|
Boolean Ok = false;
|
|
#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
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)) && (!token.IsCancellationRequested) && !GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
#region Abort
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
return true; // sequence failed
|
|
}
|
|
else
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Testprocedure
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
Ok = this.PerformTest(token);
|
|
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true; // sequence failed
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
_sequenceFailed = false;
|
|
AskForActions = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
_sequenceFailed = true;
|
|
AskForActions = DialogResult.Cancel;
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
}
|
|
#endregion
|
|
}
|
|
return _sequenceFailed;
|
|
|
|
}, token);
|
|
}
|
|
#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 Checkinterval = 4;
|
|
Boolean _sequenceFailed = sequenceFailed;
|
|
Boolean Ok = true;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
{
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(DeltaDelay);
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
Boolean LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
|
|
while (LoggingIndicator && (Boolean.Equals(Ok, true)))
|
|
{
|
|
#region Abort
|
|
if (!token.IsCancellationRequested)
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Testprocedure
|
|
Ok = PerformTempMonitoring(token);
|
|
Misc.WaitNSeconds(Checkinterval);
|
|
|
|
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)
|
|
{
|
|
// GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t AMPLITUDE TEST successful at METER{MeterIndex}\t{AppendID}\n", this.Culture);
|
|
// GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line, this.Culture);
|
|
_sequenceFailed = false;
|
|
}
|
|
else
|
|
_sequenceFailed = true;
|
|
#endregion
|
|
LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
|
|
}
|
|
|
|
return _sequenceFailed;
|
|
|
|
}, token);
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
private Boolean PerformTest(CancellationToken token)
|
|
{
|
|
this.ClearData();
|
|
|
|
#region Definitions and initializations
|
|
String TempPcbID = this.PcbID.Replace(" ", String.Empty);
|
|
const Int32 FirstHitShiftValue = 4;
|
|
const Int32 FirstHitShiftValueEnd = 4;
|
|
const Int32 FirstHitUpdatePeriodeValue = 1;
|
|
const Int32 FirstHitUpdatePeriodeValueEnd = 10;
|
|
const Int32 WaitBeforeLogging = 1;
|
|
String DebugMessage = String.Empty;
|
|
Double[] TofAvgMean = new Double[Constants.NumberOfPaths];
|
|
TofAvgMean = ArrayInit.Path((Double)0);
|
|
Int32[] OptimalPoint = new Int32[Constants.NumberOfPaths];
|
|
OptimalPoint = ArrayInit.Path((Int32)0);
|
|
List<Double>[] TofAvgMeanTotal = new List<Double>[Constants.NumberOfPaths];
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
TofAvgMeanTotal[Path] = new List<Double>();
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Test sequence
|
|
#region StartLogging
|
|
if (this.GenerateLogFiles)
|
|
{
|
|
String time = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
|
|
String Header = $"Genesis ZeroFlowOffsetCalibration {this.MeterType}{this.MeterIndex}; PCB ID = {TempPcbID}; Date = {time}; Operator = {Environment.UserName}\n";
|
|
GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, Header);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingPathAmplitudeTest(this.MeterNumber, $"{DataLogging.DefaultPath}AmplitudeTest_RawData_{TempPcbID}_{time}.txt");
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmpTest(this.MeterNumber, true);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start logging at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
}
|
|
#endregion
|
|
#region Set first hit update period
|
|
if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
Ok = WriteRegister(GenesisMeter, "First hit update period", Register.Genesisflow.FirstHitUpdatePeriod, FirstHitUpdatePeriodeValue, FirstHitUpdatePeriodeValue.ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Set first hit shift to 4
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
Ok = WriteRegister(GenesisMeter, "First hit shift", Register.Genesisflow.FirstHitShift, FirstHitShiftValue, FirstHitShiftValue.ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Set first hit level percentage from 5 to 40
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start first hit level percentage sweep at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
for (Int32 FirstHitLevelPercentage = (Int32)(this.FirstHitLevelPercMin); FirstHitLevelPercentage <= (this.FirstHitLevelPercMax); FirstHitLevelPercentage++)
|
|
{
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} {FirstHitLevelPercentage.ToString(this.Culture)}/{FirstHitLevelPercMax.ToString(this.Culture)}");
|
|
#region Write to percentage register PATH0
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
Ok = WriteRegister(GenesisMeter, "Percentage", Register.Genesisflow.FirstHitPercent1, FirstHitLevelPercentage, FirstHitLevelPercentage.ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Write to percentage register PATH1
|
|
if (Constants.NumberOfPaths > 1)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
Ok = WriteRegister(GenesisMeter, "Percentage", Register.Genesisflow.FirstHitPercent2, FirstHitLevelPercentage, FirstHitLevelPercentage.ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Write to percentage register PATH2
|
|
if (Constants.NumberOfPaths > 2)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
Ok = WriteRegister(GenesisMeter, "Percentage", Register.Genesisflow.FirstHitPercent3, FirstHitLevelPercentage, FirstHitLevelPercentage.ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Wait for 1 second
|
|
for (Int32 i = 0; i < WaitBeforeLogging; i++)
|
|
{
|
|
if ((token.IsCancellationRequested) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} {FirstHitLevelPercentage.ToString(this.Culture)}/{FirstHitLevelPercMax.ToString(this.Culture)}; {(this.TofRecordingTime + WaitBeforeLogging - i).ToString(this.Culture)}s");
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
#endregion
|
|
#region Record TOF
|
|
GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, true);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start collecting data at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path(0);
|
|
|
|
for (Int32 Seconds = 0; Seconds < this.TofRecordingTime; Seconds++) // eight seconds remove /2
|
|
{
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
|
|
// if (Seconds % 60 == 0)
|
|
Int32 ActivityCheckInterval = GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeActivityCheckInterval();
|
|
if (Int32.Equals((Seconds % ActivityCheckInterval), 0))
|
|
Ok = this.ActivityCheck(ref LinecounterFollowing, Seconds);
|
|
// else
|
|
// Ok = true;
|
|
if (Ok && !GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} {FirstHitLevelPercentage.ToString(this.Culture)}/{ FirstHitLevelPercMax.ToString(this.Culture)}; {(this.TofRecordingTime - Seconds).ToString(this.Culture)}s");
|
|
Misc.WaitNSeconds(1); // replace 2 with 1
|
|
}
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Activity check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
}
|
|
GenesisZeroFlow.Display.StatusLabel($"{ GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} { FirstHitLevelPercentage.ToString(this.Culture)}/{FirstHitLevelPercMax.ToString(this.Culture)}; 0s");
|
|
|
|
Ok = true;
|
|
#endregion
|
|
#region Calculate mean value
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Calculate mean value at {this.MeterType}{this.MeterIndex}; PATH{(Path + 1).ToString(this.Culture)}\n", this.Culture);
|
|
TofAvgMean[Path] = GenesisZeroFlow._GenesisZeroFlow.GetTotalTimeOfFlightAverage()[this.MeterNumber][Path].Mean();
|
|
if(TofAvgMean[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)}; Value = {Math.Round(TofAvgMean[Path], 4).ToString("000.0000", this.Culture)}\n", this.Culture);
|
|
this.LeaveSequence();
|
|
return false;
|
|
}
|
|
GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, true);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Mean value at {this.MeterType}{this.MeterIndex}; PATH{(Path + 1).ToString(this.Culture)}; Value = {Math.Round(TofAvgMean[Path], 4).ToString("000.0000", this.Culture)}\n", this.Culture);
|
|
TofAvgMeanTotal[Path].Add(TofAvgMean[Path]);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetAmpValuesToLog(this.MeterNumber, Path, $"{ GenesisZeroFlow._GenesisZeroFlow.GetAmpValuesToLog()[this.MeterNumber][Path]} {Math.Round(TofAvgMean[Path], 4).ToString("000.0000", this.Culture)}\n");
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Write raw data to files
|
|
if (this.GenerateLogFiles)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmpTest(this.MeterNumber, false);
|
|
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.GetLoggingPathAmplitudeTest()[this.MeterNumber]);
|
|
}
|
|
#endregion
|
|
#region Write mean values to file
|
|
String DateTime = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
|
|
if (this.GenerateMeanFiles)
|
|
{
|
|
for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetAmpValuesToLog()[this.MeterNumber][Constants.PATH0], $@"..\ZeroflowCalibrationTool_MeanAmplitude_{this.MeterType}{this.MeterIndex}_PATH{Path + 1}_{TempPcbID}_{DateTime}.csv");
|
|
}
|
|
|
|
|
|
this.ClearData();
|
|
#endregion
|
|
#region Calculate optimal point
|
|
Double[] DistanceLeft = new Double[Constants.NumberOfPaths];
|
|
DistanceLeft = ArrayInit.Path((Double)0);
|
|
Double[] DistanceRight = new Double[Constants.NumberOfPaths];
|
|
DistanceRight = ArrayInit.Path((Double)0);
|
|
Boolean[] CalculationFailed = new Boolean[Constants.NumberOfPaths];
|
|
CalculationFailed = ArrayInit.Path(false);
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start calculating optimal points at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Boolean OptPointFailed = false;
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
CalculationFailed[Path] = CalculateOptimalPoint(Path, TofAvgMeanTotal[Path], out DistanceLeft[Path], out DistanceRight[Path], out OptimalPoint[Path]);
|
|
if (Boolean.Equals(CalculationFailed[Path], false))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Optimal point calculation successful at {this.MeterType}{this.MeterIndex}, PATH{Path + 1}; Value = {OptimalPoint[Path].ToString(this.Culture)}\n", this.Culture);
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Optimal point calculation failed at {this.MeterType}{this.MeterIndex}, PATH{Path + 1}\n", this.Culture);
|
|
OptPointFailed = true;
|
|
}
|
|
if (OptPointFailed || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Check value
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start optimal point values check at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Boolean OptimalPointOK = true;
|
|
for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if(!this.CheckOptimalPoint(OptimalPoint[Path], out DebugMessage))
|
|
OptimalPointOK = false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t {DebugMessage}, PATH{Path + 1}\n", this.Culture);
|
|
}
|
|
if ((!OptimalPointOK) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
#endregion
|
|
#region Check distance
|
|
Boolean CheckDistOK = true;
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (!this.CheckDistance(DistanceLeft[Path], DistanceRight[Path], out DebugMessage))
|
|
CheckDistOK = false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t {DebugMessage}, PATH{Path +1}\n", this.Culture);
|
|
}
|
|
if (!CheckDistOK || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
#endregion
|
|
#region Set first hit level percentage registers
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start writing to percentage registers at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture)}");
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
|
|
String RegValue = String.Empty;
|
|
switch (Path)
|
|
{
|
|
case Constants.PATH0: RegValue = Register.Genesisflow.FirstHitPercent1;
|
|
break;
|
|
case Constants.PATH1: RegValue = Register.Genesisflow.FirstHitPercent2;
|
|
break;
|
|
case Constants.PATH2: RegValue = Register.Genesisflow.FirstHitPercent3;
|
|
break;
|
|
default: RegValue = Register.Genesisflow.FirstHitPercent1;
|
|
break;
|
|
};
|
|
Ok = WriteRegister(GenesisMeter, "Percentage", RegValue, OptimalPoint[Path], OptimalPoint[Path].ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
//here
|
|
|
|
#region Set first hit update period to 10
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
Ok = WriteRegister(GenesisMeter, "first hit update period", Register.Genesisflow.FirstHitUpdatePeriod, FirstHitUpdatePeriodeValueEnd, FirstHitUpdatePeriodeValueEnd.ToString(this.Culture));
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
#endregion
|
|
#region Set first hit shift to 4
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
Ok = WriteRegister(GenesisMeter, "First hit shift", Register.Genesisflow.FirstHitShift, FirstHitShiftValueEnd, FirstHitShiftValueEnd.ToString(this.Culture));
|
|
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[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path((Int32)0);
|
|
Boolean Ok = true;
|
|
Int32 ActivityCheckInterval = GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeActivityCheckInterval();
|
|
Ok = this.ThermoActivityCheck(ref LinecounterFollowing, 0);
|
|
#endregion
|
|
#region Test sequence
|
|
#region Check upper 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)}\t\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}\t\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)}\t\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}\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
|
|
}
|
|
#endregion
|
|
|
|
catch (Exception ex)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
ErrorLog.Log(LogErrReason.Exeption, "Amplitude.PerformTemperatureMonitoring() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
|
|
return false;
|
|
}
|
|
#endregion
|
|
}
|
|
return Ok;
|
|
}
|
|
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 (!Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path], 0))
|
|
{
|
|
if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
|
|
return false;
|
|
else
|
|
lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path];
|
|
|
|
}
|
|
if ((seconds > 0) && (Boolean.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[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 (!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 WriteRegister(ZeroFlowGenesisMeter genesisMeter, String RegisterText, string reg, Int32 value,
|
|
String ValueText)
|
|
{
|
|
return WriteRegister(genesisMeter, RegisterText, reg, value, ValueText, 4);
|
|
}
|
|
|
|
private Boolean WriteRegister(ZeroFlowGenesisMeter genesisMeter, String RegisterText, string reg, Int32 value, String ValueText, int RetrysLeft )
|
|
{
|
|
var Ok = false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = genesisMeter.WriteRegisterSafe(reg, value);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
|
|
if (Ok == false && RetrysLeft > 0)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register retry at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
return WriteRegister(genesisMeter, RegisterText, reg, value, ValueText, RetrysLeft - 1);
|
|
}
|
|
return Ok;
|
|
}
|
|
private Boolean CalculateOptimalPoint(UInt16 path, List<Double> TofAvg, out Double left, out Double right, out Int32 xAtOptimalPoint)
|
|
{
|
|
List<Double> ValuesLeft = new List<Double>();
|
|
List<Double> ValuesRight = new List<Double>();
|
|
List<Double> MinDistance = new List<Double>();
|
|
xAtOptimalPoint = 0;
|
|
Boolean Error = true;
|
|
left = 0;
|
|
right = 0;
|
|
|
|
ValuesLeft = this.CalculateNearestDistanceLeft(TofAvg, out left);
|
|
ValuesRight = this.CalculateNearestDistanceRight(TofAvg, out right);
|
|
|
|
for (UInt16 i = 0; i < ValuesLeft.Count(); i++)
|
|
{
|
|
Double temp1 = ValuesLeft.ElementAt(i);
|
|
Double temp2 = ValuesRight.ElementAt(i);
|
|
Misc.WaitNMilliseconds(10);
|
|
MinDistance.Add(Math.Min(temp1, temp2));
|
|
}
|
|
|
|
//String mindistance = $"mindistance: PATH{path.ToString(GlobalCulture)}\n";
|
|
//for (Int16 i = 0; i < MinDistance.Count(); i++)
|
|
//{
|
|
// Double temp = MinDistance.ElementAt(i);
|
|
// Misc.WaitNMilliseconds(10);
|
|
// mindistance = $"{mindistance}{temp.ToString(GlobalCulture)}\n";
|
|
//}
|
|
//Logging.WriteToFile(mindistance, @"..\mindistance_PATH"+ path.ToString() + ".txt");
|
|
|
|
Double Maximum = 0;
|
|
|
|
for (Int16 i = 0; i < MinDistance.Count(); i++)
|
|
{
|
|
if ((!Int16.Equals(i, 0)) && (!Int16.Equals(i, (Int16)(TofAvg.Count() - 1))))
|
|
{
|
|
if (MinDistance.ElementAt(i) > Maximum)
|
|
{
|
|
Maximum = MinDistance.ElementAt(i);
|
|
xAtOptimalPoint = (Int32)i + this.FirstHitLevelPercMin;
|
|
Error = false;
|
|
}
|
|
/*
|
|
if ((ValuesLeft.ElementAt(i - 1) > ValuesRight.ElementAt(i - 1)) && (ValuesRight.ElementAt(i + 1) > ValuesLeft.ElementAt(i + 1)))
|
|
{
|
|
xAtOptimalPoint = i + this.FirstHitLevelPercMin;
|
|
Error = false;
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
return Error;
|
|
}
|
|
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++)
|
|
{
|
|
Detected = false;
|
|
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)
|
|
NearestDistance = this.FirstHitLevelPercMax - Percentage;
|
|
|
|
Distance.Add(NearestDistance);
|
|
}
|
|
|
|
for (Int16 i = 0; i < (Int16)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 Percentage = this.FirstHitLevelPercMax; Percentage >= (this.FirstHitLevelPercMin); Percentage--)
|
|
{
|
|
Detected = false;
|
|
|
|
for (Int32 ProportionFollowing = Percentage; ProportionFollowing >= this.FirstHitLevelPercMin; ProportionFollowing--)
|
|
{
|
|
if ((TofAvg.ElementAt(ProportionFollowing - FirstHitLevelPercMin)) - (TofAvg.ElementAt(Percentage - FirstHitLevelPercMin)) < -this.TriggerValue)
|
|
{
|
|
NearestDistance = Percentage - ProportionFollowing;
|
|
Detected = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Detected)
|
|
NearestDistance = Percentage - this.FirstHitLevelPercMin;
|
|
|
|
Distance.Add(NearestDistance);
|
|
}
|
|
|
|
|
|
Distance.Reverse();
|
|
|
|
for (Int16 i = 0; i < Distance.Count(); i++)
|
|
{
|
|
if (Distance.ElementAt(i) >= right)
|
|
{
|
|
right = Distance.ElementAt(i);
|
|
}
|
|
}
|
|
return Distance;
|
|
}
|
|
private Boolean CheckOptimalPoint(Int32 optimalPoint, out String debugMessage)
|
|
{
|
|
Boolean Ok = true;
|
|
debugMessage = $"Optimal point check successful at {this.MeterType}{this.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 {this.MeterType}{this.MeterIndex}";
|
|
Ok = false;
|
|
return Ok;
|
|
}
|
|
|
|
if (optimalPoint < this.OptimumMinValue)
|
|
{
|
|
debugMessage = $"Optimal point minimum check failed at {this.MeterType}{this.MeterIndex}";
|
|
Ok = false;
|
|
return Ok;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean CheckDistance(Double left, Double right, out String debugMessage)
|
|
{
|
|
Boolean Ok = true;
|
|
debugMessage = $"Distance check successful at {this.MeterType}{this.MeterIndex}";
|
|
|
|
if (left < this.OptimumMinDistance)
|
|
{
|
|
Ok = false;
|
|
debugMessage = $"Distance check failed at {this.MeterType}{this.MeterIndex}";
|
|
return Ok;
|
|
}
|
|
|
|
if (right < this.OptimumMinDistance)
|
|
{
|
|
Ok = false;
|
|
debugMessage = $"Distance check failed at {this.MeterType}{this.MeterIndex}";
|
|
return Ok;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
private void LeaveSequence()
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, false);
|
|
|
|
#region Write raw data to files
|
|
if (this.GenerateLogFiles)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmpTest(this.MeterNumber, false);
|
|
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.GetLoggingPathAmplitudeTest()[this.MeterNumber]);
|
|
}
|
|
#endregion
|
|
|
|
this.ClearData();
|
|
}
|
|
private void ClearData()
|
|
{
|
|
try
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Path);
|
|
GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty);
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exeption, "Amplitude.ClearData() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
|
|
}
|
|
}
|
|
|
|
public void Initialize(String pcbID, String meterType, Int32 optimumMinValue, Int32 optimumMaxValue, Int32 optimumMinDistance, Int32 firstHitLevelPropMin, Int32 firstHitLevelPropMax, Int32 tofRecordingTime, Double triggerValue, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, Boolean generateMeanFiles, Boolean generateLogFiles)
|
|
{
|
|
this.TofRecordingTime = tofRecordingTime;
|
|
this.FirstHitLevelPercMin = firstHitLevelPropMin;
|
|
this.FirstHitLevelPercMax = firstHitLevelPropMax;
|
|
this.TriggerValue = triggerValue;
|
|
this.OptimumMinValue = optimumMinValue;
|
|
this.OptimumMaxValue = optimumMaxValue;
|
|
this.OptimumMinDistance = optimumMinDistance;
|
|
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.PcbID = pcbID;
|
|
this.GenerateMeanFiles = generateMeanFiles;
|
|
this.GenerateLogFiles = generateLogFiles;
|
|
}
|
|
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 Int32 FirstHitLevelPercMin { get; set; }
|
|
private Int32 FirstHitLevelPercMax { get; set; }
|
|
private Int32 TofRecordingTime { get; set; }
|
|
private Double TriggerValue { get; set; }
|
|
private Int32 OptimumMinValue { get; set; }
|
|
private Int32 OptimumMaxValue { get; set; }
|
|
private Double OptimumMinDistance { get; set; }
|
|
private Double[] TempDeviationMin { get; set; }
|
|
private Double[] GetTempDeviationMin()
|
|
{
|
|
return (Double[])TempDeviationMin.Clone();
|
|
}
|
|
private Double[] TempDeviationMax { get; set; }
|
|
private Double[] GetTempDeviationMax()
|
|
{
|
|
return (Double[])TempDeviationMax.Clone();
|
|
}
|
|
private Double UpperTempLimit { get; set; }
|
|
private Double LowerTempLimit { get; set; }
|
|
private Double TempDeviationLimit { get; set; }
|
|
private Boolean GenerateMeanFiles { get; set; }
|
|
private Boolean GenerateLogFiles { get; set; }
|
|
|
|
}
|
|
} |