void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
base.Initialize(frame);
if (frame.Length < MinimumFrameSize)
{
throw new FormatException("Message frame does not contain enough bytes.");
}
var opCode167RequestMessage = requestMessage as OpCode167Request;
if (opCode167RequestMessage != null)
{
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
parameters = opCode167RequestMessage.Parameters;
var paramQuery = from p in parameters
orderby p.Tlp.Parameter
select p;
var dataOffset = 4;
paramQuery.ToList().ForEach((parameter) =>
{
Buffer.BlockCopy(data, dataOffset, parameter.Data, 0, parameter.Data.Length);
dataOffset += parameter.Data.Length;
});
}
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
base.Initialize(frame);
if (frame.Length < MinimumFrameSize)
{
throw new FormatException("Message frame does not contain enough bytes.");
}
var opCode180RequestMessage = requestMessage as OpCode180Request;
if (opCode180RequestMessage != null)
{
try
{
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
parameters = opCode180RequestMessage.Parameters;
var valueIndex = 1;
parameters.ToList().ForEach((parameter) =>
{
// Check TLP info
if (parameter.Tlp.PointType != data[valueIndex])
{
throw new FormatException("Point type does not match point type requested");
}
valueIndex++;
if (parameter.Tlp.LogicalNumber != data[valueIndex])
{
throw new FormatException("Logical number does not match logical number requested");
}
valueIndex++;
if (parameter.Tlp.Parameter != data[valueIndex])
{
throw new FormatException("Parameter number does not match parameter number requested");
}
valueIndex++;
try
{
Buffer.BlockCopy(data, valueIndex, parameter.Data, 0, parameter.Data.Length);
}
catch
{
throw new FormatException("Unable to decode opcode 180 data payload.");
}
valueIndex += (parameter.Data.Length);
});
}
catch (Exception ex)
{
throw new FormatException("Unable to parse Opcode 180 response.", ex);
}
}
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
var opCode139RequestMessage = requestMessage as OpCode139Request;
if (opCode139RequestMessage != null)
{
switch (opCode139RequestMessage.Command)
{
case 0:
requestCommand = opCode139RequestMessage.Command;
break;
case 1:
historyIndex = opCode139RequestMessage.HistoryIndex;
requestedHistoryPoints = new List <byte>(opCode139RequestMessage.RequestedHistoryPoints.ToArray());
break;
}
}
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
StartingDatabaseNumber = (requestMessage as OpCode165Request).StartingDatabaseNumber;
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
var opCode126RequestMessage = requestMessage as OpCode126Request;
if (opCode126RequestMessage != null)
{
historyPointNumber = opCode126RequestMessage.HistoryPointNumber;
}
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
var opCode130RequestMessage = requestMessage as OpCode130Request;
if (opCode130RequestMessage != null)
{
startIndex = opCode130RequestMessage.StartingHistoryIndexPointer;
}
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
var opCode080Request = requestMessage as OpCode080Request;
function = opCode080Request.Function;
Offset = opCode080Request.Offset;
Length = opCode080Request.Length;
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
var opCode136RequestMessage = requestMessage as OpCode136Request;
if (opCode136RequestMessage != null)
{
startingHistoryPoint = opCode136RequestMessage.StartingHistoryPoint;
numberOfHistoryPoints = opCode136RequestMessage.NumberOfHistoryPoints;
numberOfTimePeriods = opCode136RequestMessage.NumberOfTimePeriods;
}
base.Initialize(frame);
var dataLength = frame[5];
data = new byte[dataLength];
Buffer.BlockCopy(frame, 6, data, 0, dataLength);
}
internal void ValidateResponse(IROCRequestMessage request, IROCResponseMessage response)
{
if (request.OpCode != response.OpCode)
{
throw new IOException(String.Format(CultureInfo.InvariantCulture, "Received response with unexpected OpCode. Expected {0}, received {1}.", request.OpCode, response.OpCode));
}
if (request.DestinationUnit != response.SourceUnit)
{
throw new IOException(String.Format(CultureInfo.InvariantCulture, "Response source unit does not match request. Expected {0}, received {1}.", response.DestinationUnit, request.SourceUnit));
}
if (request.DestinationGroup != response.SourceGroup)
{
throw new IOException(String.Format(CultureInfo.InvariantCulture, "Response source group does not match request. Expected {0}, received {1}.", response.DestinationGroup, request.SourceGroup));
}
request.ValidateResponse(response);
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
base.Initialize(frame);
if (frame.Length < MinimumFrameSize)
{
throw new FormatException("Message frame does not contain enough bytes.");
}
ErrorOpCode = requestMessage.OpCode;
switch (frame.Length)
{
case 9:
ErrorCode = frame[5];
ErrorNumber = frame[6];
break;
case 10:
ErrorCode = frame[5];
ErrorNumber = frame[6];
ErrorPointer = frame[7];
break;
default:
{
var messageFrameLengthNoCrc = Convert.ToByte(frame.Length - 2);
ROCPlusErrors = new List <ROCPlusError>();
for (var i = 5; messageFrameLengthNoCrc > i; i += 2)
{
ROCPlusErrors.Add(new ROCPlusError()
{
ErrorCode = frame[i - 1], Offset = frame[i]
});
}
}
break;
}
}
void IROCResponseMessage.Initialize(byte[] frame, IROCRequestMessage requestMessage)
{
this.Initialize(frame);
}
internal virtual TResponseMessage UnicastMessage <TResponseMessage>(IROCRequestMessage requestMessage)
where TResponseMessage : IROCResponseMessage, new()
{
if (TracingEnabled)
{
Trace.WriteLine(string.Format("ROCMaster.Transport,WriteDelay,{0},{1}", requestMessage.OpCode.ToString(), DateTime.Now.ToString("O"), "Transport"));
}
var lastException = (Exception)null;
var transactionStopWatch = Stopwatch.StartNew();
IROCResponseMessage responseMessage = default(TResponseMessage);
int attempt = 0;
bool success = false;
object channelLock = Channel.LockObject;
lock (channelLock)
{
do
{
try
{
attempt++;
if (RequestWriteDelayMilliseconds > 0)
{
if (TracingEnabled)
{
Trace.WriteLine(string.Format("ROCMaster.Transport,WriteDelay,{0},{1}", requestMessage.OpCode.ToString(), RequestWriteDelayMilliseconds.ToString("0.0")));
}
TimedThreadBlocker.Wait(RequestWriteDelayMilliseconds);
}
Write(requestMessage);
if (ResponseReadDelayMilliseconds > 0)
{
if (TracingEnabled)
{
Trace.WriteLine(string.Format("ROCMaster.Transport,ReadDelay,{0},{1}", requestMessage.OpCode.ToString(), ResponseReadDelayMilliseconds.ToString("0.0")));
}
TimedThreadBlocker.Wait(RequestWriteDelayMilliseconds);
}
responseMessage = ReadResponse <TResponseMessage>(requestMessage);
if (responseMessage.OpCode == 255)
{
var opCode255Response = responseMessage as OpCode255Response;
if (opCode255Response != null)
{
throw new OpCode255Exception(opCode255Response);
}
}
else
{
ValidateResponse(requestMessage, responseMessage);
transactionStopWatch.Stop();
if (TracingEnabled)
{
Trace.WriteLine(string.Format("ROCMaster.Transport,Read,{0},{1},{3},{4}", requestMessage.OpCode.ToString(), transactionStopWatch.Elapsed.TotalMilliseconds.ToString(), HexConverter.ToHexString(requestMessage.ProtocolDataUnit), HexConverter.ToHexString(responseMessage.ProtocolDataUnit), ""));
}
return((TResponseMessage)responseMessage);
}
}
catch (Exception e)
{
lastException = e;
Trace.WriteLine(string.Format("ROCMaster.Transport.Error,{0},{1}", requestMessage.OpCode.ToString(), e.Message), "Transport");
if (e is FormatException ||
e is NotImplementedException ||
e is TimeoutException ||
e is IOException)
{
if (attempt > NumberOfRetries)
{
goto Finish;
}
else
{
TimedThreadBlocker.Wait(WaitToRetryMilliseconds);
}
}
else
{
throw;
}
}
if (TracingEnabled)
{
Trace.WriteLine(string.Format("ROCMaster.Transport.Warning,Retry,{0},{1}", requestMessage.OpCode.ToString(), attempt.ToString()));
}
} while (!success && NumberOfRetries > attempt);
}
Finish:
throw new TimeoutException("Device not responding to requests", lastException);
}
internal IROCResponseMessage ReadResponse <TResponseMessage>(IROCRequestMessage requestMessage)
where TResponseMessage : IROCResponseMessage, new()
{
var sequence = 0;
var referenceHeader = new byte[] { requestMessage.SourceUnit, requestMessage.SourceGroup, requestMessage.DestinationUnit, requestMessage.DestinationGroup, requestMessage.OpCode };
var errorHeader = new byte[] { requestMessage.SourceUnit, requestMessage.SourceGroup, requestMessage.DestinationUnit, requestMessage.DestinationGroup, Device.OpCode255 };
var header = Read(RESPONSE_FRAME_START_LENGTH, sequence);
while ((!header.SequenceEqual(referenceHeader)) && (!header.SequenceEqual(errorHeader)))
{
sequence++;
var streamByte = Read(1, sequence)[0];
header = new byte[] { header[1], header[2], header[3], header[4], streamByte };
}
if (header.SequenceEqual(errorHeader))
{
var errorBytes = new List <byte>();
var errorFrameBytes = new List <byte>(header);
var numberOfBytesAvailable = Channel.NumberOfBytesAvailable;
while (numberOfBytesAvailable > 0)
{
sequence++;
errorBytes.AddRange(Read(numberOfBytesAvailable, (-1 * sequence)));
Thread.Sleep(500);
numberOfBytesAvailable = Channel.NumberOfBytesAvailable;
}
for (var i = 0; errorBytes.Count > i; i++)
{
errorFrameBytes.Add(errorBytes[i]);
if (ChecksumsMatch(errorFrameBytes.ToArray(), new byte[] { errorFrameBytes[errorFrameBytes.Count - 2], errorFrameBytes[errorFrameBytes.Count - 1] }))
{
return(CreateResponse <TResponseMessage>(errorFrameBytes.ToArray(), requestMessage));
}
}
throw new IOException("Checksum Error");
}
else
{
sequence++;
byte[] frameStart = header.Concat(Read(1, sequence)).ToArray();
sequence++;
byte[] frameEnd = Read(ResponseBytesToRead(frameStart), sequence);
byte[] frameBytes = frameStart.Concat(frameEnd).ToArray();
var numberOfBytesAvailable = Channel.NumberOfBytesAvailable;
while (numberOfBytesAvailable > 0)
{
sequence++;
Read(numberOfBytesAvailable, (-1 * sequence));
Thread.Sleep(0);
numberOfBytesAvailable = Channel.NumberOfBytesAvailable;
}
var responseMessage = CreateResponse <TResponseMessage>(frameBytes, requestMessage);
if (!ChecksumsMatch(responseMessage, frameBytes))
{
throw new IOException("Checksum Error");
}
else
{
return(responseMessage);
}
}
}
internal virtual IROCResponseMessage CreateResponse <TResponseMessage>(byte[] frame, IROCRequestMessage requestMessage)
where TResponseMessage : IROCResponseMessage, new()
{
byte opCode = frame[4];
IROCResponseMessage response;
switch (opCode)
{
case Device.OpCode7:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode007Response>(frame);
break;
case Device.OpCode8:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode008Response>(frame);
break;
case Device.OpCode17:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode017Response>(frame);
break;
case Device.OpCode80:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode080Response>(frame, requestMessage);
break;
case Device.OpCode120:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode120Response>(frame);
break;
case Device.OpCode118:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode118Response>(frame);
break;
case Device.OpCode119:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode119Response>(frame);
break;
case Device.OpCode121:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode121Response>(frame);
break;
case Device.OpCode122:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode122Response>(frame);
break;
case Device.OpCode126:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode126Response>(frame, requestMessage);
break;
case Device.OpCode130:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode130Response>(frame, requestMessage);
break;
case Device.OpCode131:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode131Response>(frame, requestMessage);
break;
case Device.OpCode132:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode132Response>(frame, requestMessage);
break;
case Device.OpCode136:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode136Response>(frame, requestMessage);
break;
case Device.OpCode139:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode139Response>(frame, requestMessage);
break;
case Device.OpCode165:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode165Response>(frame, requestMessage);
break;
case Device.OpCode166:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode166Response>(frame);
break;
case Device.OpCode167:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode167Response>(frame, requestMessage);
break;
case Device.OpCode180:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode180Response>(frame, requestMessage);
break;
case Device.OpCode181:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode181Response>(frame);
break;
case Device.OpCode255:
response = ROCMessageFactory.CreateROCResponseMessage <OpCode255Response>(frame, requestMessage);
break;
default:
throw new FormatException(string.Format("Unknown OpCode ({0}).", opCode.ToString()));
}
return(response);
}
public static IROCResponseMessage CreateROCResponseMessage <TResponseMessage>(byte[] frame, IROCRequestMessage requestMessage)
where TResponseMessage : IROCResponseMessage, new()
{
TResponseMessage responseMessage = new TResponseMessage();
responseMessage.Initialize(frame, requestMessage);
return(responseMessage);
}
