public void MockEcuStreamDefoggerTest()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
stream.DefoggerSwitch = false;
SsmPacket send = SsmPacket.CreateBlockReadRequest(0x64, 1);
byte[] payload = new byte[1];
SsmPacket receive = SsmPacket.CreateBlockReadResponse(payload);
MockEcuStreamTest.SendReceive("Defogger off", stream, send, receive);
stream.DefoggerSwitch = true;
send = SsmPacket.CreateBlockReadRequest(0x64, 1);
payload = new byte[1];
payload[0] = 1 << 5;
receive = SsmPacket.CreateBlockReadResponse(payload);
MockEcuStreamTest.SendReceive("Defogger on", stream, send, receive);
stream.DefoggerSwitch = false;
send = SsmPacket.CreateBlockReadRequest(0x64, 1);
payload = new byte[1];
receive = SsmPacket.CreateBlockReadResponse(payload);
MockEcuStreamTest.SendReceive("Defogger off again", stream, send, receive);
}
private void SendReceive(
byte device,
byte command,
bool pad,
byte[] payloadBytes,
StringBuilder builder)
{
SsmPacket probe = SsmPacket.CreateArbitrary(device, command, pad, payloadBytes);
builder.AppendFormat(
"Sending {0:X2} to {1:X2} with payload of {2} bytes:",
command,
device,
payloadBytes.Length);
builder.AppendLine();
builder.AppendLine(MainForm.BytesToString(payloadBytes));
builder.AppendLine();
byte[] requestBuffer = probe.Data;
this.stream.Write(requestBuffer, 0, requestBuffer.Length);
System.Threading.Thread.Sleep(250);
byte[] responseBuffer = new byte[2000];
int bytesRead = this.stream.Read(responseBuffer, 0, responseBuffer.Length);
builder.AppendFormat(
"Received {0} bytes total, {1} after subtracting echo, {2} payload bytes.",
bytesRead,
bytesRead - probe.Data.Length,
bytesRead - (probe.Data.Length + 6));
builder.AppendLine();
SsmPacket response = SsmPacket.ParseResponse(responseBuffer, 0, bytesRead);
builder.AppendLine("Response packet:");
builder.AppendLine(BytesToString(response.Data));
builder.AppendLine();
builder.AppendLine("Response payload:");
builder.AppendFormat("Header: {0}", response.Data[0].ToHex());
builder.AppendLine();
builder.AppendFormat("Dest: {0}", response.Data[1].ToHex());
builder.AppendLine();
builder.AppendFormat("Source: {0}", response.Data[2].ToHex());
builder.AppendLine();
builder.AppendFormat("DataSize: {0}", response.Data[3].ToHex());
builder.AppendLine();
builder.AppendFormat("Command: {0}", response.Data[4].ToHex());
builder.AppendLine();
builder.AppendFormat("Checksum: {0}", response.Data[response.Data.Length - 1].ToHex());
builder.AppendLine();
byte[] payload = new byte[response.Data.Length - 6];
for (int i = 5; i < response.Data.Length - 1; i++)
{
payload[i - 5] = response.Data[i];
}
builder.AppendFormat("Payload: {0}", BytesToString(payload));
}
public void MockEcuStreamEcuIdentifier()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmPacket send = SsmPacket.CreateEcuIdentifierRequest();
SsmPacket receive = SsmPacket.CreateEcuIdentifierResponse();
MockEcuStreamTest.SendReceive("EcuId", stream, send, receive);
}
public void SsmPacketBlockReadResponse()
{
byte[] payload = new byte[128];
SsmPacket packet = SsmPacket.CreateBlockReadResponse(payload);
IList <byte> expected = SamplePacketData.BlockReadResponse;
Utility.CompareArrays("BlockReadResponse", expected, packet.Data);
Assert.AreEqual(SsmDirection.FromEcu, packet.Direction, "Direction");
Assert.AreEqual(SsmCommand.ReadBlockResponse, packet.Command, "Command");
}
public void SsmPacketEcuIdentifierRequest()
{
SsmPacket packet = SsmPacket.CreateEcuIdentifierRequest();
IList <byte> expected = SamplePacketData.EcuInitRequest;
Utility.CompareArrays("EcuIdentifierRequest", expected, packet.Data);
Assert.AreEqual(SsmDirection.ToEcu, packet.Direction, "Direction");
Assert.AreEqual(1, packet.PayloadLength, "Payload size");
Assert.AreEqual(SsmCommand.EcuInitRequest, packet.Command, "Command");
}
public void MockEcuStreamBlockRead()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmPacket send = SsmPacket.CreateBlockReadRequest(0x200000, 128);
byte[] payload = new byte[128];
SsmPacket receive = SsmPacket.CreateBlockReadResponse(payload);
MockEcuStreamTest.SendReceive("Read", stream, send, receive);
}
public void SsmPacketCreateArbitrary()
{
SsmPacket expectedReadRequest = SsmPacket.CreateBlockReadRequest(123, 12);
SsmPacket actualReadRequest = SsmPacket.CreateArbitrary(
0x10,
(byte)SsmCommand.ReadBlockRequest,
true,
new byte[] { 0, 0, 123, 11, });
Utility.CompareArrays("Block read request", expectedReadRequest.Data, actualReadRequest.Data);
}
public void SsmPacketBlockReadRequest()
{
int address = 0x200000;
byte length = 0x80;
SsmPacket packet = SsmPacket.CreateBlockReadRequest(address, length);
IList <byte> expected = SamplePacketData.BlockReadRequest;
Utility.CompareArrays("BlockReadRequest", expected, packet.Data);
Assert.AreEqual(SsmDirection.ToEcu, packet.Direction, "Direction");
Assert.AreEqual(SsmCommand.ReadBlockRequest, packet.Command, "Command");
Assert.AreEqual(address, packet.BlockStart, "Block start");
Assert.AreEqual(length, packet.BlockLength, "Block length");
}
private static void SendReceive(string message, MockEcuStream stream, SsmPacket send, SsmPacket receive)
{
byte[] buffer = send.Data;
stream.Write(buffer, 0, buffer.Length);
List <byte> expectedList = new List <byte>(send.Data);
expectedList.AddRange(receive.Data);
byte[] expected = expectedList.ToArray();
buffer = new byte[expected.Length];
stream.Read(buffer, 0, buffer.Length);
Utility.CompareArrays(message, expected, buffer);
}
static void ReadMultipleTest(Stream ecuStream, SerialPort port)
{
SsmPacket ecuInitRequest = SsmPacket.CreateEcuIdentifierRequest();
byte[] buffer = ecuInitRequest.Data;
ecuStream.Write(buffer, 0, buffer.Length);
Thread.Sleep(100);
byte[] receiveBuffer = new byte[1000];
int expectedLength = 68;
int receiveLength = ecuStream.Read(receiveBuffer, 0, receiveBuffer.Length);
SsmPacket ecuInitResponse = SsmPacket.ParseResponse(receiveBuffer, 0, receiveLength);
// TPS and IPW
UInt32[] addresses = new UInt32[] { 0x29, 0x20 };
for (int i = 0; i < 1000 && !Console.KeyAvailable; i++)
{
SsmPacket readRequest = SsmPacket.CreateMultipleReadRequest(addresses);
buffer = readRequest.Data;
ecuStream.Write(buffer, 0, buffer.Length);
Thread.Sleep(100);
expectedLength = 21;
receiveLength = ecuStream.Read(receiveBuffer, 0, expectedLength);
if (!Check("ReceiveLength", receiveLength, expectedLength))
{
if (port != null)
{
port.DiscardInBuffer();
port.DiscardOutBuffer();
}
continue;
}
SsmPacket readResponse = SsmPacket.ParseResponse(receiveBuffer, 0, receiveLength);
if (!Check("CommandID", readResponse.Command, SsmCommand.ReadAddressesResponse))
{
if (port != null)
{
port.DiscardInBuffer();
port.DiscardOutBuffer();
}
continue;
}
Console.WriteLine(readResponse.Values[0] + " " + readResponse.Values[1]);
}
}
public void SsmPacketReadOverlongFromStream()
{
IList <int> addresses = new int[] { 1, 2, 3 };
SsmPacket request = SsmPacket.CreateMultipleReadRequest(addresses);
IList <byte> values = new byte[] { 1, 2, 3 };
SsmPacket response = SsmPacket.CreateMultipleReadResponse(values);
List <byte> buffer = new List <byte>(request.Data);
buffer.AddRange(response.Data);
buffer.AddRange(new byte[] { 0, 0, 0, 0 });
MemoryStream stream = new MemoryStream(buffer.ToArray());
SsmPacket actual = SsmPacketParser.ReadFromStream(stream);
Utility.CompareArrays("ReadFromStream", response.Data, actual.Data);
}
public void SsmPacketMultipleReadResponse()
{
List <byte> values = new List <byte>();
values.Add(0x00);
values.Add(0x09);
SsmPacket packet = SsmPacket.CreateMultipleReadResponse(values);
IList <byte> expected = SamplePacketData.MultipleReadResponse;
Utility.CompareArrays("MultipleReadResponse", expected, packet.Data);
Assert.AreEqual(SsmDirection.FromEcu, packet.Direction, "Direction");
Assert.AreEqual(SsmCommand.ReadAddressesResponse, packet.Command, "Command");
Assert.AreEqual(2, packet.Values.Count, "Values.Count");
Assert.AreEqual((byte)0x00, packet.Values[0], "Values[0]");
Assert.AreEqual((byte)0x09, packet.Values[1], "Values[1]");
}
public void SsmPacketMultipleReadRequest()
{
List <int> addresses = new List <int>();
addresses.Add(0x000029);
addresses.Add(0x000020);
SsmPacket packet = SsmPacket.CreateMultipleReadRequest(addresses);
IList <byte> expected = SamplePacketData.MultipleReadRequest;
Utility.CompareArrays("MultipeReadRequest", expected, packet.Data);
Assert.AreEqual(SsmDirection.ToEcu, packet.Direction, "Direction");
Assert.AreEqual(SsmCommand.ReadAddressesRequest, packet.Command, "Command");
Assert.AreEqual(2, packet.Addresses.Count, "Addresses.Count");
Assert.AreEqual(0x29, packet.Addresses[0], "Addresses[0]");
Assert.AreEqual(0x20, packet.Addresses[1], "Addresses[1]");
}
public void MockEcuStreamMultipleAddressRead()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
List <int> addresses = new List <int>();
addresses.Add(0x000029);
addresses.Add(0x000020);
SsmPacket send = SsmPacket.CreateMultipleReadRequest(addresses);
List <byte> payload = new List <byte>();
payload.Add(127);
payload.Add(39);
SsmPacket receive = SsmPacket.CreateMultipleReadResponse(payload);
MockEcuStreamTest.SendReceive("Read", stream, send, receive);
}
private void ReadFromStream(bool fragmented)
{
IList <int> addresses = new int[] { 1, 2, 3 };
SsmPacket request = SsmPacket.CreateMultipleReadRequest(addresses);
IList <byte> values = new byte[] { 1, 2, 3 };
SsmPacket response = SsmPacket.CreateMultipleReadResponse(values);
List <byte> buffer = new List <byte>(request.Data);
buffer.AddRange(response.Data);
MemoryStream stream = new MemoryStream(buffer.ToArray());
if (fragmented)
{
stream = FragmentedStream.GetInstance(stream);
}
SsmPacket actual = SsmPacketParser.ReadFromStream(stream);
Utility.CompareArrays("ReadFromStream", response.Data, actual.Data);
}
public void SsmPacketEcuIdentifierResponse()
{
SsmPacket packet = SsmPacket.CreateEcuIdentifierResponse();
IList <byte> expected = SamplePacketData.EcuInitResponse;
Utility.CompareArrays("EcuIdentifierResponse", expected, packet.Data);
Assert.AreEqual(SsmDirection.FromEcu, packet.Direction, "Direction");
Assert.AreEqual(SsmCommand.EcuInitResponse, packet.Command, "Command");
Assert.AreEqual("2F12785206", packet.EcuIdentifier, "EcuIdentifier");
byte[] expectedData = new byte[] {
0x73, 0xFA, 0xCB, 0xA6, 0x2B, 0x81, 0xFE, 0xA8,
0x00, 0x00, 0x00, 0x60, 0xCE, 0x54, 0xF9, 0xB1,
0xE4, 0x00, 0x0C, 0x20, 0x00, 0x00, 0x00, 0x00,
0x00, 0xDC, 0x00, 0x00, 0x5D, 0x1F, 0x30, 0xC0,
0xF2, 0x26, 0x00, 0x00, 0x43, 0xFB, 0x00, 0xE1,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC1, 0xF0,
0x28,
};
Utility.CompareArrays("CompatibilityMap", expectedData, packet.CompatibilityMap);
}
private void ReadFromStreamAsync(bool fragmented)
{
IList <int> addresses = new int[] { 1, 2, 3 };
SsmPacket request = SsmPacket.CreateMultipleReadRequest(addresses);
IList <byte> values = new byte[] { 1, 2, 3 };
SsmPacket response = SsmPacket.CreateMultipleReadResponse(values);
List <byte> buffer = new List <byte>(request.Data);
buffer.AddRange(response.Data);
MemoryStream stream = new MemoryStream(buffer.ToArray());
if (fragmented)
{
stream = FragmentedStream.GetInstance(stream);
}
SsmPacketParser parser = SsmPacketParser.CreateInstance();
IAsyncResult asyncResult = parser.BeginReadFromStream(stream, ReadCompleted, parser);
asyncResult.AsyncWaitHandle.WaitOne();
Utility.CompareArrays("ReadFromStreamAsync", response.Data, this.packet.Data);
}
private void ReadCompleted(IAsyncResult asyncResult)
{
SsmPacketParser parser = (SsmPacketParser)asyncResult.AsyncState;
this.packet = parser.EndReadFromStream(asyncResult);
}
