public async Task <Result> TryOpenConnectionAsync(IDeviceLogger deviceLogger)
{
try
{
IStreamResource streamResource;
IModbusSerialMaster modbusSerialMaster = null;
await Task.Run(() =>
{
streamResource = _connectionManager.GetSerialPortAdapter(PortName);
modbusSerialMaster = ModbusSerialMaster.CreateRtu(streamResource);
});
if (modbusSerialMaster != null)
{
_currentModbusMaster?.Dispose();
_currentModbusMaster = modbusSerialMaster;
}
else
{
throw new Exception();
}
_slaveId = SlaveId;
_deviceLogger = deviceLogger;
_isConnectionLost = false;
_lastQuerySucceed = true;
}
catch (Exception e)
{
return(Result.Create(e));
}
return(Result.Create(true));
}
public DeviceManager(IDeviceLogger defaultDeviceLogger)
{
RegisterHandler <WebRequestHandler>();
if (defaultDeviceLogger != null)
{
RegisterHandler(defaultDeviceLogger);
}
}
public void DeleteLogger(IDeviceLogger logger)
{
_deviceLoggers.Remove(logger);
if (logger?.LogMessageAriseAction != null)
{
logger.LogMessageAriseAction -= OnLogMessageArise;
}
LoggersChangedAction?.Invoke();
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseStateMachine" /> class.
/// </summary>
/// <param name="deviceLogger">The logger MGR.</param>
public BaseStateMachine(IDeviceLogger deviceLogger)
{
this.logger = deviceLogger.CreateComponentLogger(className);
this.state = GuiState.DISCONNECTED;
this.stateMessage = "Not Connected";
this.CurrentState = this.State_None;
this.eventExecLock = new object();
this.statusUpdateLockObj = new object();
}
public void AddLogger(IDeviceLogger logger, string subjectName)
{
logger.SetLoggerSubject(subjectName);
if (_deviceLoggers.Contains(logger))
{
return;
}
_deviceLoggers.Add(logger);
logger.LogMessageAriseAction += OnLogMessageArise;
LoggersChangedAction?.Invoke();
}
/// <summary>
/// Initializes a new instance of the <see cref="StateMachine{T}"/> class.
/// </summary>
/// <param name="deviceLogger">The logger MGR.</param>
public StateMachine(IDeviceLogger deviceLogger)
{
if (deviceLogger == null)
{
throw new ArgumentNullException("deviceLogger", "Device Logger cannot be null");
}
this.logger = deviceLogger.CreateComponentLogger(className);
this.state = GuiState.DISCONNECTED;
this.internalStateEnum = default(T);
this.stateMessage = "Not Connected";
this.currentState = this.StateNone;
this.eventExecLock = new object();
this.statusUpdateLockObj = new object();
this.isDisposed = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="DatabaseServer" /> class.
/// </summary>
/// <param name="deviceLogger">The logger MGR.</param>
/// <param name="dbConfig">The database configuration.</param>
/// <param name="timerSync">The timer synchronize.</param>
public DatabaseServer(IDeviceLogger deviceLogger, DatabaseSettings dbConfig, ISynchronizeInvoke timerSync)
: base(deviceLogger)
{
this.dbConfig = dbConfig;
this.stringUtils = new StringUtils();
this.isDisposed = false;
this.State = GuiState.FAULT;
this.StateMessage = "Not Connected.";
this.deviceLogger = deviceLogger;
this.logger = deviceLogger.CreateComponentLogger(className);
this.dbConn = null;
this.settingsLock = new object();
this.connectionString = string.Empty;
this.oldConnectionString = string.Empty;
// Create tables ----------------------------------------------------------------
this.locationsTable = new LocationTable.LocationTable(this, this.deviceLogger);
this.messageTable = new MessageTable.MessageTable(this, this.deviceLogger);
this.transformTable = new TransformTable.TransformTable(this, this.deviceLogger);
this.inspectionTable = new InspectionTable.InspectionTable(this, this.deviceLogger);
this.resultTable = new ResultTable.ResultTable(this, this.deviceLogger);
// Route Table TWEs when you need to update banner
this.locationsTable.TweCallback += this.Table_tweCallback;
this.messageTable.TweCallback += this.Table_tweCallback;
this.transformTable.TweCallback += this.Table_tweCallback;
this.inspectionTable.TweCallback += this.Table_tweCallback;
this.resultTable.TweCallback += this.Table_tweCallback;
this.pingTimeout = 3;
this.commandTimeout = 5;
this.LoadDatabaseSettings();
this.dbConfig.SettingsChanged += this.DbConfig_SettingsChanged;
this.terminationRequestedEvent = new ManualResetEvent(false);
this.dbConLockObj = new object();
this.runnerThread = new Thread(new ThreadStart(this.StartDatabaseServer));
this.runnerThread.Start();
// this.StartStateMachine(DatabaseState.State_Connect, this.State_Connect, true, timerSync);
}
public async Task <Result> TryOpenConnectionAsync(IDeviceLogger currentDeviceLogger)
{
try
{
await Task.Run(() =>
{
TcpClient client = new TcpClient(IpAddress, Port);
_currentModbusMaster = ModbusIpMaster.CreateIp(client);
_currentDeviceLogger = currentDeviceLogger;
});
return(Result.Create(true));
}
catch (Exception e)
{
return(Result.Create(e));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Plc" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="deviceLogger">The device logger</param>
/// <param name="configurationManager">The configuration manager.</param>
public Plc(string name, IDeviceLogger deviceLogger, IConfigurationManager configurationManager)
: base(deviceLogger)
{
this.Name = name;
this.deviceLogger = deviceLogger ?? throw new ArgumentNullException("deviceLogger", "Device Logger cannot be null");
this.logger = deviceLogger.CreateComponentLogger(className);
this.StateMessage = "PLC is not enabled";
this.State = GuiState.FAULT;
bool success = IPAddress.TryParse("0.0.0.0", out this.ipAddress);
this.isDisposed = false;
this.port = 0;
this.missedHeartbeats = 0;
this.plcDataStream = string.Empty;
this.plcDataStreamLock = new object();
this.regexHashEventSystem = new Regex("##(\\w*) (\\w*)(.*)");
this.regexfindParams = new Regex(" (([\\w]*)=((\"[a-zA-Z0-9._\\ ]*\")|(0x[0-9]*))|(\\w*))");
delay = 0;
this.configurationManager = configurationManager ?? throw new ArgumentNullException("configurationManager", "ConfigurationManager cannot be null");
this.plcSettings = configurationManager.PLCSettings;
configurationManager.PLCSettings.SettingsChanged += this.PLCSettings_SettingsChanged;
success = IPAddress.TryParse("0.0.0.0", out this.defaultIPAddress);
success = IPAddress.TryParse(this.plcSettings.IPAddress, out this.ipAddress);
this.port = this.plcSettings.Port;
this.plcTxFifo = new ConcurrentBlockingFifo <byte[]>();
this.plcInputEventData = new PlcInputEventData();
this.plcOutputEventData = new PlcOutputEventData();
this.plcSystemEventData = new PlcSystemEventData();
this.plcInputEventData.EventDataChanged += this.PlcInputEventData_EventDataChanged;
this.plcOutputEventData.EventDataChanged += this.PlcOutputEventData_EventDataChanged;
this.plcSystemEventData.EventDataChanged += this.PlcSystemEventData_EventDataChanged;
this.plcSystemEventData.HeartbeatEvent += this.PlcSystemEventData_HeartbeatEvent;
}
public void RegisterHandler(IDeviceLogger handler)
{
DeviceLogHandlers.Add(handler);
}
public Task <Result> TryOpenConnectionAsync(IDeviceLogger currentDeviceLogger)
{
return(Task.FromResult <Result>(true));
}
public async Task <bool> TryOpenConnectionAsync(bool isThrowingException, IDeviceLogger currentDeviceLogger)
{
return(false);
}
public void SetLogger(IDeviceLogger currentDeviceLogger)
{
_currentDeviceLogger = currentDeviceLogger;
}
public Task <Result> TryOpenConnectionAsync(IDeviceLogger currentDeviceLogger)
{
_currentDeviceLogger = currentDeviceLogger;
return(Task.FromResult(Result.Create(!IsConnectionLost)));
}
