/// <summary>
/// Creates an ASCII slave network.
/// </summary>
/// <param name="factory"></param>
/// <param name="streamResource"></param>
/// <returns></returns>
public static IModbusSlaveNetwork CreateAsciiSlaveNetwork(this IModbusFactory factory,
IStreamResource streamResource)
{
IModbusAsciiTransport transport = factory.CreateAsciiTransport(streamResource);
return(factory.CreateSlaveNetwork(transport));
}
public static IModbusMaster CreateSerialMaster(this IModbusFactory factory, SerialSettings settings)
{
SerialPort serialPort = new SerialPort()
{
PortName = settings.PortName,
BaudRate = settings.BaudRate,
DataBits = settings.DataBits,
Parity = settings.Parity,
StopBits = settings.StopBits,
Handshake = settings.Handshake
};
var adapter = new SerialPortAdapter(serialPort);
serialPort.Open();
switch (settings.ModbusType)
{
case ModbusType.Rtu:
return(factory.CreateRtuMaster(adapter));
case ModbusType.Ascii:
return(factory.CreateAsciiMaster(adapter));
default:
throw new ArgumentException("Serial Settings must be either of type Rtu or Ascii.");
}
}
public static IModbusMaster CreateIpMaster(this IModbusFactory factory, IpSettings ipSettings)
{
switch (ipSettings.ModbusType)
{
case ModbusType.Tcp:
return(factory.CreateMaster(
new TcpClient(ipSettings.Hostname, ipSettings.Port)));
case ModbusType.Udp:
return(factory.CreateMaster(
new UdpClient(ipSettings.Hostname, ipSettings.Port)));
case ModbusType.RtuOverTcp:
return(factory.CreateRtuMaster(
new TcpClientAdapter(
new TcpClient(ipSettings.Hostname, ipSettings.Port))));
case ModbusType.RtuOverUdp:
return(factory.CreateRtuMaster(
new UdpClientAdapter(
new UdpClient(ipSettings.Hostname, ipSettings.Port))));
default:
throw new ArgumentException(
"Ip settings must be of type Tcp, Udp, RtuOverTcp, or RtuOverUdp.");
}
}
internal ModbusRtuOverTcpTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: base(streamResource, modbusFactory, logger)
{
if (streamResource == null)
{
throw new ArgumentNullException(nameof(streamResource));
}
}
internal ModbusIpTransport(IStreamResource streamResource, IModbusFactory modbusFactory)
: base(streamResource, modbusFactory)
{
if (streamResource == null)
{
throw new ArgumentNullException(nameof(streamResource));
}
}
public TcpDeviceService(
ILogger <TcpDeviceService> logger,
IModbusFactory factory,
ModbusConfiguration configuration,
IObservable <PwsObservationsResponse> source)
: base(logger, factory, configuration, source)
{
}
internal ModbusRtuTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: base(streamResource, modbusFactory, logger)
{
if (modbusFactory == null)
{
throw new ArgumentNullException(nameof(modbusFactory));
}
Debug.Assert(streamResource != null, "Argument streamResource cannot be null.");
}
public static IModbusSlave CreateSlaveProxy(
this IModbusFactory factory,
byte unitId,
IModbusMaster master)
{
var dataStore = new ProxyDataStore(unitId, master);
return(factory.CreateSlave(unitId, dataStore));
}
internal ModbusTcpSlaveNetwork(TcpListener tcpListener, IModbusFactory modbusFactory, IModbusLogger logger)
: base(new EmptyTransport(modbusFactory), modbusFactory, logger)
{
if (tcpListener == null)
{
throw new ArgumentNullException(nameof(tcpListener));
}
_server = tcpListener;
}
protected DeviceService(
ILogger logger,
IModbusFactory factory,
ModbusConfiguration configuration,
IObservable <PwsObservationsResponse> source)
{
Logger = logger;
Factory = factory;
Configuration = configuration;
_source = source;
}
public DeviceController(IRedisConnectionFactory redisConnectionFactory,
IDataAccess mysql_dataAccess,
IModbusFactory modbusFactory, ILoggerFactory loggerFactory)
{
redis_ai = redisConnectionFactory.Connection().GetDatabase(1);
redis_di = redisConnectionFactory.Connection().GetDatabase();
modbus = modbusFactory;
modbus_master = modbus.GetModbusMaster();
logger = loggerFactory.CreateLogger <DeviceController>();
dataAccess = mysql_dataAccess;
}
public ModbusMasterRtuOverTcpConnection(TcpClient client, IModbusSlaveNetwork slaveNetwork, IModbusFactory modbusFactory)
: base(new ModbusRtuTransport(new TcpClientAdapter(client), modbusFactory))
{
//Logger = logger ?? throw new ArgumentNullException(nameof(logger));
TcpClient = client ?? throw new ArgumentNullException(nameof(client));
EndPoint = client.Client.RemoteEndPoint.ToString();
Stream = client.GetStream();
_slaveNetwork = slaveNetwork ?? throw new ArgumentNullException(nameof(slaveNetwork));
_modbusFactory = modbusFactory ?? throw new ArgumentNullException(nameof(modbusFactory));
_requestHandlerTask = Task.Run((Func <Task>)HandleRequestAsync);
}
public ControlSubscribeWorker(IModbusFactory modbus_factory,
IRedisConnectionFactory redisFactory,
IConfiguration configuration, ModbusSystem modbusSystem)
{
config = configuration;
modbusFactory = modbus_factory;
SiteId = configuration.GetSection("SiteId").Get <int>();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
modbus = modbusSystem;
redisDb = redisFactory.Connection().GetDatabase(1);
CancelToken = Program.CancellationTokenSource.Token;
this.Initialize();
}
public static IModbusFunctionService GetFunctionServiceOrThrow(this IModbusFactory factory, byte functionCode)
{
IModbusFunctionService service = factory.GetFunctionService(functionCode);
if (service == null)
{
string msg = $"Function code {functionCode} not supported.";
factory.Logger.Warning(msg);
throw new NotImplementedException(msg);
}
return(service);
}
public ModbusBackgroundService(ILoggerFactory loggerFactory, IModbusFactory modbus_factory,
MqttClientProxyCollection mqttClientProxies, IRedisConnectionFactory redisFactory,
IConfiguration configuration, ModbusSystem modbusSystem)
{
logger = loggerFactory.CreateLogger <ModbusBackgroundService>();
config = configuration;
modbusFactory = modbus_factory;
mqtt_clients = mqttClientProxies;
mqtt_config = configuration.GetSection("MQTTBrokers").Get <MqttConfig>();
SiteId = configuration.GetSection("SiteId").Get <int>();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
modbus = modbusSystem;
redis = redisFactory.Connection().GetDatabase(1);
}
public static IModbusMessage CreateModbusRequest(this IModbusFactory factory, byte[] frame)
{
if (frame.Length < MinRequestFrameLength)
{
string msg = $"Argument 'frame' must have a length of at least {MinRequestFrameLength} bytes.";
throw new FormatException(msg);
}
byte functionCode = frame[1];
var functionService = factory.GetFunctionService(functionCode);
return(functionService.CreateRequest(frame));
}
public ModbusDigitalProcessingService(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory,
IDataAccess mysql_dataAccess, IRedisConnectionFactory redisFactory,
IModbusFactory modbus_factory, IConfiguration configuration, EventPublisherWorker worker, EventMap map,
ModbusSystem modbusSystem)
{
logger = loggerFactory.CreateLogger <ModbusBackgroundService>();
config = configuration;
modbusFactory = modbus_factory;
eventPublisherWorker = worker;
UpdatePeriod = configuration.GetSection("EventPollInterval").Get <TimeSpan>();
modbus = modbusSystem;
SiteId = configuration.GetSection("SiteId").Get <short>();
redis = redisFactory.Connection().GetDatabase();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
dbAccess = mysql_dataAccess;
event_map = map;
}
/// <summary>
/// Gets modbus master object from cache or create new one.
/// </summary>
/// <param name="factory"></param>
/// <param name="frameType"></param>
/// <param name="connectionSource"></param>
/// <returns></returns>
public IModbusMaster Get(IModbusFactory factory, FrameType frameType, ConnectionSourceAbstract connectionSource)
{
if (factory == default)
{
throw new ArgumentException("argument 'factory' is mandatory");
}
if (connectionSource == default)
{
throw new ArgumentException("argument 'connectionSource' is mandatory");
}
if ((connectionSource == _connectionSource) &&
(_connectionSource.IsOpen) &&
(modbusMaster != default) &&
(modbusMaster?.Transport?.StreamResource?.IsOpen ?? false))
{
return(modbusMaster);
}
_connectionSource = connectionSource;
var streamResource = _connectionSource.Get();
if (frameType == FrameType.Ip)
{
modbusMaster = factory.CreateIpMaster(streamResource);
}
if (frameType == FrameType.Rtu)
{
var t = factory.CreateRtuTransport(streamResource);
modbusMaster = factory.CreateMaster(t);
}
if (frameType == FrameType.Ascii)
{
var t = factory.CreateAsciiTransport(streamResource);
modbusMaster = factory.CreateMaster(t);
}
return(modbusMaster);
}
internal ModbusAsciiTransport(IStreamResource streamResource, IModbusFactory modbusFactory)
: base(streamResource, modbusFactory)
{
Debug.Assert(streamResource != null, "Argument streamResource cannot be null.");
}
public static IModbusSerialMaster CreateRtuMaster(this IModbusFactory factory, SerialPort serialPort)
{
var adapter = new SerialPortAdapter(serialPort);
return(factory.CreateRtuMaster(adapter));
}
public static IModbusSlaveNetwork CreateAsciiSlaveNetwork(this IModbusFactory factory, SerialPort serialPort)
{
var adapter = new SerialPortAdapter(serialPort);
return(factory.CreateAsciiSlaveNetwork(adapter));
}
public static IModbusAsciiTransport CreateAsciiTransport(this IModbusFactory factory, SerialPort serialPort)
{
var adapter = new SerialPortAdapter(serialPort);
return(factory.CreateAsciiTransport(adapter));
}
protected ModbusSlaveNetwork(IModbusTransport transport, IModbusFactory modbusFactory)
: base(transport)
{
ModbusFactory = modbusFactory;
//_Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public TcpDeviceService(ILogger <TcpDeviceService> logger, IModbusFactory factory, DeviceConfiguration configuration)
: base(logger, factory, configuration)
{
}
public PVBackgroundService(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, IModbusFactory modbus_factory,
MqttClientProxyCollection mqttClientProxies, IRedisConnectionFactory redisFactory,
IConfiguration configuration)
{
logger = loggerFactory.CreateLogger <PVBackgroundService>();
config = configuration;
mqtt_clients = mqttClientProxies;
mqtt_config = configuration.GetSection("MQTTBrokers").Get <MqttConfig>();
SiteId = configuration.GetSection("SiteId").Get <int>();
string mssql_conn = configuration.GetConnectionString("mssql");
redis = redisFactory.Connection().GetDatabase(1);
DeviceName = configuration.GetSection("Modbus:DeviceName").Get <string>();
DeviceName = DeviceName.Substring(0, DeviceName.Length - 1);
sessionFactory = new MsSqlAccessManager().CreateSessionFactory(mssql_conn);
}
/// <summary>
/// Creates an ASCII master.
/// </summary>
/// <param name="factory"></param>
/// <param name="streamResource"></param>
/// <returns></returns>
public static IModbusSerialMaster CreateAsciiMaster(this IModbusFactory factory, IStreamResource streamResource)
{
IModbusAsciiTransport transport = factory.CreateAsciiTransport(streamResource);
return(new ModbusSerialMaster(transport));
}
public EmptyTransport(IModbusFactory modbusFactory)
: base(modbusFactory, NullModbusLogger.Instance)
{
}
protected DeviceService(ILogger logger, IModbusFactory factory, DeviceConfiguration configuration)
{
Logger = logger;
Factory = factory;
Configuration = configuration;
}
public EmptyTransport(IModbusFactory modbusFactory)
: base(modbusFactory)
{
}
internal ModbusRtuOverIpTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: base(streamResource, modbusFactory, logger)
{
}
