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