J2534 iso14230 (commaai#563)

* ISO14230

* ISO9141 (excluding 5 baud init)

* j2534 5 baud init

* disable unsupported pin select protocols

* update README for new installer

* cleanup

* cleanup

* J2534 windows registry ISO9141 flag

* make it easier to select dev J2534 driver

* update README with new installer

Author: gregjhogan

drivers/windows/.gitignore

@@ -304,3 +304,4 @@ __pycache__/
 
 # installer
 *.exe
+*.zip

drivers/windows/README.md

@@ -17,10 +17,9 @@ ______/\\\\\\\\\\\____/\\\\\\\\\_______/\\\\\\\\\\\\\\\______/\\\\\\\\\\________
                                                                                |_| (Code by Jessy Diamond Exum)
 ```
 
-
 # Installing J2534 driver:
 
-[Download](https://github.com/commaai/panda/files/4017364/panda.J2534.driver.install.zip)
+[Download](https://github.com/commaai/panda/files/4844692/panda.J2534.driver.install.zip)
 
 Depending on what version of windows you are on, you may need to separately install the WinUSB driver (see next section).
 
@@ -80,8 +79,8 @@ features.
 - [ ] **J1850PWM** *(Outdated, and not physically supported by the panda)*
 - [X] **CAN**
 - [X] **ISO15765**
-- [ ] **ISO9141** *(This protocol could be implemented if 5 BAUD init support is added to the panda.)*
-- [ ] **ISO14230/KWP2000** *(Could be supported with FAST init, 5baud init if panda adds support for 5bps serial)*
+- [X] **ISO9141**
+- [X] **ISO14230/KWP2000**
 
 # Building the Project:
 
@@ -116,7 +115,6 @@ code will not work, so without this file, the installer will refuse to build.
 
 - Apply a style-guide and consistent naming convention for Classes/Functions/Variables.
 - Send multiple messages (each with a different address) from a given connection at the same time.
-- Implement ISO14230/KWP2000 FAST (LIN communication is already supported with the raw panda USB driver).
 - Find more documentation about SW_CAN_PS (Single Wire CAN, aka GMLAN).
 - Find example of client using a _PS version of a protocol (PS is pin select, and may support using different CAN buses).
 

drivers/windows/pandaJ2534DLL/J2534Connection.cpp

@@ -7,7 +7,7 @@ J2534Connection::J2534Connection(
 	unsigned long ProtocolID,
 	unsigned long Flags,
 	unsigned long BaudRate
-) : panda_dev(panda_dev), ProtocolID(ProtocolID), Flags(Flags), BaudRate(BaudRate), port(0) { }
+) : panda_dev(panda_dev), ProtocolID(ProtocolID), Flags(Flags), BaudRate(BaudRate), Parity(0), port(0) { }
 
 unsigned long J2534Connection::validateTxMsg(PASSTHRU_MSG* msg) {
 	if (msg->DataSize < this->getMinMsgLen() || msg->DataSize > this->getMaxMsgLen())
@@ -60,7 +60,7 @@ long J2534Connection::PassThruReadMsgs(PASSTHRU_MSG *pMsg, unsigned long *pNumMs
 
 long J2534Connection::PassThruWriteMsgs(PASSTHRU_MSG *pMsg, unsigned long *pNumMsgs, unsigned long Timeout) {
 	//There doesn't seem to be much reason to implement the timeout here.
-	for (int msgnum = 0; msgnum < *pNumMsgs; msgnum++) {
+	for (unsigned int msgnum = 0; msgnum < *pNumMsgs; msgnum++) {
 		PASSTHRU_MSG* msg = &pMsg[msgnum];
 		if (msg->ProtocolID != this->ProtocolID) {
 			*pNumMsgs = msgnum;
@@ -87,7 +87,7 @@ long J2534Connection::PassThruStartPeriodicMsg(PASSTHRU_MSG *pMsg, unsigned long
 	if (pMsg->ProtocolID != this->ProtocolID) return ERR_MSG_PROTOCOL_ID;
 	if (TimeInterval < 5 || TimeInterval > 65535) return ERR_INVALID_TIME_INTERVAL;
 
-	for (int i = 0; i < this->periodicMessages.size(); i++) {
+	for (unsigned int i = 0; i < this->periodicMessages.size(); i++) {
 		if (periodicMessages[i] != nullptr) continue;
 
 		*pMsgID = i;
@@ -114,11 +114,11 @@ long J2534Connection::PassThruStopPeriodicMsg(unsigned long MsgID) {
 
 long J2534Connection::PassThruStartMsgFilter(unsigned long FilterType, PASSTHRU_MSG *pMaskMsg, PASSTHRU_MSG *pPatternMsg,
 	PASSTHRU_MSG *pFlowControlMsg, unsigned long *pFilterID) {
-	for (int i = 0; i < this->filters.size(); i++) {
+	for (unsigned int i = 0; i < this->filters.size(); i++) {
 		if (filters[i] == nullptr) {
 			try {
 				auto newfilter = std::make_shared<J2534MessageFilter>(this, FilterType, pMaskMsg, pPatternMsg, pFlowControlMsg);
-				for (int check_idx = 0; check_idx < filters.size(); check_idx++) {
+				for (unsigned int check_idx = 0; check_idx < filters.size(); check_idx++) {
 					if (filters[check_idx] == nullptr) continue;
 					if (filters[check_idx] == newfilter) {
 						filters[i] = nullptr;
@@ -147,28 +147,99 @@ long J2534Connection::PassThruIoctl(unsigned long IoctlID, void *pInput, void *p
 	return STATUS_NOERROR;
 }
 
-long J2534Connection::init5b(SBYTE_ARRAY* pInput, SBYTE_ARRAY* pOutput) { return ERR_FAILED; }
-long J2534Connection::initFast(PASSTHRU_MSG* pInput, PASSTHRU_MSG* pOutput) { return ERR_FAILED; }
+long J2534Connection::init5b(SBYTE_ARRAY* pInput, SBYTE_ARRAY* pOutput) {
+	if (pInput->NumOfBytes == 1) {
+		if (auto panda_ps = this->panda_dev.lock()) {
+			auto resp = panda_ps->kline_five_baud_init(pInput->BytePtr[0]);
+			if (resp.size() > 0) {
+				auto key_bytes = resp.c_str();
+				if (pOutput->NumOfBytes >= 1) {
+					pOutput->BytePtr[0] = key_bytes[0];
+				}
+				if (pOutput->NumOfBytes >= 2) {
+					pOutput->BytePtr[1] = key_bytes[1];
+				}
+				return STATUS_NOERROR;
+			}
+		}
+	}
+
+	return ERR_FAILED;
+}
+long J2534Connection::initFast(PASSTHRU_MSG* pInput, PASSTHRU_MSG* pOutput) {
+	if (auto panda_ps = this->panda_dev.lock()) {
+		auto start_comm = std::string((char*)pInput->Data, pInput->DataSize);
+		auto resp = panda_ps->kline_wakeup_start_comm(start_comm);
+		if (resp.size() > 0) {
+			pOutput->ProtocolID = pInput->ProtocolID;
+			pOutput->RxStatus = 0;
+			pOutput->TxFlags = 0;
+			pOutput->Timestamp = pInput->Timestamp;
+			pOutput->ExtraDataIndex = resp.size();
+			memcpy(pOutput->Data, resp.c_str(), resp.size());
+			pOutput->DataSize = resp.size();
+			return STATUS_NOERROR;
+		}
+	}
+
+	return ERR_FAILED;
+}
 long J2534Connection::clearTXBuff() {
 	if (auto panda_ps = this->panda_dev.lock()) {
 		synchronized(staged_writes_lock) {
 			this->txbuff = {};
-			panda_ps->panda->can_clear(panda::PANDA_CAN1_TX);
+			switch (this->ProtocolID)
+			{
+				case CAN:
+				case CAN_PS:
+				case ISO15765:
+				case ISO15765_PS:
+					panda_ps->panda->can_clear(panda::PANDA_CAN1_TX);
+					break;
+				case ISO9141:
+				case ISO9141_PS:
+				case ISO14230:
+				case ISO14230_PS:
+					panda_ps->panda->serial_clear(panda::SERIAL_LIN1);
+					panda_ps->panda->serial_clear(panda::SERIAL_LIN2);
+					break;
+				default:
+					break;
+			}
 		}
+		return STATUS_NOERROR;
 	}
-	return STATUS_NOERROR;
+	return ERR_FAILED;
 }
 long J2534Connection::clearRXBuff() {
 	if (auto panda_ps = this->panda_dev.lock()) {
 		synchronized(messageRxBuff_mutex) {
 			this->messageRxBuff = {};
-			panda_ps->panda->can_clear(panda::PANDA_CAN_RX);
+			switch (this->ProtocolID)
+			{
+			case CAN:
+			case CAN_PS:
+			case ISO15765:
+			case ISO15765_PS:
+				panda_ps->panda->can_clear(panda::PANDA_CAN_RX);
+				break;
+			case ISO9141:
+			case ISO9141_PS:
+			case ISO14230:
+			case ISO14230_PS:
+				panda_ps->panda->serial_clear(panda::SERIAL_LIN1);
+				panda_ps->panda->serial_clear(panda::SERIAL_LIN2);
+				break;
+			default:
+				break;
+			}
 		}
+		return STATUS_NOERROR;
 	}
-	return STATUS_NOERROR;
+	return ERR_FAILED;
 }
 long J2534Connection::clearPeriodicMsgs() {
-	for (int i = 0; i < this->periodicMessages.size(); i++) {
+	for (unsigned int i = 0; i < this->periodicMessages.size(); i++) {
 		if (periodicMessages[i] == nullptr) continue;
 		this->periodicMessages[i]->cancel();
 		this->periodicMessages[i] = nullptr;
@@ -185,6 +256,10 @@ void J2534Connection::setBaud(unsigned long baud) {
 	this->BaudRate = baud;
 }
 
+void J2534Connection::setParity(unsigned long parity) {
+	this->Parity = parity;
+}
+
 void J2534Connection::schedultMsgTx(std::shared_ptr<Action> msgout) {
 	if (auto panda_ps = this->panda_dev.lock()) {
 		synchronized(staged_writes_lock) {
@@ -226,6 +301,9 @@ void J2534Connection::processIOCTLSetConfig(unsigned long Parameter, unsigned lo
 	case LOOPBACK:			// 0 (OFF), 1 (ON) [0]
 		this->loopback = (Value != 0);
 		break;
+	case PARITY:
+		this->setParity(Value);
+		break;
 	case ISO15765_WFT_MAX:
 		break;
 	case NODE_ADDRESS:		// J1850PWM Related (Not supported by panda). HDS requires these to 'work'.
@@ -247,7 +325,6 @@ void J2534Connection::processIOCTLSetConfig(unsigned long Parameter, unsigned lo
 	case TIDLE:
 	case TINIL:
 	case TWUP:
-	case PARITY:
 	case T1_MAX:			// SCI related options. The panda does not appear to support this
 	case T2_MAX:
 	case T3_MAX:
@@ -259,9 +336,9 @@ void J2534Connection::processIOCTLSetConfig(unsigned long Parameter, unsigned lo
 	}
 
 	// reserved parameters usually mean special equiptment is required
-	if (Parameter >= 0x20) {
-		throw ERR_NOT_SUPPORTED;
-	}
+	//if (Parameter >= 0x20) {
+	//	throw ERR_NOT_SUPPORTED;
+	//}
 }
 
 unsigned long J2534Connection::processIOCTLGetConfig(unsigned long Parameter) {

drivers/windows/pandaJ2534DLL/J2534Connection.h

@@ -51,14 +51,15 @@ class J2534Connection : public std::enable_shared_from_this<J2534Connection> {
 
 	//IOCTL functions
 
-	long init5b(SBYTE_ARRAY* pInput, SBYTE_ARRAY* pOutput);
-	long initFast(PASSTHRU_MSG* pInput, PASSTHRU_MSG* pOutput);
+	virtual long init5b(SBYTE_ARRAY* pInput, SBYTE_ARRAY* pOutput);
+	virtual long initFast(PASSTHRU_MSG* pInput, PASSTHRU_MSG* pOutput);
 	long clearTXBuff();
 	long clearRXBuff();
 	long clearPeriodicMsgs();
 	long clearMsgFilters();
 
 	virtual void setBaud(unsigned long baud);
+	virtual void setParity(unsigned long parity);
 
 	unsigned long getBaud() {
 		return this->BaudRate;
@@ -124,6 +125,7 @@ class J2534Connection : public std::enable_shared_from_this<J2534Connection> {
 	unsigned long ProtocolID;
 	unsigned long Flags;
 	unsigned long BaudRate;
+	unsigned long Parity;
 	unsigned long port;
 
 	std::weak_ptr<PandaJ2534Device> panda_dev;

drivers/windows/pandaJ2534DLL/J2534Connection_ISO14230.cpp

@@ -0,0 +1,83 @@
+#include "stdafx.h"
+#include "J2534Connection_ISO14230.h"
+#include "MessageTx_ISO14230.h"
+#include "Timer.h"
+
+J2534Connection_ISO14230::J2534Connection_ISO14230(
+        std::shared_ptr<PandaJ2534Device> panda_dev,
+        unsigned long ProtocolID,
+        unsigned long Flags,
+        unsigned long BaudRate
+    ) : J2534Connection(panda_dev, ProtocolID, Flags, BaudRate) {
+    this->port = 0;
+
+    if (BaudRate % 100 || BaudRate < 2400 || BaudRate > 115200)
+        throw ERR_INVALID_BAUDRATE;
+
+    panda_dev->panda->set_uart_baud(panda::SERIAL_LIN1, BaudRate);
+    panda_dev->panda->set_uart_baud(panda::SERIAL_LIN2, BaudRate);
+};
+
+unsigned long J2534Connection_ISO14230::validateTxMsg(PASSTHRU_MSG* msg) {
+    if (msg->DataSize < this->getMinMsgLen() || msg->DataSize > this->getMaxMsgLen())
+        return ERR_INVALID_MSG;
+    return STATUS_NOERROR;
+}
+
+std::shared_ptr<MessageTx> J2534Connection_ISO14230::parseMessageTx(PASSTHRU_MSG& msg) {
+    return std::dynamic_pointer_cast<MessageTx>(std::make_shared<MessageTx_ISO14230>(shared_from_this(), msg));
+}
+
+void J2534Connection_ISO14230::setBaud(unsigned long BaudRate) {
+    if (auto panda_dev = this->getPandaDev()) {
+        if (BaudRate % 100 || BaudRate < 2400 || BaudRate > 115200)
+            throw ERR_NOT_SUPPORTED;
+
+        panda_dev->panda->set_uart_baud(panda::SERIAL_LIN1, BaudRate);
+        panda_dev->panda->set_uart_baud(panda::SERIAL_LIN2, BaudRate);
+        return J2534Connection::setBaud(BaudRate);
+    } else {
+        throw ERR_DEVICE_NOT_CONNECTED;
+    }
+}
+
+void J2534Connection_ISO14230::setParity(unsigned long Parity) {
+    if (auto panda_dev = this->getPandaDev()) {
+        panda::PANDA_SERIAL_PORT_PARITY parity;
+        switch (Parity) {
+            case 0:
+                parity = panda::PANDA_PARITY_OFF;
+                break;
+            case 1:
+                parity = panda::PANDA_PARITY_ODD;
+                break;
+            case 2:
+                parity = panda::PANDA_PARITY_EVEN;
+                break;
+            default:
+                throw ERR_NOT_SUPPORTED;
+        }
+        panda_dev->panda->set_uart_parity(panda::SERIAL_LIN1, parity);
+        panda_dev->panda->set_uart_parity(panda::SERIAL_LIN2, parity);
+        return J2534Connection::setParity(Parity);
+    }
+    else {
+        throw ERR_DEVICE_NOT_CONNECTED;
+    }
+}
+
+void J2534Connection_ISO14230::processMessage(const J2534Frame& msg) {
+    FILTER_RESULT filter_res = FILTER_RESULT_NEUTRAL;
+
+    for (auto filter : this->filters) {
+        if (filter == nullptr) continue;
+        FILTER_RESULT current_check_res = filter->check(msg);
+        if (current_check_res == FILTER_RESULT_BLOCK) return;
+        if (current_check_res == FILTER_RESULT_PASS) filter_res = FILTER_RESULT_PASS;
+    }
+
+    if (filter_res == FILTER_RESULT_PASS) {
+        addMsgToRxQueue(J2534Frame(msg.ProtocolID, START_OF_MESSAGE, 0, 0));
+        addMsgToRxQueue(msg);
+    }
+}

drivers/windows/pandaJ2534DLL/J2534Connection_ISO14230.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "J2534Connection.h"
+#include "panda_shared/panda.h"
+
+class J2534Connection_ISO14230 : public J2534Connection {
+public:
+    J2534Connection_ISO14230(
+        std::shared_ptr<PandaJ2534Device> panda_dev,
+        unsigned long ProtocolID,
+        unsigned long Flags,
+        unsigned long BaudRate
+    );
+
+    virtual unsigned long validateTxMsg(PASSTHRU_MSG* msg);
+
+    virtual std::shared_ptr<MessageTx> parseMessageTx(PASSTHRU_MSG& pMsg);
+
+    virtual void setBaud(unsigned long baud);
+    virtual void setParity(unsigned long Parity);
+
+    virtual unsigned long getMinMsgLen() {
+        return 2;
+    }
+
+    virtual unsigned long getMaxMsgLen() {
+        return KLINE_MSG_MAX_LEN;
+    }
+
+    virtual unsigned long getMaxMsgSingleFrameLen() {
+        return KLINE_MSG_MAX_LEN;
+    }
+
+    virtual bool isProtoCan() {
+        return FALSE;
+    }
+
+    virtual void processMessage(const J2534Frame& msg);
+};

drivers/windows/pandaJ2534DLL/J2534Frame.h

@@ -18,10 +18,20 @@ class J2534Frame {
 		Data += msg_in.addr & 0xFF;
 		Data += std::string((char*)&msg_in.dat, msg_in.len);
 		Timestamp = msg_in.recv_time;
+		TxFlags = 0;
 		RxStatus = (msg_in.addr_29b ? CAN_29BIT_ID : 0) |
 			(msg_in.is_receipt ? TX_MSG_TYPE : 0);
 	}
 
+	J2534Frame(unsigned long protocol, const panda::PANDA_KLINE_MSG& msg_in) {
+		ProtocolID = protocol;
+		ExtraDataIndex = msg_in.data.size() - (msg_in.valid ? 1 : 0);
+		Data = msg_in.data;
+		Timestamp = 0;
+		TxFlags = 0;
+		RxStatus = 0;
+	}
+
 	J2534Frame(const PASSTHRU_MSG& msg) {
 		this->ProtocolID = msg.ProtocolID;
 		this->RxStatus = msg.RxStatus;