public override void handleMessage(CANMessage a_message) { if (_queue == null) { _queue = new CANMessage[32]; _receiveMessageIndex = 0; _readMessageIndex = 0; } // add the message to a queue for later processing ... // the queue is a ringbuffer for CANMessage objects. // X objects are supported // we need a receive and a read pointer for this to work properly messageReceived = false; //_queue[_receiveMessageIndex] = a_message; _queue[_receiveMessageIndex] = new CANMessage(); _queue[_receiveMessageIndex].setData(a_message.getData()); _queue[_receiveMessageIndex].setID(a_message.getID()); _queue[_receiveMessageIndex].setLength(a_message.getLength()); _receiveMessageIndex++; if(_receiveMessageIndex > _queue.Length - 1) _receiveMessageIndex = 0; // make it circular DetermineSize(); }
public override void handleMessage(CANMessage a_message) { lock (m_canMessage) { if (a_message.getID() == m_waitMsgID) { m_canMessage.setData(a_message.getData()); m_canMessage.setFlags(a_message.getFlags()); m_canMessage.setID(a_message.getID()); m_canMessage.setLength(a_message.getLength()); m_canMessage.setTimeStamp(a_message.getTimeStamp()); messageReceived = true; m_resetEvent.Set(); } } }
/// <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); } } }
override public void handleMessage(CANMessage a_message) { if (_queue == null) { _queue = new CANMessage[16]; _receiveMessageIndex = 0; _readMessageIndex = 0; } // add the message to a queue for later processing ... // the queue is a ringbuffer for CANMessage objects. // X objects are supported // we need a receive and a read pointer for this to work properly messageReceived = false; //_queue[_receiveMessageIndex] = a_message; _queue[_receiveMessageIndex] = new CANMessage(); _queue[_receiveMessageIndex].setData(a_message.getData()); _queue[_receiveMessageIndex].setID(a_message.getID()); _queue[_receiveMessageIndex].setLength(a_message.getLength()); _receiveMessageIndex++; if (_receiveMessageIndex > _queue.Length - 1) { _receiveMessageIndex = 0; // make it circular } //DetermineSize(); /* * lock (m_canMessage) * { * if (a_message.getID() == m_waitMsgID) * { * m_canMessage = a_message; * messageReceived = true; * } * } * if (messageReceived) * { * m_resetEvent.Set(); * }*/ }
/// <summary> /// sendMessage send a CANMessage. /// </summary> /// <param name="a_message">A CANMessage.</param> /// <returns>true on success, othewise false.</returns> override public bool sendMessage(CANMessage a_message) { lock (lockObj) { while (interfaceBusy) { if (lastSentTimestamp < Environment.TickCount - timeoutWithoutReadyChar) { //Console.WriteLine("released"); break; } } lastSentTimestamp = Environment.TickCount; interfaceBusy = true; //Console.WriteLine("set"); Lawicel.CANUSB.CANMsg msg = new Lawicel.CANUSB.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); if (m_serialPort.IsOpen) { //m_serialPort.Write("\r"); string txstring = "t"; txstring += msg.id.ToString("X3"); txstring += "8"; // always 8 bytes to transmit for (int t = 0; t < 8; t++) { byte b = (byte)(((msg.data >> t * 8) & 0x0000000000000000FF)); txstring += b.ToString("X2"); } txstring += "\r"; AddToCanTrace(string.Format("TX: {0} {1} {2}", a_message.getID().ToString("X3"), a_message.getData().ToString("X16"), txstring)); m_serialPort.Write(txstring); return(true); } } return(false); }
//--------------------------------------------------------------------------------------------- /** * Sends a 11 bit CAN data frame. * * @param msg CAN message * * @return success (true/false) */ protected override bool sendMessageDevice(CANMessage msg) { try { caCombiAdapter.caCANFrame frame; frame.id = msg.getID(); frame.length = msg.getLength(); frame.data = msg.getData(); frame.is_extended = 0; frame.is_remote = 0; combi.CAN_SendMessage(ref frame); return(true); } catch (Exception e) { logger.Debug("tx failed with Exception.Message: " + e.Message); return(false); } }
/// <summary> /// sendMessage send a CANMessage. /// </summary> /// <param name="a_message">A CANMessage.</param> /// <returns>true on success, othewise false.</returns> override protected bool sendMessageDevice(CANMessage a_message) { Lawicel.CANUSB.CANMsg msg = new Lawicel.CANUSB.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); int writeResult; writeResult = Lawicel.CANUSB.canusb_Write(m_deviceHandle, ref msg); if (writeResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { return(true); } else { logger.Debug("tx failed writeResult: " + writeResult); return(false); } }
//--------------------------------------------------------------------------------------------- /** * 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); }
public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { canMsg = new CANMessage(); return(0); //CANMessage canMessage = new CANMessage(); //string rxMessage = string.Empty; //canMsg = new CANMessage(); //int nrOfWait = 0; //while (nrOfWait < timeout) //{ // 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 // if (rxMessage.StartsWith("w") == false) // { // Thread.Sleep(1); // nrOfWait++; // continue; // } // uint id = Convert.ToUInt32(rxMessage.Substring(1, 3), 16); // if (id != a_canID && a_canID != 0) // { // Thread.Sleep(1); // nrOfWait++; // continue; // } // 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); // return (uint)id; //} //return 0; }
public override void handleMessage(CANMessage a_message) { if (_queue == null) { _queue = new CANMessage[16]; _receiveMessageIndex = 0; _readMessageIndex = 0; } // add the message to a queue for later processing ... // the queue is a ringbuffer for CANMessage objects. // X objects are supported // we need a receive and a read pointer for this to work properly messageReceived = false; //_queue[_receiveMessageIndex] = a_message; _queue[_receiveMessageIndex] = new CANMessage(); _queue[_receiveMessageIndex].setData(a_message.getData()); _queue[_receiveMessageIndex].setID(a_message.getID()); _queue[_receiveMessageIndex].setLength(a_message.getLength()); _receiveMessageIndex++; if(_receiveMessageIndex > _queue.Length - 1) _receiveMessageIndex = 0; // make it circular //DetermineSize(); /* lock (m_canMessage) { if (a_message.getID() == m_waitMsgID) { m_canMessage = a_message; messageReceived = true; } } if (messageReceived) { m_resetEvent.Set(); }*/ }
/// <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); } } }
/// <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); }
public CANMessage waitMessage(int a_timeout) { sw.Reset(); sw.Start(); CANMessage retMsg = new CANMessage(); while (sw.ElapsedMilliseconds < a_timeout) { // search queue for the desired message if (_receiveMessageIndex < _readMessageIndex) { // first upto (_queue.Length - 1) for (int idx = _readMessageIndex; idx < _queue.Length; idx++) { if (_queue[idx].getID() == this.m_waitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) _readMessageIndex = 0; // make it circular sw.Stop(); return retMsg; } } for (int idx = 0; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) _readMessageIndex = 0; // make it circular sw.Stop(); return retMsg; } } } else { for (int idx = _readMessageIndex; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) _readMessageIndex = 0; // make it circular sw.Stop(); return retMsg; } } } Thread.Sleep(1); } sw.Stop(); return retMsg; /* CANMessage retMsg; m_resetEvent.WaitOne(a_timeout, true); lock (m_canMessage) { retMsg = m_canMessage; } messageReceived = false; return retMsg;*/ }
/// <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); } } }
/// <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; }
//--------------------------------------------------------------------------------------------- /** 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; }
// 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 } }
//------------------------------------------------------------------------- /** * Sends a 11 bit CAN data frame. * * @param message CAN message * * @return success (true/false) */ public override bool sendMessage(CANMessage message) { return(MctAdapter_SendMessage(message.getID(), message.getLength(), message.getData())); }
public InformationFrameEventArgs(CANMessage message) { this._message = message; }
/// <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; }
//------------------------------------------------------------------------- /** 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); } }
/// <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; }
//------------------------------------------------------------------------- /** Sends a 11 bit CAN data frame. @param message CAN message @return success (true/false) */ public override bool sendMessage(CANMessage message) { return MctAdapter_SendMessage(message.getID(), message.getLength(), message.getData()); }
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; } } } } }
public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { canMsg = new CANMessage(); return(0); }
public CANMessage waitMessage(int a_timeout) { sw.Reset(); sw.Start(); CANMessage retMsg = new CANMessage(); while (sw.ElapsedMilliseconds < a_timeout) { // search queue for the desired message if (_receiveMessageIndex < _readMessageIndex) { // first upto (_queue.Length - 1) for (int idx = _readMessageIndex; idx < _queue.Length; idx++) { if (_queue[idx].getID() == this.m_waitMsgID || _queue[idx].getID() == this.m_additionalWaitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) _readMessageIndex = 0; // make it circular sw.Stop(); return retMsg; } } for (int idx = 0; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID || _queue[idx].getID() == this.m_additionalWaitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) _readMessageIndex = 0; // make it circular sw.Stop(); return retMsg; } } } else { for (int idx = _readMessageIndex; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID || _queue[idx].getID() == this.m_additionalWaitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) _readMessageIndex = 0; // make it circular sw.Stop(); return retMsg; } } } Thread.Sleep(1); } sw.Stop(); return retMsg; }
public CANMessage waitMessage(int a_timeout) { sw.Reset(); sw.Start(); CANMessage retMsg = new CANMessage(); while (sw.ElapsedMilliseconds < a_timeout) { // search queue for the desired message if (_receiveMessageIndex < _readMessageIndex) { // first upto (_queue.Length - 1) for (int idx = _readMessageIndex; idx < _queue.Length; idx++) { if (_queue[idx].getID() == this.m_waitMsgID || _queue[idx].getID() == this.m_additionalWaitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) { _readMessageIndex = 0; // make it circular } sw.Stop(); return(retMsg); } } for (int idx = 0; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID || _queue[idx].getID() == this.m_additionalWaitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) { _readMessageIndex = 0; // make it circular } sw.Stop(); return(retMsg); } } } else { for (int idx = _readMessageIndex; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID || _queue[idx].getID() == this.m_additionalWaitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) { _readMessageIndex = 0; // make it circular } sw.Stop(); return(retMsg); } } } Thread.Sleep(1); } sw.Stop(); return(retMsg); }
/// <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 CANMessage waitMessage(int a_timeout) { sw.Reset(); sw.Start(); CANMessage retMsg = new CANMessage(); while (sw.ElapsedMilliseconds < a_timeout) { // search queue for the desired message if (_receiveMessageIndex < _readMessageIndex) { // first upto (_queue.Length - 1) for (int idx = _readMessageIndex; idx < _queue.Length; idx++) { if (_queue[idx].getID() == this.m_waitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) { _readMessageIndex = 0; // make it circular } sw.Stop(); return(retMsg); } } for (int idx = 0; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) { _readMessageIndex = 0; // make it circular } sw.Stop(); return(retMsg); } } } else { for (int idx = _readMessageIndex; idx < _receiveMessageIndex; idx++) { if (_queue[idx].getID() == this.m_waitMsgID) { retMsg = _queue[idx]; _readMessageIndex = idx + 1; if (_readMessageIndex > _queue.Length - 1) { _readMessageIndex = 0; // make it circular } sw.Stop(); return(retMsg); } } } Thread.Sleep(1); } sw.Stop(); return(retMsg); /* * CANMessage retMsg; * * m_resetEvent.WaitOne(a_timeout, true); * lock (m_canMessage) * { * retMsg = m_canMessage; * } * messageReceived = false; * return retMsg;*/ }
/// <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; }
abstract public uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg);
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; } } }
//--------------------------------------------------------------------------------------------- /** Sends a 11 bit CAN data frame. @param msg CAN message @return success (true/false) */ public override bool sendMessage(CANMessage msg) { this.AddToCanTrace("Sending message: " + msg.getID().ToString("X4") + " " + msg.getData().ToString("X16") + " " + msg.getLength().ToString("X2")); try { Combi.caCombiAdapter.caCANFrame frame; frame.id = msg.getID(); frame.length = msg.getLength(); frame.data = msg.getData(); frame.is_extended = 0; frame.is_remote = 0; this.combi.CAN_SendMessage(ref frame); this.AddToCanTrace("Message sent successfully"); return true; } catch (Exception e) { this.AddToCanTrace("Message failed to send: " + e.Message); return false; } }
protected override bool sendMessageDevice(CANMessage a_message) { lock (lockObj) { interfaceBusy = true; if (a_message.getID() != _ECUAddress) { _ECUAddress = a_message.getID(); string command = String.Format("ATSH{0:X3}\r", a_message.getID()); SendControlMessage(command, false); } lastSentCanMessage = a_message.Clone(); string sendString = GetELMRequest(a_message); //add expected responses, but this has to be one char only :( if (a_message.elmExpectedResponses != -1 && a_message.elmExpectedResponses < 16) sendString += " " + a_message.elmExpectedResponses.ToString("X1"); sendString += "\r"; lastSentTimestamp = Environment.TickCount; rawString = WriteToTelnetAndWait(sendString); return true; // remove after implementation } }
//--------------------------------------------------------------------------------------------- /** Tries to connect to CAN bus using the specified bitrate. @param bitrate bitrate @param check_traffic check for CAN traffic @return succ / fail */ private bool try_bitrate(uint bitrate, bool check_traffic) { try { // try connecting this.combi.CAN_SetBitrate(bitrate); this.combi.CAN_Open(true); if (check_traffic) { // look for bus activity CANMessage msg = new CANMessage(); Debug.Assert(msg != null); if (this.waitForMessage(0, 1000, out msg) < 1) { throw new Exception("No traffic at given bitrate"); } } return true; } catch { // failed this.combi.CAN_Open(false); 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; 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); } } }
public InformationFrameEventArgs(CANMessage message) { this._message = message; }
/// <summary> /// sendMessage send a CANMessage. /// </summary> /// <param name="a_message">A CANMessage.</param> /// <returns>true on success, othewise false.</returns> public override bool sendMessage(CANMessage a_message) { lock (lockObj) { while (interfaceBusy) { if (lastSentTimestamp < Environment.TickCount - timeoutWithoutReadyChar) { //Console.WriteLine("released"); break; } } lastSentTimestamp = Environment.TickCount; interfaceBusy = true; //Console.WriteLine("set"); Lawicel.CANUSB.CANMsg msg = new Lawicel.CANUSB.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); if (m_serialPort.IsOpen) { //m_serialPort.Write("\r"); string txstring = "t"; txstring += msg.id.ToString("X3"); txstring += "8"; // always 8 bytes to transmit for (int t = 0; t < 8; t++) { byte b = (byte)(((msg.data >> t * 8) & 0x0000000000000000FF)); txstring += b.ToString("X2"); } txstring += "\r"; AddToCanTrace(string.Format("TX: {0} {1} {2}", a_message.getID().ToString("X3"), a_message.getData().ToString("X16"), txstring)); m_serialPort.Write(txstring); return true; } } return false; }
/// <summary> /// sendMessage send a CANMessage. /// </summary> /// <param name="a_message">A CANMessage.</param> /// <returns>true on success, othewise false.</returns> public override bool sendMessage(CANMessage a_message) { Lawicel.CANUSB.CANMsg msg = new Lawicel.CANUSB.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); int writeResult; AddToCanTrace("TX: " + msg.id.ToString("X4") + " " + msg.data.ToString("X16")); writeResult = Lawicel.CANUSB.canusb_Write(m_deviceHandle, ref msg); if (writeResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { AddToCanTrace("Message sent successfully"); return true; } else { switch (writeResult) { case Lawicel.CANUSB.ERROR_CANUSB_COMMAND_SUBSYSTEM: AddToCanTrace("Message failed to send: ERROR_CANUSB_COMMAND_SUBSYSTEM"); break; case Lawicel.CANUSB.ERROR_CANUSB_INVALID_PARAM: AddToCanTrace("Message failed to send: ERROR_CANUSB_INVALID_PARAM"); break; case Lawicel.CANUSB.ERROR_CANUSB_NO_MESSAGE: AddToCanTrace("Message failed to send: ERROR_CANUSB_NO_MESSAGE"); break; case Lawicel.CANUSB.ERROR_CANUSB_NOT_OPEN: AddToCanTrace("Message failed to send: ERROR_CANUSB_NOT_OPEN"); break; case Lawicel.CANUSB.ERROR_CANUSB_OPEN_SUBSYSTEM: AddToCanTrace("Message failed to send: ERROR_CANUSB_OPEN_SUBSYSTEM"); break; case Lawicel.CANUSB.ERROR_CANUSB_TX_FIFO_FULL: AddToCanTrace("Message failed to send: ERROR_CANUSB_TX_FIFO_FULL"); break; default: AddToCanTrace("Message failed to send: " + writeResult.ToString()); break; } 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> /// 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; }
/// <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> /// This method is called by ICANDevices where derived objects of this class /// are registered. The method is called for each received CANMessage. /// What this method does is application dependent. /// </summary> /// <param name="a_canMessage">The CANMessage to be handled by this method.</param> public abstract void handleMessage(CANMessage a_canMessage);
/// <summary> /// sendMessage send a CANMessage. /// </summary> /// <param name="a_message">A CANMessage.</param> /// <returns>true on success, othewise false.</returns> protected override bool sendMessageDevice(CANMessage a_message) { Lawicel.CANUSB.CANMsg msg = new Lawicel.CANUSB.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); int writeResult; writeResult = Lawicel.CANUSB.canusb_Write(m_deviceHandle, ref msg); if (writeResult == Lawicel.CANUSB.ERROR_CANUSB_OK) { return true; } else { logger.Debug("tx failed writeResult: " + writeResult); return false; } }
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; } } }
abstract protected bool sendMessageDevice(CANMessage a_message);
//--------------------------------------------------------------------------------------------- /** Sends a 11 bit CAN data frame. @param msg CAN message @return success (true/false) */ protected override bool sendMessageDevice(CANMessage msg) { try { caCombiAdapter.caCANFrame frame; frame.id = msg.getID(); frame.length = msg.getLength(); frame.data = msg.getData(); frame.is_extended = 0; frame.is_remote = 0; combi.CAN_SendMessage(ref frame); return true; } catch (Exception e) { logger.Debug("tx failed with Exception.Message: " + e.Message); return false; } }
protected override bool sendMessageDevice(CANMessage a_message) { lock (lockObj) { sendDataSempahore.WaitOne(timeoutWithoutReadyChar); interfaceBusy = true; if (a_message.getID() != _ECUAddress) { _ECUAddress = a_message.getID(); string command = "ATSH" + a_message.getID().ToString("X3") + "\r"; SendControlMessage(command, false); } //check if it is beneficial to send ATR0 and ATR1 for ELM clones if (!supports8ByteResponse) { if ((a_message.elmExpectedResponses == 0) != request0Responses) { if (a_message.elmExpectedResponses == 0) { SendControlMessage("ATR0\r", false); request0Responses = true; } else { SendControlMessage("ATR1\r", false); request0Responses = false; } } } lastSentCanMessage = a_message.Clone(); string sendString = GetELMRequest(a_message); if (sendString.Length == 16 && !supports8ByteResponse) { bool canIgnoreLastByte = a_message.getCanData(7) == 0; if (canIgnoreLastByte) { sendString = sendString.Substring(0, 14); } } if (sendString.Length <= 14 || supports8ByteResponse) //ELM 2.0 supports 8 bytes + response count, previous versions dont { //add expected responses, but this has to be one char only :( if (a_message.elmExpectedResponses != -1 && a_message.elmExpectedResponses < 16) { sendString += " " + a_message.elmExpectedResponses.ToString("X1"); } } sendString += "\r"; if (m_serialPort.IsOpen) { lastSentTimestamp = Environment.TickCount; WriteToSerialWithTrace(sendString); } return(true); // remove after implementation } }
public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg) { canMsg = new CANMessage(); return 0; }
// 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> /// Creates valid request string for ELM device. Calculates data size and formats it automatically /// </summary> /// <param name="input"></param> /// <returns></returns> private static string GetELMRequest(CANMessage msg) { ulong reversed = BitTools.ReverseOrder(msg.getData()); //var length = BitTools.GetDataSize(reversed); return reversed.ToString("X16").Substring(0, msg.getLength() * 2); }
/// <summary> /// This message sends a CANMessage to the CAN device. /// The open method must have been called and returned possitive result /// before this method is called. /// </summary> /// <param name="a_message">The CANMessage</param> /// <returns>true on success, otherwise false.</returns> abstract public bool sendMessage(CANMessage a_message);