737 lines
37 KiB
C#
737 lines
37 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using GenesisDisplayTool;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
public static class PreparationSequences
|
|
{
|
|
public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, UInt16 meterSize, Boolean setOffsetToZero, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, out Boolean aborted, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
aborted = false;
|
|
Int32 NextDelayTime = 0;
|
|
Boolean[] MeterTaskStarted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] ThermoTaskStarted = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
|
|
Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
|
|
MeterTaskStarted = ArrayInit.Meter(false);
|
|
MeterSequenceFailed = ArrayInit.Meter(false);
|
|
MeterTaskCompleted = ArrayInit.Meter(false);
|
|
ThermoTaskStarted = ArrayInit.Thermo(false);
|
|
ThermoSequenceFailed = ArrayInit.Thermo(false);
|
|
ThermoTaskCompleted = ArrayInit.Thermo(false);
|
|
|
|
var listPrep = new List<Preparation>();
|
|
var listThermoPrep = new List<Preparation>();
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));
|
|
|
|
if (currentMeter != null)
|
|
listPrep.Add(new Preparation(currentMeter, Meter, culture));
|
|
else
|
|
listPrep.Add(new Preparation(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)
|
|
listThermoPrep.Add(new Preparation(currentMeter, Thermo, culture));
|
|
else
|
|
listThermoPrep.Add(new Preparation(Thermo, culture));
|
|
}
|
|
|
|
foreach (var meterprep in listPrep)
|
|
meterprep.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[meterprep.MeterNumber], Constants.Meter, meterSize, setOffsetToZero, PreparationValues.Samplerate, 0, 0, 0);
|
|
foreach (var thermoprep in listThermoPrep)
|
|
thermoprep.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermoprep.MeterNumber], Constants.Thermo, meterSize, setOffsetToZero, 2, upperTempLimit, lowerTempLimit, tempDeviationLimit);
|
|
#endregion
|
|
|
|
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
|
|
{
|
|
#region Everything else
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
|
|
foreach (var item in listPrep)
|
|
item.AddTask(new Task<Boolean>(() => { return true; }));
|
|
foreach (var item in listThermoPrep)
|
|
item.AddTask(new Task<Boolean>(() => { return true; }));
|
|
foreach (var meterprep in listPrep)
|
|
meterprep.Meter(ref MeterTaskStarted[meterprep.GetMeterNumber()], ref MeterSequenceFailed[meterprep.GetMeterNumber()], ref NextDelayTime, token);
|
|
foreach (var thermoprep in listThermoPrep)
|
|
thermoprep.Thermometer(ref ThermoTaskStarted[thermoprep.GetMeterNumber()], ref ThermoSequenceFailed[thermoprep.GetMeterNumber()], ref NextDelayTime, token);
|
|
#endregion
|
|
#region Wait for tasks (METER)
|
|
Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
|
|
MeterSequenceOk = ArrayInit.Meter(false);
|
|
|
|
while (!CheckArray(MeterTaskCompleted))
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
cancellationTokenSource.Cancel();
|
|
aborted = true;
|
|
}
|
|
listPrep.All(p => TaskOperations.WaitFor(p.MyTask));
|
|
|
|
Misc.WaitNSeconds(1);
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Meter));
|
|
|
|
if (prepToCheck != null && prepToCheck.CurrentMeter != null)
|
|
MeterTaskCompleted[Meter] = TaskOperations.WaitFor(true, prepToCheck.MyTask);
|
|
else
|
|
MeterTaskCompleted[Meter] = true;
|
|
}
|
|
}
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Meter));
|
|
|
|
if (prepToCheck != null)
|
|
MeterSequenceOk[Meter] = !TaskOperations.GetResult(true, prepToCheck.MyTask);
|
|
else
|
|
MeterSequenceOk[Meter] = true;
|
|
}
|
|
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
|
|
|
|
foreach (var item in listPrep)
|
|
TaskOperations.CheckAndDispose(ref item.MyTask);
|
|
#endregion
|
|
#region Wait for tasks (Thermometer)
|
|
Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoSequenceOk = ArrayInit.Thermo(false);
|
|
|
|
while (!CheckArray(MeterTaskCompleted))
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
cancellationTokenSource.Cancel();
|
|
aborted = true;
|
|
}
|
|
listThermoPrep.All(p => TaskOperations.WaitFor(p.MyTask));
|
|
|
|
Misc.WaitNSeconds(1);
|
|
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
{
|
|
var prepToCheck = listThermoPrep.First(p => p.GetMeterNumber().Equals(Thermo));
|
|
if (prepToCheck != null && prepToCheck.CurrentMeter != null)
|
|
MeterTaskCompleted[Thermo] = TaskOperations.WaitFor(true, prepToCheck.MyTask);
|
|
else
|
|
MeterTaskCompleted[Thermo] = true;
|
|
}
|
|
}
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Meter));
|
|
|
|
if (prepToCheck != null)
|
|
MeterSequenceOk[Meter] = !TaskOperations.GetResult(true, prepToCheck.MyTask);
|
|
else
|
|
MeterSequenceOk[Meter] = true;
|
|
}
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
{
|
|
var prepToCheck = listThermoPrep.First(p => p.GetMeterNumber().Equals(Thermo));
|
|
|
|
if (prepToCheck != null)
|
|
ThermoSequenceOk[Thermo] = !TaskOperations.GetResult(true, prepToCheck.MyTask);
|
|
else
|
|
ThermoSequenceOk[Thermo] = true;
|
|
}
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
|
|
|
|
foreach (var item in listPrep)
|
|
TaskOperations.CheckAndDispose(ref item.MyTask);
|
|
foreach (var item in listThermoPrep)
|
|
TaskOperations.CheckAndDispose(ref item.MyTask);
|
|
#endregion
|
|
}
|
|
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
}
|
|
public static Boolean TotalTempCal(MeterBatch globalMeterBatch, UInt16 meterSize, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean SequenceFailed = false;
|
|
Boolean TaskStarted = false;
|
|
Boolean TaskCompleted = false;
|
|
|
|
const Int32 Samplerate = PreparationValues.Samplerate; // 10;
|
|
var listPrep = new List<Preparation>();
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Constants.Meter1 + 1));
|
|
if (currentMeter != null)
|
|
listPrep.Add(new Preparation(currentMeter, Constants.Meter1, culture));
|
|
else
|
|
listPrep.Add(new Preparation(Constants.Meter1, culture));
|
|
|
|
foreach (var prep in listPrep)
|
|
prep.Initialize(String.Empty, Constants.Thermo, meterSize, false, Samplerate, upperTempLimit, lowerTempLimit, tempDeviationLimit);
|
|
#endregion
|
|
|
|
//using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
|
|
//{
|
|
#region Everything else
|
|
//CancellationToken token = cancellationTokenSource.Token;
|
|
var PrepTaskList = new List<Task<Boolean>>();
|
|
|
|
foreach (var item in listPrep)
|
|
item.AddTask(new Task<Boolean>(() => { return true; }));
|
|
foreach (var prep in listPrep)
|
|
prep.MeterTempCal(ref TaskStarted, ref SequenceFailed);
|
|
#endregion
|
|
#region Wait for tasks
|
|
Boolean SequenceOk = false;
|
|
|
|
while (!TaskCompleted)
|
|
{
|
|
listPrep.All(p => TaskOperations.WaitFor(p.MyTask));
|
|
|
|
Misc.WaitNSeconds(1);
|
|
var prepToCheckTempCal = listPrep.First(p => p.GetMeterNumber().Equals(Constants.Meter1));
|
|
if (prepToCheckTempCal != null && prepToCheckTempCal.CurrentMeter != null)
|
|
TaskCompleted = TaskOperations.WaitFor(true, prepToCheckTempCal.MyTask);
|
|
else
|
|
TaskCompleted = true;
|
|
}
|
|
|
|
var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Constants.Meter1));
|
|
if (prepToCheck != null)
|
|
SequenceOk = !TaskOperations.GetResult(true, prepToCheck.MyTask);
|
|
else
|
|
SequenceOk = true;
|
|
|
|
foreach (var item in listPrep)
|
|
TaskOperations.CheckAndDispose(ref item.MyTask);
|
|
#endregion
|
|
//}
|
|
|
|
return SequenceFailed;
|
|
}
|
|
private static Boolean CheckArray(Boolean[] array)
|
|
{
|
|
Boolean Completed = true;
|
|
for (Int16 i = 0; i < array.Count(); i++)
|
|
{
|
|
if (Boolean.Equals(array[i], false))
|
|
return false;
|
|
}
|
|
return Completed;
|
|
}
|
|
}
|
|
|
|
public class Preparation
|
|
{
|
|
|
|
public ZeroFlowGenesisMeter CurrentMeter;
|
|
public Task<Boolean> MyTask;
|
|
internal void AddTask(Task<Boolean> task)
|
|
{
|
|
MyTask = task;
|
|
}
|
|
public Preparation(UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
this.MeterNumber = meterNumber;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
this.Culture = culture;
|
|
}
|
|
public Preparation(IMeter currentMeter, UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
if (currentMeter is ZeroFlowGenesisMeter)
|
|
this.CurrentMeter = (ZeroFlowGenesisMeter)currentMeter;
|
|
|
|
this.MeterNumber = meterNumber;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
this.Culture = culture;
|
|
}
|
|
internal void Meter(ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
Boolean enable = CurrentMeter != null;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
Int32 DelayTime = 0;
|
|
const Int32 DeltaDelay = 5;
|
|
#endregion
|
|
|
|
if (enable)
|
|
{
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
Int32 temp = DelayTime;
|
|
taskStarted = true;
|
|
|
|
var _sequenceFailed = sequenceFailed;
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
Misc.WaitNSeconds(temp);
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Cancelation token
|
|
if (!token.IsCancellationRequested)
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Testprocedure
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
Ok = PerformPreparationMeter(token);
|
|
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.PreparationStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
return true;
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION 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.PreparationFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
return _sequenceFailed;
|
|
});
|
|
}
|
|
}
|
|
internal void Thermometer(ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
|
|
{
|
|
Boolean enable = CurrentMeter != null;
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
Int32 DelayTime = 0;
|
|
const Int32 DeltaDelay = 5;
|
|
#endregion
|
|
|
|
if (enable)
|
|
{
|
|
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
Int32 temp = DelayTime;
|
|
taskStarted = true;
|
|
|
|
var _sequenceFailed = sequenceFailed;
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
Misc.WaitNSeconds(temp);
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Cancelation token
|
|
if (!token.IsCancellationRequested)
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
#endregion
|
|
#region Testprocedure
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
Ok = PerformPreparationThermometer(token);
|
|
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
return true;
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION 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;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
return _sequenceFailed;
|
|
});
|
|
}
|
|
}
|
|
internal void MeterTempCal(ref Boolean taskStarted, ref Boolean sequenceFailed)
|
|
{
|
|
Boolean enable = CurrentMeter != null;
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String DebugMessage = String.Empty;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
#endregion
|
|
|
|
if (enable)
|
|
{
|
|
taskStarted = true;
|
|
var _sequenceFailed = sequenceFailed;
|
|
//var _logOn = logOn;
|
|
//Boolean ReAuthentication = false;
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
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 PREPARATION sequence started\n", this.Culture);
|
|
|
|
Ok = PerformPreparationTempCal();
|
|
if (Ok)
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage("APPLICATION:\t\t PREPARATION sequence successful\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
|
|
_sequenceFailed = false;
|
|
|
|
AskForActions = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage("APPLICATION:\t\t PREPARATION sequence failed\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
|
|
_sequenceFailed = true;
|
|
}
|
|
#endregion
|
|
}
|
|
AskForActions = DialogResult.None;
|
|
|
|
return _sequenceFailed;
|
|
});
|
|
}
|
|
}
|
|
private Boolean PerformPreparationMeter(CancellationToken token)
|
|
{
|
|
#region Definitions and initialisations
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Calibration factor1
|
|
if (Constants.NumberOfPaths > 0)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor1'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.CalFactor1, this.CalibrationFactor1);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor1'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor1'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Calibration factor2
|
|
if (Constants.NumberOfPaths > 1)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor2'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.CalFactor2, this.CalibrationFactor2);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor2'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor2'-register failed at {this.MeterType}{MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Calibration factor3
|
|
if (Constants.NumberOfPaths > 2)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor3'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.CalFactor3, this.CalibrationFactor3);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor3'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor3'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
if (SetOffsetToZero)
|
|
{
|
|
if (Constants.NumberOfPaths > 0)
|
|
{
|
|
#region Zeroflow Offset1
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset1, this.ZeroOffset1);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Zeroflow Offset2
|
|
if (Constants.NumberOfPaths > 1)
|
|
{
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset2, this.ZeroOffset2);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region Zeroflow Offset3
|
|
if (Constants.NumberOfPaths > 2)
|
|
{
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset3, this.ZeroOffset3);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
}
|
|
#endregion
|
|
}
|
|
#region Sample rate
|
|
Ok = false;
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, this.SampleRate);
|
|
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
#endregion
|
|
#region MeterSize
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Metersize'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.MeterSize, this.MeterSize);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Metersize'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Metersize'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
#endregion
|
|
#region LedMode
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, this.LedMode);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
#endregion
|
|
#region TriggerActiv
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterUnsafe(Register.Genesisflow.TriggerActive, 1);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean PerformPreparationThermometer(CancellationToken token)
|
|
{
|
|
#region Definitions and initialisations
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Sample rate
|
|
Ok = false;
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, this.SampleRate);
|
|
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
#endregion
|
|
#region LedMode
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, this.LedMode);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return false;
|
|
#endregion
|
|
return Ok;
|
|
}
|
|
private Boolean PerformPreparationTempCal()
|
|
{
|
|
#region Definitions and initialisations
|
|
Boolean Ok = false;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
String PcbID = CurrentMeter.GetPcbId();
|
|
if (!String.IsNullOrEmpty(PcbID))
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t PcbID = {PcbID}\n", this.Culture);
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t PcbID not available\n", this.Culture);
|
|
PcbID = "n/a";
|
|
//return false;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exeption, "Preparation.PerformPreparationTempCal() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture);
|
|
}
|
|
#region Sample rate
|
|
Ok = false;
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Samplerate'-register\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, this.SampleRate);
|
|
|
|
if (Ok)
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Samplerate'-register successful\n", this.Culture);
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Samplerate'-register failed\n", this.Culture);
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region MeterSize
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Metersize'-register\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.MeterSize, this.MeterSize);
|
|
if (Ok)
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Metersize'-register successful\n", this.Culture);
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Metersize'-register failed\n", this.Culture);
|
|
return false;
|
|
}
|
|
#endregion
|
|
#region LedMode
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'LED mode'-register\n", this.Culture);
|
|
Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, this.LedMode);
|
|
if (Ok)
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'LED mode'-register successful\n", this.Culture);
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'LED mode'-register failed\n", this.Culture);
|
|
return false;
|
|
}
|
|
#endregion
|
|
return Ok;
|
|
}
|
|
public Int32 GetMeterNumber()
|
|
{
|
|
return MeterNumber;
|
|
}
|
|
private Boolean SetOffsetToZero { get; set; }
|
|
|
|
public void Initialize(String pcbID, String meterType, UInt16 meterSize, Boolean setOffsetToZero, Int32 sampleRate, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit)
|
|
{
|
|
this.CalibrationFactor1 = PreparationValues.CalFactor1;
|
|
this.CalibrationFactor2 = PreparationValues.CalFactor2;
|
|
this.CalibrationFactor3 = PreparationValues.CalFactor3;
|
|
this.ZeroOffset1 = PreparationValues.ZeroOffset1;
|
|
this.ZeroOffset2 = PreparationValues.ZeroOffset2;
|
|
this.ZeroOffset3 = PreparationValues.ZeroOffset3;
|
|
this.SampleRate = sampleRate;
|
|
this.MeterSize = meterSize;
|
|
this.LedMode = PreparationValues.LedMode;
|
|
this.SetOffsetToZero = setOffsetToZero;
|
|
this.TempUpperLimit = upperTempLimit;
|
|
this.TempLowerLimit = lowerTempLimit;
|
|
this.TempDeviationLimit = tempDeviationLimit;
|
|
this.MeterType = meterType;
|
|
this.PcbID = pcbID;
|
|
}
|
|
public Int32 MeterNumber { get; private set; }
|
|
public String MeterIndex { get; private set; }
|
|
public String MeterType { get; private set; }
|
|
private String PcbID { get; set; }
|
|
private CultureInfo Culture { get; set; }
|
|
private Int32 CalibrationFactor1 { get; set; }
|
|
private Int32 CalibrationFactor2 { get; set; }
|
|
private Int32 CalibrationFactor3 { get; set; }
|
|
private Int32 ZeroOffset1 { get; set; }
|
|
private Int32 ZeroOffset2 { get; set; }
|
|
private Int32 ZeroOffset3 { get; set; }
|
|
private Int32 SampleRate { get; set; }
|
|
private UInt16 MeterSize { get; set; }
|
|
private Int32 LedMode { get; set; }
|
|
private Double TempUpperLimit { get; set; }
|
|
private Double TempLowerLimit { get; set; }
|
|
private Double TempDeviationLimit { get; set; }
|
|
}
|
|
|
|
} |