/// <summary>
/// Override of sending order to ECU with an 16-bit-value
/// </summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Value">Value of order</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Order(OrderByte STB, UInt16 Value)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
return(ReturnValue.PortNotOpened);
}
else
{
// Prepare value
Size = Value;
// Write order
WriteHeader(STB);
// Receive answer
ret = WaitForSync();
if (ret == ReturnValue.Retry || ret == ReturnValue.TimeOut)
{
WriteHeader(STB);
// Receive answer
ret = WaitForSync();
}
if (ret == ReturnValue.NoError)
{
ret = ReadHeader();
}
}
return(ret);
}
/// <summary>Send an order to ECU</summary>
/// <param name="STB">Communication order identifier</param>
/// <returns>0 on success, else error (see ErrorByte)</returns>
public override ReturnValue Order(OrderByte STB)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
return(ReturnValue.PortNotOpened);
}
else
{
// Do not use data
Size = 0;
// Write order
writeHeader(STB);
// Receive answer
ret = waitForSync();
if (ret == ReturnValue.Retry || ret == ReturnValue.TimeOut)
{
writeHeader(STB);
// Receive answer
ret = waitForSync();
}
if (ret == ReturnValue.NoError)
{
ret = readHeader();
}
}
return(ret);
}
/// <summary>
/// Override Read data from ECU with value for Size parameter
/// </summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Value">Special value to be send in Size parameter</param>
/// <param name="Data">Target data byte array</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Read(OrderByte STB, UInt16 Value, out byte[] Data)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
Data = new byte[0];
return(ReturnValue.PortNotOpened);
}
else
{
// Prepare value
Size = Value;
// Write order (read request)
WriteHeader(STB);
// Receive Answer
ret = WaitForSync();
if (ret == ReturnValue.Retry || ret == ReturnValue.TimeOut)
{
WriteHeader(STB);
// Receive answer
ret = WaitForSync();
}
if (ret == ReturnValue.NoError)
{
ret = ReadHeader();
if (ret != ReturnValue.NoError)
{
Data = new byte[0];
}
else
{
// Set new site of data
Data = new byte[Size];
try
{
// Receive data bytes
for (int i = 0; i < Size; i++)
{
Data[i] = (byte)mComPort.ReadByte();
}
}
catch (TimeoutException)
{
return(ReturnValue.TimeOut);
}
}
}
else
{
Data = new byte[0];
}
}
return(ret);
}
/// <summary>Write data to ECU</summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Value">Size of data or parameter</param>
/// <param name="Data">Source data byte array</param>
/// <param name="ExecutionTime">Execution time between sending request and response</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Write(OrderByte STB, UInt16 Value, ref byte[] Data, UInt16 ExecutionTime)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
ret = ReturnValue.PortNotOpened;
}
else
{
// Set protocol data length
Size = Value;
// Write order
writeHeader(STB);
// Write data
for (int i = 0; i < Data.Length; i++)
{
mComPort.Write(Data, i, 1);
}
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
if (ret == ReturnValue.Retry || ret == ReturnValue.TimeOut)
{
System.Threading.Thread.Sleep(5000 - ExecutionTime); // 5 s sind timeout von ecu.cfg2flash
writeHeader(STB);
// Write data
for (int i = 0; i < Data.Length; i++)
{
mComPort.Write(Data, i, 1);
}
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
}
if (ret == ReturnValue.NoError)
{
ret = readHeader();
}
}
return(ret);
}
/// <summary>Write data to ECU after erasing target area</summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Data">BYte array of data</param>
/// <param name="ExecutionTime">Execution time between sending request and response</param>
/// <param name="EraseTime">Time required for erasing between sending header and sending data</param>
/// <returns>0 on success, else error (see ReturnValue)</returns>
public override ReturnValue EraseAndWrite(OrderByte STB, ref byte[] Data, UInt16 ExecutionTime, UInt16 EraseTime)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
ret = ReturnValue.PortNotOpened;
}
else
{
// Set protocol data length
Size = (UInt16)Data.Length;
// Write order
WriteHeader(STB);
// Wait for target to erase
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(EraseTime);
}
// Receive answer
ret = WaitForSync();
//Console.WriteLine("< sync_a=" + ret);
if (ret == ReturnValue.NoError)
{
ret = ReadHeader();
//Console.WriteLine("< header_a=" + ret);
// Write data
//Console.WriteLine("> data");
for (int i = 0; i < Data.Length; i++)
{
mComPort.Write(Data, i, 1);
}
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = WaitForSync();
//Console.WriteLine("< sync_b=" + ret);
if (ret == ReturnValue.NoError)
{
ret = ReadHeader();
//Console.WriteLine("< header_b=" + ret);
}
}
}
return(ret);
}
/// <summary>Write data to ECU after erasing target area</summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Data">Byte array of data</param>
/// <param name="ExecutionTime">Execution time between sending request and response</param>
/// <param name="EraseTime">Time required for erasing between sending header and sending data</param>
/// <returns>0 on success, else error (see ReturnValue)</returns>
public override ReturnValue EraseAndWrite(OrderByte STB, ref byte[] Data, UInt16 ExecutionTime, UInt16 EraseTime)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
ret = ReturnValue.PortNotOpened;
}
else
{
// Set protocol data length
Size = (UInt16)Data.Length;
// Write order
writeHeader(STB);
// Wait during execution, but handle potential error messages
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
if (ret == ReturnValue.NoError)
{
ret = readHeader();
// Write data
for (int i = 0; i < Data.Length; i++)
{
mComPort.Write(Data, i, 1);
}
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
if (ret == ReturnValue.NoError)
{
ret = readHeader();
}
}
}
return(ret);
}
/// <summary>Write header to ECU</summary>
/// <param name="STB">Order byte</param>
private void writeHeader(OrderByte STB)
{
byte[] header = new byte[23];
// Save current order byte
mOrder = STB;
// Prepare header
header[0] = SYNC_0;
header[1] = SYNC_1;
header[2] = SYNC_2;
header[3] = mClient[0];
header[4] = mClient[1];
header[5] = mClient[2];
header[6] = mClient[3];
header[7] = mClient[4];
header[8] = mClient[5];
header[9] = mClient[6];
header[10] = mServer;
header[11] = pVersion;
header[12] = (byte)mOrder;
header[13] = mSizeLowByte;
header[14] = mSizeHighByte;
header[15] = mKey[0];
header[16] = mKey[1];
header[17] = mKey[2];
header[18] = mKey[3];
header[19] = mKey[4];
header[20] = mKey[5];
header[21] = mKey[6];
header[22] = mKey[7];
// Send header bytes to ECU
try
{
for (int i = 0; i < header.Length; i++)
{
mComPort.Write(header, i, 1);
}
Console.WriteLine("> " + mOrder + "(" + Size + ")");
}
catch (Exception e)
{
// Todo: implement error message!
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Write header to ECU
/// </summary>
/// <param name="STB"></param>
private void WriteHeader(OrderByte STB)
{
byte[] header = new byte[23];
// Save current order byte
mOrder = STB;
Console.WriteLine(">STB." + STB);
// Prepare header
header[0] = SYNC_0;
header[1] = SYNC_1;
header[2] = SYNC_2;
header[3] = mClient[0];
header[4] = mClient[1];
header[5] = mClient[2];
header[6] = mClient[3];
header[7] = mClient[4];
header[8] = mClient[5];
header[9] = mClient[6];
header[10] = mServer;
header[11] = pVersion;
header[12] = (byte)mOrder;
header[13] = mSizeLowByte;
header[14] = mSizeHighByte;
header[15] = mKey[0];
header[16] = mKey[1];
header[17] = mKey[2];
header[18] = mKey[3];
header[19] = mKey[4];
header[20] = mKey[5];
header[21] = mKey[6];
header[22] = mKey[7];
// Send header bytes to ECU
try
{
mComPort.Write(header, 0, header.Length);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>Override of sending order to ECU with an 16-bit-value
/// and wait for ECU to execute command</summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Value">Value of order</param>
/// <param name="ExecutionTime">Wait execution time of ECU in ms</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Order(OrderByte STB, UInt16 Value, UInt16 ExecutionTime)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
return(ReturnValue.PortNotOpened);
}
else
{
// Prepare value
Size = Value;
// Write order
writeHeader(STB);
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
if (ret == ReturnValue.Retry || ret == ReturnValue.TimeOut)
{
writeHeader(STB);
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
}
if (ret == ReturnValue.NoError)
{
ret = readHeader();
}
}
return(ret);
}
/// <summary>
/// Read data
/// </summary>
/// <param name="STB">Order</param>
/// <param name="Value">Value of order</param>
/// <param name="Data">Target byte array</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Read(OrderByte STB, UInt16 Value, out byte[] Data)
{
Data = new byte[2];
return(1);// ReturnValue.General;
}
/// <summary>Override Read data from ECU with value for Size parameter</summary> /// <param name="STB">Communication order identifier</param> /// <param name="Value">Special value to be send in Size parameter</param> /// <param name="Data">Target data byte array</param> /// <returns>0 on success, else see ReturnValue</returns> public abstract ReturnValue Read(OrderByte STB, UInt16 Value, out byte[] Data);
/// <summary>Read data from ECU</summary> /// <param name="STB">Communication order identifier</param> /// <param name="Data">Target data byte array</param> /// <param name="ExecutionTime">Wait execution time of ECU in ms</param> /// <returns>0 on success, else see ReturnValue</returns> public abstract ReturnValue Read(OrderByte STB, out byte[] Data, UInt16 ExecutionTime);
/// <summary>Send an order to ECU</summary> /// <param name="STB">Communication order identifier</param> /// <returns>0 on success, else error (see ReturnValue)</returns> public abstract ReturnValue Order(OrderByte STB);
/// <summary>Send an order with an 16-bit-value to ECU</summary> /// <param name="STB">Communication order identifier</param> /// <param name="Value">Special value to be send in Size parameter</param> /// <returns>0 on success, else error (see ReturnValue)</returns> public abstract ReturnValue Order(OrderByte STB, UInt16 Value);
/// <summary>Read data from ECU</summary>
/// <param name="STB">Communication order identifier</param>
/// <param name="Data">Target data byte array</param>
/// <param name="ExecutionTime">Wait execution time of ECU in ms</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Read(OrderByte STB, out byte[] Data, UInt16 ExecutionTime)
{
ReturnValue ret = ReturnValue.NoError;
// Do not send anything without opened port!
if (!mComPort.IsOpen)
{
Data = new byte[0];
ret = ReturnValue.PortNotOpened;
}
else
{
// Write order (read request)
writeHeader(STB);
// Receive Answer
ret = waitForSync();
if (ret == ReturnValue.Retry || ret == ReturnValue.TimeOut)
{
writeHeader(STB);
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
// Receive answer
ret = waitForSync();
}
if (ret == ReturnValue.NoError)
{
// Wait during execution
if (ExecutionTime != 0)
{
System.Threading.Thread.Sleep(ExecutionTime);
}
ret = readHeader();
if (ret != ReturnValue.NoError)
{
Data = new byte[0];
}
else
{
// Set new site of data
Data = new byte[Size];
try
{
// Receive data bytes
for (int i = 0; i < Size; i++)
{
Data[i] = (byte)mComPort.ReadByte();
}
}
catch (TimeoutException)
{
return(ReturnValue.TimeOut);
}
}
}
else
{
Data = new byte[0];
}
}
return(ret);
}
/// <summary>Send an order to ECU with an 16-bit-value and wait for ECU to execute command</summary> /// <param name="STB">Communication order identifier</param> /// <param name="Value">Special value to be send in Size parameter</param> /// <param name="ExecutionTime">Wait execution time of ECU in ms</param> /// <returns>0 on success, else see ReturnValue</returns> public abstract ReturnValue Order(OrderByte STB, UInt16 Value, UInt16 ExecutionTime);
/// <summary>Write data to ECU</summary> /// <param name="STB">Communication order identifier</param> /// <param name="Value">Parameter or size of data</param> /// <param name="Data">BYte array of data</param> /// <param name="ExecutionTime">Execution time between sending request and response</param> /// <returns>0 on success, else error (see ReturnValue)</returns> public abstract ReturnValue Write(OrderByte STB, UInt16 Value, ref byte[] Data, UInt16 ExecutionTime);
/// <summary>
/// Send order
/// </summary>
/// <param name="STB">Order</param>
/// <returns>0 on success, else see ReturnValue</returns>
public override ReturnValue Order(OrderByte STB)
{
return(1);// ReturnValue.General;
}
/// <summary>Write data to ECU after erasing target area</summary> /// <param name="STB">Communication order identifier</param> /// <param name="Data">BYte array of data</param> /// <param name="ExecutionTime">Execution time between sending request and response</param> /// <param name="EraseTime">Time required for erasing between sending header and sending data</param> /// <returns>0 on success, else error (see ReturnValue)</returns> public abstract ReturnValue EraseAndWrite(OrderByte STB, ref byte[] Data, UInt16 ExecutionTime, UInt16 EraseTime);
