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