//------------------------------------------------------------------------- /** * Handles incoming messages. */ private void read_messages() { uint id; byte length; ulong data; CANMessage msg = new CANMessage(); Debug.Assert(msg != null); // main loop while (true) { // check for thread termination request Debug.Assert(this.term_mutex != null); lock (this.term_mutex) { if (this.term_requested) { return; } } // receive messages while (MctAdapter_ReceiveMessage(out id, out length, out data)) { if (acceptMessageId(id)) { // convert message msg.setID(id); msg.setLength(length); msg.setData(data); // pass message to listeners lock (this.m_listeners) { AddToCanTrace("RX: " + id.ToString("X4") + " " + data.ToString("X16")); foreach (ICANListener listener in this.m_listeners) { listener.handleMessage(msg); } } } } // give up CPU for a moment Thread.Sleep(1); } }
public void readMessages() { CANMessage canMessage = new CANMessage(); string rxMessage = string.Empty; logger.Debug("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { logger.Debug("readMessages ended"); return; } } try { if (m_serialPort.IsOpen) { do { rxMessage = m_serialPort.ReadLine(); rxMessage = rxMessage.Replace("\r", ""); // remove prompt characters... we don't need that stuff rxMessage = rxMessage.Replace("\n", ""); // remove prompt characters... we don't need that stuff } while (rxMessage.StartsWith("w") == false); uint id = Convert.ToUInt32(rxMessage.Substring(1, 3), 16); if (acceptMessageId(id)) { canMessage.setID(id); canMessage.setLength(8); canMessage.setData(0x0000000000000000); for (uint i = 0; i < 8; i++) { canMessage.setCanData(Convert.ToByte(rxMessage.Substring(5 + (2 * (int)i), 2), 16), i); } receivedMessage(canMessage); } } } catch (Exception) { logger.Debug("MSG: " + rxMessage); } } }
/// <summary> /// readMessages is the "run" method of this class. It reads all incomming messages /// and publishes them to registered ICANListeners. /// </summary> public void readMessages() { int readResult = 0; Lawicel.CANUSB.CANMsg r_canMsg = new Lawicel.CANUSB.CANMsg(); CANMessage canMessage = new CANMessage(); Console.WriteLine("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { Console.WriteLine("readMessages ended"); return; } } readResult = Lawicel.CANUSB.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { if (acceptMessageId(r_canMsg.id)) { canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setTimeStamp(r_canMsg.timestamp); canMessage.setFlags(r_canMsg.flags); canMessage.setData(r_canMsg.data); lock (m_listeners) { AddToCanTrace(string.Format("RX: {0} {1}", canMessage.getID().ToString("X3"), canMessage.getData().ToString("X16"))); foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } } else if (readResult == Lawicel.CANUSB.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); } } }
//--------------------------------------------------------------------------------------------- /** * Waits for arrival of a specific CAN message or any message if ID = 0. * * @param a_canID message ID * @param timeout timeout, ms * @param canMsg message * * @return message ID */ public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { canMsg = new CANMessage(); Debug.Assert(canMsg != null); canMsg.setID(0); caCombiAdapter.caCANFrame frame = new caCombiAdapter.caCANFrame(); if (combi.CAN_GetMessage(ref frame, timeout) && (frame.id == a_canID || a_canID == 0)) { // message received canMsg.setID(frame.id); canMsg.setLength(frame.length); canMsg.setData(frame.data); return(frame.id); } // timed out return(0); }
/// <summary> /// Send a message that starts a session. This is used to test if there is /// a connection. /// </summary> /// <returns></returns> private bool sendSessionRequest() { CANMessage msg1 = new CANMessage(0x220, 0, 8); EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); msg1.setData(0x000040021100813f); if (!sendMessage(msg1)) { return(false); } if (waitForMessage(0x238, 1000, out msg) == 0x238) { //Ok, there seems to be a ECU somewhere out there. //Now, sleep for 10 seconds to get a session timeout. This is needed for //applications on higher level. Otherwise there will be no reply when the //higher level application tries to start a session. Thread.Sleep(10000); return(true); } return(false); }
/// <summary> /// readMessages is the "run" method of this class. It reads all incomming messages /// and publishes them to registered ICANListeners. /// </summary> public void readMessages() { int readResult = 0; Lawicel.CANUSB.CANMsg r_canMsg = new Lawicel.CANUSB.CANMsg(); CANMessage canMessage = new CANMessage(); logger.Debug("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { logger.Debug("readMessages thread ended"); return; } } readResult = Lawicel.CANUSB.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { if (acceptMessageId(r_canMsg.id)) { canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setTimeStamp(r_canMsg.timestamp); canMessage.setFlags(r_canMsg.flags); canMessage.setData(r_canMsg.data); receivedMessage(canMessage); } } else if (readResult == Lawicel.CANUSB.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); } } }
/// <summary> /// readMessages is the "run" method of this class. It reads all incomming messages /// and publishes them to registered ICANListeners. /// </summary> public void readMessages() { int readResult = 0; EASYSYNC.CANMsg r_canMsg = new EASYSYNC.CANMsg(); CANMessage canMessage = new CANMessage(); while (true) { lock (m_synchObject) { if (m_endThread) { return; } } readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == EASYSYNC.ERROR_CANUSB_OK) { canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setTimeStamp(r_canMsg.timestamp); canMessage.setFlags(r_canMsg.flags); canMessage.setData(r_canMsg.data); lock (m_listeners) { foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); } } }
//--------------------------------------------------------------------------------------------- /** * Handles incoming messages. */ private void read_messages() { caCombiAdapter.caCANFrame frame = new caCombiAdapter.caCANFrame(); // main loop while (true) { // check for thread termination request Debug.Assert(term_mutex != null); lock (term_mutex) { if (term_requested) { // exit logger.Debug("Reader thread ended"); return; } } // receive messages if (combi.CAN_GetMessage(ref frame, 1000)) { if (acceptMessageId(frame.id)) { // convert message in_msg.setID(frame.id); in_msg.setLength(frame.length); in_msg.setData(frame.data); receivedMessage(in_msg); } } else { Thread.Sleep(1); } } }
/// <summary> /// waitForMessage waits for a specific CAN message give by a CAN id. /// </summary> /// <param name="a_canID">The CAN id to listen for</param> /// <param name="timeout">Listen timeout</param> /// <param name="r_canMsg">The CAN message with a_canID that we where listening for.</param> /// <returns>The CAN id for the message we where listening for, otherwise 0.</returns> public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { Lawicel.CANUSB.CANMsg r_canMsg; canMsg = new CANMessage(); int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { r_canMsg = new Lawicel.CANUSB.CANMsg(); readResult = Lawicel.CANUSB.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { Thread.Sleep(1); logger.Trace("rx: 0x" + r_canMsg.id.ToString("X3") + r_canMsg.data.ToString("X16")); if (r_canMsg.id == 0x00) { nrOfWait++; } else if (r_canMsg.id != a_canID) { continue; } canMsg.setData(r_canMsg.data); canMsg.setID(r_canMsg.id); canMsg.setLength(r_canMsg.len); return((uint)r_canMsg.id); } else if (readResult == Lawicel.CANUSB.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); nrOfWait++; } } r_canMsg = new Lawicel.CANUSB.CANMsg(); return(0); }
/// <summary> /// Send a message that starts a session. This is used to test if there is /// a connection. /// </summary> /// <returns></returns> private bool sendSessionRequest() { Console.WriteLine("Sending session request"); // 0x220 is for T7 // 0x7E0 is for T8 CANMessage msg1 = new CANMessage(0x220, 0, 8); Lawicel.CANUSB.CANMsg msg = new Lawicel.CANUSB.CANMsg(); msg1.setData(0x000040021100813f); if (!sendMessage(msg1)) { Console.WriteLine("Unable to send session request"); return false; } if (waitForMessage(0x238, 1000, out msg) == 0x238) { //Ok, there seems to be a ECU somewhere out there. //Now, sleep for 10 seconds to get a session timeout. This is needed for //applications on higher level. Otherwise there will be no reply when the //higher level application tries to start a session. Thread.Sleep(10000); Console.WriteLine("sendSessionRequest: TRUE"); return true; } Console.WriteLine("sendSessionRequest: FALSE"); return false; }
public void InitializeSession() { CANMessage response = new CANMessage(); //101 8 FE 01 3E 00 00 00 00 00 CANMessage msg = new CANMessage(0x11, 0, 2); ulong cmd = 0x0000000000003E01; msg.setData(cmd); if (!canUsbDevice.sendMessage(msg)) { logger.Debug("Couldn't send message"); } }
//--------------------------------------------------------------------------------------------- /** Waits for arrival of a specific CAN message or any message if ID = 0. @param a_canID message ID @param timeout timeout, ms @param canMsg message @return message ID */ public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { canMsg = new CANMessage(); Debug.Assert(canMsg != null); canMsg.setID(0); caCombiAdapter.caCANFrame frame = new caCombiAdapter.caCANFrame(); if (this.combi.CAN_GetMessage(ref frame, timeout) && (frame.id == a_canID || a_canID == 0)) { // message received canMsg.setID(frame.id); canMsg.setLength(frame.length); canMsg.setData(frame.data); return frame.id; } // timed out return 0; }
public bool ProgramVIN(string VINNumber) { CANMessage msg = new CANMessage(0x7E0, 0, 8); ulong cmd = 0x00000000903B1310; if (VINNumber.Length > 17) VINNumber = VINNumber.Substring(0, 17);// lose more than 17 digits if (VINNumber.Length < 17) VINNumber = VINNumber.PadRight(17, '0'); if (VINNumber.Length != 17) return false; cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[0]), 4); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[1]), 5); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[2]), 6); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[3]), 7); msg.setData(cmd); m_canListener.setupWaitMessage(0x7E8); if (!canUsbDevice.sendMessage(msg)) { CastInfoEvent("Couldn't send message", ActivityType.ConvertingFile); return false; } ulong rxdata = m_canListener.waitMessage(timeoutP2ct).getData(); if (rxdata == 0x0000000000000030) { //2020202020202021 //0020202020202022 cmd = 0x0000000000000021; cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[4]), 1); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[5]), 2); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[6]), 3); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[7]), 4); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[8]), 5); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[9]), 6); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[10]), 7); msg.setData(cmd); m_canListener.setupWaitMessage(0x7E8); canUsbDevice.sendMessage(msg); cmd = 0x0000000000000022; cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[11]), 1); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[12]), 2); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[13]), 3); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[14]), 4); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[15]), 5); cmd = AddByteToCommand(cmd, Convert.ToByte(VINNumber[16]), 6); //msg.setLength(7); // only 7 bytes for the last message msg.setData(cmd); m_canListener.setupWaitMessage(0x7E8); canUsbDevice.sendMessage(msg); // wait for ack //0000000000907B02 rxdata = m_canListener.waitMessage(timeoutP2ct).getData(); if (getCanData(rxdata, 1) == 0x7B && getCanData(rxdata, 2) == 0x90) { return true; } } return false; }
/// <summary> /// waitAnyMessage waits for any message to be received. /// </summary> /// <param name="timeout">Listen timeout</param> /// <param name="r_canMsg">The CAN message that was first received</param> /// <returns>The CAN id for the message received, otherwise 0.</returns> private uint waitAnyMessage(uint timeout, out Lawicel.CANUSB.CANMsg r_canMsg) { CANMessage canMessage = new CANMessage(); string line = string.Empty; int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { m_serialPort.Write("\r"); m_serialPort.Write("P\r"); bool endofFrames = false; while (!endofFrames) { Console.WriteLine("reading line"); line = m_serialPort.ReadLine(); Console.WriteLine("line: " + line + " len: " + line.Length.ToString()); if (line[0] == '\x07' || line[0] == '\r' || line[0] == 'A') { endofFrames = true; } else { if (line.Length == 14) { // three bytes identifier r_canMsg = new Lawicel.CANUSB.CANMsg(); r_canMsg.id = (uint)Convert.ToInt32(line.Substring(1, 3), 16); r_canMsg.len = (byte)Convert.ToInt32(line.Substring(4, 1), 16); ulong data = 0; // add all the bytes data |= (ulong)(byte)Convert.ToInt32(line.Substring(5, 2), 16) << 7 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(7, 2), 16) << 6 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(9, 2), 16) << 5 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(11, 2), 16) << 4 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(13, 2), 16) << 3 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(15, 2), 16) << 2 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(17, 2), 16) << 1 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(19, 2), 16); r_canMsg.data = data; canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setFlags(0); canMessage.setData(r_canMsg.data); return (uint)r_canMsg.id; } } } //Thread.Sleep(0); nrOfWait++; } r_canMsg = new Lawicel.CANUSB.CANMsg(); return 0; }
/// <summary> /// waitForMessage waits for a specific CAN message give by a CAN id. /// </summary> /// <param name="a_canID">The CAN id to listen for</param> /// <param name="timeout">Listen timeout</param> /// <param name="r_canMsg">The CAN message with a_canID that we where listening for.</param> /// <returns>The CAN id for the message we where listening for, otherwise 0.</returns> public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMessage) { canMessage = new CANMessage(); Debug.Assert(canMessage != null); int wait_cnt = 0; uint id; byte length; ulong data; while (wait_cnt < timeout) { if (MctAdapter_ReceiveMessage(out id, out length, out data)) { // message received canMessage.setID(id); canMessage.setLength(length); canMessage.setData(data); if (canMessage.getID() != a_canID) continue; return (uint)canMessage.getID(); } // wait a bit Thread.Sleep(1); ++wait_cnt; } // nothing was received return 0; }
/// <summary> /// Start a KWP session. /// </summary> /// <remarks> /// A KWP session must be started before any requests can be sent. /// </remarks> /// <returns>True if the session was started, otherwise false.</returns> public bool startSession() { CANMessage msg = new CANMessage(0x220, 0, 7); msg.setData(0x000040021100813F); AddToCanTrace("Sending 0x000040021100813F message"); m_kwpCanListener.setupWaitMessage(0x238); if (!m_canDevice.sendMessage(msg)) { AddToCanTrace("Unable to send 0x000040021100813F message"); return false; } Console.WriteLine("Init msg sent"); if (m_kwpCanListener.waitMessage(timeoutPeriod).getID() == 0x238) { AddToCanTrace("Successfully sent 0x000040021100813F message and received reply 0x238"); return true; } else { AddToCanTrace("Didn't receive 0x238 message as reply on 0x000040021100813F message"); return false; } }
/// <summary> /// Send an acknowledgement message. /// </summary> /// <param name="a_rowNr">The row number that should be acknowledged.</param> private void sendAck(uint a_rowNr) { CANMessage msg = new CANMessage(0x266,0,5); msg.elmExpectedResponses =(a_rowNr==0)?0:1; uint i = 0; ulong data = 0; data = setCanData(data, (byte)0x40, i++); data = setCanData(data, (byte)0xA1, i++); data = setCanData(data, (byte)0x3F, i++); data = setCanData(data, (byte)(0x80 | (int)(a_rowNr)), i++); msg.setData(data); if (!m_canDevice.sendMessage(msg)) throw new Exception("Error sending ack"); }
public void readMessages() { CANMessage canMessage = new CANMessage(); string rxMessage = string.Empty; Console.WriteLine("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { Console.WriteLine("readMessages ended"); return; } } try { if (m_serialPort.IsOpen) { do { rxMessage = m_serialPort.ReadLine(); rxMessage = rxMessage.Replace("\r", ""); // remove prompt characters... we don't need that stuff rxMessage = rxMessage.Replace("\n", ""); // remove prompt characters... we don't need that stuff } while (rxMessage.StartsWith("w") == false); uint id = Convert.ToUInt32(rxMessage.Substring(1, 3), 16); if (acceptMessageId(id)) { canMessage.setID(id); canMessage.setLength(8); canMessage.setData(0x0000000000000000); for (uint i = 0; i < 8; i++) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(5 + (2 * (int)i), 2), 16), i); lock (m_listeners) { AddToCanTrace("RX: " + canMessage.getID().ToString("X3") + " " + canMessage.getLength().ToString("X1") + " " + canMessage.getData().ToString("X16")); //Console.WriteLine("MSG: " + rxMessage); foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } } } catch (Exception) { Console.WriteLine("MSG: " + rxMessage); } } }
/// <summary> /// Start a KWP session. /// </summary> /// <remarks> /// A KWP session must be started before any requests can be sent. /// </remarks> /// <returns>True if the session was started, otherwise false.</returns> public override bool startSession() { CANMessage msg = new CANMessage(0x220, 0, 7); msg.setData(0x000040021100813F); logger.Debug("Sending 0x000040021100813F message"); m_kwpCanListener.setupWaitMessage(0x238); if (!m_canDevice.sendMessage(msg)) { logger.Debug("Unable to send 0x000040021100813F message"); return false; } logger.Debug("Init msg sent"); if (m_kwpCanListener.waitMessage(getTimeout()).getID() == 0x238) { logger.Debug("Successfully sent 0x000040021100813F message and received reply 0x238"); return true; } else { logger.Debug("Didn't receive 0x238 message as reply on 0x000040021100813F message"); return false; } }
/// <summary> /// Send a KWP request. /// </summary> /// <param name="a_request">A KWP request.</param> /// <param name="r_reply">A KWP reply.</param> /// <returns>The status of the request.</returns> public override RequestResult sendRequest(KWPRequest a_request, out KWPReply r_reply) { uint row; uint all_rows = row = nrOfRowsToSend(a_request.getData()); m_kwpCanListener.setupWaitMessage(0x258); // Send one or several request messages. for (; row > 0; row--) { CANMessage msg = new CANMessage(0x240, 0, 8); msg.elmExpectedResponses = a_request.ElmExpectedResponses; msg.setData(createCanMessage(a_request.getData(), row - 1)); if ((msg.getData() & 0xFFFFUL) == 0xA141UL) msg.elmExpectedResponses = 0; if (all_rows == 22) { msg.elmExpectedResponses = row == 1 ? 1 : 0; // on last message (expect 1 reply) } if (!m_canDevice.sendMessage(msg)) { r_reply = new KWPReply(); return RequestResult.ErrorSending; } } var response = m_kwpCanListener.waitMessage(getTimeout()); // Receive one or several replys and send an ack for each reply. if (response.getID() == 0x258) { uint nrOfRows = (uint)(response.getCanData(0) & 0x3F) + 1; row = 0; if (nrOfRows == 0) throw new Exception("Wrong nr of rows"); //Assume that no KWP reply contains more than 0x200 bytes byte[] reply = new byte[0x200]; reply = collectReply(reply, response.getData(), row); sendAck(nrOfRows - 1); nrOfRows--; m_kwpCanListener.setupWaitMessage(0x258); while (nrOfRows > 0) { response = m_kwpCanListener.waitMessage(getTimeout()); if (response.getID() == 0x258) { row++; reply = collectReply(reply, response.getData(), row); sendAck(nrOfRows - 1); nrOfRows--; } else { logger.Debug("1response.getID == " + response.getID()); r_reply = new KWPReply(); return RequestResult.Timeout; } } r_reply = new KWPReply(reply, a_request.getNrOfPID()); return RequestResult.NoError; } else { logger.Debug("2response.getID == " + response.getID()); r_reply = new KWPReply(); return RequestResult.Timeout; } }
public void readMessages() { CANMessage canMessage = new CANMessage(); Console.WriteLine("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { Console.WriteLine("readMessages ended"); return; } } if (rawString != null) { logger.Trace(String.Format("Raw Data: {0}", rawString)); //AddToSerialTrace("RAW RX: " + rawString.Replace("\r",m_cr_sequence)); string rxString = rawString.Replace("\r", m_cr_sequence); //replace , because stringbuilder cannot handle \r bool isStopped = false; if (rxString.Length > 0) { //AddToSerialTrace("RECEIVE TEXT: " + rxString); //System.Diagnostics.Debug.WriteLine("SERMSG: " + rxString); var lines = ExtractLines(rxString); foreach (var rxMessage in lines) { if (rxMessage.StartsWith("STOPPED")) { isStopped = true; } else if (rxMessage.StartsWith("NO (MORE?) DATA")) { } //skip it else if (rxMessage.StartsWith("CAN ERROR")) { } //handle error? else if (rxMessage.StartsWith("ELM")) { isStopped = false; } //skip it, this is a trick to stop ELM from listening to more messages and send ready char else if (rxMessage.StartsWith("?")) { isStopped = false; } else if (rxMessage.Length == 19) // is it a valid line { try { rxMessage.Replace(" ", "");//remove all whitespaces uint id = Convert.ToUInt32(rxMessage.Substring(0, 3), 16); if (acceptMessageId(id)) { canMessage.setID(id); canMessage.setLength(8); // TODO: alter to match data //canMessage.setData(0x0000000000000000); // reset message content canMessage.setData(ExtractDataFromString(rxMessage)); receivedMessage(canMessage); } } catch (Exception) { //Console.WriteLine("MSG: " + rxMessage); } } //disable whitespace logging if (rxMessage.Length > 0) { logger.Debug("TELNET: " + rxMessage); } } } if (!isStopped) { logger.Debug("TELNET READY"); interfaceBusy = false; } rawString = null; } } }
private bool StartBootloader011() { CANMessage msg = new CANMessage(0x11, 0, 7); ulong cmd = 0x0060241000803606; msg.setData(cmd); m_canListener.setupWaitMessage(0x311); if (!canUsbDevice.sendMessage(msg)) { CastInfoEvent("Couldn't send message", ActivityType.ConvertingFile); return false; } CANMessage response = new CANMessage(); response = new CANMessage(); response = m_canListener.waitMessage(timeoutP2ct); ulong data = response.getData(); if (getCanData(data, 0) != 0x01 || getCanData(data, 1) != 0x76) { return false; } return true; }
/// <summary> /// waitAnyMessage waits for any message to be received. /// </summary> /// <param name="timeout">Listen timeout</param> /// <param name="r_canMsg">The CAN message that was first received</param> /// <returns>The CAN id for the message received, otherwise 0.</returns> private uint waitAnyMessage(uint timeout, out CANMessage canMessage) { canMessage = new CANMessage(); Debug.Assert(canMessage != null); int wait_cnt = 0; uint id; byte length; ulong data; while (wait_cnt < timeout) { if (MctAdapter_ReceiveMessage(out id, out length, out data)) { // message received canMessage.setID(id); canMessage.setLength(length); canMessage.setData(data); return id; } // wait a bit Thread.Sleep(1); ++wait_cnt; } // nothing was received return 0; }
public void readMessages() { CANMessage canMessage = new CANMessage(); StringBuilder receiveText = new StringBuilder(); Console.WriteLine("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { Console.WriteLine("readMessages ended"); return; } } receiveDataSemaphore.WaitOne(); if (m_serialPort != null) { if (m_serialPort.IsOpen) { if (m_serialPort.BytesToRead > 0) { string rawString = m_serialPort.ReadExisting(); //AddToSerialTrace("RAW RX: " + rawString.Replace("\r",m_cr_sequence)); string rxString = rawString.Replace("\n", "").Replace(">", "");// remove prompt characters... we don't need that stuff bool isStopped = false; if (rxString.Length > 0) { rxString = rxString.Replace("\r", m_cr_sequence); //replace , because stringbuilder cannot handle \r receiveText.Append(rxString); //AddToSerialTrace("RECEIVE TEXT: " + receiveText.ToString()); //System.Diagnostics.Debug.WriteLine("SERMSG: " + receiveText); var lines = ExtractLines(ref receiveText); foreach (var rxMessage in lines) { if (rxMessage.StartsWith("STOPPED")) { isStopped = true; } else if (rxMessage.StartsWith("NO DATA")) { } //skip it else if (rxMessage.StartsWith("CAN ERROR")) { //handle error? } else if (rxMessage.StartsWith("ELM")) { isStopped = false; } //skip it, this is a trick to stop ELM from listening to more messages and send ready char else if (rxMessage.StartsWith("?")) { isStopped = false; } else if (rxMessage.StartsWith("NO DATA")) { AddToSerialTrace("NO DATA"); Console.WriteLine("NO DATA"); } else if (rxMessage.Length == 19) // is it a valid line { try { rxMessage.Replace(" ", "");//remove all whitespaces uint id = Convert.ToUInt32(rxMessage.Substring(0, 3), 16); if (acceptMessageId(id)) { canMessage.setID(id); canMessage.setLength(8); // TODO: alter to match data //canMessage.setData(0x0000000000000000); // reset message content canMessage.setData(ExtractDataFromString(rxMessage)); lock (m_listeners) { AddToCanTrace(string.Format("RX: {0} {1}", canMessage.getID().ToString("X3"), canMessage.getData().ToString("X16"))); foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } } catch (Exception) { //Console.WriteLine("MSG: " + rxMessage); } } //disable whitespace logging if (rxMessage.Length > 0) { AddToSerialTrace("SERRX: " + rxMessage); } } } if (rawString.Contains(">") && !isStopped) { AddToSerialTrace("SERIAL READY"); sendDataSempahore.WaitOne(0); sendDataSempahore.Release(); interfaceBusy = false; } } } } } }
/// <summary> /// Send a KWP request. /// </summary> /// <param name="a_request">A KWP request.</param> /// <param name="r_reply">A KWP reply.</param> /// <returns>The status of the request.</returns> public RequestResult sendRequest(KWPRequest a_request, out KWPReply r_reply) { CANMessage msg = new CANMessage(0x240, 0, 8); uint row = nrOfRowsToSend(a_request.getData()); m_kwpCanListener.setupWaitMessage(0x258); // Send one or several request messages. for (; row > 0; row--) { msg.setData(createCanMessage(a_request.getData(), row - 1)); if (!m_canDevice.sendMessage(msg)) { r_reply = new KWPReply(); return RequestResult.ErrorSending; } } msg = m_kwpCanListener.waitMessage(timeoutPeriod); // msg = m_kwpCanListener.waitForMessage(0x258, timeoutPeriod); // Receive one or several replys and send an ack for each reply. if (msg.getID() == 0x258) { uint nrOfRows = (uint)(msg.getCanData(0) & 0x3F)+ 1; row = 0; if (nrOfRows == 0) throw new Exception("Wrong nr of rows"); //Assume that no KWP reply contains more than 0x200 bytes byte[] reply = new byte[0x200]; reply = collectReply(reply, msg.getData(), row); sendAck(nrOfRows - 1); nrOfRows--; m_kwpCanListener.setupWaitMessage(0x258); while (nrOfRows > 0) { // msg = m_kwpCanListener.waitForMessage(0x258, timeoutPeriod); msg = m_kwpCanListener.waitMessage(timeoutPeriod); if (msg.getID() == 0x258) { row++; reply = collectReply(reply, msg.getData(), row); sendAck(nrOfRows - 1); nrOfRows--; } else { r_reply = new KWPReply(); return RequestResult.Timeout; } } r_reply = new KWPReply(reply, a_request.getNrOfPID()); return RequestResult.NoError; } else { r_reply = new KWPReply(); return RequestResult.Timeout; } }
//------------------------------------------------------------------------- /** Handles incoming messages. */ private void read_messages() { uint id; byte length; ulong data; CANMessage msg = new CANMessage(); Debug.Assert(msg != null); // main loop while (true) { // check for thread termination request Debug.Assert(this.term_mutex != null); lock (this.term_mutex) { if (this.term_requested) { return; } } // receive messages while (MctAdapter_ReceiveMessage(out id, out length, out data)) { if (acceptMessageId(id)) { // convert message msg.setID(id); msg.setLength(length); msg.setData(data); // pass message to listeners lock (this.m_listeners) { AddToCanTrace("RX: " + id.ToString("X4") + " " + data.ToString("X16")); foreach (ICANListener listener in this.m_listeners) { listener.handleMessage(msg); } } } } // give up CPU for a moment Thread.Sleep(1); } }
private bool UploadBootloaderWrite() { int startAddress = 0x102400; #if (DEBUG) BootloaderFromFile btloaderdata = new BootloaderFromFile(); #else Bootloader btloaderdata = new Bootloader(); #endif int txpnt = 0; byte iFrameNumber = 0x21; int saved_progress = 0; if (requestDownload()) { for (int i = 0; i < 0x46; i++) { iFrameNumber = 0x21; //10 F0 36 00 00 10 24 00 //Console.WriteLine("Sending bootloader: " + startAddress.ToString("X8")); // cast event int percentage = (int)(((float)i * 100) / 70F); if (percentage > saved_progress) { CastProgressWriteEvent(percentage); saved_progress = percentage; } if (SendTransferData(0xF0, startAddress, 0x7E8)) { canUsbDevice.RequestDeviceReady(); // send 0x22 (34) frames with data from bootloader CANMessage msg = new CANMessage(0x7E0, 0, 8); for (int j = 0; j < 0x22; j++) { var cmd = BitTools.GetFrameBytes(iFrameNumber, btloaderdata.BootloaderProgBytes, txpnt); msg.setData(cmd); txpnt += 7; iFrameNumber++; if (iFrameNumber > 0x2F) iFrameNumber = 0x20; msg.elmExpectedResponses = j == 0x21 ? 1 : 0;//on last command (iFrameNumber 22 expect 1 message) if (j == 0x21) m_canListener.ClearQueue(); if (!canUsbDevice.sendMessage(msg)) { logger.Debug("Couldn't send message"); } Thread.Sleep(m_sleepTime); } // now wait for 01 76 00 00 00 00 00 00 ulong data = m_canListener.waitMessage(timeoutP2ct, 0x7E8).getData(); if (getCanData(data, 0) != 0x01 || getCanData(data, 1) != 0x76) { return false; } canUsbDevice.RequestDeviceReady(); SendKeepAlive(); startAddress += 0xEA; } else { Console.WriteLine("Did not receive correct response from SendTransferData"); } } iFrameNumber = 0x21; if (SendTransferData(0x0A, startAddress, 0x7E8)) { // send 0x22 (34) frames with data from bootloader CANMessage msg = new CANMessage(0x7E0, 0, 8); var cmd = BitTools.GetFrameBytes(iFrameNumber, btloaderdata.BootloaderBytes, txpnt); msg.setData(cmd); txpnt += 7; iFrameNumber++; if (iFrameNumber > 0x2F) iFrameNumber = 0x20; if (!canUsbDevice.sendMessage(msg)) { logger.Debug("Couldn't send message"); } if (m_sleepTime > 0) Thread.Sleep(m_sleepTime); ulong data = m_canListener.waitMessage(timeoutP2ct, 0x7E8).getData(); if (getCanData(data, 0) != 0x01 || getCanData(data, 1) != 0x76) { return false; } SendKeepAlive(); startAddress += 0x06; } else { Console.WriteLine("Did not receive correct response from SendTransferData"); } CastProgressWriteEvent(100); } else { Console.WriteLine("requestDownload() failed"); return false; } return true; }
private bool SendTransferDataME96(int length, int address, uint waitforResponseID, byte firstByteToSend ) { CANMessage msg = new CANMessage(0x7E0, 0, 8); // <GS-24052011> test for ELM327, set length to 16 (0x10) ulong cmd = 0x0000000000360010; // 0x36 = transferData ulong addressHigh = (uint)address & 0x0000000000FF0000; addressHigh /= 0x10000; ulong addressMiddle = (uint)address & 0x000000000000FF00; addressMiddle /= 0x100; ulong addressLow = (uint)address & 0x00000000000000FF; ulong len = (ulong)length + 5; // The extra 5 comes from the Service ID plus the sub-function parameter byte plus the 3 byte startingAddress. ulong payload = (ulong)firstByteToSend; cmd |= (payload * 0x100000000000000); cmd |= (addressLow * 0x1000000000000); cmd |= (addressMiddle * 0x10000000000); cmd |= (addressHigh * 0x100000000); cmd |= (len * 0x100); Console.WriteLine("send: " + cmd.ToString("X16")); msg.setData(cmd); msg.elmExpectedResponses = 1; m_canListener.setupWaitMessage(waitforResponseID); if (!canUsbDevice.sendMessage(msg)) { logger.Debug("Couldn't send message"); } CANMessage response = new CANMessage(); response = new CANMessage(); response = m_canListener.waitMessage(timeoutP2ct); ulong data = response.getData(); Console.WriteLine("Received in SendTransferData: " + data.ToString("X16")); if (getCanData(data, 0) != 0x30 || getCanData(data, 1) != 0x00) { return false; } return true; }
/// <summary> /// readMessages is the "run" method of this class. It reads all incomming messages /// and publishes them to registered ICANListeners. /// </summary> public void readMessages() { int readResult = 0; EASYSYNC.CANMsg r_canMsg = new EASYSYNC.CANMsg(); CANMessage canMessage = new CANMessage(); while (true) { lock (m_synchObject) { if (m_endThread) return; } readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == EASYSYNC.ERROR_CANUSB_OK) { canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setTimeStamp(r_canMsg.timestamp); canMessage.setFlags(r_canMsg.flags); canMessage.setData(r_canMsg.data); lock (m_listeners) { foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); } } }
// int thrdcnt = 0; /// <summary> /// readMessages is the "run" method of this class. It reads all incomming messages /// and publishes them to registered ICANListeners. /// </summary> public void readMessages() { while (true) { lock (m_synchObject) { if (m_endThread) { m_endThread = false; return; } } if (m_serialPort.IsOpen) { // read the status? string line = string.Empty; try { line = m_serialPort.ReadLine(); if (line.Length > 0) { if (line.Length == 25) { Lawicel.CANUSB.CANMsg r_canMsg = new Lawicel.CANUSB.CANMsg(); canMessage = new CANMessage(); // three bytes identifier r_canMsg.id = (uint)Convert.ToInt32(line.Substring(1, 3), 16); r_canMsg.len = (byte)Convert.ToInt32(line.Substring(4, 1), 16); ulong data = 0; // add all the bytes data |= (ulong)(byte)Convert.ToInt32(line.Substring(5, 2), 16); data |= (ulong)(byte)Convert.ToInt32(line.Substring(7, 2), 16) << 1 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(9, 2), 16) << 2 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(11, 2), 16) << 3 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(13, 2), 16) << 4 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(15, 2), 16) << 5 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(17, 2), 16) << 6 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(19, 2), 16) << 7 * 8; r_canMsg.data = data; canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setFlags(r_canMsg.flags); canMessage.setData(r_canMsg.data); lock (m_listeners) { AddToCanTrace(string.Format("RX: {0} {1} {2}", canMessage.getID().ToString("X3"), line.Substring(5, 16), line)); foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if(line.Contains("z")) { interfaceBusy = false; //Console.WriteLine("clear"); } else if (line.Length == 2 && Convert.ToInt32(line.Substring(1, 2), 16) != 0x07) { //Console.WriteLine("Send error"); } else { //Console.WriteLine("Unknown message: " + line); } } } catch (Exception E) { Console.WriteLine("Failed to read frames from CANbus: " + E.Message); } } //Thread.Sleep(2); Thread.Sleep(delayTimespan); // give others some air } }
/// <summary> /// waitForMessage waits for a specific CAN message give by a CAN id. /// </summary> /// <param name="a_canID">The CAN id to listen for</param> /// <param name="timeout">Listen timeout</param> /// <param name="r_canMsg">The CAN message with a_canID that we where listening for.</param> /// <returns>The CAN id for the message we where listening for, otherwise 0.</returns> public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { EASYSYNC.CANMsg r_canMsg; canMsg = new CANMessage(); int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { r_canMsg = new EASYSYNC.CANMsg(); readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == EASYSYNC.ERROR_CANUSB_OK) { if (r_canMsg.id == 0x00) { nrOfWait++; } else if (r_canMsg.id != a_canID) continue; canMsg.setData(r_canMsg.data); canMsg.setID(r_canMsg.id); canMsg.setLength(r_canMsg.len); return (uint)r_canMsg.id; } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); nrOfWait++; } } r_canMsg = new EASYSYNC.CANMsg(); return 0; }
private bool SendTransferData011(int length, int address, uint waitforResponseID) { CANMessage msg = new CANMessage(0x11, 0, 8); // <GS-24052011> test for ELM327, set length to 16 (0x10) ulong cmd = 0x0000000000360010; // 0x36 = transferData ulong addressHigh = (uint)address & 0x0000000000FF0000; addressHigh /= 0x10000; ulong addressMiddle = (uint)address & 0x000000000000FF00; addressMiddle /= 0x100; ulong addressLow = (uint)address & 0x00000000000000FF; ulong len = (ulong)length; cmd |= (addressLow * 0x100000000000000); cmd |= (addressMiddle * 0x1000000000000); cmd |= (addressHigh * 0x10000000000); cmd |= (len * 0x100); //Console.WriteLine("send: " + cmd.ToString("X16")); msg.elmExpectedResponses = 1; msg.setData(cmd); m_canListener.setupWaitMessage(waitforResponseID); if (!canUsbDevice.sendMessage(msg)) { logger.Debug("Couldn't send message"); } CANMessage response = new CANMessage(); response = new CANMessage(); response = m_canListener.waitMessage(timeoutP2ct); ulong data = response.getData(); //Console.WriteLine("Received in SendTransferData: " + data.ToString("X16")); if (getCanData(data, 0) != 0x30 || getCanData(data, 1) != 0x00) { return false; } return true; }
// int thrdcnt = 0; /// <summary> /// readMessages is the "run" method of this class. It reads all incomming messages /// and publishes them to registered ICANListeners. /// </summary> public void readMessages() { while (true) { lock (m_synchObject) { if (m_endThread) { m_endThread = false; return; } } if (m_serialPort.IsOpen) { // read the status? string line = string.Empty; try { line = m_serialPort.ReadLine(); if (line.Length > 0) { if (line.Length == 25) { Lawicel.CANUSB.CANMsg r_canMsg = new Lawicel.CANUSB.CANMsg(); canMessage = new CANMessage(); // three bytes identifier r_canMsg.id = (uint)Convert.ToInt32(line.Substring(1, 3), 16); r_canMsg.len = (byte)Convert.ToInt32(line.Substring(4, 1), 16); ulong data = 0; // add all the bytes data |= (ulong)(byte)Convert.ToInt32(line.Substring(5, 2), 16); data |= (ulong)(byte)Convert.ToInt32(line.Substring(7, 2), 16) << 1 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(9, 2), 16) << 2 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(11, 2), 16) << 3 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(13, 2), 16) << 4 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(15, 2), 16) << 5 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(17, 2), 16) << 6 * 8; data |= (ulong)(byte)Convert.ToInt32(line.Substring(19, 2), 16) << 7 * 8; r_canMsg.data = data; canMessage.setID(r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setFlags(r_canMsg.flags); canMessage.setData(r_canMsg.data); lock (m_listeners) { AddToCanTrace(string.Format("RX: {0} {1} {2}", canMessage.getID().ToString("X3"), line.Substring(5, 16), line)); foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if (line.Contains("z")) { interfaceBusy = false; //Console.WriteLine("clear"); } else if (line.Length == 2 && Convert.ToInt32(line.Substring(1, 2), 16) != 0x07) { //Console.WriteLine("Send error"); } else { //Console.WriteLine("Unknown message: " + line); } } } catch (Exception E) { Console.WriteLine("Failed to read frames from CANbus: " + E.Message); } } //Thread.Sleep(2); Thread.Sleep(delayTimespan); // give others some air } }
public void readMessages() { CANMessage canMessage = new CANMessage(); StringBuilder receiveText = new StringBuilder(); logger.Debug("readMessages started"); while (true) { receiveDataSemaphore.WaitOne(); lock (m_synchObject) { if (m_endThread) { logger.Debug("readMessages ended"); return; } } if (m_serialPort != null) { if (m_serialPort.IsOpen && m_serialPort.BytesToRead > 0) { string rawString = string.Empty; try { rawString = m_serialPort.ReadExisting(); } catch (Exception e) { logger.Debug("CANELM372Device ReadExisting()" + e.Message); } //AddToSerialTrace("RAW RX: " + rawString.Replace("\r",m_cr_sequence)); string rxString = rawString.Replace("\n", "").Replace(">", "");// remove prompt characters... we don't need that stuff bool isStopped = false; if (rxString.Length > 0) { rxString = rxString.Replace("\r", m_cr_sequence); //replace , because stringbuilder cannot handle \r receiveText.Append(rxString); //AddToSerialTrace("RECEIVE TEXT: " + receiveText.ToString()); //System.Diagnostics.Debug.WriteLine("SERMSG: " + receiveText); var lines = ExtractLines(ref receiveText); foreach (var rxMessage in lines) { if (rxMessage.StartsWith("STOPPED")) { isStopped = true; } else if (rxMessage.StartsWith("NO DATA")) { } //skip it else if (rxMessage.StartsWith("CAN ERROR")) { //handle error? } else if (rxMessage.StartsWith("ELM")) { isStopped = false; } //skip it, this is a trick to stop ELM from listening to more messages and send ready char else if (rxMessage.StartsWith("?")) { isStopped = false; } else if (rxMessage.StartsWith("NO DATA")) { logger.Debug("NO DATA"); } else if (rxMessage.Length == 19) // is it a valid line { try { rxMessage.Replace(" ", "");//remove all whitespaces uint id = Convert.ToUInt32(rxMessage.Substring(0, 3), 16); if (acceptMessageId(id)) { canMessage.setID(id); canMessage.setLength(8); // TODO: alter to match data //canMessage.setData(0x0000000000000000); // reset message content canMessage.setData(ExtractDataFromString(rxMessage)); receivedMessage(canMessage); } } catch (Exception e) { logger.Debug(e, rxMessage); } } // Catch weird message-lengths from Z22SE else if (rxMessage.StartsWith("7E8") && rxMessage.Length > 6) { try { rxMessage.Replace(" ", "");//remove all whitespaces uint id = Convert.ToUInt32(rxMessage.Substring(0, 3), 16); byte len = (byte)(rxMessage.Length - 3); len = (byte)(((len & 1) == 1 ? len + 1 : len) / 2); if (acceptMessageId(id) && len <= 8) { canMessage.setID(id); canMessage.setLength(len); canMessage.setData(ExtractDataFromString2(len, rxMessage)); receivedMessage(canMessage); } } catch (Exception e) { logger.Debug(e, rxMessage); } } //disable whitespace logging if (rxMessage.Length > 0) { logger.Debug("SERRX: " + rxMessage + " Len:" + rxMessage.Length); } } } if (rawString.Contains(">") && !isStopped) { logger.Debug("SERIAL READY"); sendDataSempahore.WaitOne(0); sendDataSempahore.Release(); interfaceBusy = false; } } } } }
/// <summary> /// waitForMessage waits for a specific CAN message give by a CAN id. /// </summary> /// <param name="a_canID">The CAN id to listen for</param> /// <param name="timeout">Listen timeout</param> /// <param name="r_canMsg">The CAN message with a_canID that we where listening for.</param> /// <returns>The CAN id for the message we where listening for, otherwise 0.</returns> public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { Lawicel.CANUSB.CANMsg r_canMsg; canMsg = new CANMessage(); int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { r_canMsg = new Lawicel.CANUSB.CANMsg(); readResult = Lawicel.CANUSB.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { Thread.Sleep(1); AddToCanTrace("rx: 0x" + r_canMsg.id.ToString("X4") + r_canMsg.data.ToString("X16")); if (r_canMsg.id == 0x00) { nrOfWait++; } else if (r_canMsg.id != a_canID) continue; canMsg.setData(r_canMsg.data); canMsg.setID(r_canMsg.id); canMsg.setLength(r_canMsg.len); return (uint)r_canMsg.id; } else if (readResult == Lawicel.CANUSB.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); nrOfWait++; } } r_canMsg = new Lawicel.CANUSB.CANMsg(); return 0; }
private bool StartSession20() { CANMessage msg = new CANMessage(0x7E0, 0, 2); ulong cmd = 0x0000000000002001; // 0x02 0x10 0x02 msg.setData(cmd); m_canListener.setupWaitMessage(0x7E8); if (!canUsbDevice.sendMessage(msg)) { CastInfoEvent("Couldn't send message", ActivityType.ConvertingFile); return false; } CANMessage response = new CANMessage(); response = new CANMessage(); response = m_canListener.waitMessage(timeoutP2ct); ulong data = response.getData(); if (getCanData(data, 0) != 0x01 || getCanData(data, 1) != 0x60) { return false; } return true; }
/// <summary> /// Send a message that starts a session. This is used to test if there is /// a connection. /// </summary> /// <returns></returns> private bool sendSessionRequest() { CANMessage msg1 = new CANMessage(0x220, 0, 8); EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); msg1.setData(0x000040021100813f); if (!sendMessage(msg1)) return false; if (waitForMessage(0x238, 1000, out msg) == 0x238) { //Ok, there seems to be a ECU somewhere out there. //Now, sleep for 10 seconds to get a session timeout. This is needed for //applications on higher level. Otherwise there will be no reply when the //higher level application tries to start a session. Thread.Sleep(10000); return true; } return false; }
private bool WriteFlashRecover(BlockManager bm) { int startAddress = 0x020000; int saved_progress = 0; for (int blockNumber = 0; blockNumber <= 0xF50; blockNumber++) { int percentage = (int)(((float)blockNumber * 100) / 3920F); if (percentage > saved_progress) { CastProgressWriteEvent(percentage); saved_progress = percentage; } byte[] data2Send = bm.GetNextBlock(); int length = 0xF0; if (blockNumber == 0xF50) length = 0xE6; if (SendTransferData(length, startAddress + (blockNumber * 0xEA), 0x311)) { //canUsbDevice.RequestDeviceReady(); // send the data from the block // calculate number of frames int numberOfFrames = (int)data2Send.Length / 7; // remnants? if (((int)data2Send.Length % 7) > 0) numberOfFrames++; byte iFrameNumber = 0x21; int txpnt = 0; CANMessage msg = new CANMessage(0x7E0, 0, 8); for (int frame = 0; frame < numberOfFrames; frame++) { var cmd = BitTools.GetFrameBytes(iFrameNumber, data2Send, txpnt); msg.setData(cmd); txpnt += 7; iFrameNumber++; if (iFrameNumber > 0x2F) iFrameNumber = 0x20; msg.elmExpectedResponses = frame == numberOfFrames - 1 ? 1 : 0; if (frame == numberOfFrames - 1) m_canListener.ClearQueue(); if (!canUsbDevice.sendMessage(msg)) { logger.Debug("Couldn't send message"); } if (m_sleepTime > 0) Thread.Sleep(m_sleepTime); } // now wait for 01 76 00 00 00 00 00 00 ulong data = m_canListener.waitMessage(timeoutP2ct, 0x7E8).getData(); if (getCanData(data, 0) != 0x01 || getCanData(data, 1) != 0x76) { _stallKeepAlive = false; return false; } //canUsbDevice.RequestDeviceReady(); BroadcastKeepAlive(); } } return true; }
private bool SendSecretCodetoCIM() { //0044585349603B06 CANMessage msg = new CANMessage(0x245, 0, 8); ulong cmd = 0x0044585349603B06; msg.setData(cmd); m_canListener.setupWaitMessage(0x645); if (!canUsbDevice.sendMessage(msg)) { CastInfoEvent("Couldn't send message", ActivityType.ConvertingFile); return false; } CANMessage ECMresponse = new CANMessage(); ECMresponse = m_canListener.waitMessage(timeoutP2ct); ulong rxdata = ECMresponse.getData(); if (getCanData(rxdata, 1) == 0x7B && getCanData(rxdata, 2) == 0x60) { return true; } return false; }