public void BasicLoggerAddressesDuplicates()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
Parameter parameter;
database.TryGetParameterById("P8", out parameter); // engine speed (14)
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P201", out parameter); // IDC, requires engine speed (14), IPW (32)
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P202", out parameter); // MRP(corrected), requires MAP (13), Atmo (35)
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P7", out parameter); // MAP (13)
profile.Add(parameter, parameter.Conversions[0]);
// IPW is not in the resulting set of addresses, why?
this.logger.SetProfile(profile, database);
List <int> addresses = this.logger.Addresses;
Assert.AreEqual(5, addresses.Count);
int[] expected = new int[] { 14, 15, 13, 32, 35 };
Utility.CompareArrays("Address arrays", expected, addresses.ToArray());
}
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);
}
static void Main(string[] args)
{
bool capture = true;
//bool mock = true;
bool mock = false;
SerialPort port = null;
Stream ecuStream;
if (mock)
{
ecuStream = MockEcuStream.GetInstance();
}
else
{
port = new SerialPort("COM3", 4800, Parity.None, 8, StopBits.One);
port.Open();
port.ReadTimeout = 1000;
port.DiscardInBuffer();
port.DiscardOutBuffer();
ecuStream = port.BaseStream;
}
if (capture)
{
Stream captureStream = File.Open(captureFileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read);
captureStream.SetLength(0);
ecuStream = new CaptureStream(ecuStream, new StreamWriter(captureStream));
}
ManualLoggingTest(ecuStream, port);
//ReadMultipleTest(ecuStream, port);
}
public void MockEcuStreamEcuIdentifier()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmPacket send = SsmPacket.CreateEcuIdentifierRequest();
SsmPacket receive = SsmPacket.CreateEcuIdentifierResponse();
MockEcuStreamTest.SendReceive("EcuId", stream, send, receive);
}
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 SsmInterfaceGetEcuIdentifier()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmInterface ssm = SsmInterface.GetInstance(stream);
this.ecuIdentifier = null;
IAsyncResult asyncResult = ssm.BeginGetEcuIdentifier(GetEcuIdentifierCallack, ssm);
asyncResult.AsyncWaitHandle.WaitOne();
Assert.AreEqual("2F12785206", this.ecuIdentifier, "EcuIdentifier");
}
public void BasicLoggerDependencyConversions()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile baseParameters = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
if (parameter.Id == "P201")
{
baseParameters.Add(parameter, parameter.Conversions[0]);
}
if (parameter.Id == "P202")
{
baseParameters.Add(parameter, parameter.Conversions[0]);
break;
}
}
this.logger.SetProfile(baseParameters, database);
LogEventArgs args = this.logger.GetOneRow();
Utility.AssertColumnParameterId(args, 0, "P201");
Utility.AssertColumnParameterId(args, 1, "P202");
Utility.AssertColumnParameterId(args, 2, "P8");
Utility.AssertColumnParameterId(args, 3, "P21");
Utility.AssertColumnParameterId(args, 4, "P7");
Utility.AssertColumnParameterId(args, 5, "P24");
Assert.AreEqual(6, args.Row.Columns.Count);
List <int> addresses = this.logger.Addresses;
Assert.AreEqual(5, addresses.Count);
int[] expected = new int[] { 14, 15, 32, 13, 35 };
Utility.CompareArrays("Address arrays", expected, addresses.ToArray());
// Values from observation...
Assert.AreEqual("2.08", args.Row.Columns[0].ValueAsString);
Assert.AreEqual("1.02", args.Row.Columns[1].ValueAsString);
}
public void LoggerCorruptPacket()
{
this.logger = SsmLogger.GetInstance(Environment.CurrentDirectory, MockEcuStream.PortName);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
profile.Add(parameter, parameter.Conversions[0]);
if (profile.Columns.Count > 3)
{
break;
}
}
this.logStartCalls = 0;
this.logEntryCalls = 0;
this.logEndCalls = 0;
this.logErrorCalls = 0;
this.logger.SetProfile(profile, database);
this.logger.LogStart += this.LogStart;
this.logger.LogEntry += this.LogEntry;
this.logger.LogStop += this.LogStop;
this.logger.LogError += this.LogError;
this.logger.StartLogging();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.25));
MockEcuStream.CorruptResponse();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.25));
int entriesBeforeCorruption = this.logEntryCalls;
Debug.WriteLine("Entries before corrupted packet: " + entriesBeforeCorruption.ToString());
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1.25));
int entriesAfterCorruption = this.logEntryCalls;
Debug.WriteLine("Entries after corrupted packet: " + entriesAfterCorruption.ToString());
this.logger.BeginStopLogging(NoOp, null);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.1));
Assert.IsTrue(entriesAfterCorruption > entriesBeforeCorruption, "Resumed logging after corrupted response.");
}
public void SsmInterfaceSyncReadMultiple()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmInterface ssm = SsmInterface.GetInstance(stream);
List <int> addresses = new List <int>();
addresses.Add(0x000029);
addresses.Add(0x000020);
byte[] values = ssm.SyncReadMultiple(addresses);
Assert.AreEqual(values.Length, addresses.Count, "Values.Count");
Assert.AreEqual(127, values[0], "Values[0]");
Assert.AreEqual(39, values[1], "Values[1]");
}
public void SsmInterfaceBlockRead()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmInterface ssm = SsmInterface.GetInstance(stream);
IAsyncResult asyncResult = ssm.BeginBlockRead(0, 200, BlockReadCallack, ssm);
asyncResult.AsyncWaitHandle.WaitOne();
Assert.AreEqual(200, this.values.Length, "Values.Count");
Assert.AreEqual(0, values[0], "Values[0]");
Assert.AreEqual(1, values[1], "Values[1]");
Assert.AreEqual(198, values[198], "Values[198]");
Assert.AreEqual(199, values[199], "Values[199]");
}
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);
}
public void BasicLoggerConnect()
{
MockEcuStream mock = MockEcuStream.CreateInstance();
FragmentedStream stream = FragmentedStream.GetInstance(mock);
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
Assert.AreEqual("2F12785206", this.logger.EcuIdentifier, "EcuIdentifier");
Assert.IsNotNull(source);
Assert.IsNotNull(source.Parameters);
}
public void SsmInterfaceMultipleRead()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmInterface ssm = SsmInterface.GetInstance(stream);
IList <int> addresses = new List <int>();
addresses.Add(0x29);
addresses.Add(0x20);
this.values = null;
IAsyncResult asyncResult = ssm.BeginMultipleRead(addresses, MultipleReadCallack, ssm);
asyncResult.AsyncWaitHandle.WaitOne();
Assert.AreEqual(2, this.values.Length, "Values.Count");
Assert.AreEqual(127, values[0], "Values[0]");
Assert.AreEqual(39, values[1], "Values[1]");
}
public void SsmInterfaceSyncReadBlock()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmInterface ssm = SsmInterface.GetInstance(stream);
List <int> addresses = new List <int>();
byte[] values = ssm.SyncReadBlock(0, 16);
Assert.AreEqual(values.Length, 16, "Values.Count");
Assert.AreEqual(0x00, values[0], "Values[0]");
Assert.AreEqual(0x01, values[1], "Values[1]");
Assert.AreEqual(0x02, values[2], "Values[2]");
Assert.AreEqual(0x03, values[3], "Values[3]");
Assert.AreEqual(0x0c, values[12], "Values[12]");
Assert.AreEqual(0x6C, values[13], "Values[13]");
Assert.AreEqual(0x03, values[14], "Values[14]");
Assert.AreEqual(0xE8, values[15], "Values[15]");
}
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);
}
public void LoggerConnect()
{
MockEcuStream mock = MockEcuStream.CreateInstance();
this.logger = SsmLogger.GetInstance(Environment.CurrentDirectory, MockEcuStream.PortName);
IAsyncResult result = logger.BeginConnect(ConnectCallback, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
Assert.AreEqual("2F12785206", this.logger.EcuIdentifier, "EcuIdentifier");
Assert.IsNotNull(database);
Assert.IsNotNull(database.Parameters);
Assert.AreEqual(database.Parameters.Count, 178);
}
public void ManualLoggingTest(Action <ParameterDatabase> callback)
{
MockEcuStream stream = MockEcuStream.CreateInstance();
FragmentedStream fragStream = FragmentedStream.GetInstance(stream);
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, fragStream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile Profile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
Profile.Add(parameter, parameter.Conversions[0]);
if (Profile.Columns.Count > 3)
{
break;
}
}
this.logStartCalls = 0;
this.logEntryCalls = 0;
this.logEndCalls = 0;
this.logErrorCalls = 0;
this.logger.SetProfile(Profile, database);
this.logger.LogStart += this.LogStart;
this.logger.LogEntry += this.LogEntry;
this.logger.LogStop += this.LogStop;
this.logger.LogError += this.LogError;
this.logger.StartLogging();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.25));
callback(database);
this.logger.BeginStopLogging(NoOp, null);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.1));
}
private ParameterDatabase InitializeLogger()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
Assert.AreEqual("2F12785206", this.logger.EcuIdentifier, "EcuIdentifier");
Assert.IsNotNull(source);
Assert.AreEqual(178, source.Parameters.Count);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
Assert.AreEqual(178, database.Parameters.Count);
return(database);
}
public void BasicLoggerAddresses()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
SsmBasicLogger logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
profile.Add(parameter, parameter.Conversions[0]);
if (profile.Columns.Count == 8)
{
break;
}
}
logger.SetProfile(profile, database);
IList <int> actual = logger.Addresses;
// Note that parameters get re-ordered alphabetically
IList <int> expected = new int[]
{
// 9, 10, 8, 14, 15, 17, 18, 13, 16,
8, 9, 10, 13, 14, 15, 16, 17, 18,
};
Assert.AreEqual(expected.Count, actual.Count, "Addresses.Length");
for (int i = 0; i < expected.Count; i++)
{
Assert.AreEqual(expected[i], actual[i], "Addresses[" + i + "]");
}
}
public void BasicLoggerProfile()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile expectedProfile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
expectedProfile.Add(parameter, parameter.Conversions[0]);
if (expectedProfile.Columns.Count > 3)
{
break;
}
}
logger.SetProfile(expectedProfile, database);
LogProfile actualProfile = logger.CurrentProfile;
Assert.AreEqual(expectedProfile.Columns.Count, actualProfile.Columns.Count, "Actual count and expected count");
foreach (LogColumn expectedColumn in expectedProfile.Columns)
{
Assert.IsTrue(actualProfile.Contains(expectedColumn.Parameter), "Actual expected parameter set is missing something");
}
foreach (LogColumn actualColumn in actualProfile.Columns)
{
Assert.IsTrue(expectedProfile.Contains(actualColumn.Parameter), "Actual expected parameter set contains something extra");
}
}
/// <summary>
/// Get the stream from which to read ECU data
/// </summary>
private Stream GetDataStream()
{
Trace.WriteLine("GetDataStream");
string portName = ConfigurationManager.AppSettings["Port"];
if (portName == "Mock ECU")
{
MessageBox.Show(
"Bogus data will be displayed." +
Environment.NewLine +
"If you want real data, change the \"Port\" setting in" +
Environment.NewLine +
"TreeHugger.exe.config to COM1 or COM2 or whatever.");
MockEcuStream.Image = new EcuImage2F12785206();
return(MockEcuStream.CreateInstance());
}
Stream stream = null;
Exception exception = null;
try
{
if (this.port == null)
{
Trace.WriteLine("Creating port.");
this.port = new SerialPort(portName, 4800, Parity.None, 8);
this.port.ReadTimeout = 500;
this.port.WriteTimeout = 500;
}
if (!this.port.IsOpen)
{
Trace.WriteLine("Port not open.");
this.port.Open();
stream = this.port.BaseStream;
Trace.WriteLine("Port opened, returning stream.");
return(stream);
}
Trace.WriteLine("Port already created, draining input queue...");
int bytesToRead = 0;
while ((bytesToRead = this.port.BytesToRead) > 0)
{
Trace.WriteLine(bytesToRead.ToString() + " bytes in queue, reading...");
byte[] buffer = new byte[bytesToRead];
this.port.Read(buffer, 0, buffer.Length);
Trace.WriteLine("Read completed.");
Thread.Sleep(500);
}
stream = this.port.BaseStream;
Trace.WriteLine("Input queue drained, returning stream.");
return(stream);
}
catch (System.TimeoutException ex)
{
exception = ex;
}
catch (System.IO.IOException ex)
{
exception = ex;
}
catch (System.UnauthorizedAccessException ex)
{
exception = ex;
}
this.DisplayException(exception);
Thread.Sleep(1000);
return(null);
}
