/// <summary>
/// Create a factory which optionally uses the built in function services and allows custom services to be added.
/// </summary>
/// <param name="functionServices">User provided function services.</param>
/// <param name="includeBuiltIn">If true, the built in function services are included. Otherwise, all function services will come from the functionService parameter.</param>
/// <param name="logger">Logger</param>
public ModbusFactory(
IEnumerable <IModbusFunctionService> functionServices = null,
bool includeBuiltIn = true,
IModbusLogger logger = null)
{
Logger = logger ?? NullModbusLogger.Instance;
//Determine if we're including the built in services
if (includeBuiltIn)
{
//Make a dictionary out of the built in services
_functionServices = BuiltInFunctionServices
.ToDictionary(s => s.FunctionCode, s => s);
}
else
{
//Create an empty dictionary
_functionServices = new Dictionary <byte, IModbusFunctionService>();
}
if (functionServices != null)
{
//Add and replace the provided function services as necessary.
foreach (IModbusFunctionService service in functionServices)
{
//This will add or replace the service.
_functionServices[service.FunctionCode] = service;
}
}
}
internal ModbusIpTransport(IStreamResource streamResource, IModbusLogger logger)
: base(streamResource, logger)
{
if (streamResource == null)
{
throw new ArgumentNullException(nameof(streamResource));
}
}
public IModbusMaster CreateMaster <TResource>(TResource tcpClient, IModbusLogger logger) where TResource : TcpClient
{
return(new ModbusMaster(
new ModbusIpTransport(
new PipeAdapter <TResource>(
new TcpClientAdapter <TResource>(tcpClient)),
logger,
new TransactionIdProvider())));
}
public static void Log(this IModbusLogger logger, LoggingLevel level, Func <string> messageFactory)
{
if (logger.ShouldLog(level))
{
string message = messageFactory();
logger.Log(level, message);
}
}
internal static byte[] ReadRequestResponse(IStreamResource streamResource, IModbusLogger logger)
{
if (streamResource == null)
{
throw new ArgumentNullException(nameof(streamResource));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
// read header
var mbapHeader = new byte[6];
int numBytesRead = 0;
while (numBytesRead != 6)
{
int bRead = streamResource.Read(mbapHeader, numBytesRead, 6 - numBytesRead);
if (bRead == 0)
{
throw new IOException("Read resulted in 0 bytes returned.");
}
numBytesRead += bRead;
}
logger.Debug($"MBAP header: {string.Join(", ", mbapHeader)}");
var frameLength = (ushort)IPAddress.HostToNetworkOrder(BitConverter.ToInt16(mbapHeader, 4));
logger.Debug($"{frameLength} bytes in PDU.");
// read message
var messageFrame = new byte[frameLength];
numBytesRead = 0;
while (numBytesRead != frameLength)
{
int bRead = streamResource.Read(messageFrame, numBytesRead, frameLength - numBytesRead);
if (bRead == 0)
{
throw new IOException("Read resulted in 0 bytes returned.");
}
numBytesRead += bRead;
}
logger.Debug($"PDU: {frameLength}");
var frame = mbapHeader.Concat(messageFrame).ToArray();
logger.Debug($"RX: {string.Join(", ", frame)}");
return(frame);
}
internal ModbusTcpSlaveNetwork(TcpListener tcpListener, IModbusLogger logger)
: base(new EmptyTransport(), logger)
{
if (tcpListener == null)
{
throw new ArgumentNullException(nameof(tcpListener));
}
_server = tcpListener;
}
protected ModbusTransport(IPipeResource pipeResource, IModbusLogger logger, ITransactionIdProvider transactionIdProvider)
{
PipeResource = pipeResource ?? throw new ArgumentNullException(nameof(pipeResource));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.transactionIdProvider = transactionIdProvider ?? throw new ArgumentNullException(nameof(transactionIdProvider));
semaphoreSlim = new SemaphoreSlim(1, 1);
disposingTokenSource = new CancellationTokenSource();
}
private static void LogFrame(this IModbusLogger logger, string validPrefix, string invalidPrefix, byte[] frame)
{
if (logger.ShouldLog(LoggingLevel.Trace))
{
if (logger.ShouldLog(LoggingLevel.Trace))
{
string prefix = frame.DoesCrcMatch() ? validPrefix : invalidPrefix;
logger.Trace($"{prefix}: {string.Join(" ", frame.Select(b => b.ToString("X2")))}");
}
}
}
internal ModbusRtuOverTcpTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: base(streamResource, modbusFactory, logger)
{
if (streamResource == null)
{
throw new ArgumentNullException(nameof(streamResource));
}
}
internal ModbusTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: this(modbusFactory, logger)
{
_streamResource = streamResource ?? throw new ArgumentNullException(nameof(streamResource));
}
/// <summary>
/// This constructor is called by the NullTransport.
/// </summary>
internal ModbusTransport(IModbusFactory modbusFactory, IModbusLogger logger)
{
ModbusFactory = modbusFactory;
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public static void Error(this IModbusLogger logger, string message)
{
logger.Log(LoggingLevel.Error, message);
}
internal static void LogFrameRx(this IModbusLogger logger, byte[] frame)
{
logger.LogFrame("RX", "rx", frame);
}
public ModbusFactory()
{
logger = NullModbusLogger.Instance;
}
public static void Critical(this IModbusLogger logger, Func <string> messageFactory)
{
logger.Log(LoggingLevel.Critical, messageFactory);
}
public static void Error(this IModbusLogger logger, Func <string> messageFactory)
{
logger.Log(LoggingLevel.Error, messageFactory);
}
public static void Warning(this IModbusLogger logger, Func <string> messageFactory)
{
logger.Log(LoggingLevel.Warning, messageFactory);
}
public static void Information(this IModbusLogger logger, Func <string> messageFactory)
{
logger.Log(LoggingLevel.Information, messageFactory);
}
public static void Trace(this IModbusLogger logger, Func <string> messageFactory)
{
logger.Log(LoggingLevel.Trace, messageFactory);
}
public static void Information(this IModbusLogger logger, string message)
{
logger.Log(LoggingLevel.Information, message);
}
public static void Critical(this IModbusLogger logger, string message)
{
logger.Log(LoggingLevel.Critical, message);
}
internal static void LogFrameIgnoreRx(this IModbusLogger logger, byte[] frame)
{
logger.LogFrame("IR", "ir", frame);
}
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 void Debug(this IModbusLogger logger, string message)
{
logger.Log(LoggingLevel.Debug, message);
}
public ModbusFactory(IModbusLogger logger)
{
this.logger = logger;
}
internal ModbusSerialTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: base(streamResource, modbusFactory, logger)
{
Debug.Assert(streamResource != null, "Argument streamResource cannot be null.");
}
internal ModbusRtuOverIpTransport(IStreamResource streamResource, IModbusFactory modbusFactory, IModbusLogger logger)
: base(streamResource, modbusFactory, logger)
{
}
protected ModbusSlaveNetwork(IModbusTransport transport, IModbusFactory modbusFactory, IModbusLogger logger)
: base(transport)
{
ModbusFactory = modbusFactory;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public ModbusUdpSlaveNetwork(UdpClient udpClient, IModbusFactory modbusFactory, IModbusLogger logger)
: base(new ModbusIpTransport(new UdpClientAdapter(udpClient), modbusFactory, logger), modbusFactory, logger)
{
_udpClient = udpClient;
}
public static void Warning(this IModbusLogger logger, string message)
{
logger.Log(LoggingLevel.Warning, message);
}
