893 lines
46 KiB
C#
893 lines
46 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 CompletionSequences
|
|
{
|
|
public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, out Boolean aborted, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
|
|
Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);
|
|
|
|
Boolean[] MeterTaskStarted = new Boolean[Constants.NumberOfMeters];
|
|
MeterTaskStarted = ArrayInit.Meter(false);
|
|
Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
|
|
MeterSequenceOk = ArrayInit.Meter(false);
|
|
Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
|
|
MeterSequenceFailed = ArrayInit.Meter(false);
|
|
Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
|
|
MeterTaskCompleted = ArrayInit.Meter(false);
|
|
|
|
Boolean[] ThermoTaskStarted = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoTaskStarted = ArrayInit.Thermo(false);
|
|
Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoSequenceOk = ArrayInit.Thermo(false);
|
|
Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoSequenceFailed = ArrayInit.Thermo(false);
|
|
Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
|
|
ThermoTaskCompleted = ArrayInit.Thermo(false);
|
|
|
|
Int32 NextDelayTime = 0;
|
|
aborted = false;
|
|
const Int16 LedMode = 6;
|
|
const Int16 StoreCalibration = 1;
|
|
var listCompl = new List<Completion>();
|
|
var listMeterNumber = new List<Int32>();
|
|
var thermolistCompl = new List<Completion>();
|
|
var thermolistMeterNumber = new List<Int32>();
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));
|
|
|
|
if (currentMeter != null)
|
|
listCompl.Add(new Completion(Meter, currentMeter, culture));
|
|
else
|
|
listCompl.Add(new Completion(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)
|
|
thermolistCompl.Add(new Completion(Thermo, currentMeter, culture));
|
|
else
|
|
thermolistCompl.Add(new Completion(Thermo, culture));
|
|
}
|
|
#region Initialize
|
|
foreach (var compl in listCompl)
|
|
{
|
|
compl.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[compl.MeterNumber], Constants.Meter, LedMode, StoreCalibration);
|
|
compl.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
foreach (var thermocompl in thermolistCompl)
|
|
{
|
|
thermocompl.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermocompl.MeterNumber], Constants.Thermo, LedMode, StoreCalibration);
|
|
thermocompl.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region Perform tests
|
|
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
// Completion
|
|
|
|
// todo move action into tasks
|
|
foreach (var compl in listCompl)
|
|
compl.Meter(MeterEnable[compl.MeterNumber], ref MeterTaskStarted[compl.MeterNumber], ref MeterSequenceFailed[compl.MeterNumber], ref NextDelayTime, token);
|
|
foreach (var thermocompl in thermolistCompl)
|
|
thermocompl.Thermometer(ThermoEnable[thermocompl.MeterNumber], ref ThermoTaskStarted[thermocompl.MeterNumber], ref ThermoSequenceFailed[thermocompl.MeterNumber], ref NextDelayTime, token);
|
|
#endregion
|
|
#region Wait for tasks
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = false;
|
|
|
|
while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
aborted = true;
|
|
cancellationTokenSource.Cancel();
|
|
}
|
|
Misc.WaitNSeconds(1);
|
|
|
|
foreach (var compl in listCompl)
|
|
MeterTaskCompleted[compl.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[compl.MeterNumber], compl.MyTask);
|
|
foreach (var compl in listCompl)
|
|
MeterSequenceFailed[compl.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[compl.MeterNumber], compl.MyTask);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
|
|
foreach (var thermocompl in thermolistCompl)
|
|
ThermoTaskCompleted[thermocompl.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[thermocompl.MeterNumber], thermocompl.MyTask);
|
|
foreach (var thermocompl in thermolistCompl)
|
|
ThermoSequenceFailed[thermocompl.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermocompl.MeterNumber], thermocompl.MyTask);
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
ThermoSequenceOk[Thermo] = !ThermoSequenceFailed[Thermo];
|
|
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
|
|
}
|
|
#endregion
|
|
|
|
foreach (var compl in listCompl)
|
|
MeterSequenceFailed[compl.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[compl.MeterNumber], compl.MyTask);
|
|
foreach (var thermocompl in thermolistCompl)
|
|
ThermoSequenceFailed[thermocompl.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[thermocompl.MeterNumber], thermocompl.MyTask);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
ThermoSequenceOk[Thermo] = !ThermoSequenceFailed[Thermo];
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
|
|
GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
|
|
|
|
#region Destroy tasks
|
|
foreach (var metercompl in listCompl)
|
|
TaskOperations.CheckAndDispose(metercompl.MyTask);
|
|
foreach (var thermocompl in thermolistCompl)
|
|
TaskOperations.CheckAndDispose(thermocompl.MyTask);
|
|
#endregion
|
|
|
|
return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
|
|
}
|
|
public static Boolean TotalTempCal(MeterBatch globalMeterBatch, Boolean enable, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean SequenceFailed = false;
|
|
Boolean TaskStarted = false;
|
|
Boolean TaskCompleted = false;
|
|
const Int16 LedMode = 0;
|
|
const Int16 StoreCalibration = 1;
|
|
var listCompl = new List<Completion>();
|
|
|
|
var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Constants.Meter1 + 1));
|
|
if (currentMeter != null)
|
|
listCompl.Add(new Completion(Constants.Meter1, currentMeter, culture));
|
|
else
|
|
listCompl.Add(new Completion(Constants.Meter1, culture));
|
|
|
|
foreach (var compl in listCompl)
|
|
{
|
|
UInt16 MeterNumber = 0;
|
|
if (((Int32)currentMeter.Slot - 1) >= -1)
|
|
MeterNumber = (UInt16)(currentMeter.Slot - 1);
|
|
|
|
compl.Initialize(String.Empty, Constants.Thermo, LedMode, StoreCalibration);
|
|
compl.MyTask = new Task<Boolean>(() => { return true; });
|
|
}
|
|
#endregion
|
|
#region Perform test
|
|
foreach (var compl in listCompl)
|
|
compl.MeterTempCal(enable, ref TaskStarted, ref SequenceFailed);
|
|
#endregion
|
|
#region Wait for tasks
|
|
Boolean SequenceOk = false;
|
|
|
|
while (!TaskCompleted)
|
|
{
|
|
foreach (var compl in listCompl)
|
|
TaskCompleted = TaskOperations.WaitFor(TaskStarted, compl.MyTask);
|
|
|
|
Misc.WaitNSeconds(1);
|
|
|
|
foreach (var compl in listCompl)
|
|
SequenceFailed = TaskOperations.GetResult(TaskStarted, compl.MyTask);
|
|
SequenceOk = !SequenceFailed;
|
|
frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
|
|
}
|
|
#endregion
|
|
|
|
foreach (var compl in listCompl)
|
|
SequenceFailed = TaskOperations.GetResult(TaskStarted, compl.MyTask);
|
|
|
|
SequenceOk = !SequenceFailed;
|
|
|
|
#region Destroy tasks
|
|
frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
|
|
|
|
foreach (var compl in listCompl)
|
|
TaskOperations.CheckAndDispose(compl.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 Completion
|
|
{
|
|
private readonly ZeroFlowGenesisMeter GenesisMeter;
|
|
public Task<Boolean> MyTask { get; internal set; }
|
|
/// <summary>
|
|
/// For ZeroFlowCalibration tool
|
|
/// Provides task control for Completion Sequence of 'METER'
|
|
/// </summary>
|
|
/// <param name="enable"></param>
|
|
/// <param name="taskStarted"></param>
|
|
/// <param name="sequenceFailed"></param>
|
|
/// <param name="nextDelayTime"></param>
|
|
/// <param name="token"></param>
|
|
public 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
|
|
DialogResult AskForActions = DialogResult.None;
|
|
var _sequenceFailed = sequenceFailed;
|
|
Boolean Ok = true;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
{
|
|
taskStarted = true;
|
|
|
|
#region Testprocedure
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Cancellation token
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#region Sequence
|
|
Ok = this.PerformCompletion(token);
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.CompletionStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
return false;
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION 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
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.CompletionFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
|
|
AskForActions = DialogResult.Cancel;
|
|
_sequenceFailed = true;
|
|
}
|
|
#endregion
|
|
}
|
|
return _sequenceFailed;
|
|
});
|
|
#endregion
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
/// <summary>
|
|
/// For ZeroFlowCalibration tool
|
|
/// Provides task control for Completion Sequence of 'THERMOMETER'
|
|
/// </summary>
|
|
/// <param name="enable"></param>
|
|
/// <param name="taskStarted"></param>
|
|
/// <param name="sequenceFailed"></param>
|
|
/// <param name="nextDelayTime"></param>
|
|
/// <param name="token"></param>
|
|
public 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 = 5;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
var _sequenceFailed = sequenceFailed;
|
|
Int32 temp = DelayTime;
|
|
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((Int32)temp);
|
|
|
|
#region Testprocedure
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(temp);
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
while ((Byte.Equals(AskForActions, DialogResult.Retry)) || (Byte.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Cancellation token
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#region Sequence
|
|
Ok = this.PerformCompletion(token);
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
return false;
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION 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
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
AskForActions = DialogResult.Cancel;
|
|
_sequenceFailed = true;
|
|
}
|
|
#endregion
|
|
}
|
|
return _sequenceFailed;
|
|
});
|
|
#endregion
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
/// <summary>
|
|
/// For temperature calibration tool
|
|
///
|
|
/// </summary>
|
|
/// <param name="enable"></param>
|
|
/// <param name="taskStarted"></param>
|
|
/// <param name="sequenceFailed"></param>
|
|
public void MeterTempCal(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed)
|
|
{
|
|
#region Avoid CA1062
|
|
if (MyTask == null)
|
|
return;
|
|
#endregion
|
|
#region Definitions and initializations
|
|
DialogResult AskForActions = DialogResult.None;
|
|
var _sequenceFailed = sequenceFailed;
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
|
|
{
|
|
taskStarted = true;
|
|
|
|
#region Testprocedure
|
|
taskStarted = true;
|
|
|
|
MyTask = Task.Run(() =>
|
|
{
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Sequence
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t COMPLETION sequence started\n", this.Culture);
|
|
Ok = PerformCompletionTempCal();
|
|
if (Ok)
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t COMPLETION sequence successful\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
|
|
_sequenceFailed = false;
|
|
|
|
AskForActions = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t COMPLETION sequence failed\n", this.Culture);
|
|
frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
|
|
|
|
_sequenceFailed = true;
|
|
}
|
|
#endregion
|
|
}
|
|
return _sequenceFailed;
|
|
});
|
|
#endregion
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
/// <summary>
|
|
/// For ZeroFlowCalibration tool
|
|
/// Completion sequence for Meter and Thermometer, both identical
|
|
/// </summary>
|
|
/// <param name="token"></param>
|
|
/// <returns></returns>
|
|
private Boolean PerformCompletion(CancellationToken token)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false; // Ok == true when register write successful
|
|
List<Double>[] DeltaTimeOfFlight = new List<Double>[Constants.NumberOfPaths];
|
|
for (UInt16 i = 0; i < Constants.NumberOfPaths; i++)
|
|
DeltaTimeOfFlight[i] = new List<Double>();
|
|
#endregion
|
|
#region Completion sequence
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Start COMPLETION at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#region Write '0' to samplerate register
|
|
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 = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, 10);
|
|
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 Ok;
|
|
#endregion
|
|
#region Write to led mode register
|
|
Ok = false;
|
|
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to '{LedMode.ToString(this.Culture)}' to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, (Byte)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 Ok;
|
|
#endregion
|
|
#region Write '1' to store completion register
|
|
Misc.WaitNSeconds(1);
|
|
Ok = false;
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Store calibration'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.StoreCalibration, 1);
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Store calibration'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Store calibration'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
#endregion
|
|
#endregion
|
|
#region Get registers
|
|
GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Read registers at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
//todo reimplement
|
|
//#region Read zero offset register PATH0
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.ZeroOffset1(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset1'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset1'-register failed at METER" + MeterIndex + "\n");
|
|
// if (CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read zero offset register PATH1
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.ZeroOffset2(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset2'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset2'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read zero offset register PATH2
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.ZeroOffset3(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset3'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset3'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read first hit percentage register PATH0
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath0(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage1'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage1'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read first hit percentage register PATH1
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath1(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage2'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage2'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read first hit percentage register PATH2
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath2(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage3'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage3'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read tof temp offset register PATH0
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.ToFTempOffset1(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset1'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset1'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read tof temp offset register PATH1
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.ToFTempOffset2(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset2'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset2'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read tof temp offset register PATH2
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.ToFTempOffset3(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset3'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset3'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read calfactor register PATH0
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.CalFactor1(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor1'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor1'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read calfactor register PATH1
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.CalFactor2(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor2'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor2'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//if (Ok == false)
|
|
// return Ok;
|
|
//#endregion
|
|
//#region Read calfactor register PATH2
|
|
//Trials = 0;
|
|
//Ok = false;
|
|
//while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
|
|
//{
|
|
// if (token.IsCancellationRequested)
|
|
// return false;
|
|
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");
|
|
|
|
// Ok = this.GetRegister(GP30Registers.CalFactor3(), out DebugMessage);
|
|
// if (Ok)
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor3'-register successful at METER" + MeterIndex + "\n");
|
|
// else
|
|
// {
|
|
// GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor3'-register failed at METER" + MeterIndex + "\n");
|
|
// if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
|
|
// reAuthentication = true;
|
|
// }
|
|
// Trials++;
|
|
//}
|
|
//System.Diagnostics.Debug.WriteLine(Ok.ToString());
|
|
//if (Ok == false)
|
|
//{
|
|
// System.Diagnostics.Debug.WriteLine("Returning");
|
|
// return Ok;
|
|
//}
|
|
//System.Diagnostics.Debug.WriteLine("Write data to file");
|
|
//#endregion
|
|
//#region Write to file
|
|
//DateTime Timestamp = new DateTime();
|
|
//Timestamp = DateTime.Now;
|
|
//String TimestampFileName = Timestamp.ToString(Formats.LogFileDateTimeString, this.GlobalCulture);
|
|
//String LoggingText =
|
|
//"GENESISFLOW_ZeroOffset;0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" +
|
|
//"GENESISFLOW_FirstHitPercent;0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" +
|
|
//"GENESISFLOW_ToFTempOffset;0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" +
|
|
//"GENESISFLOW_Calfactor;0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
|
|
//GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n";
|
|
//Logging.WriteToFile(LoggingText, @"..\GenesisZeroflowTest_Registers_METER" + MeterIndex + "_" + TimestampFileName + ".csv");
|
|
//ClearData();
|
|
//#endregion
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
/// <summary>
|
|
/// For temperature calibration tool
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private Boolean PerformCompletionTempCal()
|
|
{
|
|
#region Definitions and initializations
|
|
List<Double>[] DeltaTimeOfFlight = new List<Double>[Constants.NumberOfPaths];
|
|
for (UInt16 i = 0; i < Constants.NumberOfPaths; i++)
|
|
DeltaTimeOfFlight[i] = new List<Double>();
|
|
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Completion sequence
|
|
#region Write '0' to samplerate register
|
|
Ok = false;
|
|
frmTempCalibration.DisplayTempCal.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register\n", this.Culture);
|
|
|
|
Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, 0);
|
|
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);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return Ok;
|
|
#endregion
|
|
#region Write to led mode register
|
|
Ok = false;
|
|
frmTempCalibration.DisplayTempCal.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register\n", this.Culture);
|
|
Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, (Byte)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);
|
|
|
|
if (Boolean.Equals(Ok, false))
|
|
return Ok;
|
|
#endregion
|
|
#region Write to store completion register
|
|
Misc.WaitNSeconds(1);
|
|
Ok = false;
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Store calibration'-register\n", this.Culture);
|
|
Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.StoreCalibration, 1);
|
|
if (Ok)
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Store calibration'-register successful\n", this.Culture);
|
|
else
|
|
frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Store calibration'-register failed\n", this.Culture);
|
|
#endregion
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
public Completion(UInt16 meterNumber, CultureInfo culture)
|
|
{
|
|
this.Culture = culture;
|
|
this.MeterNumber = meterNumber;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
public Completion(UInt16 meterNumber, IMeter meter, CultureInfo culture)
|
|
{
|
|
if (meter is ZeroFlowGenesisMeter)
|
|
{
|
|
GenesisMeter = meter as ZeroFlowGenesisMeter;
|
|
}
|
|
this.Culture = culture;
|
|
this.MeterNumber = meterNumber;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
}
|
|
public void Initialize(String pcbID, String meterType, Int16 ledMode, Int16 storeCalibration)
|
|
{
|
|
this.LedMode = ledMode;
|
|
this.StoreCalibration = storeCalibration;
|
|
this.MeterType = meterType;
|
|
this.PcbID = pcbID;
|
|
}
|
|
public UInt16 MeterNumber { get; private set; }
|
|
public String MeterIndex { get; set; }
|
|
public String PcbID { get; private set; }
|
|
private String MeterType { get; set; }
|
|
private CultureInfo Culture { get; set; }
|
|
private Int16 LedMode { get; set; }
|
|
private Int16 StoreCalibration { get; set; }
|
|
}
|
|
} |