1220 lines
65 KiB
C#
1220 lines
65 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 partial class GenesisZeroFlow : Form
|
|
{
|
|
public Boolean TempMonitoringFailed;
|
|
|
|
private Double[][] MeasuredTemps = new Double[Constants.NumberOfThermometers][];
|
|
|
|
private Boolean[][] MeasuredTempsIndicator = new Boolean[Constants.NumberOfThermometers][];
|
|
|
|
|
|
public void SetMeasuredTemps(UInt16 thermoNumber, UInt16 path, Double value)
|
|
{
|
|
MeasuredTemps[thermoNumber][path] = value;
|
|
}
|
|
public void SetMeasuredTempsIndicator(UInt16 thermoNumber, UInt16 path, Boolean value)
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<UInt16, UInt16, Boolean>)SetMeasuredTempsIndicator, thermoNumber, path, value);
|
|
return;
|
|
}
|
|
MeasuredTempsIndicator[thermoNumber][path] = value;
|
|
}
|
|
public Double GetMeasuredTemps(UInt16 thermoNumber, UInt16 path)
|
|
{
|
|
return MeasuredTemps[thermoNumber][path];
|
|
}
|
|
public Boolean GetMeasuredTempsIndicator(UInt16 thermoNumber, UInt16 path)
|
|
{
|
|
Boolean temp = MeasuredTempsIndicator[thermoNumber][path];
|
|
return temp;
|
|
}
|
|
|
|
}
|
|
public static class TempCalibrationSequences
|
|
{
|
|
public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, Boolean manTempAcquisition, 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);
|
|
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];
|
|
|
|
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;
|
|
|
|
List<TempCalibration> listTempCalib = new List<TempCalibration>();
|
|
List<TempCalibration> listThermoTempCalib = new List<TempCalibration>();
|
|
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)
|
|
listTempCalib.Add(new TempCalibration(Meter, currentMeter, culture));
|
|
else
|
|
listTempCalib.Add(new TempCalibration(Meter, culture));
|
|
}
|
|
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
{
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Thermo + 11));
|
|
|
|
if (currentMeter != null)
|
|
listThermoTempCalib.Add(new TempCalibration(Thermo, currentMeter, culture));
|
|
else
|
|
listThermoTempCalib.Add(new TempCalibration(Thermo, culture));
|
|
}
|
|
#region Initialize
|
|
foreach (var tempcalib in listTempCalib)
|
|
{
|
|
tempcalib.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[tempcalib.MeterNumber], Constants.Meter, 0, upperTempLimit, lowerTempLimit, tempDeviationLimit);
|
|
tempcalib.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
foreach (var thermotempcalib in listThermoTempCalib)
|
|
{
|
|
thermotempcalib.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermotempcalib.MeterNumber], Constants.Thermo, 0, upperTempLimit, lowerTempLimit, tempDeviationLimit);
|
|
thermotempcalib.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region Perform tests
|
|
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
// Temperature acquisition
|
|
#region Get manually measured temperatures
|
|
if(manTempAcquisition)
|
|
GetManualTemperatures(MeterEnable, culture);
|
|
|
|
// For what?
|
|
Int32 NumberOfTextboxes = 0;
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
if (MeterEnable[Meter])
|
|
NumberOfTextboxes++;
|
|
}
|
|
if (Int32.Equals(NumberOfTextboxes, 0))
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
|
|
if (manTempAcquisition)
|
|
{
|
|
listTempCalib[Constants.Meter1].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter1());
|
|
listTempCalib[Constants.Meter2].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter2());
|
|
listTempCalib[Constants.Meter3].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter3());
|
|
listTempCalib[Constants.Meter4].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter4());
|
|
listTempCalib[Constants.Meter5].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter5());
|
|
listTempCalib[Constants.Meter6].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter6());
|
|
listTempCalib[Constants.Meter7].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter7());
|
|
listTempCalib[Constants.Meter8].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter8());
|
|
listTempCalib[Constants.Meter9].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter9());
|
|
listTempCalib[Constants.Meter10].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter10());
|
|
}
|
|
#endregion
|
|
// Set meter temperatures
|
|
foreach (var tempcalib in listTempCalib)
|
|
tempcalib.Meter(ThermoEnable, manTempAcquisition, MeterEnable[tempcalib.MeterNumber], ref MeterTaskStarted[tempcalib.MeterNumber], ref MeterSequenceFailed[tempcalib.MeterNumber], ref NextDelayTime, token);
|
|
// Thermometers
|
|
foreach (var tempthermocalib in listThermoTempCalib)
|
|
{
|
|
if (ThermoEnable[tempthermocalib.MeterNumber])
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(tempthermocalib.MeterNumber, true);
|
|
GenesisZeroFlow.Display.DebugMessage($"{tempthermocalib.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING started at {tempthermocalib.MeterType}{tempthermocalib.MeterIndex}\n", tempthermocalib.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(tempthermocalib.MeterNumber, true);
|
|
}
|
|
Misc.WaitNMilliseconds(300);
|
|
tempthermocalib.Thermometer(ThermoEnable[tempthermocalib.MeterNumber], ref MeterTaskStarted[tempthermocalib.MeterNumber], ref MeterSequenceFailed[tempthermocalib.MeterNumber], ref NextDelayTime, token);
|
|
}
|
|
#endregion
|
|
#region Wait for tasks
|
|
while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
|
|
{
|
|
#region Temperature check
|
|
foreach (var thermotempcalib in listThermoTempCalib)
|
|
{
|
|
if (CheckArray(MeterTaskCompleted) && (ThermoEnable[thermotempcalib.MeterNumber])) // If all METERs finished, not THERMOMETERs
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(thermotempcalib.MeterNumber, false);
|
|
GenesisZeroFlow.Display.DebugMessage($"{thermotempcalib.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {thermotempcalib.MeterType}{thermotempcalib.MeterIndex}\n", thermotempcalib.Culture);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Abort check
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
cancellationTokenSource.Cancel();
|
|
aborted = true;
|
|
}
|
|
#endregion
|
|
#region Check result
|
|
Misc.WaitNSeconds(1);
|
|
#region Meter
|
|
foreach (var tempcalib in listTempCalib)
|
|
{
|
|
MeterTaskCompleted[tempcalib.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[tempcalib.MeterNumber], tempcalib.MyTask);
|
|
// Stop temperature check
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(tempcalib.MeterNumber, !MeterTaskCompleted[tempcalib.MeterNumber]);
|
|
}
|
|
foreach (var tempcalib in listTempCalib)
|
|
MeterSequenceFailed[tempcalib.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[tempcalib.MeterNumber], tempcalib.MyTask);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
#endregion
|
|
#region Thermometer
|
|
foreach (var thermotempcalib in listThermoTempCalib)
|
|
{
|
|
ThermoTaskCompleted[thermotempcalib.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[thermotempcalib.MeterNumber], thermotempcalib.MyTask);
|
|
// Stop temperature check
|
|
GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(thermotempcalib.MeterNumber, !MeterTaskCompleted[thermotempcalib.MeterNumber]);
|
|
}
|
|
foreach (var thermotempcalib in listThermoTempCalib)
|
|
ThermoSequenceFailed[thermotempcalib.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermotempcalib.MeterNumber], thermotempcalib.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 tempcalib in listTempCalib)
|
|
MeterSequenceFailed[tempcalib.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[tempcalib.MeterNumber], tempcalib.MyTask);
|
|
foreach (var thermotempcalib in listThermoTempCalib)
|
|
ThermoSequenceFailed[thermotempcalib.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermotempcalib.MeterNumber], thermotempcalib.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 tempcalib in listTempCalib)
|
|
TaskOperations.CheckAndDispose(tempcalib.MyTask);
|
|
foreach (var thermotempcalib in listThermoTempCalib)
|
|
TaskOperations.CheckAndDispose(thermotempcalib.MyTask);
|
|
#endregion
|
|
#region Clear data
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
|
|
#endregion
|
|
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
}
|
|
|
|
public static Boolean TotalTempCal(MeterBatch globalMeterBatch, Boolean enable, Boolean adjust, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, CultureInfo culture, frmTempCalibration parent)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean SequenceFailed = false;
|
|
Boolean TaskStarted = false;
|
|
Boolean TaskCompleted = false;
|
|
Double RefTemp = 0.0;
|
|
List<TempCalibration> listTempCalib = new List<TempCalibration>();
|
|
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Constants.Meter1 + 1));
|
|
if (currentMeter != null)
|
|
listTempCalib.Add(new TempCalibration(Constants.Meter1, currentMeter, culture));
|
|
else
|
|
listTempCalib.Add(new TempCalibration(Constants.Meter1, culture));
|
|
|
|
foreach (var tempcalib in listTempCalib)
|
|
{
|
|
tempcalib.Initialize(String.Empty, Constants.Thermo, RefTemp, upperTempLimit, lowerTempLimit, tempDeviationLimit);
|
|
tempcalib.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
#endregion
|
|
#region Perform tests
|
|
#region Get manually measured temperatures
|
|
if (adjust)
|
|
{
|
|
frmTempCalibration.DisplayTempCal.StatusLabel("Enter reference temperature value");
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
frmTempCalibration.DisplayTempCal.StatusLabel("Press OK");
|
|
}
|
|
GetTemperaturesTempCal(enable, parent);
|
|
Int32 NumberOfTextboxes = 0;
|
|
|
|
if (enable)
|
|
NumberOfTextboxes++;
|
|
|
|
if (Int32.Equals(NumberOfTextboxes, 0))
|
|
return SequenceFailed;
|
|
#endregion
|
|
if (adjust)
|
|
{
|
|
TemperatureFieldTempCal._TemperatureFieldTempCal.SetEnabledGbLogging(false);
|
|
listTempCalib[Constants.Meter1].SetRefTemperature(TemperatureFieldTempCal._TemperatureFieldTempCal.GetValueMeter1());
|
|
frmTempCalibration.DisplayTempCal.TempCalRefTemperatureLabel(TemperatureFieldTempCal._TemperatureFieldTempCal.GetValueMeter1().ToString("0.00", culture));
|
|
}
|
|
else
|
|
TemperatureFieldTempCal._TemperatureFieldTempCal.SetEnabledGbLogging(true);
|
|
|
|
foreach (var tempcalib in listTempCalib)
|
|
tempcalib.MeterTempCal(enable, ref TaskStarted, ref SequenceFailed, adjust);
|
|
#endregion
|
|
#region Wait for tasks
|
|
Boolean SequenceOk = false;
|
|
|
|
while (!TaskCompleted)
|
|
{
|
|
foreach (var tempcalib in listTempCalib)
|
|
TaskCompleted = TaskOperations.WaitFor(TaskStarted, tempcalib.MyTask);
|
|
|
|
Misc.WaitNSeconds(1);
|
|
|
|
foreach (var tempcalib in listTempCalib)
|
|
SequenceFailed = TaskOperations.GetResult(TaskStarted, tempcalib.MyTask);
|
|
SequenceOk = !SequenceFailed;
|
|
frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
|
|
}
|
|
|
|
foreach (var tempcalib in listTempCalib)
|
|
SequenceFailed = TaskOperations.GetResult(TaskStarted, tempcalib.MyTask);
|
|
|
|
SequenceOk = !SequenceFailed;
|
|
frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
|
|
#endregion
|
|
#region Destroy tasks
|
|
foreach (var tempcalib in listTempCalib)
|
|
{
|
|
TaskOperations.CheckAndDispose(tempcalib.MyTask);
|
|
}
|
|
#endregion
|
|
#region Clear data
|
|
if (Boolean.Equals(adjust, false))
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE MEASUREMENT stopped\n", culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"{Debugmessages.Line}", culture);
|
|
}
|
|
#endregion
|
|
|
|
return SequenceFailed;
|
|
}
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// For ZeroFlowCalibration tool
|
|
/// </summary>
|
|
/// <param name="enable"></param>
|
|
/// <param name="culture"></param>
|
|
private static void GetManualTemperatures(Boolean[] enable, CultureInfo culture)
|
|
{
|
|
if (Boolean.Equals(GenesisZeroFlow._GenesisZeroFlow.AbortIndicator, false))
|
|
{
|
|
// GenesisZeroFlow.Display.SetProgressPanel(StatusPanelItems.TempCal);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION sequence started\n", culture);
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilTemperatureCalibrationFinished(culture));
|
|
GenesisZeroFlow.Display.TemperatureField(enable);
|
|
}
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence stopped\n", culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.StopMainSequence(GenesisZeroFlow.PredefinedMessages.ZeroflowCalibrationSequenceStopped(culture), MessageBoxIcon.Error, culture);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// For temperature calibration tool
|
|
/// </summary>
|
|
/// <param name="enable"></param>
|
|
private static void GetTemperaturesTempCal(Boolean enable, frmTempCalibration parent = null)
|
|
{
|
|
if (parent == null)
|
|
{
|
|
frmTempCalibration.DisplayTempCal.SetProgressPanel(StatusPanelItems.TempCal);
|
|
frmTempCalibration.DisplayTempCal.TemperatureFieldTempCal();
|
|
}
|
|
else
|
|
{
|
|
parent.Invoke(new Action(() =>
|
|
{
|
|
frmTempCalibration.DisplayTempCal.SetProgressPanel(StatusPanelItems.TempCal);
|
|
frmTempCalibration.DisplayTempCal.TemperatureFieldTempCal();
|
|
}));
|
|
}
|
|
|
|
}
|
|
}
|
|
public class TempCalibration
|
|
{
|
|
private readonly ZeroFlowGenesisMeter GenesisMeter;
|
|
public Task<Boolean> MyTask { get; internal set; }
|
|
public TempCalibration(UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
this.MeterNumber = meterNumber;
|
|
this.Culture = culture;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
public TempCalibration(UInt16 meterNumber, IMeter meter, CultureInfo culture)
|
|
{
|
|
if (meter is ZeroFlowGenesisMeter)
|
|
{
|
|
GenesisMeter = meter as ZeroFlowGenesisMeter;
|
|
}
|
|
this.MeterNumber = meterNumber;
|
|
this.Culture = culture;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
internal void Meter(Boolean[] thermoEnable, Boolean manTempAcquisition, 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;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
Boolean _sequenceFailed = sequenceFailed;
|
|
Int32 temp = DelayTime;
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
//if ((!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
{
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(temp);
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
//if (enable) // tbc
|
|
//{
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)) && (!token.IsCancellationRequested))
|
|
{
|
|
#region Abort
|
|
if (!token.IsCancellationRequested)
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
|
|
String Text = String.Empty;
|
|
|
|
#region Testprocedure
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
Ok = this.PerformTest(thermoEnable, manTempAcquisition, PcbID, token);
|
|
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION 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
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION 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;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
AskForActions = DialogResult.Cancel;// MessageBox.Show($"{GenesisZeroFlow.PredefinedMessages.TemCalFailed(this.Culture)}{this.MeterIndex}", "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
}
|
|
#endregion
|
|
}
|
|
// }
|
|
return _sequenceFailed;
|
|
|
|
|
|
}, token);
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
internal void MeterTempCal(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, Boolean adjust)
|
|
{
|
|
#region Definitions and initializations
|
|
DialogResult AskForActions = DialogResult.None;
|
|
var _sequenceFailed = sequenceFailed;
|
|
var _adjust = adjust;
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Avoid CA1062
|
|
if (MyTask == null)
|
|
return;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
{
|
|
taskStarted = true;
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
if (_adjust)
|
|
{
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Testprocedure
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE CALIBRATION sequence started\n", this.Culture);
|
|
|
|
Ok = this.PerformTestTempCal();
|
|
|
|
if (Boolean.Equals(Ok, true))
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE CALIBRATION sequence successful\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
|
|
_sequenceFailed = false;
|
|
AskForActions = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
_sequenceFailed = true;
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE CALIBRATION sequence failed\n", this.Culture);
|
|
AskForActions = MessageBox.Show($"TEMPERATURE CALIBRATION failed", "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE MEASUREMENT started\n", this.Culture);
|
|
}
|
|
|
|
|
|
return _sequenceFailed;
|
|
});
|
|
|
|
}
|
|
#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;
|
|
Boolean _sequenceFailed = sequenceFailed;
|
|
Boolean Ok = true;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
//if (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running) && (!MyTask.IsCompleted))
|
|
{
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(DelayTime);
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
//if(enable) // tbc
|
|
//{
|
|
Boolean LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[MeterNumber];
|
|
|
|
while (LoggingIndicator && (Ok == true))
|
|
{
|
|
#region Abort
|
|
if (!token.IsCancellationRequested)
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Testprocedure
|
|
Ok = this.PerformTempMonitoring(token);
|
|
if (Ok == false)
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
//Misc.WaitNSeconds(1);
|
|
|
|
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
|
|
Misc.WaitNSeconds(1);
|
|
LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
|
|
}
|
|
//}
|
|
|
|
return _sequenceFailed;
|
|
|
|
}, token);
|
|
}
|
|
#endregion
|
|
#region Write log data to file
|
|
//String DateTime = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
|
|
//if (GenesisZeroFlow._GenesisZeroFlow.GetCBMeanAmplitudeFiles())
|
|
//{
|
|
// Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH0], $@"..\GenesisZeroFlowTest_Temperature_THERMOMETER{MeterIndex}_PATH0_{DateTime}.csv");
|
|
// Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH1], $@"..\GenesisZeroFlowTest_Temperature_THERMOMETER{MeterIndex}_PATH1_{DateTime}.csv");
|
|
// Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH2], $@"..\GenesisZeroFlowTest_Temperature_THERMOMETER{MeterIndex}_PATH2_{DateTime}.csv");
|
|
//}
|
|
|
|
this.ClearData();
|
|
#endregion
|
|
}
|
|
private Boolean PerformTest(Boolean[] thermoEnable, Boolean manTempAcquisition, String pcbID, CancellationToken token)
|
|
{
|
|
this.ClearData();
|
|
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
const UInt16 NumberOfAvgValues = 10;
|
|
UInt16[] Values = new UInt16[Constants.NumberOfThermometers];
|
|
Values = ArrayInit.Thermo((UInt16)0);
|
|
Double[][] Temperatures = new Double[Constants.NumberOfThermometers][];
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
{
|
|
Temperatures[Thermo] = new Double[Constants.NumberOfPaths];
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
Temperatures[Thermo][Path] = new Double();
|
|
}
|
|
String DebugMessage = String.Empty;
|
|
#endregion
|
|
#region Automatic acquisition
|
|
if (!manTempAcquisition)
|
|
{
|
|
#region Wait for temperature values
|
|
Boolean[] GotTemperature = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] GotTemperaturesPaths1 = new Boolean[Constants.NumberOfPaths];
|
|
Boolean[] GotTemperaturesPaths2 = new Boolean[Constants.NumberOfPaths];
|
|
|
|
GotTemperature = ArrayInit.Thermo(false);
|
|
GotTemperaturesPaths1 = ArrayInit.Path(false);
|
|
GotTemperaturesPaths2 = ArrayInit.Path(false);
|
|
|
|
while ((!GotTemperature[Constants.Thermo1]) && (thermoEnable[Constants.Thermo1]))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Waiting for Temperature data at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
Boolean temp = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTempsIndicator(Constants.Thermo1, Path);
|
|
GotTemperaturesPaths1[Path] = temp;
|
|
GotTemperature[Constants.Thermo1] = GotTemperaturesPaths1[Constants.PATH0] & GotTemperaturesPaths1[Constants.PATH1] & GotTemperaturesPaths1[Constants.PATH2];
|
|
}
|
|
if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
|
|
while ((!GotTemperature[Constants.Thermo2]) && (thermoEnable[Constants.Thermo2]))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Waiting for Temperature data at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
GotTemperaturesPaths2[Path] = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTempsIndicator(Constants.Thermo2, Path);
|
|
GotTemperature[Constants.Thermo2] = GotTemperaturesPaths2[Constants.PATH0] & GotTemperaturesPaths2[Constants.PATH1] & GotTemperaturesPaths2[Constants.PATH2];
|
|
}
|
|
if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
#endregion
|
|
#region Get temperatures
|
|
if (thermoEnable[Constants.Thermo1])
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
var temp = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTemps(Constants.Thermo1, Path);
|
|
Temperatures[Constants.Thermo1][Path] = temp;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE ACQUISITION at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Math.Round(Temperatures[Constants.Thermo1][Path], 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
|
|
if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
}
|
|
if (thermoEnable[Constants.Thermo2])
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
Temperatures[Constants.Thermo2][Path] = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTemps(Constants.Thermo2, Path);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE ACQUISITION at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Math.Round(Temperatures[Constants.Thermo2][Path], 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
|
|
if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Stop temperature monitoring
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(Constants.Thermo1, false);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(Constants.Thermo2, false);
|
|
#endregion
|
|
#region Automatic acquisition
|
|
List<Double> Avg = new List<Double>();
|
|
if (thermoEnable[Constants.Thermo1])
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
Avg.Add(Temperatures[Constants.Thermo1][Path]);
|
|
}
|
|
if (thermoEnable[Constants.Thermo2])
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
Avg.Add(Temperatures[Constants.Thermo2][Path]);
|
|
}
|
|
if (Avg.Count() > 1)
|
|
this.SetRefTemperature(Avg.Average());
|
|
|
|
else
|
|
{
|
|
if ((Avg.Count() == 1) && (!GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
|
|
{
|
|
this.SetRefTemperature(Avg.ElementAt(0));
|
|
}
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Automatic temperature acquisition not possible at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
this.ClearData();
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Set temperature calibration register
|
|
UInt32 TempToRegister = (UInt32)(this.RefTemp * 4096);
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(Culture));
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.ToFTempCalibrate, TempToRegister);
|
|
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (!Ok || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
#endregion
|
|
#region Wait for some seconds
|
|
const UInt16 WaitingTime = 10;
|
|
Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path(0);
|
|
// GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(this.MeterNumber, true);
|
|
for (UInt16 Time = 0; Time < WaitingTime; Time++)
|
|
{
|
|
Ok = this.ActivityCheck(ref LinecounterFollowing, Time);
|
|
if (Ok && !GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
{
|
|
var Seconds = WaitingTime - Time;
|
|
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitSeconds(Seconds, this.Culture));
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Activity check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, false);
|
|
this.ClearData();
|
|
|
|
return false;
|
|
}
|
|
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, false);
|
|
#endregion
|
|
#region Check temperature
|
|
Ok = this.CheckTemperature(NumberOfAvgValues, out DebugMessage);
|
|
if (Boolean.Equals(Ok, true))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Temperature check OK at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Temperature check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Temperatures at {this.MeterType}{this.MeterIndex}: {DebugMessage}", this.Culture);
|
|
#endregion
|
|
#region Get 'TOF offset1' register
|
|
if (Constants.NumberOfPaths > 0)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterReadFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset1'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
var tmp = BitConverter.ToInt32(GenesisMeter.ReadRegister(Register.Genesisflow.ToFTempOffset1), 0);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH0, tmp);
|
|
Ok = true;
|
|
if (Boolean.Equals(Ok, true))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset1'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset1'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Get 'TOF offset2' register
|
|
if (Constants.NumberOfPaths > 1)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterReadFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset2'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
var tmp = BitConverter.ToInt32(GenesisMeter.ReadRegister(Register.Genesisflow.ToFTempOffset2), 0);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH1, tmp);
|
|
Ok = true;
|
|
if (Boolean.Equals(Ok, true) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset2'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset2'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Get 'TOF offset3' register
|
|
if (Constants.NumberOfPaths > 2)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterReadFinished(this.Culture));
|
|
Ok = false;
|
|
if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset3'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
var tmp = BitConverter.ToInt32(GenesisMeter.ReadRegister(Register.Genesisflow.ToFTempOffset3), 0);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH2, tmp);
|
|
Ok = true;
|
|
if (Boolean.Equals(Ok, true))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset3'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset3'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
this.ClearData();
|
|
return Ok;
|
|
}
|
|
private Boolean PerformTestTempCal()
|
|
{
|
|
this.ClearDataTempCal();
|
|
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String DebugMessage = String.Empty;
|
|
#endregion
|
|
|
|
UInt32 TempToRegister = (UInt32)(RefTemp * 4096);
|
|
|
|
|
|
try
|
|
{
|
|
#region Set temperature calibration register
|
|
frmTempCalibration.DisplayTempCal.StatusLabel("Wait until register write has finished");
|
|
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register\n", this.Culture);
|
|
var temp = BitConverter.GetBytes(TempToRegister);
|
|
Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.ToFTempCalibrate, temp);
|
|
|
|
if (Ok)
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register successful\n", this.Culture);
|
|
else
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register failed\n", this.Culture);
|
|
if (!Ok)
|
|
return false;
|
|
#endregion
|
|
#region Wait for some seconds
|
|
const UInt16 WaitingTime = 20;
|
|
Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path(0);
|
|
frmTempCalibration._frmTempCalibration.SetEnableIndicatorTempTest(true);
|
|
for (UInt16 Time = 0; Time < WaitingTime; Time++)
|
|
{
|
|
Ok = this.ActivityCheckTempCal(ref LinecounterFollowing, Time);
|
|
if (Ok)
|
|
{
|
|
frmTempCalibration.DisplayTempCal.StatusLabel($"Wait {(WaitingTime - Time).ToString(this.Culture)} seconds");
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"DATA CHANNEL:\t\t Activity check failed\n", this.Culture);
|
|
frmTempCalibration._frmTempCalibration.SetEnableIndicatorTempTest(false);
|
|
this.ClearDataTempCal();
|
|
return false;
|
|
}
|
|
}
|
|
frmTempCalibration._frmTempCalibration.SetEnableIndicatorTempTest(false);
|
|
#endregion
|
|
#region Check temperature
|
|
Ok = this.CheckTemperatureTempCal(out DebugMessage);
|
|
if (Ok)
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t Temperature check OK\n", this.Culture);
|
|
else
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t Temperature check failed\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t Temperatures: {DebugMessage}", this.Culture);
|
|
#endregion
|
|
this.ClearDataTempCal();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exeption, "TempCalibration.PerformTestTempCal() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture);
|
|
this.ClearDataTempCal();
|
|
}
|
|
return Ok;
|
|
}
|
|
private Boolean PerformTempMonitoring(CancellationToken token)
|
|
{
|
|
this.ClearData();
|
|
|
|
#region Definitions and initializations
|
|
Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
|
|
LinecounterFollowing = ArrayInit.Path(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}");
|
|
GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTemps(Constants.Meter1, Path, temp);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTempsIndicator(Constants.Meter1, Path, true);
|
|
break;
|
|
case Constants.Meter2:
|
|
GenesisZeroFlow.Display.SetThermoLabel2($"{Temperature}°C");
|
|
GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTemps(Constants.Meter2, Path, temp);
|
|
GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTempsIndicator(Constants.Meter2, Path, true);
|
|
break;
|
|
default: break;
|
|
}
|
|
|
|
if (temp > this.UpperTempLimit)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value check failed at {this.MeterType}{this.MeterIndex}; (actual/ limit) = {Temperature}/ {Math.Round(this.UpperTempLimit, 2).ToString("00.000", this.Culture)}°C\n", this.Culture);
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value successful at {this.MeterType}{this.MeterIndex}; Value = {Temperature}\t\n", this.Culture);
|
|
|
|
if (temp < this.LowerTempLimit)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value check failed at {this.MeterType}{this.MeterIndex}; (actual/ limit) = {Temperature}/ {Math.Round(this.LowerTempLimit, 2).ToString("00.000", this.Culture)}°C\n", this.Culture);
|
|
return false;
|
|
}
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value successful at {this.MeterType}{this.MeterIndex}; Value = {Temperature}\n", this.Culture);
|
|
#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 = $"{DeviationValue.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, "TempCalibration.PerformTemperatureMonitoring() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
return Ok;
|
|
}
|
|
private Boolean CheckTemperature(UInt16 numberOfAvgValues, out String debugMessage)
|
|
{
|
|
#region Definitions and initializations
|
|
Double[] MeasTemperature = new Double[Constants.NumberOfPaths];
|
|
Boolean TempOk = true;
|
|
List<Double>[] AvgValues = new List<Double>[Constants.NumberOfPaths];
|
|
Double Avg = 0;
|
|
|
|
#endregion
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
AvgValues[Path] = new List<Double>();
|
|
for (UInt16 Values = 0; Values < numberOfAvgValues; Values++)
|
|
{
|
|
MeasTemperature[Path] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[this.MeterNumber][Path].TemperatureDegC;
|
|
AvgValues[Path].Add(MeasTemperature[Path]);
|
|
}
|
|
Avg = AvgValues[Path].Average();
|
|
AvgValues[Path].Clear();
|
|
if (Math.Abs(this.RefTemp - Avg) > this.TempDeviationLimit)
|
|
TempOk = false;
|
|
}
|
|
|
|
#region Debug message
|
|
debugMessage = $"Ref. temp = {Math.Round(this.RefTemp, 2).ToString("00.00", this.Culture)}°C at {this.MeterType}{this.MeterIndex}; meas. PATH"; // meas. temp PATH1/2/3 = {Math.Round(MeasTemperature[Constants.PATH0], 2).ToString("00.00", this.Culture)}°C/ {Math.Round(MeasTemperature[Constants.PATH1], 2).ToString("00.00", this.Culture)}°C/ {Math.Round(MeasTemperature[Constants.PATH2], 2).ToString("0.00", this.Culture)}°C\n";
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
debugMessage = $"{debugMessage}{Path}";
|
|
if ((Constants.NumberOfPaths - 1) == Path)
|
|
debugMessage = $"{debugMessage}/";
|
|
else
|
|
debugMessage = $"{debugMessage} = ";
|
|
}
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if ((Constants.NumberOfPaths - 1) == Path)
|
|
debugMessage = $"{debugMessage}{Math.Round(MeasTemperature[Path], 2).ToString("00.00", this.Culture)}°C /";
|
|
else
|
|
debugMessage = $"{debugMessage}{Math.Round(MeasTemperature[Path], 2).ToString("00.00", this.Culture)}°C\n";
|
|
}
|
|
#endregion
|
|
|
|
return TempOk;
|
|
}
|
|
private Boolean CheckTemperatureTempCal(out String debugMessage)
|
|
{
|
|
#region Definitions and initializations
|
|
Double[] MeasTemperature = new Double[Constants.NumberOfPaths];
|
|
MeasTemperature = ArrayInit.Path((Double)0);
|
|
Boolean TempOk = true;
|
|
#endregion
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
MeasTemperature[Path] = frmTempCalibration._frmTempCalibration.GetDecodedAllMeters()[Path].TemperatureDegC;
|
|
if (Math.Abs(this.RefTemp - MeasTemperature[Path]) > this.TempDeviationLimit)
|
|
TempOk = false;
|
|
}
|
|
|
|
#region Debug message
|
|
debugMessage = $"ref. temperature = {this.RefTemp.ToString("00.00", this.Culture)}°C; meas. temperature ";
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
debugMessage = $"{ debugMessage} PATH{(Path + 1).ToString(this.Culture)} = {Math.Round(MeasTemperature[Path], 2).ToString("00.00", this.Culture)}°C;";
|
|
debugMessage = $"{debugMessage}\n";
|
|
#endregion
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
frmTempCalibration.DisplayTempCal.TempCalSetTemperatureLabel(Path, Math.Round(MeasTemperature[Path], 2).ToString("0.00", this.Culture));
|
|
|
|
frmTempCalibration.DisplayTempCal.TempCalRefTemperatureLabel(this.RefTemp.ToString("0.00", this.Culture));
|
|
return TempOk;
|
|
}
|
|
private void ClearData()
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
|
|
// GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Path);
|
|
// GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(this.MeterNumber, false);
|
|
// GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
|
|
// GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Path, 0);
|
|
}
|
|
}
|
|
private void ClearDataTempCal()
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
frmTempCalibration._frmTempCalibration.SetToFTempOffset(Path, 0);
|
|
}
|
|
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.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) && (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], 0)))
|
|
// return false;
|
|
//}
|
|
#endregion
|
|
#region Result
|
|
Ok = !Error;
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean ActivityCheckTempCal(ref Int32[] lineCounterFollowing, Int32 seconds)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = true;
|
|
Boolean Error = false;
|
|
#endregion
|
|
#region Check activity
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if (!(Int32.Equals(frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[Path], 0)))
|
|
{
|
|
if (Int32.Equals(frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[Path], lineCounterFollowing[Path]))
|
|
return false;
|
|
else
|
|
lineCounterFollowing[Path] = frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[Path];
|
|
|
|
}
|
|
if ((seconds > 0) && (Int32.Equals(frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[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;
|
|
}
|
|
public void SetRefTemperature(Double temp)
|
|
{
|
|
this.RefTemp = temp;
|
|
}
|
|
|
|
public void Initialize(String pcbID, String meterType, Double refTemp, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit)
|
|
{
|
|
this.RefTemp = refTemp;
|
|
this.UpperTempLimit = upperTempLimit;
|
|
this.LowerTempLimit = lowerTempLimit;
|
|
this.TempDeviationLimit = tempDeviationLimit;
|
|
this.MeterType = meterType;
|
|
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.PcbID = pcbID;
|
|
}
|
|
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 RefTemp { get; set; }
|
|
private Double UpperTempLimit { get; set; }
|
|
private Double LowerTempLimit { get; set; }
|
|
private Double TempDeviationLimit { get; set; }
|
|
private Double[] TempDeviationMin { get; set; }
|
|
private Double[] GetTempDeviationMin()
|
|
{
|
|
return (Double[])this.TempDeviationMin;
|
|
}
|
|
private Double[] TempDeviationMax { get; set; }
|
|
private Double[] GetTempDeviationMax()
|
|
{
|
|
return (Double[])this.TempDeviationMax;
|
|
}
|
|
|
|
}
|
|
}
|