476 lines
25 KiB
C#
476 lines
25 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.IO.Ports;
|
|
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
public static class LogOnSequences
|
|
{
|
|
public static Boolean[] Total(Boolean[] enable, CmdInterface[] commandInterface, String[] password, UInt16 numberOfTrials, out Boolean aborted, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] TaskStarted = new Boolean[Constants.NumberOfMeters];
|
|
Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters];
|
|
Int32 NextDelayTime = 0;
|
|
aborted = false;
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
SequenceFailed[Meter] = false;
|
|
TaskStarted[Meter] = false;
|
|
TaskCompleted[Meter] = false;
|
|
}
|
|
#region CA1062
|
|
if ((enable == null) || (password == null) || (commandInterface == null))
|
|
return SequenceFailed;
|
|
#endregion
|
|
LogOn LogOn1 = new LogOn();
|
|
LogOn LogOn2 = new LogOn();
|
|
LogOn LogOn3 = new LogOn();
|
|
LogOn LogOn4 = new LogOn();
|
|
LogOn LogOn5 = new LogOn();
|
|
LogOn LogOn6 = new LogOn();
|
|
LogOn LogOn7 = new LogOn();
|
|
LogOn LogOn8 = new LogOn();
|
|
LogOn LogOn9 = new LogOn();
|
|
LogOn LogOn10 = new LogOn();
|
|
|
|
LogOn1.Initialize(commandInterface[Constants.Meter1], Constants.Meter, password[Constants.Meter1], Constants.Meter1, numberOfTrials, culture);
|
|
LogOn2.Initialize(commandInterface[Constants.Meter2], Constants.Meter, password[Constants.Meter2], Constants.Meter2, numberOfTrials, culture);
|
|
LogOn3.Initialize(commandInterface[Constants.Meter3], Constants.Meter, password[Constants.Meter3], Constants.Meter3, numberOfTrials, culture);
|
|
LogOn4.Initialize(commandInterface[Constants.Meter4], Constants.Meter, password[Constants.Meter4], Constants.Meter4, numberOfTrials, culture);
|
|
LogOn5.Initialize(commandInterface[Constants.Meter5], Constants.Meter, password[Constants.Meter5], Constants.Meter5, numberOfTrials, culture);
|
|
LogOn6.Initialize(commandInterface[Constants.Meter6], Constants.Meter, password[Constants.Meter6], Constants.Meter6, numberOfTrials, culture);
|
|
LogOn7.Initialize(commandInterface[Constants.Meter7], Constants.Meter, password[Constants.Meter7], Constants.Meter7, numberOfTrials, culture);
|
|
LogOn8.Initialize(commandInterface[Constants.Meter8], Constants.Meter, password[Constants.Meter8], Constants.Meter8, numberOfTrials, culture);
|
|
LogOn9.Initialize(commandInterface[Constants.Meter9], Constants.Meter, password[Constants.Meter9], Constants.Meter9, numberOfTrials, culture);
|
|
LogOn10.Initialize(commandInterface[Constants.Meter10], Constants.Meter, password[Constants.Meter10], Constants.Meter10, numberOfTrials, culture);
|
|
#endregion
|
|
#region Perform test
|
|
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
|
|
CancellationToken token = cancellationTokenSource.Token;
|
|
#region METER1
|
|
Task<Boolean> Task1 = new Task<Boolean>(() => { return true; });
|
|
LogOn1.Meter(enable[Constants.Meter1], ref Task1, ref TaskStarted[Constants.Meter1], ref SequenceFailed[Constants.Meter1], LogOn1, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER2
|
|
Task<Boolean> Task2 = new Task<Boolean>(() => { return true; });
|
|
LogOn2.Meter(enable[Constants.Meter2], ref Task2, ref TaskStarted[Constants.Meter2], ref SequenceFailed[Constants.Meter2], LogOn2, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER3
|
|
Task<Boolean> Task3 = new Task<Boolean>(() => { return true; });
|
|
LogOn3.Meter(enable[Constants.Meter3], ref Task3, ref TaskStarted[Constants.Meter3], ref SequenceFailed[Constants.Meter3], LogOn3, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER4
|
|
Task<Boolean> Task4 = new Task<Boolean>(() => { return true; });
|
|
LogOn4.Meter(enable[Constants.Meter4], ref Task4, ref TaskStarted[Constants.Meter4], ref SequenceFailed[Constants.Meter4], LogOn4, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER5
|
|
Task<Boolean> Task5 = new Task<Boolean>(() => { return true; });
|
|
LogOn5.Meter(enable[Constants.Meter5], ref Task5, ref TaskStarted[Constants.Meter5], ref SequenceFailed[Constants.Meter5], LogOn5, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER6
|
|
Task<Boolean> Task6 = new Task<Boolean>(() => { return true; });
|
|
LogOn6.Meter(enable[Constants.Meter6], ref Task6, ref TaskStarted[Constants.Meter6], ref SequenceFailed[Constants.Meter6], LogOn6, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER7
|
|
Task<Boolean> Task7 = new Task<Boolean>(() => { return true; });
|
|
LogOn7.Meter(enable[Constants.Meter7], ref Task7, ref TaskStarted[Constants.Meter7], ref SequenceFailed[Constants.Meter7], LogOn7, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER8
|
|
Task<Boolean> Task8 = new Task<Boolean>(() => { return true; });
|
|
LogOn8.Meter(enable[Constants.Meter8], ref Task8, ref TaskStarted[Constants.Meter8], ref SequenceFailed[Constants.Meter8], LogOn8, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER9
|
|
Task<Boolean> Task9 = new Task<Boolean>(() => { return true; });
|
|
LogOn9.Meter(enable[Constants.Meter9], ref Task9, ref TaskStarted[Constants.Meter9], ref SequenceFailed[Constants.Meter9], LogOn9, ref NextDelayTime, token);
|
|
#endregion
|
|
#region METER10
|
|
Task<Boolean> Task10 = new Task<Boolean>(() => { return true; });
|
|
LogOn10.Meter(enable[Constants.Meter10], ref Task10, ref TaskStarted[Constants.Meter10], ref SequenceFailed[Constants.Meter10], LogOn10, ref NextDelayTime, token);
|
|
#endregion
|
|
#endregion
|
|
#region Wait for tasks
|
|
Int32[] KeepAuthentifiedCounter = new Int32[Constants.NumberOfMeters];
|
|
Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters];
|
|
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
{
|
|
KeepAuthentifiedCounter[Meter] = 0;
|
|
SequenceOk[Meter] = false;
|
|
}
|
|
|
|
while (!CheckArray(TaskCompleted))
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
|
|
{
|
|
aborted = true;
|
|
cancellationTokenSource.Cancel();
|
|
}
|
|
TaskCompleted[Constants.Meter1] = TaskOperations.WaitFor(TaskStarted[Constants.Meter1], Task1);
|
|
TaskCompleted[Constants.Meter2] = TaskOperations.WaitFor(TaskStarted[Constants.Meter2], Task2);
|
|
TaskCompleted[Constants.Meter3] = TaskOperations.WaitFor(TaskStarted[Constants.Meter3], Task3);
|
|
TaskCompleted[Constants.Meter4] = TaskOperations.WaitFor(TaskStarted[Constants.Meter4], Task4);
|
|
TaskCompleted[Constants.Meter5] = TaskOperations.WaitFor(TaskStarted[Constants.Meter5], Task5);
|
|
TaskCompleted[Constants.Meter6] = TaskOperations.WaitFor(TaskStarted[Constants.Meter6], Task6);
|
|
TaskCompleted[Constants.Meter7] = TaskOperations.WaitFor(TaskStarted[Constants.Meter7], Task7);
|
|
TaskCompleted[Constants.Meter8] = TaskOperations.WaitFor(TaskStarted[Constants.Meter8], Task8);
|
|
TaskCompleted[Constants.Meter9] = TaskOperations.WaitFor(TaskStarted[Constants.Meter9], Task9);
|
|
TaskCompleted[Constants.Meter10] = TaskOperations.WaitFor(TaskStarted[Constants.Meter10], Task10);
|
|
LogOn1.KeepAuthentified(enable[Constants.Meter1], SequenceOk[Constants.Meter1], TaskCompleted[Constants.Meter1], ref KeepAuthentifiedCounter[Constants.Meter1]);
|
|
LogOn2.KeepAuthentified(enable[Constants.Meter2], SequenceOk[Constants.Meter2], TaskCompleted[Constants.Meter2], ref KeepAuthentifiedCounter[Constants.Meter2]);
|
|
LogOn3.KeepAuthentified(enable[Constants.Meter3], SequenceOk[Constants.Meter3], TaskCompleted[Constants.Meter3], ref KeepAuthentifiedCounter[Constants.Meter3]);
|
|
LogOn4.KeepAuthentified(enable[Constants.Meter4], SequenceOk[Constants.Meter4], TaskCompleted[Constants.Meter4], ref KeepAuthentifiedCounter[Constants.Meter4]);
|
|
LogOn5.KeepAuthentified(enable[Constants.Meter5], SequenceOk[Constants.Meter5], TaskCompleted[Constants.Meter5], ref KeepAuthentifiedCounter[Constants.Meter5]);
|
|
LogOn6.KeepAuthentified(enable[Constants.Meter6], SequenceOk[Constants.Meter6], TaskCompleted[Constants.Meter6], ref KeepAuthentifiedCounter[Constants.Meter6]);
|
|
LogOn7.KeepAuthentified(enable[Constants.Meter7], SequenceOk[Constants.Meter7], TaskCompleted[Constants.Meter7], ref KeepAuthentifiedCounter[Constants.Meter7]);
|
|
LogOn8.KeepAuthentified(enable[Constants.Meter8], SequenceOk[Constants.Meter8], TaskCompleted[Constants.Meter8], ref KeepAuthentifiedCounter[Constants.Meter8]);
|
|
LogOn9.KeepAuthentified(enable[Constants.Meter9], SequenceOk[Constants.Meter9], TaskCompleted[Constants.Meter9], ref KeepAuthentifiedCounter[Constants.Meter9]);
|
|
LogOn10.KeepAuthentified(enable[Constants.Meter10], SequenceOk[Constants.Meter10], TaskCompleted[Constants.Meter10], ref KeepAuthentifiedCounter[Constants.Meter10]);
|
|
Misc.WaitNSeconds(1);
|
|
|
|
SequenceFailed = TaskOperations.GetResultTotal(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
SequenceOk[Meter] = !SequenceFailed[Meter];
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted);
|
|
// GenesisZeroFlow.Display.ShowResultStatus("Login sequence OK (while loop) = ", SequenceOk);
|
|
}
|
|
#endregion
|
|
#region Destroy tasks
|
|
SequenceFailed = TaskOperations.GetResultTotal(TaskStarted, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10);
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
SequenceOk[Meter] = !SequenceFailed[Meter];
|
|
GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, TaskStarted);
|
|
// GenesisZeroFlow.Display.ShowResultStatus("Login sequence failed = ", SequenceFailed);
|
|
// GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted);
|
|
|
|
TaskOperations.CheckAndDispose(ref Task1);
|
|
TaskOperations.CheckAndDispose(ref Task2);
|
|
TaskOperations.CheckAndDispose(ref Task3);
|
|
TaskOperations.CheckAndDispose(ref Task4);
|
|
TaskOperations.CheckAndDispose(ref Task5);
|
|
TaskOperations.CheckAndDispose(ref Task6);
|
|
TaskOperations.CheckAndDispose(ref Task7);
|
|
TaskOperations.CheckAndDispose(ref Task8);
|
|
TaskOperations.CheckAndDispose(ref Task9);
|
|
TaskOperations.CheckAndDispose(ref Task10);
|
|
#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 static Boolean CheckIfNoMeterSelected(Boolean[] meterSelected)
|
|
{
|
|
Boolean noMeterSelected = true;
|
|
|
|
#region CA1062
|
|
if (meterSelected == null)
|
|
return noMeterSelected;
|
|
#endregion
|
|
|
|
for (Int16 i = 0; i < meterSelected.Count(); i++)
|
|
{
|
|
if (meterSelected[i])
|
|
noMeterSelected = false;
|
|
}
|
|
|
|
return noMeterSelected;
|
|
}
|
|
public static Boolean CheckIfPortIndicatorsValid(Boolean[] meterSelected, Boolean[] serialPortOpenIndicator)
|
|
{
|
|
Boolean portIndicatorsValid = true;
|
|
|
|
#region CA1062
|
|
if ((meterSelected == null) || (serialPortOpenIndicator == null))
|
|
return portIndicatorsValid = false; ;
|
|
#endregion
|
|
|
|
|
|
for (Int16 i = 0; i < meterSelected.Count(); i++)
|
|
{
|
|
if (meterSelected[i] != (serialPortOpenIndicator[i] & serialPortOpenIndicator[Constants.NumberOfMeters + i]))
|
|
portIndicatorsValid = false;
|
|
}
|
|
|
|
return portIndicatorsValid;
|
|
}
|
|
}
|
|
|
|
public class LogOn
|
|
{
|
|
private String Password { get; set; }
|
|
private UInt16 MeterNumber { get; set; }
|
|
private String MeterIndex { get; set; }
|
|
private String MeterType { get; set; }
|
|
private UInt16 NumberOfTrials { get; set; }
|
|
private CultureInfo Culture { get; set; }
|
|
private SerialPort SerialPort { get; set; }
|
|
private CmdInterface CommandInterface { get; set; }
|
|
public void Initialize(CmdInterface commandInterface, String meterType, String password, UInt16 meterNumber, UInt16 numberOfTrials, CultureInfo culture)
|
|
{
|
|
this.Password = password;
|
|
this.MeterNumber = meterNumber;
|
|
this.NumberOfTrials = numberOfTrials;
|
|
this.CommandInterface = commandInterface;
|
|
this.Culture = culture;
|
|
this.MeterIndex = (meterNumber + 1).ToString(culture);
|
|
this.MeterType = meterType;
|
|
|
|
}
|
|
public Boolean PerformLogOn(CancellationToken token, out String debugMessage)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean reAuthentication = false;
|
|
Boolean Ok = false;
|
|
UInt16 Trials = 0;
|
|
Byte[] Password = new Byte[12] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
String DebugMessage = String.Empty;
|
|
#endregion
|
|
#region Get password
|
|
debugMessage = String.Empty;
|
|
if (this.Password.Count() != 12)
|
|
{
|
|
debugMessage = $"COMMAND CHANNEL:\t Password length wrong at {this.MeterType}{this.MeterIndex}\n";
|
|
return Ok;
|
|
}
|
|
Boolean OnlyHex = Misc.OnlyHexInString(this.Password);
|
|
if (!OnlyHex)
|
|
{
|
|
if (String.IsNullOrEmpty(this.Password))
|
|
debugMessage = $"COMMAND CHANNEL:\t Missing password at {this.MeterType}{this.MeterIndex}\n";
|
|
else
|
|
debugMessage = $"COMMAND CHANNEL:\t Password contains invalid characters at {this.MeterType}{MeterIndex}\n";
|
|
return Ok;
|
|
}
|
|
Password = Encoding.ASCII.GetBytes(this.Password);
|
|
#endregion
|
|
#region Send data to privilege register
|
|
Trials = 0;
|
|
Ok = false;
|
|
while ((Trials < this.NumberOfTrials) && (Boolean.Equals(Ok, false)) && (Boolean.Equals(reAuthentication, false)))
|
|
{
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Writing '8' to 'Privilege'-register at {this.MeterType}{this.MeterIndex}; Trial: {(Trials + 1).ToString(this.Culture)} of {this.NumberOfTrials}\n", this.Culture);
|
|
Ok = this.SetPrivilegeRegister(8, out DebugMessage);
|
|
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Writing '8' to 'Privilege'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Writing '8' to 'Privilege'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
if ((Byte.Equals(this.CommandInterface.Subreason, GP30ConfigExErrors.AccessDenied)) || (Byte.Equals(this.CommandInterface.Subreason, GP30ConfigExErrors.LockedOut)))
|
|
reAuthentication = true;
|
|
}
|
|
Trials++;
|
|
}
|
|
if (Boolean.Equals(Ok, false))
|
|
return Ok;
|
|
|
|
#endregion
|
|
#region Send data to password register
|
|
Trials = 0;
|
|
Ok = false;
|
|
while ((Trials < this.NumberOfTrials) && (Boolean.Equals(Ok, false)) && (Boolean.Equals(reAuthentication, false)))
|
|
{
|
|
if (token.IsCancellationRequested)
|
|
return false;
|
|
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Password'-register at {this.MeterType}{this.MeterIndex}; Trial: {(Trials + 1).ToString(this.Culture)} of {this.NumberOfTrials}\n", this.Culture);
|
|
Ok = this.SetPasswordRegister(Password, out DebugMessage);
|
|
|
|
if (Ok)
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Password'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Password'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
if ((Byte.Equals(this.CommandInterface.Subreason, GP30ConfigExErrors.AccessDenied)) || (Byte.Equals(this.CommandInterface.Subreason, GP30ConfigExErrors.LockedOut)))
|
|
reAuthentication = true;
|
|
}
|
|
Trials++;
|
|
}
|
|
if (Boolean.Equals(Ok, false))
|
|
return Ok;
|
|
#endregion
|
|
#region Command memory
|
|
this.CommandInterface.GP30LastCommand = GP30Commands.MultipleWritedata;
|
|
this.CommandInterface.SetGP30LastRegister(GP30Registers.Password());
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
public void Meter(Boolean enable, ref Task<Boolean> task, ref Boolean taskStarted, ref Boolean sequenceFailed, LogOn logOn, ref Int32 nextDelayTime, CancellationToken token)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 DelayTime = 0;
|
|
const Int32 DeltaDelay = 5;
|
|
DialogResult AskForActions = DialogResult.None;
|
|
var _sequenceFailed = sequenceFailed;
|
|
var _logOn = logOn;
|
|
String DebugMessage = String.Empty;
|
|
Int32 temp = DelayTime;
|
|
Boolean Ok = false;
|
|
#endregion
|
|
#region Avoid CA1062
|
|
if (task == null)
|
|
return;
|
|
#endregion
|
|
#region Everything else
|
|
if ((enable) && (task.Status != TaskStatus.Running) && (!task.IsCompleted))
|
|
{
|
|
DelayTime = nextDelayTime;
|
|
nextDelayTime = nextDelayTime + DeltaDelay;
|
|
|
|
taskStarted = true;
|
|
Misc.WaitNSeconds(temp);
|
|
|
|
task = Task.Run(() =>
|
|
{
|
|
while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
|
|
{
|
|
#region Login procedure
|
|
if (DialogResult.Equals(AskForActions, DialogResult.None))
|
|
GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t LOGIN started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
|
|
Ok = _logOn.PerformLogOn(token, out DebugMessage);
|
|
|
|
if (token.IsCancellationRequested)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t LOGIN aborted at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
return true;
|
|
}
|
|
if (Ok)
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t LOGIN successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
_sequenceFailed = false;
|
|
AskForActions = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t LOGIN failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
_sequenceFailed = true;
|
|
AskForActions = AskHowToProceedSequence("LOGIN");
|
|
}
|
|
#endregion
|
|
}
|
|
return _sequenceFailed;
|
|
});
|
|
}
|
|
#endregion
|
|
}
|
|
private DialogResult AskHowToProceedSequence(String sequenceName)
|
|
{
|
|
DialogResult AskForActions;
|
|
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(false);
|
|
AskForActions = MessageBox.Show($"{sequenceName} failed at {this.MeterType}{this.MeterIndex}", "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
|
|
switch (AskForActions)
|
|
{
|
|
case DialogResult.Retry:
|
|
GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t {sequenceName} restarted at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
break;
|
|
case DialogResult.Cancel:
|
|
GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t {sequenceName} canceled at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line, this.Culture);
|
|
break;
|
|
default: break;
|
|
}
|
|
GenesisZeroFlow.Display.AbortButtonEnabled(true);
|
|
|
|
return AskForActions;
|
|
}
|
|
public void KeepAuthentified(Boolean enable, Boolean sequenceOk, Boolean taskCompleted, ref Int32 counter)
|
|
{
|
|
const Int32 CounterValue = 30;
|
|
|
|
if (enable && taskCompleted && sequenceOk && (counter >= CounterValue))
|
|
{
|
|
GenesisZeroFlow.Display.DebugMessage($"COMMAND CHANNEL:\t Keep authentified at {this.MeterType}{this.MeterIndex}\n", this.Culture);
|
|
String DebugMessage = String.Empty;
|
|
this.GetLedModeRegister(out DebugMessage);
|
|
counter = 0;
|
|
}
|
|
else
|
|
counter++;
|
|
}
|
|
private Boolean SetPrivilegeRegister(Int32 value, out String debugMessage)
|
|
{
|
|
#region Definitions and initializations
|
|
Byte[] Payload = new Byte[4] { 0, 0, 0, 0 };
|
|
Boolean Ok = false;
|
|
Int32 ErrCode = GP30LowLevelErrors.NoError;
|
|
#endregion
|
|
#region Write register
|
|
Payload = BitConverter.GetBytes((Int32)value);
|
|
ErrCode = this.CommandInterface.WriteRegister(GP30Registers.Privilege(), Payload, true);
|
|
#endregion
|
|
#region Wait for answer
|
|
if (Int32.Equals(ErrCode, GP30LowLevelErrors.NoError))
|
|
ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.WriteRegister);
|
|
#endregion
|
|
#region Debug message
|
|
debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok);
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean SetPasswordRegister(Byte[] password, out String debugMessage)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
Int32 ErrCode = GP30LowLevelErrors.NoError;
|
|
#endregion
|
|
#region Write register
|
|
ErrCode = this.CommandInterface.MultipleWriteRegister(GP30Registers.Password(), password, true);
|
|
#endregion
|
|
#region Wait for answer
|
|
if (Int32.Equals(ErrCode, GP30LowLevelErrors.NoError))
|
|
ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.MultipleWrite);
|
|
#endregion
|
|
#region Debug message
|
|
debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok);
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
private Boolean GetLedModeRegister(out String debugMessage)
|
|
{
|
|
#region Definitions and initialisations
|
|
Boolean Ok = false;
|
|
Int32 ErrCode = GP30LowLevelErrors.NoError;
|
|
#endregion
|
|
#region Read register
|
|
ErrCode = this.CommandInterface.ReadRegister(GP30Registers.LedMode());
|
|
#endregion
|
|
#region Wait for answer
|
|
if (Int32.Equals(ErrCode, GP30LowLevelErrors.NoError))
|
|
ErrCode = this.CommandInterface.RXProcessor(GP30RequestType.ReadRegister);
|
|
#endregion
|
|
#region Debug message
|
|
debugMessage = this.CommandInterface.LowLevelMessages(ErrCode, out Ok);
|
|
#endregion
|
|
|
|
return Ok;
|
|
}
|
|
|
|
}
|
|
} |