652 lines
22 KiB
C#
652 lines
22 KiB
C#
using System;
|
|
using System.Threading.Tasks;
|
|
using Common;
|
|
using GenesisCordonelInterface.API;
|
|
using log4net;
|
|
using TBF.Rig.BridgeComponents.GciBridge;
|
|
using TBF.Rig.RegisterReaders.GenesisRegReader.communication.common;
|
|
using TBF.Rig.RegisterReaders.GenesisRegReader.implementations;
|
|
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.diagnosticLed;
|
|
|
|
|
|
namespace TBF.Rig.RegisterReaders.GenesisRegReader.communication
|
|
{
|
|
public class OptoHeadTest : IDisposable
|
|
{
|
|
//protected static readonly ILog rfidDataLogger = LogManager.GetLogger("RfidData");
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(OptoHeadTest));
|
|
|
|
private GenesisSmartReader genesisHead;
|
|
//private SerialDriver serialDriver;
|
|
|
|
|
|
|
|
public async Task BuildConnection(GenesisSmartReader genesidHead)
|
|
{
|
|
await BuildConnectionAsync(genesidHead).ConfigureAwait(false);
|
|
}
|
|
public async Task BuildConnectionAsync(GenesisSmartReader genesidHead)
|
|
{
|
|
if (genesidHead == null)
|
|
throw new ArgumentNullException(nameof(genesidHead));
|
|
|
|
bool simulation = genesidHead.DebugLevel == DebugMode.Simulate;
|
|
|
|
var request = new PublicModels.GciInitSlotRequest
|
|
{
|
|
SlotId = genesidHead.GetSlotNr,
|
|
ConfigSource = PublicModels.GciConfigSource.InterfaceInputConfig,
|
|
PasswordSource = PublicModels.GciPasswordSource.InterfaceInputPassword,
|
|
|
|
RequestPort = new PublicModels.GciPortConfig
|
|
{
|
|
PortName = $"COM{genesidHead.RfidComPortNr}",
|
|
Type = simulation ? "SIMULATE" : PublicModels.MapPortType("IRDA")
|
|
},
|
|
|
|
StreamingPort = new PublicModels.GciPortConfig
|
|
{
|
|
PortName = "NA", //$"COM{genesidHead.OptoComPortNr}",
|
|
Type = simulation ? "SIMULATE" : string.Empty
|
|
}
|
|
};
|
|
|
|
log.Debug($"BuildConnection() - SlotNr: {genesidHead.GetSlotNr} initializing... Request: {request}");
|
|
|
|
var bridge = genesidHead.CommInterfaceBridge;
|
|
if (bridge == null)
|
|
throw new InvalidOperationException("CommInterfaceBridge is null.");
|
|
|
|
var initResult = await WithTimeout(
|
|
bridge.InitSlotAsync(request),
|
|
TimeSpan.FromSeconds(15),
|
|
"InitSlotAsync timeout");
|
|
|
|
log.Debug($"BuildConnection() - SlotNr: {genesidHead.GetSlotNr} initialized. Result: {initResult}");
|
|
|
|
if (initResult == null)
|
|
throw new InvalidOperationException("InitSlotAsync returned null.");
|
|
|
|
var updateResult = await WithTimeout(
|
|
bridge.UpdateSlotAsync(request),
|
|
TimeSpan.FromSeconds(15),
|
|
"UpdateSlotAsync timeout");
|
|
|
|
log.Debug($"BuildConnection() - SlotNr: {genesidHead.GetSlotNr} updated! Result: {updateResult}");
|
|
|
|
if (updateResult == null)
|
|
throw new InvalidOperationException("UpdateSlotAsync returned null.");
|
|
|
|
slotDefined = true;
|
|
}
|
|
|
|
private static async Task<T> WithTimeout<T>(
|
|
Task<T> task,
|
|
TimeSpan timeout,
|
|
string timeoutMessage)
|
|
{
|
|
var timeoutTask = Task.Delay(timeout);
|
|
|
|
var completedTask = await Task.WhenAny(task, timeoutTask);
|
|
|
|
if (completedTask == timeoutTask)
|
|
throw new TimeoutException(timeoutMessage);
|
|
|
|
return await task;
|
|
}
|
|
|
|
public OptoHeadTest(GenesisSmartReader genesisHead)
|
|
{
|
|
this.genesisHead = genesisHead;
|
|
}
|
|
|
|
public void CloseConnection()
|
|
{
|
|
genesisHead?.CommInterfaceBridge?.DisconnectAsync(genesisHead.GetSlotNr);
|
|
DisposeSlot();
|
|
|
|
// if (serialDriver != null)
|
|
// serialDriver.CloseConnection();
|
|
// serialDriver = null;
|
|
}
|
|
|
|
private bool isConnected = false;
|
|
private bool slotDefined = false;
|
|
|
|
public bool IsSlotDefined { get => slotDefined; }
|
|
public bool IsConnected { get => isConnected; }
|
|
|
|
public void DisposeSlot() { slotDefined = false; isConnected = false; }
|
|
|
|
public async Task<string> ReadRequest_PCBAsync(GenesisSmartReader genesisHead)
|
|
{
|
|
try
|
|
{
|
|
log.Debug("ReadRequest_PCB called for iHead: " + genesisHead);
|
|
|
|
if (genesisHead == null)
|
|
return string.Empty;
|
|
|
|
if (string.IsNullOrEmpty(genesisHead.CommInterface))
|
|
return string.Empty;
|
|
|
|
if (genesisHead.CommInterfaceBridge == null)
|
|
return string.Empty;
|
|
|
|
if (!IsSlotDefined)
|
|
{
|
|
await BuildConnectionAsync(genesisHead);
|
|
}
|
|
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
log.Debug("ReadRequest_PCB() - Simulated response");
|
|
return "-OK Simulated PCB-";
|
|
}
|
|
|
|
GciBridge gciBridge = genesisHead.CommInterfaceBridge;
|
|
|
|
log.Debug("ReadRequest_PCB() - GciBridge created");
|
|
|
|
gciBridge.GciBridgeCfg.EnableExternalAccess = true;
|
|
gciBridge.GciBridgeCfg.EnableGuiAccess = false;
|
|
|
|
gciBridge.Initialize();
|
|
|
|
log.Debug("ReadRequest_PCB() - GciBridge initialized");
|
|
|
|
RadioService headService = new RadioService(gciBridge);
|
|
|
|
|
|
ReadPcbResult pcbResult = await headService.ReadRequest_PCBAsync(genesisHead);
|
|
|
|
if (pcbResult == null)
|
|
{
|
|
log.Info( $"PCB Number NOT found on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr}");
|
|
return string.Empty;
|
|
}
|
|
|
|
isConnected = pcbResult.IsConnected;
|
|
|
|
string serialNo = pcbResult.PcbId;
|
|
log.Info( $"PCB Number: {serialNo} on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr}");
|
|
|
|
if (pcbResult.IsValidPcb)
|
|
{
|
|
genesisHead.SerialNr = pcbResult.PcbId;
|
|
if (genesisHead.ConfigStruct != null)
|
|
{
|
|
genesisHead.ConfigStruct.PCBNumberString = pcbResult.PcbId;
|
|
}
|
|
log.Info( $"PCB STORED TO HEAD Number: {serialNo} on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr} is valid");
|
|
}
|
|
|
|
return serialNo;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("ReadRequest_PCBAsync() - Exception:", ex);
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
public string ReadRequest_PCB()
|
|
{
|
|
return Task.Run(() => ReadRequest_PCBAsync(genesisHead))
|
|
.GetAwaiter()
|
|
.GetResult();
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Set Test mode
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
public bool SetTestMode()
|
|
{
|
|
return Task.Run(SetTestMode_Async)
|
|
.GetAwaiter()
|
|
.GetResult();
|
|
}
|
|
|
|
|
|
public async Task<bool> SetTestMode_Async()
|
|
{
|
|
try
|
|
{
|
|
log.Debug("SetTestMode_Async called for iHead: " + genesisHead);
|
|
|
|
if (genesisHead == null)
|
|
return false;
|
|
|
|
if (string.IsNullOrEmpty(genesisHead.CommInterface))
|
|
return false;
|
|
|
|
if (genesisHead.CommInterfaceBridge == null)
|
|
return false;
|
|
|
|
if (!IsSlotDefined)
|
|
{
|
|
await BuildConnectionAsync(genesisHead);
|
|
}
|
|
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
log.Debug("SetTestMode_Async() - Simulated response");
|
|
return true;
|
|
}
|
|
|
|
GciBridge gciBridge = genesisHead.CommInterfaceBridge;
|
|
|
|
log.Debug("SetTestMode_Async() - GciBridge created");
|
|
|
|
gciBridge.GciBridgeCfg.EnableExternalAccess = true;
|
|
gciBridge.GciBridgeCfg.EnableGuiAccess = false;
|
|
gciBridge.Initialize();
|
|
|
|
log.Debug("SetTestMode_Async() - GciBridge initialized");
|
|
|
|
RadioService headService = new RadioService(gciBridge);
|
|
var ledModeAsync = await headService.SetLedMode_Async(genesisHead, LedState.active, isConnected);
|
|
|
|
if (!ledModeAsync)
|
|
{
|
|
log.Info(
|
|
$"FAILED - SET LED MODE ACTIVE on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr}");
|
|
return false;
|
|
}
|
|
|
|
isConnected = true;
|
|
|
|
try
|
|
{
|
|
await headService.Disconnect_Async(genesisHead);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetTestMode_Async() - DISCONNECT Exception:", ex);
|
|
}
|
|
|
|
|
|
return ledModeAsync;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetTestMode_Async() - Exception:", ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set Active mode
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
public bool SetActiveMode()
|
|
{
|
|
return Task.Run(SetActiveMode_Async)
|
|
.GetAwaiter()
|
|
.GetResult();
|
|
}
|
|
|
|
|
|
public async Task<bool> SetActiveMode_Async()
|
|
{
|
|
try
|
|
{
|
|
log.Debug("SetActiveMode_Async called for iHead: " + genesisHead);
|
|
|
|
if (genesisHead == null)
|
|
return false;
|
|
|
|
if (string.IsNullOrEmpty(genesisHead.CommInterface))
|
|
return false;
|
|
|
|
if (genesisHead.CommInterfaceBridge == null)
|
|
return false;
|
|
|
|
if (!IsSlotDefined)
|
|
{
|
|
await BuildConnectionAsync(genesisHead);
|
|
}
|
|
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
log.Debug("SetActiveMode_Async() - Simulated response");
|
|
return true;
|
|
}
|
|
|
|
GciBridge gciBridge = genesisHead.CommInterfaceBridge;
|
|
|
|
log.Debug("SetActiveMode_Async() - GciBridge created");
|
|
|
|
gciBridge.GciBridgeCfg.EnableExternalAccess = true;
|
|
gciBridge.GciBridgeCfg.EnableGuiAccess = false;
|
|
gciBridge.Initialize();
|
|
|
|
log.Debug("SetActiveMode_Async() - GciBridge initialized");
|
|
|
|
RadioService headService = new RadioService(gciBridge);
|
|
var ledModeAsync = await headService.SetLedMode_Async(genesisHead, LedState.inactive, isConnected);
|
|
|
|
if (!ledModeAsync)
|
|
{
|
|
log.Info(
|
|
$"FAILED - SET LED MODE INACTIVE on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr}");
|
|
return false;
|
|
}
|
|
|
|
isConnected = true;
|
|
|
|
try
|
|
{
|
|
await headService.Disconnect_Async(genesisHead);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetActiveMode_Async() - DISCONNECT Exception:", ex);
|
|
}
|
|
|
|
|
|
return ledModeAsync;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetActiveMode_Async() - Exception:", ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set Idle mode - only
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
public bool SetIdleMode()
|
|
{
|
|
log.Debug("SetIdleMode called for iHead: " + genesisHead.ToString());
|
|
bool activityModeIdle = SetActivityMode_Idle();
|
|
|
|
return activityModeIdle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set Test mode - string response
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <param name="isTestModeSuccessful"></param>
|
|
/// <returns></returns>
|
|
public string SetTestMode(ref bool isTestModeSuccessful)
|
|
{
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
isTestModeSuccessful = true;
|
|
return "-OK Simulated response-";
|
|
}
|
|
|
|
try
|
|
{
|
|
bool testMode = SetTestMode();
|
|
isTestModeSuccessful = testMode;
|
|
return testMode ? "Set Test Mode - OK" : "Set Test Mode - FAILED";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetTestMode() - Exception:" + ex.StackTrace);
|
|
return "Set Test Mode - Exception";
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Set Optical -> Test mode
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="Exception"></exception>
|
|
private bool SetOptTestMode()
|
|
{
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// try
|
|
// {
|
|
// if (genesisHead != null)
|
|
// {
|
|
// if(genesisHead.RfidComPortNr != 0 && !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
|
|
// BuildConnection(genesisHead).ConfigureAwait(false).GetAwaiter().GetResult();
|
|
//
|
|
//
|
|
// RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
|
|
// bool optTestMode = headService.SetOptTestMode(genesisHead);
|
|
// if (genesisHead.ConfigStruct != null)
|
|
// genesisHead.ConfigStruct.OpthoStatusMode = optTestMode ? DiagnosticLedState.State4 : DiagnosticLedState.StatusUnknown;
|
|
// return optTestMode;
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// log.Error("SetOptTestMode() - Exception:" + ex.StackTrace);
|
|
// }
|
|
|
|
return false;
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set Active mode - string response
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <param name="isTestModeSuccessful"></param>
|
|
/// <returns></returns>
|
|
public string SetActiveMode(ref bool isTestModeSuccessful)
|
|
{
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
isTestModeSuccessful = true;
|
|
return "-OK Simulated response-";
|
|
}
|
|
|
|
try
|
|
{
|
|
bool testMode = SetActiveMode();
|
|
isTestModeSuccessful = testMode;
|
|
return testMode ? "Set Active Mode - OK" : "Set Active Mode - FAILED";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetActiveMode() - Exception:" + ex.StackTrace);
|
|
return "Set Active Mode - Exception";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set Optical -> Active mode
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="Exception"></exception>
|
|
private bool SetOptActiveMode(GenesisSmartReader iHead)
|
|
{
|
|
// try
|
|
// {
|
|
// if (iHead != null)
|
|
// {
|
|
// if(genesisHead.RfidComPortNr != 0 && !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
|
|
// BuildConnection(genesisHead).ConfigureAwait(false).GetAwaiter().GetResult();
|
|
//
|
|
// RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
|
|
// return headService.SetOptActiveMode(iHead);
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// log.Error("SetOptActiveMode() - Exception:" + ex.StackTrace);
|
|
// }
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set activity mode to active
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="Exception"></exception>
|
|
private async Task<bool> SetActivityMode_Active()
|
|
{
|
|
|
|
try
|
|
{
|
|
log.Debug("SetActivityMode_Active called for iHead: " + genesisHead);
|
|
|
|
if (genesisHead == null)
|
|
return false;
|
|
|
|
if (string.IsNullOrEmpty(genesisHead.CommInterface))
|
|
return false;
|
|
|
|
if (genesisHead.CommInterfaceBridge == null)
|
|
return false;
|
|
|
|
if (!IsSlotDefined)
|
|
{
|
|
await BuildConnectionAsync(genesisHead);
|
|
}
|
|
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
log.Debug("SetActivityMode_Active() - Simulated response");
|
|
return true;
|
|
}
|
|
|
|
GciBridge gciBridge = genesisHead.CommInterfaceBridge;
|
|
|
|
log.Debug("SetActivityMode_Active() - GciBridge created");
|
|
|
|
gciBridge.GciBridgeCfg.EnableExternalAccess = true;
|
|
gciBridge.GciBridgeCfg.EnableGuiAccess = false;
|
|
|
|
gciBridge.Initialize();
|
|
|
|
log.Debug("SetActivityMode_Active() - GciBridge initialized");
|
|
|
|
RadioService headService = new RadioService(gciBridge);
|
|
var active = await headService.SetActivityMode_Active(genesisHead, isConnected);
|
|
|
|
if (!active)
|
|
{
|
|
log.Info( $"SetActivityMode_Active not set on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr}");
|
|
return false;
|
|
}
|
|
|
|
log.Info( $"SetActivityMode_Active set on COM{genesisHead.RfidComPortNr} SlotNr: {genesisHead.GetSlotNr}");
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Error("SetActivityMode_Active() - Exception:", ex);
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set activity mode to idle
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="Exception"></exception>
|
|
private bool SetActivityMode_Idle()
|
|
{
|
|
// try
|
|
// {
|
|
// if (genesisHead != null)
|
|
// {
|
|
// if (genesisHead.RfidComPortNr != 0 &&
|
|
// !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
|
|
// BuildConnection(genesisHead).ConfigureAwait(false).GetAwaiter().GetResult();
|
|
//
|
|
// log.Debug("SetActivityMode_Idle called for iHead: " + genesisHead.ToString());
|
|
//
|
|
// RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
|
|
// return headService.SetActivityMode_Idle(genesisHead);
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// log.Error("SetActivityMode_Idle() - Exception:" + ex.StackTrace);
|
|
// }
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
public void Dispose()
|
|
{
|
|
CloseConnection();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read configuration from iHead
|
|
/// DiagnosticLedState is not readable, mus only be set!
|
|
/// </summary>
|
|
/// <param name="iHead"></param>
|
|
/// <param name="ledState"></param>
|
|
/// <returns></returns>
|
|
public bool ReadConfiguration(DiagnosticLedState ledState )
|
|
{
|
|
if (genesisHead.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
try
|
|
{
|
|
|
|
// if (genesisHead != null)
|
|
// {
|
|
// genesisHead.ConfigStruct = new ConfigStruct();
|
|
//
|
|
// if (genesisHead.RfidComPortNr != 0 &&
|
|
// !genesisHead?.CommInterfaceBridgeComponent?.GciExternalInterface?.IsConnected == false)
|
|
// BuildConnection(genesisHead).ConfigureAwait(false).GetAwaiter().GetResult();
|
|
//
|
|
// RadioService headService = new RadioService(genesisHead?.CommInterfaceBridgeComponent);
|
|
// genesisHead.ConfigStruct.PCBNumberString = headService.ReadRequest_PCB(ref genesisHead);
|
|
// genesisHead.ConfigStruct.StatusMode = headService.GetActivityStatusMode(genesisHead);
|
|
// genesisHead.ConfigStruct.Unit = headService.GetUnit(genesisHead);
|
|
//
|
|
// if (ledState != DiagnosticLedState.StatusUnknown) // do set
|
|
// {
|
|
// genesisHead.ConfigStruct.OpthoStatusMode = headService.SetLedMode_Async(genesisHead, ledState);
|
|
// }
|
|
// else
|
|
// {
|
|
// genesisHead.ConfigStruct.OpthoStatusMode = DiagnosticLedState.StatusUnknown;
|
|
// }
|
|
//
|
|
// genesisHead.ConfigStruct.Version = headService.GetVersion(genesisHead);
|
|
//
|
|
// return true;
|
|
// }
|
|
//
|
|
// else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
} |