public static UInt32 GetUint32(this IModbusResponse reg) { byte[] b = (byte[])reg.Data.Clone(); Array.Reverse(b); return(BitConverter.ToUInt32(b, 0)); }
/// <summary> /// Validates a response for current request /// </summary> /// <param name="response">An instance of a modbus response to validate</param> protected override void OnValidateResponse(IModbusResponse response) { base.OnValidateResponse(response); Guard.AgainstIsFalse <ClientModbusResponseException>( this.TransactionId == ((TcpModbusClientResponse)response).TransactionId, ResourceConstants.TRANSACTION_ID_ERROR_MESSAGE); }
/// <summary> /// Validates a response for current request /// </summary> /// <param name="response">An instance of a modbus response to validate</param> protected override void OnValidateResponse(IModbusResponse response) { base.OnValidateResponse(response); var typedResponse = (TcpWriteMultipleRegistersClientResponse)response; Guard.AgainstIsFalse <ClientModbusResponseException>(this.NumberOfPoints == typedResponse.NumberOfPoints); Guard.AgainstIsFalse <ClientModbusResponseException>(this.Address == typedResponse.Address); }
protected override bool RetryReadResponse(IModbusRequest request, IModbusResponse response) { // Do not retry for these on invalid function code or slave address return(request.FunctionCode == response.FunctionCode && request.SlaveAddress == response.SlaveAddress && request.TransactionId > response.TransactionId && request.TransactionId - response.TransactionId < RetryOnOldResponseThreshold); }
protected override void Validate(IModbusRequest request, IModbusResponse response) { request.Validate(response); if (request.TransactionId != response.TransactionId) { throw new IOException($"Received unexpected transaction Id. Expected: {request.TransactionId}. Received: {response.TransactionId}."); } }
/// <summary> /// Validates a response for current request /// </summary> /// <param name="response">An instance of a modbus response to validate</param> public void ValidateResponse(IModbusResponse response) { // ReSharper disable PossibleNullReferenceException Guard.AgainstNullReference <ClientModbusResponseException>(response); Guard.AgainstIsFalse <ClientModbusResponseException>(this.FunctionCode == response.FunctionCode, ResourceConstants.NOT_EQUALS_FUNCTIONCODES_MESSAGE); // ReSharper restore PossibleNullReferenceException this.OnValidateResponse(response); }
/// <summary> /// Represents template method for validation in derived class. /// </summary> /// <param name="request">An instance of modbus request.</param> /// <param name="response">An instance of modbus response to validate.</param> protected override void OnValidateResponse(IModbusClientRequest request, IModbusResponse response) { base.OnValidateResponse(request, response); var tcpModbusRequest = (TcpModbusClientRequest)request; var tcpModbusResponse = (TcpModbusClientResponse)response; Guard.AgainstIsFalse <ClientModbusResponseException>( tcpModbusRequest.TransactionId == tcpModbusResponse.TransactionId, ResourceConstants.TRANSACTION_ID_ERROR_MESSAGE); }
public override void Validate(IModbusResponse response) { base.Validate(response); var typedResponse = (TResponse)response; if (NumberOfPoints != typedResponse.NumberOfPoints) { throw new IOException($"Received unexpected number of points. Expected: {NumberOfPoints}. Received: {typedResponse.NumberOfPoints}."); } }
public override void Validate(IModbusResponse response) { base.Validate(response); var typedResponse = (TResponse)response; if (StartAddress != typedResponse.StartAddress) { throw new IOException($"Received unexpected start address. Expected: {StartAddress}. Received: {typedResponse.StartAddress}."); } }
public override void Validate(IModbusResponse response) { base.Validate(response); var typedResponse = (TResponse)response; if (Value != typedResponse.Value) { throw new IOException($"Received unexpected value. Expected: {Value}. Received: {typedResponse.Value}."); } }
public override void Validate(IModbusResponse response) { base.Validate(response); var typedResponse = (TResponse)response; if (NumberOfPoints > typedResponse.Data.Length) { throw new IOException($"Received less discretes than expected. Expected: {NumberOfPoints}. Received: {typedResponse.Data.Length}."); } }
public virtual void Validate(IModbusResponse response) { if (FunctionCode != response.FunctionCode) { throw new IOException($"Received unexpected function code. Expected: {FunctionCode}. Received: {response.FunctionCode}."); } if (SlaveAddress != response.SlaveAddress) { throw new IOException($"Received unexpected slave address. Expected: {SlaveAddress}. Received: {response.SlaveAddress}."); } }
public static float GetFloat(this IModbusResponse reg, int offset = 0, bool changeEndian = false) { offset *= 4; var ret = new byte[] { reg.Data[2 + offset], reg.Data[3 + offset], reg.Data[0 + offset], reg.Data[1 + offset] }; Array.Reverse(ret); return(BitConverter.ToSingle(ret, 0)); }
/// <summary> /// Represents template method for validation in derived class. /// </summary> /// <param name="request">An instance of modbus request.</param> /// <param name="response">An instance of modbus response to validate.</param> protected virtual void OnValidateResponse(IModbusClientRequest request, IModbusResponse response) { /*none*/ }
public void ValidatesResponse(IModbusRequest request, IModbusResponse response) { // Arrange/Act/Assert Assert.Throws <IOException>(() => request.Validate(response)); }
/// <summary> /// Validates a response for current request /// </summary> /// <param name="response">An instance of a modbus response to validate</param> protected virtual void OnValidateResponse(IModbusResponse response) { /*none*/ }
internal static void SetupValidate(this Mock <ModbusTransport> mock, IModbusRequest request, IModbusResponse response) { mock.Protected().As <IModbusTransportMock>().Setup(x => x.Validate(request, response)); }
internal static void SetupRetryReadResponse(this Mock <ModbusTransport> mock, IModbusRequest request, IModbusResponse response, params bool[] results) { if (results.Length == 1) { mock.Protected() .As <IModbusTransportMock>() .Setup(x => x.RetryReadResponse(request, response)) .Returns(results[0]); return; } var sequenceMock = mock.Protected() .As <IModbusTransportMock>() .SetupSequence(x => x.RetryReadResponse(request, response)); foreach (var item in results) { sequenceMock .Returns(item); } }
protected override void Validate(IModbusRequest request, IModbusResponse response) { request.Validate(response); }
protected override bool RetryReadResponse(IModbusRequest request, IModbusResponse response) { return(false); }
/// <summary> /// Validates a response for current request /// </summary> /// <param name="response">An instance of a modbus response to validate</param> protected override void OnValidateResponse(IModbusResponse response) { base.OnValidateResponse(response); Guard.AgainstIsFalse <ClientModbusResponseException>(this.NumberOfPoints == (response.NumberOfPoints / ProtocolConstants.BYTES_IN_WORD)); }
public static string GetString(this IModbusResponse reg, bool changeEndian = true) { return(Encoding.ASCII.GetString(reg.Data)); }
public static ushort GetUint16(this IModbusResponse reg) { return(BitConverter.ToUInt16(reg.Data, 0)); }