/// <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); }