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