private void DumpCanMsg(EASYSYNC.CANMsg r_canMsg, bool IsTransmit) { /*DateTime dt = DateTime.Now; * try * { * using (StreamWriter sw = new StreamWriter(Path.Combine(m_startuppath, dt.Year.ToString("D4") + dt.Month.ToString("D2") + dt.Day.ToString("D2") + "-CanTrace.log"), true)) * { * if (IsTransmit) * { * // get the byte transmitted * int transmitvalue = (int)(r_canMsg.data & 0x000000000000FF00); * transmitvalue /= 256; * * sw.WriteLine(dt.ToString("dd/MM/yyyy HH:mm:ss") + " TX: id=" + r_canMsg.id.ToString("D2") + " len= " + r_canMsg.len.ToString("X8") + " data=" + r_canMsg.data.ToString("X16") + " " + r_canMsg.flags.ToString("X2") + " character = " + GetCharString(transmitvalue) + "\t ts: " + r_canMsg.timestamp.ToString("X16") + " flags: " + r_canMsg.flags.ToString("X2")); * } * else * { * // get the byte received * int receivevalue = (int)(r_canMsg.data & 0x0000000000FF0000); * receivevalue /= (256 * 256); * sw.WriteLine(dt.ToString("dd/MM/yyyy HH:mm:ss") + " RX: id=" + r_canMsg.id.ToString("D2") + " len= " + r_canMsg.len.ToString("X8") + " data=" + r_canMsg.data.ToString("X16") + " " + r_canMsg.flags.ToString("X2") + " character = " + GetCharString(receivevalue) + "\t ts: " + r_canMsg.timestamp.ToString("X16") + " flags: " + r_canMsg.flags.ToString("X2")); * } * } * } * catch (Exception E) * { * Console.WriteLine("Failed to write to logfile: " + E.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> private uint waitForMessage(uint a_canID, uint timeout, out EASYSYNC.CANMsg r_canMsg) { int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { 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; } return((uint)r_canMsg.id); } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); nrOfWait++; } } r_canMsg = new EASYSYNC.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 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); }
/// <summary> /// The open method tries to connect to both busses to see if one of them is connected and /// active. The first strategy is to listen for any CAN message. If this fails there is a /// check to see if the application is started after an interrupted flash session. This is /// done by sending a message to set address and length (only for P-bus). /// </summary> /// <returns>OpenResult.OK is returned on success. Otherwise OpenResult.OpenError is /// returned.</returns> override public OpenResult open() { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); //Check if I bus is connected close(); /*m_deviceHandle = EASYSYNC.canusb_Open(IntPtr.Zero, * "0xcb:0x9a", // Slow * EASYSYNC.CANUSB_ACCEPTANCE_CODE_ALL, * EASYSYNC.CANUSB_ACCEPTANCE_MASK_ALL, * EASYSYNC.CANUSB_FLAG_TIMESTAMP); * if (waitAnyMessage(1000, out msg) != 0) * { * if (m_readThread.ThreadState == ThreadState.Unstarted) * m_readThread.Start(); * return OpenResult.OK; * } * close(); */ //I bus wasn't connected. //Check if P bus is connected /* char[] adapter = new char[16]; * int result = EASYSYNC.canusb_getFirstAdapter(adapter, 16); * Console.WriteLine("Number of adapters found: " + result.ToString("X8"));*/ m_deviceHandle = EASYSYNC.canusb_Open(IntPtr.Zero, "500", IntPtr.Zero, IntPtr.Zero, 1); /* m_deviceHandle = EASYSYNC.canusb_Open( null, * EASYSYNC.CAN_BAUD_500K, //500Kb/s * null,//EASYSYNC.CANUSB_ACCEPTANCE_CODE_ALL, * null,//EASYSYNC.CANUSB_ACCEPTANCE_MASK_ALL, * EASYSYNC.CANUSB_FLAG_TIMESTAMP);*/ int errorval = (int)m_deviceHandle; Console.WriteLine(errorval.ToString()); if (m_deviceHandle < 0) { Console.WriteLine("Invalid handle received"); return(OpenResult.OpenError); } if (DisableCanConnectionCheck || boxIsThere()) { if (m_readThread.ThreadState == ThreadState.Unstarted) { m_readThread.Start(); } return(OpenResult.OK); } close(); return(OpenResult.OpenError); }
/*private void AddToCanTrace(string line) * { * if (m_EnableCanLog) * { * DateTime dtnow = DateTime.Now; * using (StreamWriter sw = new StreamWriter(System.Windows.Forms.Application.StartupPath + "\\CanTraceCANUSBDevice.txt", true)) * { * sw.WriteLine(dtnow.ToString("dd/MM/yyyy HH:mm:ss") + " - " + line); * } * } * }*/ /// <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) { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); //Console.WriteLine("Data to send: " + msg.data.ToString("X16")); //Console.WriteLine("Data (original) to send: " + a_message.getData().ToString("X16")); int writeResult; AddToCanTrace("Sending message"); writeResult = EASYSYNC.canusb_Write(m_deviceHandle, ref msg); if (writeResult == EASYSYNC.ERROR_CANUSB_OK) { AddToCanTrace("Message sent successfully"); return(true); } else { switch (writeResult) { case EASYSYNC.ERROR_CANUSB_COMMAND_SUBSYSTEM: AddToCanTrace("Message failed to send: ERROR_CANUSB_COMMAND_SUBSYSTEM"); break; case EASYSYNC.ERROR_CANUSB_INVALID_PARAM: AddToCanTrace("Message failed to send: ERROR_CANUSB_INVALID_PARAM"); break; case EASYSYNC.ERROR_CANUSB_NO_MESSAGE: AddToCanTrace("Message failed to send: ERROR_CANUSB_NO_MESSAGE"); break; case EASYSYNC.ERROR_CANUSB_NOT_OPEN: AddToCanTrace("Message failed to send: ERROR_CANUSB_NOT_OPEN"); break; case EASYSYNC.ERROR_CANUSB_OPEN_SUBSYSTEM: AddToCanTrace("Message failed to send: ERROR_CANUSB_OPEN_SUBSYSTEM"); break; case EASYSYNC.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> /// Check if there is connection with a CAN bus. /// </summary> /// <returns>true on connection, otherwise false</returns> private bool boxIsThere() { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); Console.WriteLine("Waiting for any message on the bus..."); if (waitAnyMessage(2000, out msg) != 0) { return(true); } Console.WriteLine("No message seen, sending session request..."); if (sendSessionRequest()) { 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 EASYSYNC.CANMsg r_canMsg) { int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == EASYSYNC.ERROR_CANUSB_OK) { return((uint)r_canMsg.id); } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); // changed to 0 to see performance impact nrOfWait++; } } r_canMsg = new EASYSYNC.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() { 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; 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> /// Check if there is connection with a CAN bus. /// </summary> /// <returns>true on connection, otherwise false</returns> private bool boxIsThere() { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); Console.WriteLine("Waiting for any message on the bus..."); if (waitAnyMessage(2000, out msg) != 0) return true; Console.WriteLine("No message seen, sending session request..."); if (sendSessionRequest()) 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) { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); msg.id = a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); msg.data = a_message.getData(); //Console.WriteLine("Data to send: " + msg.data.ToString("X16")); //Console.WriteLine("Data (original) to send: " + a_message.getData().ToString("X16")); int writeResult; AddToCanTrace("Sending message"); writeResult = EASYSYNC.canusb_Write(m_deviceHandle, ref msg); if (writeResult == EASYSYNC.ERROR_CANUSB_OK) { AddToCanTrace("Message sent successfully"); return true; } else { switch (writeResult) { case EASYSYNC.ERROR_CANUSB_COMMAND_SUBSYSTEM: AddToCanTrace("Message failed to send: ERROR_CANUSB_COMMAND_SUBSYSTEM"); break; case EASYSYNC.ERROR_CANUSB_INVALID_PARAM: AddToCanTrace("Message failed to send: ERROR_CANUSB_INVALID_PARAM"); break; case EASYSYNC.ERROR_CANUSB_NO_MESSAGE: AddToCanTrace("Message failed to send: ERROR_CANUSB_NO_MESSAGE"); break; case EASYSYNC.ERROR_CANUSB_NOT_OPEN: AddToCanTrace("Message failed to send: ERROR_CANUSB_NOT_OPEN"); break; case EASYSYNC.ERROR_CANUSB_OPEN_SUBSYSTEM: AddToCanTrace("Message failed to send: ERROR_CANUSB_OPEN_SUBSYSTEM"); break; case EASYSYNC.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> /// 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> /// The open method tries to connect to both busses to see if one of them is connected and /// active. The first strategy is to listen for any CAN message. If this fails there is a /// check to see if the application is started after an interrupted flash session. This is /// done by sending a message to set address and length (only for P-bus). /// </summary> /// <returns>OpenResult.OK is returned on success. Otherwise OpenResult.OpenError is /// returned.</returns> public override OpenResult open() { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); //Check if I bus is connected close(); /*m_deviceHandle = EASYSYNC.canusb_Open(IntPtr.Zero, "0xcb:0x9a", // Slow EASYSYNC.CANUSB_ACCEPTANCE_CODE_ALL, EASYSYNC.CANUSB_ACCEPTANCE_MASK_ALL, EASYSYNC.CANUSB_FLAG_TIMESTAMP); if (waitAnyMessage(1000, out msg) != 0) { if (m_readThread.ThreadState == ThreadState.Unstarted) m_readThread.Start(); return OpenResult.OK; } close(); */ //I bus wasn't connected. //Check if P bus is connected /* char[] adapter = new char[16]; int result = EASYSYNC.canusb_getFirstAdapter(adapter, 16); Console.WriteLine("Number of adapters found: " + result.ToString("X8"));*/ m_deviceHandle = EASYSYNC.canusb_Open(IntPtr.Zero, "500", IntPtr.Zero, IntPtr.Zero, 1); /* m_deviceHandle = EASYSYNC.canusb_Open( null, EASYSYNC.CAN_BAUD_500K, //500Kb/s null,//EASYSYNC.CANUSB_ACCEPTANCE_CODE_ALL, null,//EASYSYNC.CANUSB_ACCEPTANCE_MASK_ALL, EASYSYNC.CANUSB_FLAG_TIMESTAMP);*/ int errorval = (int)m_deviceHandle; Console.WriteLine(errorval.ToString()); if (m_deviceHandle < 0) { Console.WriteLine("Invalid handle received"); return OpenResult.OpenError; } if (boxIsThere()) { if(m_readThread.ThreadState == ThreadState.Unstarted) m_readThread.Start(); return OpenResult.OK; } close(); return OpenResult.OpenError; }
/// <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) { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); msg.id = (ushort)a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); ulong msgdata = a_message.getData(); // store in data (ulong) /*byte databyte = a_message.getCanData(7); msg.data_1 = GetDataMSBADCII(databyte); msg.data_2 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(6); msg.data_3 = GetDataMSBADCII(databyte); msg.data_4 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(5); msg.data_5 = GetDataMSBADCII(databyte); msg.data_6 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(4); msg.data_7 = GetDataMSBADCII(databyte); msg.data_8 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(3); msg.data_9 = GetDataMSBADCII(databyte); msg.data_10 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(2); msg.data_11 = GetDataMSBADCII(databyte); msg.data_12 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(1); msg.data_13 = GetDataMSBADCII(databyte); msg.data_14 = GetDataLSBADCII(databyte); databyte = a_message.getCanData(0); msg.data_15 = GetDataMSBADCII(databyte); msg.data_16 = GetDataLSBADCII(databyte); */ msg.data = a_message.getData(); // this data should be in ascii: unsigned char data[16]; // Databytes 0...7 // example: /* msg.data[0]='A'; msg.data[1]='1'; msg.data[2]='B'; msg.data[3]='2'; msg.data[4]='C'; msg.data[5]='3'; msg.data[6]='D'; msg.data[7]='4'; msg.data[8]='E'; msg.data[9]='5'; msg.data[10]='F'; msg.data[11]='6'; msg.data[12]='1'; msg.data[13]='2'; msg.data[14]='3'; msg.data[15]='4'; * */ if (m_DoLogging) { DumpCanMsg(msg, true); } int writeResult; Console.WriteLine("Writing to handle: " + m_deviceHandle.ToString("X8")); writeResult = EASYSYNC.canusb_Write(m_deviceHandle, ref msg); if (writeResult == EASYSYNC.ERROR_CANUSB_OK) return true; else { //EASYSYNC.canusb_Flush(m_deviceHandle); Console.WriteLine("Failed to send message: " + writeResult.ToString("X8")); 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(); /* Stopwatch while (true) { lock (m_synchObject) { if (m_endThread) return; } readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult > 0) { 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); if (m_DoLogging) { DumpCanMsg(r_canMsg, false); } lock (m_listeners) { foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); } }*/ while (true) { /*if ((thrdcnt++ % 1000) == 0) { Console.WriteLine("Reading messages"); }*/ lock (m_synchObject) { if (m_endThread) { m_endThread = false; return; } } readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult > 0) { canMessage.setID((uint)r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setTimeStamp((uint)r_canMsg.timestamp); canMessage.setFlags(r_canMsg.flags); //TODO: data hier nog vullen canMessage.setData(r_canMsg.data); if (m_DoLogging) { DumpCanMsg(r_canMsg, false); } lock (m_listeners) { foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); // changed to 0 to see performance impact } } }
/// <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> /// 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 EASYSYNC.CANMsg r_canMsg) { int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult == EASYSYNC.ERROR_CANUSB_OK) { return (uint)r_canMsg.id; } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); // changed to 0 to see performance impact nrOfWait++; } } r_canMsg = new EASYSYNC.CANMsg(); return 0; }
/// <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) { EASYSYNC.CANMsg msg = new EASYSYNC.CANMsg(); msg.id = (ushort)a_message.getID(); msg.len = a_message.getLength(); msg.flags = a_message.getFlags(); ulong msgdata = a_message.getData(); // store in data (ulong) /*byte databyte = a_message.getCanData(7); * msg.data_1 = GetDataMSBADCII(databyte); * msg.data_2 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(6); * msg.data_3 = GetDataMSBADCII(databyte); * msg.data_4 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(5); * msg.data_5 = GetDataMSBADCII(databyte); * msg.data_6 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(4); * msg.data_7 = GetDataMSBADCII(databyte); * msg.data_8 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(3); * msg.data_9 = GetDataMSBADCII(databyte); * msg.data_10 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(2); * msg.data_11 = GetDataMSBADCII(databyte); * msg.data_12 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(1); * msg.data_13 = GetDataMSBADCII(databyte); * msg.data_14 = GetDataLSBADCII(databyte); * databyte = a_message.getCanData(0); * msg.data_15 = GetDataMSBADCII(databyte); * msg.data_16 = GetDataLSBADCII(databyte); */ msg.data = a_message.getData(); // this data should be in ascii: unsigned char data[16]; // Databytes 0...7 // example: /* * msg.data[0]='A'; * msg.data[1]='1'; * * msg.data[2]='B'; * msg.data[3]='2'; * * msg.data[4]='C'; * msg.data[5]='3'; * * msg.data[6]='D'; * msg.data[7]='4'; * * msg.data[8]='E'; * msg.data[9]='5'; * * msg.data[10]='F'; * msg.data[11]='6'; * * msg.data[12]='1'; * msg.data[13]='2'; * * msg.data[14]='3'; * msg.data[15]='4'; * */ if (m_DoLogging) { DumpCanMsg(msg, true); } int writeResult; Console.WriteLine("Writing to handle: " + m_deviceHandle.ToString("X8")); writeResult = EASYSYNC.canusb_Write(m_deviceHandle, ref msg); if (writeResult == EASYSYNC.ERROR_CANUSB_OK) { return(true); } else { //EASYSYNC.canusb_Flush(m_deviceHandle); Console.WriteLine("Failed to send message: " + writeResult.ToString("X8")); 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(); /* Stopwatch * while (true) * { * lock (m_synchObject) * { * if (m_endThread) * return; * } * readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); * if (readResult > 0) * { * 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); * if (m_DoLogging) * { * DumpCanMsg(r_canMsg, false); * } * lock (m_listeners) * { * foreach (ICANListener listener in m_listeners) * { * listener.handleMessage(canMessage); * } * } * } * else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) * { * Thread.Sleep(1); * } * }*/ while (true) { /*if ((thrdcnt++ % 1000) == 0) * { * Console.WriteLine("Reading messages"); * }*/ lock (m_synchObject) { if (m_endThread) { m_endThread = false; return; } } readResult = EASYSYNC.canusb_Read(m_deviceHandle, out r_canMsg); if (readResult > 0) { canMessage.setID((uint)r_canMsg.id); canMessage.setLength(r_canMsg.len); canMessage.setTimeStamp((uint)r_canMsg.timestamp); canMessage.setFlags(r_canMsg.flags); //TODO: data hier nog vullen canMessage.setData(r_canMsg.data); if (m_DoLogging) { DumpCanMsg(r_canMsg, false); } lock (m_listeners) { foreach (ICANListener listener in m_listeners) { listener.handleMessage(canMessage); } } } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); // changed to 0 to see performance impact } } }
/// <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> private uint waitForMessage(uint a_canID, uint timeout, out EASYSYNC.CANMsg r_canMsg) { int readResult = 0; int nrOfWait = 0; while (nrOfWait < timeout) { 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; return (uint)r_canMsg.id; } else if (readResult == EASYSYNC.ERROR_CANUSB_NO_MESSAGE) { Thread.Sleep(1); nrOfWait++; } } r_canMsg = new EASYSYNC.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 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; }