/// <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) { if (m_endThread) { return(false); } byte[] msg = a_message.getHeaderAndData(); PassThruMsg txMsg = new PassThruMsg(); txMsg.ProtocolID = ProtocolID.CAN; txMsg.TxFlags = TxFlag.NONE; txMsg.SetBytes(msg); int numMsgs = 1; const int timeout = 0; m_status = passThru.PassThruWriteMsgs(m_channelId, txMsg.ToIntPtr(), ref numMsgs, timeout); if (J2534Err.STATUS_NOERROR != m_status) { logger.Debug(String.Format("tx failed with status {0} {1}", m_status, BitConverter.ToString(msg))); return(false); } return(true); }
public override void Write(byte[] buffer, int offset, int count) { if (this.channel == null) { throw new InvalidOperationException("PassThruStream.OpenSsmStream() must succeed before calling PassThruStream.Read()"); } int written = 0; while (written < count) { PassThruMsg message = new PassThruMsg(); message.ProtocolID = PassThruProtocol.Iso9141; int length = Math.Min(count, message.Data.Length); for (int i = 0; i < length; i++) { message.Data[i] = buffer[offset + i]; } message.DataSize = (uint)length; this.channel.WriteMessage(message, TimeSpan.FromSeconds(0.5)); written += length; } }
/// <summary> /// Set filter /// </summary> private Response <J2534Err> SetFilter(UInt32 Mask, UInt32 Pattern, UInt32 FlowControl, TxFlag txflag, FilterType Filtertype) { PassThruMsg maskMsg; PassThruMsg patternMsg; IntPtr MaskPtr; IntPtr PatternPtr; IntPtr FlowPtr; maskMsg = new PassThruMsg(Protocol, txflag, new Byte[] { (byte)(0xFF & (Mask >> 16)), (byte)(0xFF & (Mask >> 8)), (byte)(0xFF & Mask) }); patternMsg = new PassThruMsg(Protocol, txflag, new Byte[] { (byte)(0xFF & (Pattern >> 16)), (byte)(0xFF & (Pattern >> 8)), (byte)(0xFF & Pattern) }); MaskPtr = maskMsg.ToIntPtr(); PatternPtr = patternMsg.ToIntPtr(); FlowPtr = IntPtr.Zero; int tempfilter = 0; OBDError = J2534Port.Functions.PassThruStartMsgFilter((int)ChannelID, Filtertype, MaskPtr, PatternPtr, FlowPtr, ref tempfilter); Marshal.FreeHGlobal(MaskPtr); Marshal.FreeHGlobal(PatternPtr); Marshal.FreeHGlobal(FlowPtr); if (OBDError != J2534Err.STATUS_NOERROR) { return(Response.Create(ResponseStatus.Error, OBDError)); } Filters.Add((ulong)tempfilter); return(Response.Create(ResponseStatus.Success, OBDError)); }
public void ConnectISO15765() { Connect(); byte[] value; J2534Status = J2534Interface.PassThruConnect(DeviceId, ProtocolID.ISO15765, ConnectFlag.NONE, BaudRate.ISO15765, ref ChannelId); if (J2534Err.STATUS_NOERROR != J2534Status) { throw new J2534Exception(J2534Status); } //List<SConfig> configBits = new List<SConfig>(); //SConfig conf = new SConfig(); //conf.Parameter = ConfigParameter.LOOPBACK; //conf.Value = 0; //SConfig conf1 = new SConfig(); //conf1.Parameter = ConfigParameter.DATA_RATE; //conf1.Value = 0; //configBits.Add(conf); //configBits.Add(conf1); //m_status = m_j2534Interface.GetConfig(m_channelId, ref configBits); int filterId = 0; byte i; for (i = 0; i < 1; i++) { PassThruMsg maskMsg = new PassThruMsg(ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0xff, 0xff, 0xff, 0xff }); PassThruMsg patternMsg = new PassThruMsg(ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, (byte)(0xE8 + i) }); PassThruMsg flowControlMsg = new PassThruMsg(ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, (byte)(0xE0 + i) }); J2534Status = J2534Interface.PassThruStartMsgFilter( ChannelId, FilterType.FLOW_CONTROL_FILTER, maskMsg.ToIntPtr(), patternMsg.ToIntPtr(), flowControlMsg.ToIntPtr(), ref filterId); if (J2534Err.STATUS_NOERROR != J2534Status) { J2534Interface.PassThruDisconnect(ChannelId); throw new J2534Exception(J2534Status); } } //Check we can read some PIDs back ReadObdPid(OBDcmd.Mode.REQUEST_CURRENT_DATA, out value); if (value.Length <= 0) { //m_status = j2534Interface.PassThruDisconnect(channelId); //throw new OBDException(OBDcmd.Response.NEGATIVE_RESPONSE); } ProtocolId = ProtocolID.ISO15765; }
public void Transmit_Message(string DID_REAL, string MessageToSend) { int DID = Convert.ToInt32(DID_REAL.Trim(), 16); string[] dataStr = MessageToSend.Trim().Split(' '); int[] byteStr = new int[dataStr.Length + 4]; byteStr[0] = 0; byteStr[1] = 0; byteStr[2] = (byte)((int)DID / 256); byteStr[3] = (byte)((int)DID % 256); strDatebyte = ""; for (int i = 0; i < dataStr.Length; i++) { byteStr[i + 4] = Convert.ToInt32(dataStr[i], 16); } PassThruMsg TxMsg = new PassThruMsg(); TxMsg.ProtocolID = ProtocolID.ISO15765; //SEND TxMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; //TxMsg.ProtocolID = ProtocolID.CAN; //TxMsg.TxFlags = TxFlag.NONE; TxMsg.Data = new byte[byteStr.Length]; for (int i = 0; i < byteStr.Length; i++) { TxMsg.Data[i] = (byte)byteStr[i]; } for (int i = 0; i < (TxMsg.Data.Length - 4); i++) { strDatebyte += string.Format("{0:X2}", TxMsg.Data[i + 4]) + " "; } passThru.ClearRxBuffer(channelId); int numMsgs = 1; //to be tested later J2534Error = passThru.WriteMsgs(channelId, ref TxMsg, ref numMsgs, 50); if (strDatebyte.Substring(0, 2) == "3E") { return; } Sum_Message = DTCANRxScroll.Rows.Count; DataRow canRow; canRow = DTCANRxScroll.NewRow(); canRow[0] = Sum_Message + 1; canRow[1] = "Tx"; canRow[2] = "0x" + RequestID.Text.Trim(); canRow[3] = TxMsg.Data.Length - 4; canRow[4] = strDatebyte; canRow[5] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");//string.Format("{0:G}", System.DateTime.Now);//结果为:2009-3-20 15:39:27 DTCANRxScroll.Rows.Add(canRow); INIT_Timestamp = TxMsg.Timestamp; dgvCANRx.FirstDisplayedScrollingRowIndex = dgvCANRx.RowCount - 1; }
/// <summary> /// Parse the replies checking for a valid response, if we have a valid response extract the payload data /// </summary> /// <param name="rxMsgs"></param> /// <param name="txMode"></param> /// <param name="payload"></param> /// <returns></returns> UDSPacket ParseUDSResponse(PassThruMsg rxMsg, UDScmd.Mode txMode) { var rxMsgBytes = rxMsg.GetBytes(); UDSPacket rxPacket = new UDSPacket(); //Iterate the reply bytes to find the echod ECU index, response code, function response and payload data if there is any //If we could use some kind of HEX regex this would be a bit neater int stateMachine = 0; for (int i = 0; i < rxMsgBytes.Length; i++) { switch (stateMachine) { case 0: if (rxMsgBytes[i] == 0x07) { stateMachine = 1; } else if (rxMsgBytes[i] != 0) { return(rxPacket); } break; case 1: if (rxMsgBytes[i] == 0xE8) { stateMachine = 2; } else { return(rxPacket); } break; case 2: var payload = new byte[rxMsgBytes.Length - i]; int payloadLength = rxMsgBytes.Length - i; if (payloadLength > 0) { payload = new byte[payloadLength]; Array.Copy(rxMsgBytes, i, payload, 0, payloadLength); rxPacket = new UDSPacket(payload, txMode); ; } return(rxPacket); case 3: default: return(rxPacket); } } return(rxPacket); }
public bool ResetECU() { PassThruMsg txMsg = new PassThruMsg(); int timeout; var value = new byte[0]; txMsg.ProtocolID = ProtocolId; switch (ProtocolId) { case ProtocolID.ISO15765: txMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; txMsg.SetBytes(new byte[] { 0, 0, 0x07, 0xE0, 0x11, 0x02, 0, 0 }); timeout = 50; break; case ProtocolID.J1850PWM: case ProtocolID.J1850VPW: case ProtocolID.ISO9141: case ProtocolID.ISO14230: default: return(false); } J2534Interface.ClearRxBuffer(ChannelId); int numMsgs = 1; J2534Status = J2534Interface.PassThruWriteMsgs(ChannelId, txMsg.ToIntPtr(), ref numMsgs, timeout); if (J2534Err.STATUS_NOERROR != J2534Status) { return(false); } //Attempt to read at least 1 message as a reply List <PassThruMsg> messages; J2534Status = J2534Interface.ReadAllMessages(ChannelId, 1, _defaultTimeout, out messages, true); if (messages.Count <= 0) { return(false); } var response1 = messages[0].GetBytes(); var response2 = messages[1].GetBytes(); //needs to respond with 00 00 07 e8 67 03 xx xx xx var code = response2[6]; if (response2[4] != 0x7F) { return(true); } return(false); }
public override int Read(byte[] buffer, int offset, int count) { if (this.channel == null) { throw new InvalidOperationException("PassThruStream.OpenSsmStream() must succeed before calling PassThruStream.Read()"); } if (this.received != null) { int bytesToCopy = Math.Min(count, this.received.Length); for (int i = 0; i < bytesToCopy; i++) { buffer[i + offset] = this.received[i]; } int remaining = this.received.Length - bytesToCopy; if (remaining > 0) { byte[] newBuffer = new byte[remaining]; for (int i = 0; i < remaining; i++) { newBuffer[i] = this.received[bytesToCopy + i]; } this.received = newBuffer; } else { this.received = null; } return(bytesToCopy); } else { PassThruMsg message = new PassThruMsg(); this.channel.ReadMessage(message, TimeSpan.FromSeconds(0.5)); int bytesToCopy = (int)Math.Min(count, message.DataSize); for (int i = 0; i < bytesToCopy; i++) { buffer[i + offset] = message.Data[i]; } if (bytesToCopy < message.DataSize) { this.received = new byte[message.DataSize - bytesToCopy]; for (int i = 0; i < (message.DataSize - bytesToCopy); i++) { this.received[i] = message.Data[bytesToCopy + i]; } } return(bytesToCopy); } }
public unsafe PassThruMsg[] ReadMsgs(int timeout, int numMsgs) { var msgs = new PassThruMsg[numMsgs]; fixed(void *ptr = &msgs[0]) { var status = PassThruInterface.PassThruReadMsgs(channelId, new IntPtr(ptr), ref numMsgs, timeout); ThrowIfError(status); } return(msgs); }
public void TxMsg(string msgID, string msgData, Action <string, int, string, string> Callback) { /* if not connect device, return */ if (!IsConnectDevice) { MessageBox.Show("Please connect device!", "Error"); return; } string strDatebyte = ""; int ID = Convert.ToInt32(msgID.Trim(), 16); string[] dataStr = msgData.Trim().Split(' '); int[] byteStr = new int[dataStr.Length + 4]; byteStr[0] = 0; byteStr[1] = 0; byteStr[2] = (byte)((int)ID / 256); byteStr[3] = (byte)((int)ID % 256); for (int i = 0; i < dataStr.Length; i++) { byteStr[i + 4] = Convert.ToInt32("0x" + dataStr[i], 16); } PassThruMsg TxMsg = new PassThruMsg(); TxMsg.ProtocolID = ProtocolID.ISO15765; //SEND TxMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; //TxMsg.ProtocolID = ProtocolID.CAN; //TxMsg.TxFlags = TxFlag.NONE; TxMsg.Data = new byte[byteStr.Length]; for (int i = 0; i < byteStr.Length; i++) { TxMsg.Data[i] = (byte)byteStr[i]; } for (int i = 0; i < (TxMsg.Data.Length - 4); i++) { strDatebyte += string.Format("{0:X2}", TxMsg.Data[i + 4]) + " "; } //passThru.ClearRxBuffer(channelId); int numMsgs = 1; //to be tested later J2534ErrStatus = passThru.WriteMsgs(channelId, ref TxMsg, ref numMsgs, 50); //Console.Write("Debug"); // Debug /* Update UI */ Callback(msgID, TxMsg.Data.Length - 4, strDatebyte, "Tx"); }
/// <summary> /// Read an network packet from the interface, and return a Response/Message /// </summary> protected override Task Receive() { //this.Logger.AddDebugMessage("Trace: Read Network Packet"); PassThruMsg PassMess = new PassThruMsg(); Message TempMessage = new Message(null); int NumMessages = 1; IntPtr rxMsgs = Marshal.AllocHGlobal((int)(Marshal.SizeOf(typeof(PassThruMsg)) * NumMessages)); OBDError = 0; //Clear any previous faults Stopwatch sw = new Stopwatch(); sw.Start(); while (OBDError == J2534Err.STATUS_NOERROR || sw.ElapsedMilliseconds > (long)ReadTimeout) { NumMessages = 1; OBDError = J2534Port.Functions.PassThruReadMsgs((int)ChannelID, rxMsgs, ref NumMessages, ReadTimeout); if (OBDError != J2534Err.STATUS_NOERROR) { this.Logger.AddDebugMessage("ReadMsgs OBDError: " + OBDError); return(Task.FromResult(0)); } sw.Stop(); PassMess = rxMsgs.AsMsgList(1).Last(); if ((int)PassMess.RxStatus == (((int)RxStatus.TX_INDICATION_SUCCESS) + ((int)RxStatus.TX_MSG_TYPE)) || (PassMess.RxStatus == RxStatus.START_OF_MESSAGE)) { continue; } else { byte[] TempBytes = PassMess.GetBytes(); //Perform additional filter check if required here... or show to debug break;//leave while loop } } Marshal.FreeHGlobal(rxMsgs); if (OBDError != J2534Err.STATUS_NOERROR || sw.ElapsedMilliseconds > (long)ReadTimeout) { this.Logger.AddDebugMessage("ReadMsgs OBDError: " + OBDError); return(Task.FromResult(0)); } this.Logger.AddDebugMessage("RX: " + PassMess.GetBytes().ToHex()); this.Enqueue(new Message(PassMess.GetBytes(), PassMess.Timestamp, (ulong)OBDError)); return(Task.FromResult(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() { uint id; int numMsgs = 1; const int timeout = 1000; CANMessage canMessage = new CANMessage(); logger.Debug("readMessages started"); while (true) { lock (m_synchObject) { if (m_endThread) { logger.Debug("readMessages thread ended"); return; } } IntPtr rxMsgs = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PassThruMsg))); m_status = passThru.PassThruReadMsgs(m_channelId, rxMsgs, ref numMsgs, timeout); if (m_status == J2534Err.STATUS_NOERROR) { if (numMsgs > 0) { PassThruMsg msg = rxMsgs.AsMsgList(numMsgs)[0]; byte[] all = msg.GetBytes(); id = (uint)(all[2] * 0x100 + all[3]); uint length = msg.DataSize - 4; byte[] data = new byte[length]; Array.Copy(all, 4, data, 0, length); if (acceptMessageId(id)) { canMessage.setID(id); canMessage.setTimeStamp(msg.Timestamp); canMessage.setCanData(data, (byte)(length)); receivedMessage(canMessage); } } } else { logger.Debug(String.Format("PassThruReadMsgs, status:{0}", m_status)); } Marshal.FreeHGlobal(rxMsgs); } }
public bool ConnectIso15765() { List <byte> value = new List <byte>(); m_status = m_j2534Interface.Connect(m_deviceId, ProtocolID.ISO15765, ConnectFlag.NONE, BaudRate.ISO15765, ref m_channelId); if (J2534Err.STATUS_NOERROR != m_status) { return(false); } PassThruMsg maskMsg = new PassThruMsg(); PassThruMsg patternMsg = new PassThruMsg(); PassThruMsg flowControlMsg = new PassThruMsg(); int filterId = 0; byte i; //for (i=0; i < 8; i++) for (i = 0; i < 1; i++) { maskMsg.ProtocolID = ProtocolID.ISO15765; maskMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; maskMsg.Data = new byte[] { 0xff, 0xff, 0xff, 0xff }; patternMsg.ProtocolID = ProtocolID.ISO15765; patternMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; patternMsg.Data = new byte[] { 0x00, 0x00, 0x07, (byte)(0xE8 + i) }; flowControlMsg.ProtocolID = ProtocolID.ISO15765; flowControlMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; flowControlMsg.Data = new byte[] { 0x00, 0x00, 0x07, (byte)(0xE0 + i) }; m_status = m_j2534Interface.StartMsgFilter(m_channelId, FilterType.FLOW_CONTROL_FILTER, ref maskMsg, ref patternMsg, ref flowControlMsg, ref filterId); if (J2534Err.STATUS_NOERROR != m_status) { m_j2534Interface.Disconnect(m_channelId); return(false); } } if (!ReadObdPid(0x01, 0x00, ProtocolID.ISO15765, ref value)) { m_j2534Interface.Disconnect(m_channelId); return(false); } return(true); }
private bool connectCAN() { J2534Error = passThru.Connect(deviceId, ProtocolID.CAN, ConnectFlag.NONE, baudRate, ref channelId); if (J2534Error == J2534Err.STATUS_NOERROR) { PassThruMsg maskMsg = new PassThruMsg(ProtocolID.CAN, TxFlag.NONE, new byte[] { 0x00, 0x00, 0x00, 0x00 }); //all to receive PassThruMsg patternMsg = new PassThruMsg(ProtocolID.CAN, TxFlag.NONE, new byte[] { 0x00, 0x00, 0x00, 0x00 }); passThru.StartMsgFilter(channelId, FilterType.PASS_FILTER, ref maskMsg, ref patternMsg, ref filterId); passThru.ClearRxBuffer(channelId); return(true); } else { return(false); } }
public bool ConnectIso15765(string RequestID, string ResponseID, BaudRate baudRate) { List <byte> value = new List <byte>(); J2534ErrStatus = passThru.Connect(deviceId, ProtocolID.ISO15765, ConnectFlag.NONE, baudRate, ref channelId); if (J2534Err.STATUS_NOERROR != J2534ErrStatus) { return(false); } PassThruMsg maskMsg = new PassThruMsg(); PassThruMsg patternMsg = new PassThruMsg(); PassThruMsg flowControlMsg = new PassThruMsg(); byte i; for (i = 0; i < 1; i++) { maskMsg.ProtocolID = ProtocolID.ISO15765; maskMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; maskMsg.Data = new byte[] { 0xff, 0xff, 0xff, 0xff }; //4 "FF" for stand ID,5 "FF" for extend ID byte ReqID_1 = (byte)Convert.ToUInt16(RequestID.Trim().ToUpper().Substring(0, 1), 16); byte ReqID_2 = (byte)Convert.ToUInt16(RequestID.Trim().ToUpper().Substring(1, 2), 16); byte RespID_1 = (byte)Convert.ToUInt16(ResponseID.Trim().ToUpper().Substring(0, 1), 16); byte RespID_2 = (byte)Convert.ToUInt16(ResponseID.Trim().ToUpper().Substring(1, 2), 16); patternMsg.ProtocolID = ProtocolID.ISO15765; patternMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; patternMsg.Data = new byte[] { 0x00, 0x00, RespID_1, RespID_2 }; flowControlMsg.ProtocolID = ProtocolID.ISO15765; flowControlMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; flowControlMsg.Data = new byte[] { 0x00, 0x00, ReqID_1, ReqID_2 }; J2534ErrStatus = passThru.StartMsgFilter(channelId, FilterType.FLOW_CONTROL_FILTER, ref maskMsg, ref patternMsg, ref flowControlMsg, ref filterId); if (J2534Err.STATUS_NOERROR != J2534ErrStatus) { passThru.Disconnect(channelId); return(false); } } return(true); }
public void SendMessage(byte[] payload, bool headerSuppled = false) { J2534Status = J2534Interface.ClearTxBuffer(ChannelId); var txMsg = new PassThruMsg(); int timeout; if (headerSuppled) { txMsg.SetBytes(payload); } else { //Use the standard header //First 4 bytes are 00 00 07 E8 byte[] txMsgBytes = new byte[4 + payload.Length]; txMsgBytes[2] = 0x07; txMsgBytes[3] = 0xE0; Array.Copy(payload, 0, txMsgBytes, 4, payload.Length); txMsg.SetBytes(txMsgBytes); } txMsg.ProtocolID = ProtocolId; if (ProtocolId != ProtocolID.ISO15765) { throw new J2534Exception(J2534Err.ERR_NOT_SUPPORTED); } txMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; timeout = 50; J2534Interface.ClearRxBuffer(ChannelId); var numMsgs = 1; J2534Status = J2534Interface.PassThruWriteMsgs(ChannelId, txMsg.ToIntPtr(), ref numMsgs, timeout); if (J2534Err.STATUS_NOERROR != J2534Status) { throw new J2534Exception(J2534Status); } }
public void TxMsg(UInt32 RequestID, byte[] msgData, Action <string, string, string, string, string> UpdateUICallback) { J2534Err J2534ErrStatus; int numMsgs = 1; PassThruMsg TxMsg = new PassThruMsg(); TxMsg.ProtocolID = ProtocolID.ISO15765; //SEND TxMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; //TxMsg.ProtocolID = ProtocolID.CAN; //TxMsg.TxFlags = TxFlag.NONE; TxMsg.Data = PackMsgTxData(RequestID, msgData); //passThru.ClearRxBuffer(channelId); J2534ErrStatus = passThru.WriteMsgs(channelId, ref TxMsg, ref numMsgs, 10); UpdateUICallback(string.Format("{0:X}", RequestID), Convert.ToString(TxMsg.Data.Length - 4), GetMsgDataString(TxMsg.Data), "Tx", DateTime.Now.ToString("HH:mm:ss:fff:ffffff")); }
public void SetNullFilters(int swChannelId, int dwChannelId) { // Set up a message filter to watch for response messages int filterId = 0; PassThruMsg swMask1 = new PassThruMsg( ProtocolID.SW_CAN, TxFlag.CAN_29BIT_ID, new byte[] { 0x00, 0x00, 0x00, 0x00 }); PassThruMsg swMask2 = new PassThruMsg( ProtocolID.SW_CAN, TxFlag.CAN_29BIT_ID, new byte[] { 0x10, 0x00, 0x00, 0x00 }); PassThruMsg swMask3 = new PassThruMsg( ProtocolID.SW_CAN, TxFlag.CAN_29BIT_ID, new byte[] { 0x0f, 0x00, 0x00, 0x00 }); PassThruMsg dwMask1 = new PassThruMsg( ProtocolID.DW_CAN, TxFlag.CAN_29BIT_ID, new byte[] { 0x00, 0x00, 0x00, 0x00 }); PassThruMsg dwMask2 = new PassThruMsg( ProtocolID.DW_CAN, TxFlag.CAN_29BIT_ID, new byte[] { 0x10, 0x00, 0x00, 0x00 }); PassThruMsg dwMask3 = new PassThruMsg( ProtocolID.DW_CAN, TxFlag.CAN_29BIT_ID, new byte[] { 0x0f, 0x00, 0x00, 0x00 }); m_j2534Interface.PassThruStartMsgFilter(swChannelId, FilterType.PASS_FILTER, swMask1.ToIntPtr(), swMask1.ToIntPtr(), IntPtr.Zero, ref filterId); m_j2534Interface.PassThruStartMsgFilter(swChannelId, FilterType.PASS_FILTER, swMask2.ToIntPtr(), swMask2.ToIntPtr(), IntPtr.Zero, ref filterId); m_j2534Interface.PassThruStartMsgFilter(swChannelId, FilterType.PASS_FILTER, swMask3.ToIntPtr(), swMask3.ToIntPtr(), IntPtr.Zero, ref filterId); m_j2534Interface.PassThruStartMsgFilter(dwChannelId, FilterType.PASS_FILTER, dwMask1.ToIntPtr(), dwMask1.ToIntPtr(), IntPtr.Zero, ref filterId); m_j2534Interface.PassThruStartMsgFilter(dwChannelId, FilterType.PASS_FILTER, dwMask2.ToIntPtr(), dwMask2.ToIntPtr(), IntPtr.Zero, ref filterId); m_j2534Interface.PassThruStartMsgFilter(dwChannelId, FilterType.PASS_FILTER, dwMask3.ToIntPtr(), dwMask3.ToIntPtr(), IntPtr.Zero, ref filterId); }
public bool ConnectIso15765() { List <byte> value = new List <byte>(); m_status = m_j2534Interface.PassThruConnect(m_deviceId, ProtocolID.ISO15765, ConnectFlag.NONE, BaudRate.ISO15765, ref m_channelId); if (J2534Err.STATUS_NOERROR != m_status) { return(false); } int filterId = 0; byte i; for (i = 0; i < 1; i++) { PassThruMsg maskMsg = new PassThruMsg(ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0xff, 0xff, 0xff, 0xff }); PassThruMsg patternMsg = new PassThruMsg(ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, (byte)(0xE8 + i) }); PassThruMsg flowControlMsg = new PassThruMsg(ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, (byte)(0xE0 + i) }); m_status = m_j2534Interface.PassThruStartMsgFilter( m_channelId, FilterType.FLOW_CONTROL_FILTER, maskMsg.ToIntPtr(), patternMsg.ToIntPtr(), flowControlMsg.ToIntPtr(), ref filterId); if (J2534Err.STATUS_NOERROR != m_status) { m_j2534Interface.PassThruDisconnect(m_channelId); return(false); } } if (!ReadObdPid(0x01, 0x00, ProtocolID.ISO15765, ref value)) { m_j2534Interface.PassThruDisconnect(m_channelId); return(false); } return(true); }
/// <summary> /// Convert a Message to an J2534 formatted transmit, and send to the interface /// </summary> private Response <J2534Err> SendNetworkMessage(Message message, TxFlag Flags) { //this.Logger.AddDebugMessage("Trace: Send Network Packet"); PassThruMsg TempMsg = new PassThruMsg(); TempMsg.ProtocolID = Protocol; TempMsg.TxFlags = Flags; TempMsg.SetBytes(message.GetBytes()); int NumMsgs = 1; IntPtr MsgPtr = TempMsg.ToIntPtr(); OBDError = J2534Port.Functions.PassThruWriteMsgs((int)ChannelID, MsgPtr, ref NumMsgs, WriteTimeout); Marshal.FreeHGlobal(MsgPtr); if (OBDError != J2534Err.STATUS_NOERROR) { //Debug messages here...check why failed.. return(Response.Create(ResponseStatus.Error, OBDError)); } return(Response.Create(ResponseStatus.Success, OBDError)); }
public bool SendDwMessage(String id, bool extended, bool highVoltage, String data) { PassThruMsg txMsg = new PassThruMsg(); int timeout = 200; String rawMessage; if (extended) { rawMessage = CreateExtendedMessage(id, data); } else { rawMessage = CreateStandardMessage(id, data); } txMsg.ProtocolID = ProtocolID.DW_CAN; txMsg.SetBytes(StringToHex(rawMessage)); if (extended) { txMsg.TxFlags |= TxFlag.CAN_29BIT_ID; } if (highVoltage) { txMsg.TxFlags |= TxFlag.SW_CAN_HV_TX; } int numMsgs = 1; m_status = m_j2534Interface.PassThruWriteMsgs(m_dwChannelId, txMsg.ToIntPtr(), ref numMsgs, timeout); if (J2534Err.STATUS_NOERROR != m_status) { return(false); } return(true); }
public void SendReceiveHighLevelApi() { try { System.IO.File.Copy(@"..\..\..\J2534Mock\Debug\J2534Mock.dll", "J2534Mock.dll"); } catch (System.IO.IOException ex) { Debug.WriteLine(ex.ToString()); } try { System.IO.File.Copy(@"..\..\..\J2534Mock\Debug\J2534Mock.pdb", "J2534Mock.pdb"); } catch (System.IO.IOException ex) { Debug.WriteLine(ex.ToString()); } Debug.WriteLine("Opening device"); //PassThruDevice device = PassThruDevice.GetInstance(new OpenPort20()); PassThruDevice device = PassThruDevice.GetInstance(new MockPassThru()); device.Open(); Debug.WriteLine("Opening channel"); PassThruChannel channel = device.OpenChannel( PassThruProtocol.Iso9141, PassThruConnectFlags.Iso9141NoChecksum, PassThruBaudRate.Rate4800); Debug.WriteLine("Initializing channel for SSM"); channel.InitializeSsm(); byte[] messageBytes = new byte[] { 0x80, 0x10, 0xF0, 0x01, 0xBF, 0x40 }; PassThruMsg initRequestMsg = new PassThruMsg(PassThruProtocol.Iso9141); initRequestMsg.ProtocolID = PassThruProtocol.Iso9141; initRequestMsg.DataSize = (UInt32)messageBytes.Length; for (int i = 0; i < messageBytes.Length; i++) { initRequestMsg.Data[i] = messageBytes[i]; } PassThruMsg[] initRequestMsgs = new PassThruMsg[] { initRequestMsg }; UInt32 numMsgs = 1; Debug.WriteLine("Sending SSM init message"); channel.WriteMessages(initRequestMsgs, ref numMsgs, TimeSpan.FromMilliseconds(1000)); PassThruMsg received = new PassThruMsg(PassThruProtocol.Iso9141); Debug.WriteLine("Waiting for SSM init response"); channel.ReadMessage( received, TimeSpan.FromMilliseconds(1000)); Debug.WriteLine("Closing channel"); channel.Close(); Debug.WriteLine("Closing device"); device.Close(); }
private bool ReadObdPid(byte mode, byte pid, ProtocolID protocolId, ref List <byte> value) { List <PassThruMsg> rxMsgs = new List <PassThruMsg>(); PassThruMsg txMsg = new PassThruMsg(); int timeout; txMsg.ProtocolID = protocolId; switch (protocolId) { case ProtocolID.ISO15765: txMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; if (mode == 0x03 || mode == 0x04) { txMsg.Data = new byte[] { 0x00, 0x00, 0x07, 0xdf, mode }; } else { txMsg.Data = new byte[] { 0x00, 0x00, 0x07, 0xdf, mode, pid }; } timeout = 50; break; case ProtocolID.J1850PWM: case ProtocolID.J1850VPW: case ProtocolID.ISO9141: case ProtocolID.ISO14230: byte protocolByte = (byte)((protocolId == ProtocolID.J1850PWM) ? 0x61 : 0x68); txMsg.TxFlags = TxFlag.NONE; txMsg.Data = new byte[] { protocolByte, 0x6A, 0xF1, mode, pid }; timeout = 100; break; default: return(false); } m_j2534Interface.ClearRxBuffer(m_channelId); int numMsgs = 1; m_status = m_j2534Interface.WriteMsgs(m_channelId, ref txMsg, ref numMsgs, timeout); if (J2534Err.STATUS_NOERROR != m_status) { return(false); } numMsgs = 1; while (J2534Err.STATUS_NOERROR == m_status) { m_status = m_j2534Interface.ReadMsgs(m_channelId, ref rxMsgs, ref numMsgs, timeout * 4); } if (J2534Err.ERR_BUFFER_EMPTY == m_status || J2534Err.ERR_TIMEOUT == m_status) { if (rxMsgs.Count > 1) { // Select the last value value = rxMsgs[rxMsgs.Count - 1].Data.ToList(); value.RemoveRange(0, txMsg.Data.Length); return(true); } return(false); } return(false); }
/* * * Example 2: * Use the J2534 protocol to send and receive a message (w/o error checking) * */ private void SendReceiveNoErrorChecking(object sender, EventArgs e) { J2534Extended passThru = new J2534Extended(); // Find all of the installed J2534 passthru devices List <J2534Device> availableJ2534Devices = J2534Detect.ListDevices(); J2534Device j2534Device; var sd = new SelectDevice(); if (sd.ShowDialog() == DialogResult.OK) { j2534Device = sd.Device; } else { return; } // We will always choose the first J2534 device in the list, if there are multiple devices // installed, you should do something more intelligent. passThru.LoadLibrary(j2534Device); // Attempt to open a communication link with the pass thru device int deviceId = 0; passThru.PassThruOpen(IntPtr.Zero, ref deviceId); // Open a new channel configured for ISO15765 (CAN) int channelId = 0; passThru.PassThruConnect(deviceId, ProtocolID.ISO15765, ConnectFlag.NONE, BaudRate.ISO15765, ref channelId); // Set up a message filter to watch for response messages int filterId = 0; PassThruMsg maskMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0xff, 0xff, 0xff, 0xff }); PassThruMsg patternMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, 0xE8 }); PassThruMsg flowControlMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, 0xE0 }); IntPtr maskMsgPtr = maskMsg.ToIntPtr(); IntPtr patternMsgPtr = patternMsg.ToIntPtr(); IntPtr flowControlMsgPtr = flowControlMsg.ToIntPtr(); passThru.PassThruStartMsgFilter(channelId, FilterType.FLOW_CONTROL_FILTER, maskMsgPtr, patternMsgPtr, flowControlMsgPtr, ref filterId); // Clear out the response buffer so we know we're getting the freshest possible data passThru.ClearRxBuffer(channelId); // Finally we can send the message! PassThruMsg txMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, 0xdf, 0x01, 0x00 }); var txMsgPtr = txMsg.ToIntPtr(); int numMsgs = 1; passThru.PassThruWriteMsgs(channelId, txMsgPtr, ref numMsgs, 50); // Read messages in a loop until we either timeout or we receive data numMsgs = 1; IntPtr rxMsgs = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PassThruMsg)) * numMsgs); J2534Err status = J2534Err.STATUS_NOERROR; while (J2534Err.STATUS_NOERROR == status) { status = passThru.PassThruReadMsgs(channelId, rxMsgs, ref numMsgs, 200); } // If we received data, we want to extract the data of interest. I'm removing the reflection of the transmitted message. if ((J2534Err.ERR_BUFFER_EMPTY == status || J2534Err.ERR_TIMEOUT == status) && numMsgs > 0) { foreach (PassThruMsg msg in rxMsgs.AsList <PassThruMsg>(numMsgs)) { // // // Now do something with the data! // // } } // Disconnect this channel passThru.PassThruDisconnect(channelId); // When we are done with the device, we can free the library. passThru.FreeLibrary(); }
/* * * Example 2: * Use the J2534 protocol to send and receive a message (w/o error checking) * */ private void SendReceiveNoErrorChecking(object sender, EventArgs e) { J2534 passThru = new J2534(); // Find all of the installed J2534 passthru devices List <J2534Device> availableJ2534Devices = J2534Detect.ListDevices(); // We will always choose the first J2534 device in the list, if there are multiple devices // installed, you should do something more intelligent. passThru.LoadLibrary(availableJ2534Devices[0]); // Attempt to open a communication link with the pass thru device int deviceId = 0; passThru.Open(ref deviceId); // Open a new channel configured for ISO15765 (CAN) int channelId = 0; passThru.Connect(deviceId, ProtocolID.ISO15765, ConnectFlag.NONE, BaudRate.ISO15765, ref channelId); // Set up a message filter to watch for response messages int filterId = 0; PassThruMsg maskMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0xff, 0xff, 0xff, 0xff }); PassThruMsg patternMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, 0xE8 }); PassThruMsg flowControlMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, 0xE0 }); passThru.StartMsgFilter(channelId, FilterType.FLOW_CONTROL_FILTER, ref maskMsg, ref patternMsg, ref flowControlMsg, ref filterId); // Clear out the response buffer so we know we're getting the freshest possible data passThru.ClearRxBuffer(channelId); // Finally we can send the message! PassThruMsg txMsg = new PassThruMsg( ProtocolID.ISO15765, TxFlag.ISO15765_FRAME_PAD, new byte[] { 0x00, 0x00, 0x07, 0xdf, 0x01, 0x00 }); int numMsgs = 1; passThru.WriteMsgs(channelId, ref txMsg, ref numMsgs, 50); // Read messages in a loop until we either timeout or we receive data List <PassThruMsg> rxMsgs = new List <PassThruMsg>(); J2534Err status = J2534Err.STATUS_NOERROR; numMsgs = 1; while (J2534Err.STATUS_NOERROR == status) { status = passThru.ReadMsgs(channelId, ref rxMsgs, ref numMsgs, 200); } // If we received data, we want to extract the data of interest. I'm removing the reflection of the transmitted message. List <byte> responseData; if ((J2534Err.ERR_BUFFER_EMPTY == status || J2534Err.ERR_TIMEOUT == status) && rxMsgs.Count > 1) { responseData = rxMsgs[rxMsgs.Count - 1].Data.ToList(); responseData.RemoveRange(0, txMsg.Data.Length); } // // // Now do something with the data! // // // Disconnect this channel passThru.Disconnect(channelId); // When we are done with the device, we can free the library. passThru.FreeLibrary(); }
static void Main(string[] args) { if (args.Length == 0) { PrintUsage(); return; } string mode = args[0]; IPassThru implementation = null; if (mode.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { implementation = DynamicPassThru.GetInstance(mode); } else if (mode == "mock") { //Copy("J2534Mock.dll"); //Copy("J2534Mock.pdb"); implementation = new MockPassThru(); } else if (mode == "op") { implementation = new OpenPort20PassThru(); } else { PrintUsage(); return; } Console.WriteLine("Opening device"); PassThruDevice device = PassThruDevice.GetInstance(implementation); device.Open(); Console.WriteLine("Opening channel"); PassThruChannel channel = device.OpenChannel( PassThruProtocol.Iso9141, PassThruConnectFlags.Iso9141NoChecksum, PassThruBaudRate.Rate4800); Console.WriteLine("Initializing channel for SSM"); channel.InitializeSsm(); byte[] messageBytes = new byte[] { 0x80, 0x10, 0xF0, 0x01, 0xBF, 0x40 }; PassThruMsg initRequestMsg = new PassThruMsg(PassThruProtocol.Iso9141); initRequestMsg.ProtocolID = PassThruProtocol.Iso9141; initRequestMsg.DataSize = (UInt32)messageBytes.Length; for (int i = 0; i < messageBytes.Length; i++) { initRequestMsg.Data[i] = messageBytes[i]; } //PassThruMsg[] initRequestMsgs = new PassThruMsg[] { initRequestMsg }; //UInt32 numMsgs = 1; Console.WriteLine("Sending SSM init message"); channel.WriteMessage(initRequestMsg, TimeSpan.FromMilliseconds(1000)); PassThruMsg received = new PassThruMsg(PassThruProtocol.Iso9141); //PassThruMsg[] receivedMessages = new PassThruMsg[] { received }; //UInt32 numMsgs = 1; Console.WriteLine("Waiting for SSM init response"); bool success = channel.ReadMessage( received, TimeSpan.FromMilliseconds(1000)); Console.WriteLine("ReadMessage success: " + success); Console.WriteLine("SSM init response:"); string response = BitConverter.ToString(received.Data, 0, (int)received.DataSize); Console.WriteLine(response); Console.WriteLine("Closing channel"); channel.Close(); Console.WriteLine("Closing device"); device.Close(); implementation.Dispose(); }
public void SendReceiveLowLevelApi() { UInt32 deviceID; Int32 status = NativeOpenPort20.PassThruOpen(null, out deviceID); TraceStatus("PassThruOpen", status); Trace.WriteLine("Device ID: " + deviceID); UInt32 channelID; status = NativeOpenPort20.PassThruConnect( deviceID, (UInt32)PassThruProtocol.Iso9141, (UInt32)PassThruConnectFlags.Iso9141NoChecksum, (UInt32)PassThruBaudRate.Rate4800, out channelID); TraceStatus("PassThruConnect", status); Trace.WriteLine("Channel ID: " + channelID); SetConfiguration P1Max = new SetConfiguration(SetConfigurationParameter.P1Max, 2); SetConfiguration P3Min = new SetConfiguration(SetConfigurationParameter.P3Min, 0); SetConfiguration P4Min = new SetConfiguration(SetConfigurationParameter.P4Min, 0); SetConfiguration Terminator = new SetConfiguration(SetConfigurationParameter.FinalParam, 0); // TODO: add loopback=1 SetConfiguration[] setConfigurationArray = new SetConfiguration[] { P1Max, P3Min, P4Min }; using (SetConfigurationList setConfigurationList = new SetConfigurationList(setConfigurationArray)) //IntPtr buffer = Marshal.AllocCoTaskMem(Marshal.SizeOf(SetConfiguration) * setConfigurationArray.Length); //IntPtr buffer = Marshal.AllocCoTaskMem(Marshal.SizeOf(setConfigurationList)); //{ status = NativeOpenPort20.PassThruIoctl( channelID, PassThruIOControl.SetConfig, ref setConfigurationArray,//setConfigurationList.Pointer, IntPtr.Zero); //} //Marshal.FreeCoTaskMem(buffer); TraceStatus("PassThruIoCtl SetConfig", status); UInt32 filterID; PassThruMsg maskMsg = new PassThruMsg(PassThruProtocol.Iso9141); //maskMsg.ExtraDataIndex = 1; maskMsg.DataSize = 1; status = NativeOpenPort20.PassThruStartMsgFilter( channelID, (UInt32)PassThruFilterType.Pass, maskMsg, maskMsg, null, out filterID); TraceStatus("PassThruStartMsgFilter", status); Trace.WriteLine("Filter ID: " + filterID); byte[] messageBytes = new byte[] { 0x80, 0x10, 0xF0, 0x01, 0xBF, 0x40 }; PassThruMsg initRequestMsg = new PassThruMsg(PassThruProtocol.Iso9141); initRequestMsg.ProtocolID = PassThruProtocol.Iso9141; initRequestMsg.DataSize = (UInt32)messageBytes.Length; for (int i = 0; i < messageBytes.Length; i++) { initRequestMsg.Data[i] = messageBytes[i]; } PassThruMsg[] initRequestMsgs = new PassThruMsg[] { initRequestMsg }; UInt32 numMsgs = 1; status = NativeOpenPort20.PassThruWriteMsgs( channelID, initRequestMsgs, ref numMsgs, 500); TraceStatus("PassThruWriteMsgs", status); PassThruMsg received = new PassThruMsg(PassThruProtocol.Iso9141); PassThruMsg[] receivedMessages = new PassThruMsg[] { received }; numMsgs = 1; status = NativeOpenPort20.PassThruReadMsgs( channelID, receivedMessages, ref numMsgs, 500); TraceStatus("PassThruReadMsgs", status); if (status == (UInt32)PassThruStatus.NoError) { for (int i = 0; i < received.DataSize; i++) { Trace.Write(received.Data[i].ToString()); Trace.Write(' '); } } status = NativeOpenPort20.PassThruDisconnect(channelID); TraceStatus("PassThruDisconnect", status); status = NativeOpenPort20.PassThruClose(deviceID); TraceStatus("PassThruClose", status); }
private bool ReadObdPid(byte mode, byte pid, ProtocolID protocolId, ref List <byte> value) { PassThruMsg txMsg = new PassThruMsg(); int timeout; txMsg.ProtocolID = protocolId; switch (protocolId) { case ProtocolID.ISO15765: txMsg.TxFlags = TxFlag.ISO15765_FRAME_PAD; if (mode == 0x03 || mode == 0x04) { txMsg.SetBytes(new byte[] { 0x00, 0x00, 0x07, 0xdf, mode }); } else { txMsg.SetBytes(new byte[] { 0x00, 0x00, 0x07, 0xdf, mode, pid }); } timeout = 50; break; case ProtocolID.J1850PWM: case ProtocolID.J1850VPW: case ProtocolID.ISO9141: case ProtocolID.ISO14230: byte protocolByte = (byte)((protocolId == ProtocolID.J1850PWM) ? 0x61 : 0x68); txMsg.TxFlags = TxFlag.NONE; txMsg.SetBytes(new byte[] { protocolByte, 0x6A, 0xF1, mode, pid }); timeout = 100; break; default: return(false); } m_j2534Interface.ClearRxBuffer(m_channelId); int numMsgs = 1; m_status = m_j2534Interface.PassThruWriteMsgs(m_channelId, txMsg.ToIntPtr(), ref numMsgs, timeout); if (J2534Err.STATUS_NOERROR != m_status) { return(false); } IntPtr rxMsgs = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PassThruMsg)) * numMsgs); numMsgs = 1; while (J2534Err.STATUS_NOERROR == m_status) { m_status = m_j2534Interface.PassThruReadMsgs(m_channelId, rxMsgs, ref numMsgs, timeout * 4); } if (J2534Err.ERR_BUFFER_EMPTY == m_status || J2534Err.ERR_TIMEOUT == m_status) { if (numMsgs > 0) { // Select the last value PassThruMsg msg = rxMsgs.AsMsgList(numMsgs).Last(); value = msg.GetBytes().ToList(); value.RemoveRange(0, txMsg.GetBytes().Length); return(true); } return(false); } return(false); }
/// <summary> /// </summary> /// <returns>OpenResult.OK is returned on success. Otherwise OpenResult.OpenError is /// returned.</returns> override public OpenResult open() { if (isOpen()) { close(); } m_deviceId = 0; m_status = passThru.PassThruOpen(IntPtr.Zero, ref m_deviceId); if (m_status != J2534Err.STATUS_NOERROR) { return(OpenResult.OpenError); } m_readThread = new Thread(readMessages) { Name = "J2534CANDevice.m_readThread" }; m_endThread = false; if (TrionicECU == API.ECU.TRIONIC5) { m_status = passThru.PassThruConnect(m_deviceId, ProtocolID.CAN, ConnectFlag.NONE, BaudRate.CAN_615000, ref m_channelId); } else { m_status = passThru.PassThruConnect(m_deviceId, ProtocolID.CAN, ConnectFlag.NONE, BaudRate.CAN_500000, ref m_channelId); } if (J2534Err.STATUS_NOERROR != m_status) { return(OpenResult.OpenError); } uint acpFilt = 0xFFFF; uint acpMask = 0x0000; foreach (var id in AcceptOnlyMessageIds) { acpFilt &= id; acpMask |= id; } acpMask = (~acpMask & 0x7FF) | acpFilt; logger.Debug("Filter: " + acpFilt.ToString("X8")); logger.Debug("Mask: " + acpMask.ToString("X8")); byte[] maskBytes = new byte[4]; byte[] patternBytes = new byte[4]; for (int i = 0; i < 4; i++) { maskBytes[i] = (byte)(acpMask >> (i * 8)); patternBytes[i] = (byte)(acpFilt >> (i * 8)); } //PassThruMsg maskMsg = new PassThruMsg(ProtocolID.CAN, TxFlag.NONE, maskBytes); //PassThruMsg patternMsg = new PassThruMsg(ProtocolID.CAN, TxFlag.NONE, patternBytes); PassThruMsg maskMsg = new PassThruMsg(ProtocolID.CAN, TxFlag.NONE, new byte[] { 0x00, 0x00, 0x00, 0x00 }); PassThruMsg patternMsg = new PassThruMsg(ProtocolID.CAN, TxFlag.NONE, new byte[] { 0x00, 0x00, 0x00, 0x00 }); int filterId = 0; m_status = passThru.PassThruStartMsgFilter( m_channelId, FilterType.PASS_FILTER, maskMsg.ToIntPtr(), patternMsg.ToIntPtr(), IntPtr.Zero, ref filterId); if (J2534Err.STATUS_NOERROR != m_status) { return(OpenResult.OpenError); } m_status = passThru.PassThruIoctl(m_channelId, (int)Ioctl.CLEAR_RX_BUFFER, IntPtr.Zero, IntPtr.Zero); if (J2534Err.STATUS_NOERROR != m_status) { return(OpenResult.OpenError); } logger.Debug("P bus connected"); if (m_readThread.ThreadState == ThreadState.Unstarted) { m_readThread.Start(); } m_deviceIsOpen = true; return(OpenResult.OK); }