Michel2/Seeed_Arduino_CAN
1
0
Fork 0
mirror of https://github.com/Seeed-Studio/Seeed_Arduino_CAN.git synced 2026-07-28 04:06:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update: sync code from https://github.com/latonita/arduino-canbus-monitor

Browse Source
This commit is contained in:
turmary
2021-01-29 16:16:46 +08:00
parent 7c195a14ed
commit 3dea108ee3
3 changed files with 316 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/canbus-monitor/can-serial.cpp
+210 -208
View File
@@ -1,6 +1,6 @@
/*****************************************************************************************
* This is implementation of CAN BUS ASCII protocol based on LAWICEL v1.3 serial protocol
* of CanSerial/CANUSB device (http://www.CanSerial.com/docs/CanSerial_v3.pdf)
* of CAN232/CANUSB device (http://www.can232.com/docs/can232_v3.pdf)
*
* Made for Arduino with Seeduino/ElecFreaks CAN BUS Shield based on MCP2515
*
@@ -41,359 +41,361 @@
//#define debug Serial
#endif
CanSerial* CanSerial::_instance = 0;
Can232* Can232::_instance = 0;
CanSerial* CanSerial::instance() {
Can232* Can232::instance() {
if (_instance == 0)
_instance = new CanSerial();
_instance = new Can232();
return _instance;
}
void CanSerial::init(INT8U defaultCanSpeed, const INT8U clock) {
dbg_begin(LWUART_DEFAULT_BAUD_RATE); // logging through software serial
void Can232::init(INT8U defaultCanSpeed, const INT8U clock) {
dbg_begin(LW232_DEFAULT_BAUD_RATE); // logging through software serial
dbg1("CAN ASCII. Welcome to debug");
instance()->LWUARTCanSpeedSelection = defaultCanSpeed;
instance()->LWUARTMcpModuleClock = clock;
instance()->lw232CanSpeedSelection = defaultCanSpeed;
instance()->lw232McpModuleClock = clock;
instance()->initFunc();
}
MCP_CAN * CanSerial::LWUARTCAN = NULL;
void CanSerial::init(MCP_CAN *CAN) {
LWUARTCAN = CAN;
MCP_CAN* Can232::MCP_OBJECT = NULL;
void Can232::init(MCP_CAN *CAN) {
MCP_OBJECT = CAN;
#define lw232CAN (*MCP_OBJECT)
}
void CanSerial::setFilter(INT8U (*userFunc)(INT32U)) {
void Can232::setFilter(INT8U (*userFunc)(INT32U)) {
instance()->setFilterFunc(userFunc);
}
void CanSerial::loop() {
void Can232::loop() {
instance()->loopFunc();
}
void CanSerial::serialEvent() {
void Can232::serialEvent() {
instance()->serialEventFunc();
}
void CanSerial::initFunc() {
if (!inputString.reserve(LWUART_INPUT_STRING_BUFFER_SIZE)) {
void Can232::initFunc() {
if (!inputString.reserve(LW232_INPUT_STRING_BUFFER_SIZE)) {
dbg0("inputString.reserve failed in initFunc. less optimal String work is expected");
}
// LWUARTAutoStart = true; //todo: read from eeprom
// LWUARTAutoPoll = false; //todo: read from eeprom
// LWUARTTimeStamp = //read from eeprom
// LWUARTMessage[0] = 'Z'; LWUARTMessage[1] = '1'; exec();
//if (LWUARTAutoStart) {
// lw232AutoStart = true; //todo: read from eeprom
// lw232AutoPoll = false; //todo: read from eeprom
// lw232TimeStamp = //read from eeprom
// lw232Message[0] = 'Z'; lw232Message[1] = '1'; exec();
//if (lw232AutoStart) {
inputString = "O\0x0D";
stringComplete = true;
loopFunc();
//}
}
void CanSerial::setFilterFunc(INT8U (*userFunc)(INT32U)) {
void Can232::setFilterFunc(INT8U (*userFunc)(INT32U)) {
instance()->userAddressFilterFunc = userFunc;
}
void CanSerial::loopFunc() {
void Can232::loopFunc() {
if (stringComplete) {
int len = inputString.length();
if (len > 0 && len < LWUART_FRAME_MAX_SIZE) {
strcpy((char*)LWUARTMessage, inputString.c_str());
unsigned len = inputString.length();
if (len > 0 && len < LW232_FRAME_MAX_SIZE) {
strcpy((char*)lw232Message, inputString.c_str());
exec();
}
// clear the string:
inputString = "";
stringComplete = false;
}
if (LWUARTCanChannelMode != LWUART_STATUS_CAN_CLOSED) {
if (lw232CanChannelMode != LW232_STATUS_CAN_CLOSED) {
int recv = 0;
while (CAN_MSGAVAIL == checkReceive() && recv++<5) {
dbg0('+');
if (CAN_OK == receiveSingleFrame()) {
Serial.write(LWUART_CR);
Serial.write(LW232_CR);
}
}
Serial.flush();
}
}
void CanSerial::serialEventFunc() {
void Can232::serialEventFunc() {
while (Serial.available()) {
char inChar = (char)Serial.read();
inputString += inChar;
if (inChar == LWUART_CR) {
if (inChar == LW232_CR) {
stringComplete = true;
}
}
}
INT8U CanSerial::exec() {
INT8U Can232::exec() {
dbg2("Command received:", inputString);
LWUARTLastErr = parseAndRunCommand();
switch (LWUARTLastErr) {
case LWUART_OK:
Serial.write(LWUART_RET_ASCII_OK);
lw232LastErr = parseAndRunCommand();
switch (lw232LastErr) {
case LW232_OK:
Serial.write(LW232_RET_ASCII_OK);
break;
case LWUART_OK_SMALL:
Serial.write(LWUART_RET_ASCII_OK_SMALL);
Serial.write(LWUART_RET_ASCII_OK);
case LW232_OK_SMALL:
Serial.write(LW232_RET_ASCII_OK_SMALL);
Serial.write(LW232_RET_ASCII_OK);
break;
case LWUART_OK_BIG:
Serial.write(LWUART_RET_ASCII_OK_BIG);
Serial.write(LWUART_RET_ASCII_OK);
case LW232_OK_BIG:
Serial.write(LW232_RET_ASCII_OK_BIG);
Serial.write(LW232_RET_ASCII_OK);
break;
case LWUART_ERR_NOT_IMPLEMENTED:
case LW232_ERR_NOT_IMPLEMENTED:
// Choose behavior: will it fail or not when not implemented command comes in. Some can monitors might be affected by this selection.
Serial.write(LWUART_RET_ASCII_ERROR);
//Serial.write(LWUART_RET_ASCII_OK);
Serial.write(LW232_RET_ASCII_ERROR);
//Serial.write(LW232_RET_ASCII_OK);
break;
default:
Serial.write(LWUART_RET_ASCII_ERROR);
Serial.write(LW232_RET_ASCII_ERROR);
}
return 0;
}
INT8U CanSerial::parseAndRunCommand() {
INT8U ret = LWUART_OK;
INT8U Can232::parseAndRunCommand() {
INT8U ret = LW232_OK;
INT8U idx = 0;
INT8U err = 0;
LWUARTLastErr = LWUART_OK;
lw232LastErr = LW232_OK;
switch (LWUARTMessage[0]) {
case LWUART_CMD_SETUP:
switch (lw232Message[0]) {
case LW232_CMD_SETUP:
// Sn[CR] Setup with standard CAN bit-rates where n is 0-9.
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_CLOSED) {
idx = HexHelper::parseNibbleWithLimit(LWUARTMessage[1], LWUART_CAN_BAUD_NUM);
LWUARTCanSpeedSelection = idx; //todo
if (lw232CanChannelMode == LW232_STATUS_CAN_CLOSED) {
idx = HexHelper::parseNibbleWithLimit(lw232Message[1], LW232_CAN_BAUD_NUM);
lw232CanSpeedSelection = lw232CanBaudRates[idx];
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_SETUP_BTR:
case LW232_CMD_SETUP_BTR:
// sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex value.
ret = LWUART_ERR; break;
case LWUART_CMD_OPEN:
ret = LW232_ERR; break;
case LW232_CMD_OPEN:
// O[CR] Open the CAN channel in normal mode (sending & receiving).
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_CLOSED) {
if (lw232CanChannelMode == LW232_STATUS_CAN_CLOSED) {
ret = openCanBus();
if (ret == LWUART_OK) {
LWUARTCanChannelMode = LWUART_STATUS_CAN_OPEN_NORMAL;
if (ret == LW232_OK) {
lw232CanChannelMode = LW232_STATUS_CAN_OPEN_NORMAL;
}
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_LISTEN:
case LW232_CMD_LISTEN:
// L[CR] Open the CAN channel in listen only mode (receiving).
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_CLOSED) {
if (lw232CanChannelMode == LW232_STATUS_CAN_CLOSED) {
ret = openCanBus();
if (ret == LWUART_OK) {
LWUARTCanChannelMode = LWUART_STATUS_CAN_OPEN_LISTEN;
if (ret == LW232_OK) {
lw232CanChannelMode = LW232_STATUS_CAN_OPEN_LISTEN;
}
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_CLOSE:
case LW232_CMD_CLOSE:
// C[CR] Close the CAN channel.
if (LWUARTCanChannelMode != LWUART_STATUS_CAN_CLOSED) {
LWUARTCanChannelMode = LWUART_STATUS_CAN_CLOSED;
if (lw232CanChannelMode != LW232_STATUS_CAN_CLOSED) {
lw232CanChannelMode = LW232_STATUS_CAN_CLOSED;
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_TX11:
case LW232_CMD_TX11:
// tiiildd...[CR] Transmit a standard (11bit) CAN frame.
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_OPEN_NORMAL) {
if (lw232CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
parseCanStdId();
LWUARTPacketLen = HexHelper::parseNibbleWithLimit(LWUARTMessage[LWUART_OFFSET_STD_PKT_LEN], LWUART_FRAME_MAX_LENGTH + 1);
for (; idx < LWUARTPacketLen; idx++) {
LWUARTBuffer[idx] = HexHelper::parseFullByte(LWUARTMessage[LWUART_OFFSET_STD_PKT_DATA + idx * 2], LWUARTMessage[LWUART_OFFSET_STD_PKT_DATA + idx * 2 + 1]);
lw232PacketLen = HexHelper::parseNibbleWithLimit(lw232Message[LW232_OFFSET_STD_PKT_LEN], LW232_FRAME_MAX_LENGTH + 1);
for (; idx < lw232PacketLen; idx++) {
lw232Buffer[idx] = HexHelper::parseFullByte(lw232Message[LW232_OFFSET_STD_PKT_DATA + idx * 2], lw232Message[LW232_OFFSET_STD_PKT_DATA + idx * 2 + 1]);
}
INT8U mcpErr = sendMsgBuf(LWUARTCanId, 0, 0, LWUARTPacketLen, LWUARTBuffer);
INT8U mcpErr = sendMsgBuf(lw232CanId, 0, 0, lw232PacketLen, lw232Buffer);
if (mcpErr != CAN_OK) {
ret = LWUART_ERR;
} else if (LWUARTAutoPoll) {
ret = LWUART_OK_SMALL;
ret = LW232_ERR;
} else if (lw232AutoPoll) {
ret = LW232_OK_SMALL;
}
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_TX29:
case LW232_CMD_TX29:
// Tiiiiiiiildd...[CR] Transmit an extended (29bit) CAN frame
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_OPEN_NORMAL) {
if (lw232CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
parseCanExtId();
LWUARTPacketLen = HexHelper::parseNibbleWithLimit(LWUARTMessage[LWUART_OFFSET_EXT_PKT_LEN], LWUART_FRAME_MAX_LENGTH + 1);
for (; idx < LWUARTPacketLen; idx++) {
LWUARTBuffer[idx] = HexHelper::parseFullByte(LWUARTMessage[LWUART_OFFSET_EXT_PKT_DATA + idx * 2], LWUARTMessage[LWUART_OFFSET_EXT_PKT_DATA + idx * 2 + 1]);
lw232PacketLen = HexHelper::parseNibbleWithLimit(lw232Message[LW232_OFFSET_EXT_PKT_LEN], LW232_FRAME_MAX_LENGTH + 1);
for (; idx < lw232PacketLen; idx++) {
lw232Buffer[idx] = HexHelper::parseFullByte(lw232Message[LW232_OFFSET_EXT_PKT_DATA + idx * 2], lw232Message[LW232_OFFSET_EXT_PKT_DATA + idx * 2 + 1]);
}
if (CAN_OK != sendMsgBuf(LWUARTCanId, 1, 0, LWUARTPacketLen, LWUARTBuffer)) {
ret = LWUART_ERR;
} else if (LWUARTAutoPoll) {
ret = LWUART_OK_BIG;
if (CAN_OK != sendMsgBuf(lw232CanId, 1, 0, lw232PacketLen, lw232Buffer)) {
ret = LW232_ERR;
} else if (lw232AutoPoll) {
ret = LW232_OK_BIG;
} else {
ret = LWUART_OK;
ret = LW232_OK;
}
}
break;
case LWUART_CMD_RTR11:
case LW232_CMD_RTR11:
// riiil[CR] Transmit an standard RTR (11bit) CAN frame.
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_OPEN_NORMAL) {
if (lw232CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
parseCanStdId();
LWUARTPacketLen = HexHelper::parseNibbleWithLimit(LWUARTMessage[LWUART_OFFSET_STD_PKT_LEN], LWUART_FRAME_MAX_LENGTH + 1);
if (CAN_OK != sendMsgBuf(LWUARTCanId, 0, 1, LWUARTPacketLen, LWUARTBuffer)) {
ret = LWUART_ERR;
lw232PacketLen = HexHelper::parseNibbleWithLimit(lw232Message[LW232_OFFSET_STD_PKT_LEN], LW232_FRAME_MAX_LENGTH + 1);
if (CAN_OK != sendMsgBuf(lw232CanId, 0, 1, lw232PacketLen, lw232Buffer)) {
ret = LW232_ERR;
}
else if (LWUARTAutoPoll) {
ret = LWUART_OK_SMALL;
else if (lw232AutoPoll) {
ret = LW232_OK_SMALL;
}
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_RTR29:
case LW232_CMD_RTR29:
// Riiiiiiiil[CR] Transmit an extended RTR (29bit) CAN frame.
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_OPEN_NORMAL) {
if (lw232CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
parseCanExtId();
LWUARTPacketLen = HexHelper::parseNibbleWithLimit(LWUARTMessage[LWUART_OFFSET_EXT_PKT_LEN], LWUART_FRAME_MAX_LENGTH + 1);
if (CAN_OK != sendMsgBuf(LWUARTCanId, 1, 1, LWUARTPacketLen, LWUARTBuffer)) {
ret = LWUART_ERR;
lw232PacketLen = HexHelper::parseNibbleWithLimit(lw232Message[LW232_OFFSET_EXT_PKT_LEN], LW232_FRAME_MAX_LENGTH + 1);
if (CAN_OK != sendMsgBuf(lw232CanId, 1, 1, lw232PacketLen, lw232Buffer)) {
ret = LW232_ERR;
}
else if (LWUARTAutoPoll) {
ret = LWUART_OK_SMALL; // not a typo. strangely CanSerial_v3.pdf tells to return "z[CR]", not "Z[CR]" as in 29bit. todo: check if it is error in pdf???
else if (lw232AutoPoll) {
ret = LW232_OK_SMALL; // not a typo. strangely can232_v3.pdf tells to return "z[CR]", not "Z[CR]" as in 29bit. todo: check if it is error in pdf???
}
} else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_POLL_ONE:
case LW232_CMD_POLL_ONE:
// P[CR] Poll incomming FIFO for CAN frames (single poll)
if (LWUARTCanChannelMode != LWUART_STATUS_CAN_CLOSED && LWUARTAutoPoll == LWUART_AUTOPOLL_OFF) {
if (lw232CanChannelMode != LW232_STATUS_CAN_CLOSED && lw232AutoPoll == LW232_AUTOPOLL_OFF) {
if (CAN_MSGAVAIL == checkReceive()) {
ret = receiveSingleFrame();
}
} else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_POLL_MANY:
case LW232_CMD_POLL_MANY:
// A[CR] Polls incomming FIFO for CAN frames (all pending frames)
if (LWUARTCanChannelMode != LWUART_STATUS_CAN_CLOSED && LWUARTAutoPoll == LWUART_AUTOPOLL_OFF) {
if (lw232CanChannelMode != LW232_STATUS_CAN_CLOSED && lw232AutoPoll == LW232_AUTOPOLL_OFF) {
while (CAN_MSGAVAIL == checkReceive()) {
ret = ret ^ receiveSingleFrame();
if (ret != CAN_OK)
break;
Serial.write(LWUART_CR);
Serial.write(LW232_CR);
}
if (ret == CAN_OK)
Serial.print(LWUART_ALL);
Serial.print(LW232_ALL);
} else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_FLAGS:
case LW232_CMD_FLAGS:
// F[CR] Read Status Flags.
// LAWICEL CanSerial and CANUSB have some specific errors which differ from MCP2515/MCP2551 errors. We just return MCP2515 error.
Serial.print(LWUART_FLAG);
if (LWUARTCAN->checkError() == CAN_OK)
// LAWICEL CAN232 and CANUSB have some specific errors which differ from MCP2515/MCP2551 errors. We just return MCP2515 error.
Serial.print(LW232_FLAG);
if (lw232CAN.checkError(&err) == CAN_OK)
err = 0;
HexHelper::printFullByte(err);
HexHelper::printFullByte(err /*& MCP_EFLG_ERRORMASK*/);
break;
case LWUART_CMD_AUTOPOLL:
case LW232_CMD_AUTOPOLL:
// Xn[CR] Sets Auto Poll/Send ON/OFF for received frames.
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_CLOSED) {
LWUARTAutoPoll = (LWUARTMessage[1] == LWUART_ON_ONE) ? LWUART_AUTOPOLL_ON : LWUART_AUTOPOLL_OFF;
if (lw232CanChannelMode == LW232_STATUS_CAN_CLOSED) {
lw232AutoPoll = (lw232Message[1] == LW232_ON_ONE) ? LW232_AUTOPOLL_ON : LW232_AUTOPOLL_OFF;
//todo: save to eeprom
} else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_FILTER:
// Wn[CR] Filter mode setting. By default CanSerial works in dual filter mode (0) and is backwards compatible with previous CanSerial versions.
ret = LWUART_ERR_NOT_IMPLEMENTED; break;
case LWUART_CMD_ACC_CODE:
case LW232_CMD_FILTER:
// Wn[CR] Filter mode setting. By default CAN232 works in dual filter mode (0) and is backwards compatible with previous CAN232 versions.
ret = LW232_ERR_NOT_IMPLEMENTED; break;
case LW232_CMD_ACC_CODE:
// Mxxxxxxxx[CR] Sets Acceptance Code Register (ACn Register of SJA1000). // we use MCP2515,
ret = LWUART_ERR_NOT_IMPLEMENTED; break;
case LWUART_CMD_ACC_MASK:
ret = LW232_ERR_NOT_IMPLEMENTED; break;
case LW232_CMD_ACC_MASK:
// mxxxxxxxx[CR] Sets Acceptance Mask Register (AMn Register of SJA1000).
ret = LWUART_ERR_NOT_IMPLEMENTED; break;
case LWUART_CMD_UART:
ret = LW232_ERR_NOT_IMPLEMENTED; break;
case LW232_CMD_UART:
// Un[CR] Setup UART with a new baud rate where n is 0-6.
idx = HexHelper::parseNibbleWithLimit(LWUARTMessage[1], LWUART_UART_BAUD_NUM);
Serial.begin(LWUARTSerialBaudRates[idx]);
idx = HexHelper::parseNibbleWithLimit(lw232Message[1], LW232_UART_BAUD_NUM);
Serial.begin(lw232SerialBaudRates[idx]);
break;
case LWUART_CMD_VERSION1:
case LWUART_CMD_VERSION2:
// V[CR] Get Version number of both CanSerial hardware and software
Serial.print(LWUART_LAWICEL_VERSION_STR);
case LW232_CMD_VERSION1:
case LW232_CMD_VERSION2:
// V[CR] Get Version number of both CAN232 hardware and software
Serial.print(LW232_LAWICEL_VERSION_STR);
break;
case LWUART_CMD_SERIAL:
// N[CR] Get Serial number of the CanSerial.
Serial.print(LWUART_LAWICEL_SERIAL_NUM);
case LW232_CMD_SERIAL:
// N[CR] Get Serial number of the CAN232.
Serial.print(LW232_LAWICEL_SERIAL_NUM);
break;
case LWUART_CMD_TIMESTAMP:
case LW232_CMD_TIMESTAMP:
// Zn[CR] Sets Time Stamp ON/OFF for received frames only. Z0 - OFF, Z1 - Lawicel's timestamp 2 bytes, Z2 - arduino timestamp 4 bytes.
if (LWUARTCanChannelMode == LWUART_STATUS_CAN_CLOSED) {
// LWUARTTimeStamp = (LWUARTMessage[1] == LWUART_ON_ONE);
if (LWUARTMessage[1] == LWUART_ON_ONE) {
LWUARTTimeStamp = LWUART_TIMESTAMP_ON_NORMAL;
if (lw232CanChannelMode == LW232_STATUS_CAN_CLOSED) {
// lw232TimeStamp = (lw232Message[1] == LW232_ON_ONE);
if (lw232Message[1] == LW232_ON_ONE) {
lw232TimeStamp = LW232_TIMESTAMP_ON_NORMAL;
}
else if (LWUARTMessage[1] == LWUART_ON_TWO) {
LWUARTTimeStamp = LWUART_TIMESTAMP_ON_EXTENDED;
else if (lw232Message[1] == LW232_ON_TWO) {
lw232TimeStamp = LW232_TIMESTAMP_ON_EXTENDED;
}
else {
LWUARTTimeStamp = LWUART_TIMESTAMP_OFF;
lw232TimeStamp = LW232_TIMESTAMP_OFF;
}
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
case LWUART_CMD_AUTOSTART:
case LW232_CMD_AUTOSTART:
// Qn[CR] Auto Startup feature (from power on).
if (LWUARTCanChannelMode != LWUART_STATUS_CAN_CLOSED) {
if (LWUARTMessage[1] == LWUART_ON_ONE) {
LWUARTAutoStart = LWUART_AUTOSTART_ON_NORMAL;
if (lw232CanChannelMode != LW232_STATUS_CAN_CLOSED) {
if (lw232Message[1] == LW232_ON_ONE) {
lw232AutoStart = LW232_AUTOSTART_ON_NORMAL;
}
else if (LWUARTMessage[1] == LWUART_ON_TWO) {
LWUARTAutoStart = LWUART_AUTOSTART_ON_LISTEN;
else if (lw232Message[1] == LW232_ON_TWO) {
lw232AutoStart = LW232_AUTOSTART_ON_LISTEN;
}
else {
LWUARTAutoStart = LWUART_AUTOSTART_OFF;
lw232AutoStart = LW232_AUTOSTART_OFF;
}
//todo: save to eeprom
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
break;
default:
ret = LWUART_ERR_UNKNOWN_CMD;
ret = LW232_ERR_UNKNOWN_CMD;
}
return ret;
}
INT8U CanSerial::checkReceive() {
INT8U Can232::checkReceive() {
#ifndef _MCP_FAKE_MODE_
return LWUARTCAN->checkReceive();
return lw232CAN.checkReceive();
#else
return CAN_MSGAVAIL;
#endif
}
INT8U CanSerial::readMsgBufID(INT32U *ID, INT8U *len, INT8U buf[]) {
INT8U Can232::readMsgBufID(INT32U *ID, INT8U *len, INT8U buf[]) {
#ifndef _MCP_FAKE_MODE_
return LWUARTCAN->readMsgBufID(ID, len, buf);
return lw232CAN.readMsgBufID(ID, len, buf);
#else
*ID = random(0x100, 0x110);
*len = 4;
@@ -407,36 +409,36 @@ INT8U CanSerial::readMsgBufID(INT32U *ID, INT8U *len, INT8U buf[]) {
INT8U CanSerial::receiveSingleFrame() {
INT8U ret = LWUART_OK;
INT8U Can232::receiveSingleFrame() {
INT8U ret = LW232_OK;
INT8U idx = 0;
if (CAN_OK == readMsgBufID(&LWUARTCanId, &LWUARTPacketLen, LWUARTBuffer)) {
if (LWUARTCanId > 0x1FFFFFFF) {
ret = LWUART_ERR; // address if totally wrong
if (CAN_OK == readMsgBufID(&lw232CanId, &lw232PacketLen, lw232Buffer)) {
if (lw232CanId > 0x1FFFFFFF) {
ret = LW232_ERR; // address if totally wrong
}
else if (checkPassFilter(LWUARTCanId)) {// do we want to skip some addresses?
else if (checkPassFilter(lw232CanId)) {// do we want to skip some addresses?
if (isExtendedFrame()) {
Serial.print(LWUART_TR29);
HexHelper::printFullByte(HIGH_BYTE(HIGH_WORD(LWUARTCanId)));
HexHelper::printFullByte(LOW_BYTE(HIGH_WORD(LWUARTCanId)));
HexHelper::printFullByte(HIGH_BYTE(LOW_WORD(LWUARTCanId)));
HexHelper::printFullByte(LOW_BYTE(LOW_WORD(LWUARTCanId)));
Serial.print(LW232_TR29);
HexHelper::printFullByte(HIGH_BYTE(HIGH_WORD(lw232CanId)));
HexHelper::printFullByte(LOW_BYTE(HIGH_WORD(lw232CanId)));
HexHelper::printFullByte(HIGH_BYTE(LOW_WORD(lw232CanId)));
HexHelper::printFullByte(LOW_BYTE(LOW_WORD(lw232CanId)));
}
else {
Serial.print(LWUART_TR11);
HexHelper::printNibble(HIGH_BYTE(LOW_WORD(LWUARTCanId)));
HexHelper::printFullByte(LOW_BYTE(LOW_WORD(LWUARTCanId)));
Serial.print(LW232_TR11);
HexHelper::printNibble(HIGH_BYTE(LOW_WORD(lw232CanId)));
HexHelper::printFullByte(LOW_BYTE(LOW_WORD(lw232CanId)));
}
//write data len
HexHelper::printNibble(LWUARTPacketLen);
HexHelper::printNibble(lw232PacketLen);
//write data
for (idx = 0; idx < LWUARTPacketLen; idx++) {
HexHelper::printFullByte(LWUARTBuffer[idx]);
for (idx = 0; idx < lw232PacketLen; idx++) {
HexHelper::printFullByte(lw232Buffer[idx]);
}
//write timestamp if needed
if (LWUARTTimeStamp != LWUART_TIMESTAMP_OFF) {
if (lw232TimeStamp != LW232_TIMESTAMP_OFF) {
INT32U time = millis();
if (LWUARTTimeStamp == LWUART_TIMESTAMP_ON_NORMAL) {
if (lw232TimeStamp == LW232_TIMESTAMP_ON_NORMAL) {
// standard LAWICEL protocol. two bytes.
time %= 60000;
} else {
@@ -450,41 +452,41 @@ INT8U CanSerial::receiveSingleFrame() {
}
}
else {
ret = LWUART_ERR;
ret = LW232_ERR;
}
return ret;
}
INT8U CanSerial::isExtendedFrame() {
INT8U Can232::isExtendedFrame() {
#ifndef _MCP_FAKE_MODE_
return LWUARTCAN->isExtendedFrame();
return lw232CAN.isExtendedFrame();
#else
return LWUARTCanId > 0x7FF ? 1 : 0; //simple hack for fake mode
return lw232CanId > 0x7FF ? 1 : 0; //simple hack for fake mode
#endif
}
INT8U CanSerial::checkPassFilter(INT32U addr) {
INT8U Can232::checkPassFilter(INT32U addr) {
if (userAddressFilterFunc == 0)
return LWUART_FILTER_PROCESS;
return LW232_FILTER_PROCESS;
return (*userAddressFilterFunc)(addr);
}
INT8U CanSerial::openCanBus() {
INT8U ret = LWUART_OK;
INT8U Can232::openCanBus() {
INT8U ret = LW232_OK;
#ifndef _MCP_FAKE_MODE_
if (CAN_OK != LWUARTCAN->begin(LWUARTCanSpeedSelection, LWUARTMcpModuleClock))
ret = LWUART_ERR;
if (CAN_OK != lw232CAN.begin(lw232CanSpeedSelection, lw232McpModuleClock))
ret = LW232_ERR;
#endif
return ret;
}
INT8U CanSerial::sendMsgBuf(INT32U id, INT8U ext, INT8U rtr, INT8U len, INT8U *buf) {
INT8U Can232::sendMsgBuf(INT32U id, INT8U ext, INT8U rtr, INT8U len, INT8U *buf) {
#ifndef _MCP_FAKE_MODE_
return LWUARTCAN->sendMsgBuf(id, ext, rtr, len, buf);
return lw232CAN.sendMsgBuf(id, ext, rtr, len, buf);
#else
Serial.print("<sending:");
Serial.print(id, HEX);
@@ -504,23 +506,23 @@ INT8U CanSerial::sendMsgBuf(INT32U id, INT8U ext, INT8U rtr, INT8U len, INT8U *b
void CanSerial::parseCanStdId() {
LWUARTCanId = (((INT32U)HexHelper::parseNibble(LWUARTMessage[1])) << 8)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[2])) << 4)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[3])));
LWUARTCanId &= 0x7FF;
void Can232::parseCanStdId() {
lw232CanId = (((INT32U)HexHelper::parseNibble(lw232Message[1])) << 8)
+ (((INT32U)HexHelper::parseNibble(lw232Message[2])) << 4)
+ (((INT32U)HexHelper::parseNibble(lw232Message[3])));
lw232CanId &= 0x7FF;
}
void CanSerial::parseCanExtId() {
LWUARTCanId = (((INT32U)HexHelper::parseNibble(LWUARTMessage[1])) << 28)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[2])) << 24)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[3])) << 20)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[4])) << 16)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[5])) << 12)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[6])) << 8)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[7])) << 4)
+ (((INT32U)HexHelper::parseNibble(LWUARTMessage[8])));
LWUARTCanId &= 0x1FFFFFFF;
void Can232::parseCanExtId() {
lw232CanId = (((INT32U)HexHelper::parseNibble(lw232Message[1])) << 28)
+ (((INT32U)HexHelper::parseNibble(lw232Message[2])) << 24)
+ (((INT32U)HexHelper::parseNibble(lw232Message[3])) << 20)
+ (((INT32U)HexHelper::parseNibble(lw232Message[4])) << 16)
+ (((INT32U)HexHelper::parseNibble(lw232Message[5])) << 12)
+ (((INT32U)HexHelper::parseNibble(lw232Message[6])) << 8)
+ (((INT32U)HexHelper::parseNibble(lw232Message[7])) << 4)
+ (((INT32U)HexHelper::parseNibble(lw232Message[8])));
lw232CanId &= 0x1FFFFFFF;
}
void HexHelper::printFullByte(INT8U b) {
examples/canbus-monitor/can-serial.h
+99 -117
View File
@@ -1,6 +1,6 @@
/*****************************************************************************************
* This is implementation of CAN BUS ASCII protocol based on LAWICEL v1.3 serial protocol
* of CanSerial/CANUSB device (http://www.CanSerial.com/docs/CanSerial_v3.pdf)
* of CAN232/CANUSB device (http://www.can232.com/docs/can232_v3.pdf)
*
* Made for Arduino with Seeduino/ElecFreaks CAN BUS Shield based on MCP2515
*
@@ -15,33 +15,19 @@
#ifndef _CAN_SERIAL_H_
#define _CAN_SERIAL_H_
//#if defined(ARDUINO) && ARDUINO >= 100
// #include "arduino.h"
//#else
// #include "WProgram.h"
//#endif
#include "mcp_can.h"
#define LOGGING_ENABLED
#ifdef LOGGING_ENABLED
#include "SoftwareSerial.h"
#define dbg_begin(x) debug.begin(x)
#define dbg0(x) debug.print(x)
#define dbg1(x) debug.println(x)
#define dbg2(x,y) debug.print(x); debug.println(y)
#define dbgH(x) debug.print(x,HEX)
#define DEBUG_RX_PIN 8
#define DEBUG_TX_PIN 9
#else
#define dbg_begin(x)
#define dbg0(x)
#define dbg1(x)
#define dbg2(x,y)
#define dbgH(x)
#endif
#define LWUART_LAWICEL_VERSION_STR "V1013"
#define LWUART_LAWICEL_SERIAL_NUM "NA123"
#define LWUART_CAN_BUS_SHIELD_CS_PIN 10
#define LW232_LAWICEL_VERSION_STR "V1013"
#define LW232_LAWICEL_SERIAL_NUM "NA123"
#define LW232_CAN_BUS_SHIELD_CS_PIN 10
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -59,32 +45,32 @@
//
// CODE SUPPORTED SYNTAX DESCRIPTION
//
#define LWUART_CMD_SETUP 'S' // YES+ Sn[CR] Setup with standard CAN bit-rates where n is 0-8.
#define LW232_CMD_SETUP 'S' // YES+ Sn[CR] Setup with standard CAN bit-rates where n is 0-8.
// S0 10Kbit S4 125Kbit S8 1Mbit
// S1 20Kbit S5 250Kbit S9 83.3Kbit
// S2 50Kbit S6 500Kbit
// S3 100Kbit S7 800Kbit
#define LWUART_CMD_SETUP_BTR 's' // - sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex value.
#define LWUART_CMD_OPEN 'O' // YES O[CR] Open the CAN channel in normal mode (sending & receiving).
#define LWUART_CMD_LISTEN 'L' // YES L[CR] Open the CAN channel in listen only mode (receiving).
#define LWUART_CMD_CLOSE 'C' // YES C[CR] Close the CAN channel.
#define LWUART_CMD_TX11 't' // YES tiiildd...[CR] Transmit a standard (11bit) CAN frame.
#define LWUART_CMD_TX29 'T' // YES Tiiiiiiiildd...[CR] Transmit an extended (29bit) CAN frame
#define LWUART_CMD_RTR11 'r' // YES riiil[CR] Transmit an standard RTR (11bit) CAN frame.
#define LWUART_CMD_RTR29 'R' // YES Riiiiiiiil[CR] Transmit an extended RTR (29bit) CAN frame.
#define LWUART_CMD_POLL_ONE 'P' // YES P[CR] Poll incomming FIFO for CAN frames (single poll)
#define LWUART_CMD_POLL_MANY 'A' // YES A[CR] Polls incomming FIFO for CAN frames (all pending frames)
#define LWUART_CMD_FLAGS 'F' // YES+ F[CR] Read Status Flags.
#define LWUART_CMD_AUTOPOLL 'X' // YES Xn[CR] Sets Auto Poll/Send ON/OFF for received frames.
#define LWUART_CMD_FILTER 'W' // - Wn[CR] Filter mode setting. By default CanSerial works in dual filter mode (0) and is backwards compatible with previous CanSerial versions.
#define LWUART_CMD_ACC_CODE 'M' // - Mxxxxxxxx[CR] Sets Acceptance Code Register (ACn Register of SJA1000). // we use MCP2515, not supported
#define LWUART_CMD_ACC_MASK 'm' // - mxxxxxxxx[CR] Sets Acceptance Mask Register (AMn Register of SJA1000). // we use MCP2515, not supported
#define LWUART_CMD_UART 'U' // YES Un[CR] Setup UART with a new baud rate where n is 0-6.
#define LWUART_CMD_VERSION1 'V' // YES v[CR] Get Version number of both CanSerial hardware and software
#define LWUART_CMD_VERSION2 'v' // YES V[CR] Get Version number of both CanSerial hardware and software
#define LWUART_CMD_SERIAL 'N' // YES N[CR] Get Serial number of the CanSerial.
#define LWUART_CMD_TIMESTAMP 'Z' // YES+ Zn[CR] Sets Time Stamp ON/OFF for received frames only. EXTENSION to LAWICEL: Z2 - millis() timestamp w/o standard 60000ms cycle
#define LWUART_CMD_AUTOSTART 'Q' // YES todo Qn[CR] Auto Startup feature (from power on).
#define LW232_CMD_SETUP_BTR 's' // - sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex value.
#define LW232_CMD_OPEN 'O' // YES O[CR] Open the CAN channel in normal mode (sending & receiving).
#define LW232_CMD_LISTEN 'L' // YES L[CR] Open the CAN channel in listen only mode (receiving).
#define LW232_CMD_CLOSE 'C' // YES C[CR] Close the CAN channel.
#define LW232_CMD_TX11 't' // YES tiiildd...[CR] Transmit a standard (11bit) CAN frame.
#define LW232_CMD_TX29 'T' // YES Tiiiiiiiildd...[CR] Transmit an extended (29bit) CAN frame
#define LW232_CMD_RTR11 'r' // YES riiil[CR] Transmit an standard RTR (11bit) CAN frame.
#define LW232_CMD_RTR29 'R' // YES Riiiiiiiil[CR] Transmit an extended RTR (29bit) CAN frame.
#define LW232_CMD_POLL_ONE 'P' // YES P[CR] Poll incomming FIFO for CAN frames (single poll)
#define LW232_CMD_POLL_MANY 'A' // YES A[CR] Polls incomming FIFO for CAN frames (all pending frames)
#define LW232_CMD_FLAGS 'F' // YES+ F[CR] Read Status Flags.
#define LW232_CMD_AUTOPOLL 'X' // YES Xn[CR] Sets Auto Poll/Send ON/OFF for received frames.
#define LW232_CMD_FILTER 'W' // - Wn[CR] Filter mode setting. By default CAN232 works in dual filter mode (0) and is backwards compatible with previous CAN232 versions.
#define LW232_CMD_ACC_CODE 'M' // - Mxxxxxxxx[CR] Sets Acceptance Code Register (ACn Register of SJA1000). // we use MCP2515, not supported
#define LW232_CMD_ACC_MASK 'm' // - mxxxxxxxx[CR] Sets Acceptance Mask Register (AMn Register of SJA1000). // we use MCP2515, not supported
#define LW232_CMD_UART 'U' // YES Un[CR] Setup UART with a new baud rate where n is 0-6.
#define LW232_CMD_VERSION1 'V' // YES v[CR] Get Version number of both CAN232 hardware and software
#define LW232_CMD_VERSION2 'v' // YES V[CR] Get Version number of both CAN232 hardware and software
#define LW232_CMD_SERIAL 'N' // YES N[CR] Get Serial number of the CAN232.
#define LW232_CMD_TIMESTAMP 'Z' // YES+ Zn[CR] Sets Time Stamp ON/OFF for received frames only. EXTENSION to LAWICEL: Z2 - millis() timestamp w/o standard 60000ms cycle
#define LW232_CMD_AUTOSTART 'Q' // YES todo Qn[CR] Auto Startup feature (from power on).
#define LOW_BYTE(x) ((unsigned char)((x)&0xFF))
#define HIGH_BYTE(x) ((unsigned char)(((x)>>8)&0xFF))
@@ -103,92 +89,87 @@
#define INT8U byte
#endif
#define LWUART_OK 0x00
#define LWUART_OK_SMALL 0x01
#define LWUART_OK_BIG 0x02
#define LWUART_ERR 0x03
#define LWUART_ERR_NOT_IMPLEMENTED 0x04
#define LWUART_ERR_UNKNOWN_CMD 0x05
#define LW232_OK 0x00
#define LW232_OK_SMALL 0x01
#define LW232_OK_BIG 0x02
#define LW232_ERR 0x03
#define LW232_ERR_NOT_IMPLEMENTED 0x04
#define LW232_ERR_UNKNOWN_CMD 0x05
#define LWUART_FILTER_SKIP 0x00
#define LWUART_FILTER_PROCESS 0x01
#define LW232_FILTER_SKIP 0x00
#define LW232_FILTER_PROCESS 0x01
//#define LWUART_IS_OK(x) ((x)==LWUART_OK ||(x)==LWUART_OK_NEW ? TRUE : FALSE)
//#define LW232_IS_OK(x) ((x)==LW232_OK ||(x)==LW232_OK_NEW ? TRUE : FALSE)
#define LWUART_CR '\r'
#define LWUART_ALL 'A'
#define LWUART_FLAG 'F'
#define LWUART_TR11 't'
#define LWUART_TR29 'T'
#define LW232_CR '\r'
#define LW232_ALL 'A'
#define LW232_FLAG 'F'
#define LW232_TR11 't'
#define LW232_TR29 'T'
#define LWUART_RET_ASCII_OK 0x0D
#define LWUART_RET_ASCII_ERROR 0x07
#define LWUART_RET_ASCII_OK_SMALL 'z'
#define LWUART_RET_ASCII_OK_BIG 'Z'
#define LW232_RET_ASCII_OK 0x0D
#define LW232_RET_ASCII_ERROR 0x07
#define LW232_RET_ASCII_OK_SMALL 'z'
#define LW232_RET_ASCII_OK_BIG 'Z'
#define LWUART_STATUS_CAN_CLOSED 0x00
#define LWUART_STATUS_CAN_OPEN_NORMAL 0x01
#define LWUART_STATUS_CAN_OPEN_LISTEN 0x01
#define LW232_STATUS_CAN_CLOSED 0x00
#define LW232_STATUS_CAN_OPEN_NORMAL 0x01
#define LW232_STATUS_CAN_OPEN_LISTEN 0x01
#define LWUART_FRAME_MAX_LENGTH 0x08
#define LWUART_FRAME_MAX_SIZE (sizeof("Tiiiiiiiildddddddddddddddd\r")+1)
#define LW232_FRAME_MAX_LENGTH 0x08
#define LW232_FRAME_MAX_SIZE (sizeof("Tiiiiiiiildddddddddddddddd\r")+1)
#define LWUART_INPUT_STRING_BUFFER_SIZE 200
#define LW232_INPUT_STRING_BUFFER_SIZE 200
#define LWUART_OFF '0'
#define LWUART_ON_ONE '1'
#define LWUART_ON_TWO '2'
#define LW232_OFF '0'
#define LW232_ON_ONE '1'
#define LW232_ON_TWO '2'
#define LWUART_AUTOPOLL_OFF 0x00
#define LWUART_AUTOPOLL_ON 0x01
#define LW232_AUTOPOLL_OFF 0x00
#define LW232_AUTOPOLL_ON 0x01
#define LWUART_AUTOSTART_OFF 0x00
#define LWUART_AUTOSTART_ON_NORMAL 0x01
#define LWUART_AUTOSTART_ON_LISTEN 0x02
#define LW232_AUTOSTART_OFF 0x00
#define LW232_AUTOSTART_ON_NORMAL 0x01
#define LW232_AUTOSTART_ON_LISTEN 0x02
#define LWUART_TIMESTAMP_OFF 0x00
#define LWUART_TIMESTAMP_ON_NORMAL 0x01
#define LWUART_TIMESTAMP_ON_EXTENDED 0x02
#define LW232_TIMESTAMP_OFF 0x00
#define LW232_TIMESTAMP_ON_NORMAL 0x01
#define LW232_TIMESTAMP_ON_EXTENDED 0x02
#define LWUART_OFFSET_STD_PKT_LEN 0x04
#define LWUART_OFFSET_STD_PKT_DATA 0x05
#define LWUART_OFFSET_EXT_PKT_LEN 0x09
#define LWUART_OFFSET_EXT_PKT_DATA 0x0A
#define LW232_OFFSET_STD_PKT_LEN 0x04
#define LW232_OFFSET_STD_PKT_DATA 0x05
#define LW232_OFFSET_EXT_PKT_LEN 0x09
#define LW232_OFFSET_EXT_PKT_DATA 0x0A
#define LWUART_DEFAULT_BAUD_RATE 115200
// #define LWUART_DEFAULT_CAN_RATE CAN_500KBPS
// #define LWUART_DEFAULT_CLOCK_FREQ MCP_16MHz
#define LW232_DEFAULT_BAUD_RATE 115200
#define LW232_DEFAULT_CAN_RATE CAN_500KBPS
#define LW232_DEFAULT_CLOCK_FREQ MCP_16MHz
#define LWUART_CAN_BAUD_NUM 0x0a
#define LWUART_UART_BAUD_NUM 0x07
#define CAN_OK (0)
#define CAN_FAILINIT (1)
#define CAN_FAILTX (2)
#define CAN_MSGAVAIL (3)
#define LW232_CAN_BAUD_NUM 0x0a
#define LW232_UART_BAUD_NUM 0x07
const INT32U LWUARTSerialBaudRates[] //PROGMEM
const INT32U lw232SerialBaudRates[] //PROGMEM
= { 230400, 115200, 57600, 38400, 19200, 9600, 2400 };
// const INT32U LWUARTCanBaudRates[] //PROGMEM
// = { CAN_10KBPS, CAN_20KBPS, CAN_50KBPS, CAN_100KBPS, CAN_125KBPS, CAN_250KBPS, CAN_500KBPS, CAN_500KBPS /*CAN_800KBPS*/, CAN_1000KBPS, CAN_83K3BPS };
const INT32U lw232CanBaudRates[] //PROGMEM
= { CAN_10KBPS, CAN_20KBPS, CAN_50KBPS, CAN_100KBPS, CAN_125KBPS, CAN_250KBPS, CAN_500KBPS, CAN_500KBPS /*CAN_800KBPS*/, CAN_1000KBPS, CAN_83K3BPS };
class CanSerial
class Can232
{
public:
static void init(INT8U defaultCanSpeed, const INT8U clock);
static void init(INT8U defaultCanSpeed = LW232_DEFAULT_CAN_RATE, const INT8U clock = LW232_DEFAULT_CLOCK_FREQ);
static void init(MCP_CAN *can);
static void setFilter(INT8U (*userFunc)(INT32U));
static void loop();
static void serialEvent();
private:
static CanSerial* _instance;
static CanSerial* instance();
static MCP_CAN *MCP_OBJECT;
static Can232* _instance;
static Can232* instance();
void initFunc();
void setFilterFunc(INT8U (*userFunc)(INT32U));
@@ -197,24 +178,25 @@ private:
INT8U (*userAddressFilterFunc)(INT32U addr) = 0;
static MCP_CAN *LWUARTCAN;
//MCP_CAN LWUARTCAN = MCP_CAN(LWUART_CAN_BUS_SHIELD_CS_PIN);
/*
MCP_CAN lw232CAN = MCP_CAN(LW232_CAN_BUS_SHIELD_CS_PIN);
*/
INT8U LWUARTCanSpeedSelection ;
INT8U LWUARTMcpModuleClock ;
INT8U LWUARTCanChannelMode = LWUART_STATUS_CAN_CLOSED;
INT8U LWUARTLastErr = LWUART_OK;
INT8U lw232CanSpeedSelection = CAN_83K3BPS;
INT8U lw232McpModuleClock = MCP_16MHz;
INT8U lw232CanChannelMode = LW232_STATUS_CAN_CLOSED;
INT8U lw232LastErr = LW232_OK;
INT8U LWUARTAutoStart = LWUART_AUTOSTART_OFF;
INT8U LWUARTAutoPoll = LWUART_AUTOPOLL_OFF;
INT8U LWUARTTimeStamp = LWUART_TIMESTAMP_OFF;
INT8U lw232AutoStart = LW232_AUTOSTART_OFF;
INT8U lw232AutoPoll = LW232_AUTOPOLL_OFF;
INT8U lw232TimeStamp = LW232_TIMESTAMP_OFF;
INT32U LWUARTCanId = 0;
INT32U lw232CanId = 0;
INT8U LWUARTBuffer[8];
INT8U LWUARTPacketLen = 0;
INT8U lw232Buffer[8];
INT8U lw232PacketLen = 0;
INT8U LWUARTMessage[LWUART_FRAME_MAX_SIZE];
INT8U lw232Message[LW232_FRAME_MAX_SIZE];
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
@@ -245,7 +227,7 @@ public:
static INT8U parseNibbleWithLimit(INT8U hex, INT8U limit);
};
class CanSerialFake : CanSerial {
class Can232Fake : Can232 {
};
examples/canbus-monitor/canbus-monitor.ino
+7 -8
View File
@@ -21,7 +21,7 @@
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = BCM8;
const int CAN_INT_PIN = BCM25;;
const int CAN_INT_PIN = BCM25;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif
@@ -34,7 +34,7 @@
void setup() {
Serial.begin(LWUART_DEFAULT_BAUD_RATE); // default COM baud rate is 115200.
Serial.begin(LW232_DEFAULT_BAUD_RATE); // default COM baud rate is 115200.
// Can232::init (RATE, CLOCK)
// Rates: CAN_10KBPS, CAN_20KBPS, CAN_50KBPS, CAN_100KBPS, CAN_125KBPS, CAN_250KBPS, CAN_500KBPS, CAN_500KBPS, CAN_1000KBPS, CAN_83K3BPS
// Default is CAN_83K3BPS ;)))))))))
@@ -44,21 +44,20 @@ void setup() {
// Can232::init(); // rate and clock = LW232_DEFAULT_CAN_RATE and LW232_DEFAULT_CLOCK_FREQ
// Can232::init(CAN_125KBPS); // rate = 125, clock = LW232_DEFAULT_CLOCK_FREQ
//CanSerial::init(CAN_125KBPS, MCP_16MHz); // set default rate you need here and clock frequency of CAN shield. Typically it is 16MHz, but on some MCP2515 + TJA1050 it is 8Mhz
Can232::init(CAN_125KBPS, MCP_16MHz); // set default rate you need here and clock frequency of CAN shield. Typically it is 16MHz, but on some MCP2515 + TJA1050 it is 8Mhz
CanSerial::init(&CAN);
// optional custom packet filter to reduce number of messages comingh through to canhacker
// Can232::setFilter(myCustomAddressFilter);
}
INT8U myCustomAddressFilter(INT32U addr) {
INT8U ret = LWUART_FILTER_SKIP; //LW232_FILTER_PROCESS or LW232_FILTER_SKIP
INT8U ret = LW232_FILTER_SKIP; //LW232_FILTER_PROCESS or LW232_FILTER_SKIP
switch(addr) {
// case 0x01b: //VIN
// case 0x1C8: //lights
// case 0x2C0: // pedals
case 0x3d0: // sound vol, treb..
ret = LWUART_FILTER_PROCESS;
ret = LW232_FILTER_PROCESS;
// case 0x000: // ?
// case 0x003: //shifter
// case 0x015: // dor open close affects this as well
@@ -77,9 +76,9 @@ INT8U myCustomAddressFilter(INT32U addr) {
}
void loop() {
CanSerial::loop();
Can232::loop();
}
void serialEvent() {
CanSerial::serialEvent();
Can232::serialEvent();
}