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

Refactoring C -> C++

Browse Source
This commit is contained in:
Dmitry
2016-01-06 04:08:44 +03:00
parent de232fcbbe
commit aba5fb9225
3 changed files with 489 additions and 747 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mcp_can.cpp
+229 -380
View File
@@ -1,29 +1,18 @@
/*
mcp_can.cpp
2012 Copyright (c) Seeed Technology Inc. All right reserved.
Author:Loovee
Contributor: Cory J. Fowler
2014-1-16
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-
1301 USA
*/
#include "mcp_can.h"
const struct MCP_CAN::TXBn_REGS MCP_CAN::TXB[MCP_CAN::N_TXBUFFERS] = {
{MCP_TXB0CTRL, MCP_TXB0SIDH, MCP_TXB0DATA},
{MCP_TXB1CTRL, MCP_TXB1SIDH, MCP_TXB1DATA},
{MCP_TXB2CTRL, MCP_TXB2SIDH, MCP_TXB2DATA}
};
const struct MCP_CAN::RXBn_REGS MCP_CAN::RXB[N_RXBUFFERS] = {
{MCP_RXB0CTRL, MCP_RXB0SIDH, MCP_RXB0DATA},
{MCP_RXB1CTRL, MCP_RXB1SIDH, MCP_RXB1DATA}
};
void MCP_CAN::startSPI() {
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0));
SPI.beginTransaction(SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0));
digitalWrite(SPICS, LOW);
}
@@ -39,84 +28,78 @@ void MCP_CAN::endSPI() {
void MCP_CAN::mcp2515_reset(void)
{
startSPI();
SPI.transfer(MCP_RESET);
SPI.transfer(INSTRUCTION_RESET);
endSPI();
delay(10);
}
/*********************************************************************************************************
** Function name: mcp2515_readRegister
** Function name: readRegister
** Descriptions: read register
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_readRegister(const INT8U address)
uint8_t MCP_CAN::readRegister(const REGISTER reg)
{
INT8U ret;
startSPI();
SPI.transfer(MCP_READ);
SPI.transfer(address);
ret = SPI.transfer(0x00);
SPI.transfer(INSTRUCTION_READ);
SPI.transfer(reg);
uint8_t ret = SPI.transfer(0x00);
endSPI();
return ret;
}
/*********************************************************************************************************
** Function name: mcp2515_readRegisterS
** Function name: readRegisterS
** Descriptions: read registerS
*********************************************************************************************************/
void MCP_CAN::mcp2515_readRegisterS(const INT8U address, INT8U values[], const INT8U n)
void MCP_CAN::readRegisterS(const REGISTER address, uint8_t values[], const uint8_t n)
{
INT8U i;
startSPI();
SPI.transfer(MCP_READ);
SPI.transfer(address);
// mcp2515 has auto-increment of address-pointer
for (i=0; i<n; i++) {
values[i] = SPI.transfer(0x00);
}
endSPI();
startSPI();
SPI.transfer(INSTRUCTION_READ);
SPI.transfer(address);
// mcp2515 has auto-increment of address-pointer
for (uint8_t i=0; i<n; i++) {
values[i] = SPI.transfer(0x00);
}
endSPI();
}
/*********************************************************************************************************
** Function name: mcp2515_setRegister
** Function name: setRegister
** Descriptions: set register
*********************************************************************************************************/
void MCP_CAN::mcp2515_setRegister(const INT8U address, const INT8U value)
void MCP_CAN::setRegister(const REGISTER reg, const uint8_t value)
{
startSPI();
SPI.transfer(MCP_WRITE);
SPI.transfer(address);
SPI.transfer(INSTRUCTION_WRITE);
SPI.transfer(reg);
SPI.transfer(value);
endSPI();
}
/*********************************************************************************************************
** Function name: mcp2515_setRegisterS
** Function name: setRegisterS
** Descriptions: set registerS
*********************************************************************************************************/
void MCP_CAN::mcp2515_setRegisterS(const INT8U address, const INT8U values[], const INT8U n)
void MCP_CAN::setRegisterS(const REGISTER reg, const uint8_t values[], const uint8_t n)
{
INT8U i;
startSPI();
SPI.transfer(MCP_WRITE);
SPI.transfer(address);
for (i=0; i<n; i++)
{
SPI.transfer(INSTRUCTION_WRITE);
SPI.transfer(reg);
for (uint8_t i=0; i<n; i++) {
SPI.transfer(values[i]);
}
endSPI();
}
/*********************************************************************************************************
** Function name: mcp2515_modifyRegister
** Function name: modifyRegister
** Descriptions: set bit of one register
*********************************************************************************************************/
void MCP_CAN::mcp2515_modifyRegister(const INT8U address, const INT8U mask, const INT8U data)
void MCP_CAN::modifyRegister(const REGISTER address, const uint8_t mask, const uint8_t data)
{
startSPI();
SPI.transfer(MCP_BITMOD);
SPI.transfer(INSTRUCTION_BITMOD);
SPI.transfer(address);
SPI.transfer(mask);
SPI.transfer(data);
@@ -124,49 +107,43 @@ void MCP_CAN::mcp2515_modifyRegister(const INT8U address, const INT8U mask, cons
}
/*********************************************************************************************************
** Function name: mcp2515_readStatus
** Function name: getStatus
** Descriptions: read mcp2515's Status
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_readStatus(void)
uint8_t MCP_CAN::getStatus(void)
{
INT8U i;
startSPI();
SPI.transfer(MCP_READ_STATUS);
i = SPI.transfer(0x00);
endSPI();
return i;
startSPI();
SPI.transfer(INSTRUCTION_READ_STATUS);
uint8_t i = SPI.transfer(0x00);
endSPI();
return i;
}
/*********************************************************************************************************
** Function name: mcp2515_setCANCTRL_Mode
** Function name: setCANCTRL_Mode
** Descriptions: set control mode
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_setCANCTRL_Mode(const INT8U newmode)
MCP_CAN::ERROR MCP_CAN::setCANCTRL_Mode(const MODE newmode)
{
INT8U i;
modifyRegister(MCP_CANCTRL, MODE_MASK, newmode);
mcp2515_modifyRegister(MCP_CANCTRL, MODE_MASK, newmode);
i = mcp2515_readRegister(MCP_CANCTRL);
i &= MODE_MASK;
if ( i == newmode )
{
return MCP2515_OK;
uint8_t i = readRegister(MCP_CANCTRL) & MODE_MASK;
if (i == newmode) {
return ERROR_OK;
}
return MCP2515_FAIL;
return ERROR_FAIL;
}
/*********************************************************************************************************
** Function name: mcp2515_configRate
** Function name: configRate
** Descriptions: set boadrate
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_configRate(const INT8U canSpeed)
MCP_CAN::ERROR MCP_CAN::configRate(const CAN_SPEED canSpeed)
{
INT8U set, cfg1, cfg2, cfg3;
uint8_t set, cfg1, cfg2, cfg3;
set = 1;
switch (canSpeed)
{
@@ -230,7 +207,7 @@ INT8U MCP_CAN::mcp2515_configRate(const INT8U canSpeed)
cfg3 = MCP_16MHz_95kBPS_CFG3;
break;
case (CAN_100KBPS): /* 100KBPS */
case (CAN_100KBPS):
cfg1 = MCP_16MHz_100kBPS_CFG1;
cfg2 = MCP_16MHz_100kBPS_CFG2;
cfg3 = MCP_16MHz_100kBPS_CFG3;
@@ -272,190 +249,126 @@ INT8U MCP_CAN::mcp2515_configRate(const INT8U canSpeed)
}
if (set) {
mcp2515_setRegister(MCP_CNF1, cfg1);
mcp2515_setRegister(MCP_CNF2, cfg2);
mcp2515_setRegister(MCP_CNF3, cfg3);
return MCP2515_OK;
setRegister(MCP_CNF1, cfg1);
setRegister(MCP_CNF2, cfg2);
setRegister(MCP_CNF3, cfg3);
return ERROR_OK;
}
else {
return MCP2515_FAIL;
return ERROR_FAIL;
}
}
/*********************************************************************************************************
** Function name: mcp2515_initCANBuffers
** Function name: initCANBuffers
** Descriptions: init canbuffers
*********************************************************************************************************/
void MCP_CAN::mcp2515_initCANBuffers(void)
void MCP_CAN::initCANBuffers(void)
{
INT8U i, a1, a2, a3;
//INT8U std = 0;
//INT8U ext = 1;
//INT32U ulMask = 0x00, ulFilt = 0x00;
//uint8_t std = 0;
//uint8_t ext = 1;
//uint32_t ulMask = 0x00, ulFilt = 0x00;
//mcp2515_write_id(MCP_RXM0SIDH, ext, ulMask); /*Set both masks to 0 */
//mcp2515_write_id(MCP_RXM1SIDH, ext, ulMask); /*Mask register ignores ext bit */
//write_id(MCP_RXM0SIDH, ext, ulMask); /*Set both masks to 0 */
//write_id(MCP_RXM1SIDH, ext, ulMask); /*Mask register ignores ext bit */
/* Set all filters to 0 */
//mcp2515_write_id(MCP_RXF0SIDH, ext, ulFilt); /* RXB0: extended */
//mcp2515_write_id(MCP_RXF1SIDH, std, ulFilt); /* RXB1: standard */
//mcp2515_write_id(MCP_RXF2SIDH, ext, ulFilt); /* RXB2: extended */
//mcp2515_write_id(MCP_RXF3SIDH, std, ulFilt); /* RXB3: standard */
//mcp2515_write_id(MCP_RXF4SIDH, ext, ulFilt);
//mcp2515_write_id(MCP_RXF5SIDH, std, ulFilt);
//write_id(MCP_RXF0SIDH, ext, ulFilt); /* RXB0: extended */
//write_id(MCP_RXF1SIDH, std, ulFilt); /* RXB1: standard */
//write_id(MCP_RXF2SIDH, ext, ulFilt); /* RXB2: extended */
//write_id(MCP_RXF3SIDH, std, ulFilt); /* RXB3: standard */
//write_id(MCP_RXF4SIDH, ext, ulFilt);
//write_id(MCP_RXF5SIDH, std, ulFilt);
/* Clear, deactivate the three */
/* transmit buffers */
/* TXBnCTRL -> TXBnD7 */
a1 = MCP_TXB0CTRL;
a2 = MCP_TXB1CTRL;
a3 = MCP_TXB2CTRL;
for (i = 0; i < 14; i++) { /* in-buffer loop */
mcp2515_setRegister(a1, 0);
mcp2515_setRegister(a2, 0);
mcp2515_setRegister(a3, 0);
a1++;
a2++;
a3++;
}
mcp2515_setRegister(MCP_RXB0CTRL, 0);
mcp2515_setRegister(MCP_RXB1CTRL, 0);
uint8_t zeros[14];
memset(zeros, 0, sizeof(zeros));
setRegisterS(MCP_TXB0CTRL, zeros, 14);
setRegisterS(MCP_TXB1CTRL, zeros, 14);
setRegisterS(MCP_TXB2CTRL, zeros, 14);
setRegister(MCP_RXB0CTRL, 0);
setRegister(MCP_RXB1CTRL, 0);
}
/*********************************************************************************************************
** Function name: mcp2515_init
** Descriptions: init the device
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_init(const INT8U canSpeed) /* mcp2515init */
MCP_CAN::ERROR MCP_CAN::mcp2515_init(const CAN_SPEED canSpeed) /* mcp2515init */
{
INT8U res;
mcp2515_reset();
res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
if(res > 0)
{
#if DEBUG_MODE
Serial.print("Enter setting mode fall\r\n");
#else
delay(10);
#endif
return res;
}
#if DEBUG_MODE
Serial.print("Enter setting mode success \r\n");
#else
ERROR res = setCANCTRL_Mode(MODE_CONFIG);
delay(10);
#endif
/* set boadrate */
if(mcp2515_configRate(canSpeed))
{
#if DEBUG_MODE
Serial.print("set rate fall!!\r\n");
#else
delay(10);
#endif
return res;
if (res != ERROR_OK) {
return res;
}
#if DEBUG_MODE
Serial.print("set rate success!!\r\n");
#else
res = configRate(canSpeed);
delay(10);
#endif
if ( res == MCP2515_OK ) {
/* init canbuffers */
mcp2515_initCANBuffers();
/* interrupt mode */
mcp2515_setRegister(MCP_CANINTE, MCP_RX0IF | MCP_RX1IF);
#if (DEBUG_RXANY==1)
/* enable both receive-buffers */
/* to receive any message */
/* and enable rollover */
mcp2515_modifyRegister(MCP_RXB0CTRL,
MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK,
MCP_RXB_RX_ANY | MCP_RXB_BUKT_MASK);
mcp2515_modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK,
MCP_RXB_RX_ANY);
#else
/* enable both receive-buffers */
/* to receive messages */
/* with std. and ext. identifie */
/* rs */
/* and enable rollover */
mcp2515_modifyRegister(MCP_RXB0CTRL,
MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK,
MCP_RXB_RX_STDEXT | MCP_RXB_BUKT_MASK );
mcp2515_modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK,
MCP_RXB_RX_STDEXT);
#endif
/* enter normal mode */
res = mcp2515_setCANCTRL_Mode(m_mode);
if(res)
{
#if DEBUG_MODE
Serial.print("Enter Normal Mode Fall!!\r\n");
#else
delay(10);
#endif
return res;
}
#if DEBUG_MODE
Serial.print("Enter Normal Mode Success!!\r\n");
#else
delay(10);
#endif
if (res != ERROR_OK) {
return res;
}
initCANBuffers();
setRegister(MCP_CANINTE, CANINTF_RX0IF | CANINTF_RX1IF);
modifyRegister(MCP_RXB0CTRL,
MCP_RXB_RX_MASK | MCP_RXB_BUKT_MASK,
MCP_RXB_RX_STDEXT | MCP_RXB_BUKT_MASK );
modifyRegister(MCP_RXB1CTRL, MCP_RXB_RX_MASK,
MCP_RXB_RX_STDEXT);
/* enter normal mode */
res = setCANCTRL_Mode(m_mode);
delay(10);
return res;
}
/*********************************************************************************************************
** Function name: mcp2515_write_id
** Function name: write_id
** Descriptions: write can id
*********************************************************************************************************/
void MCP_CAN::mcp2515_write_id( const INT8U mcp_addr, const bool ext, const INT32U id )
void MCP_CAN::write_id(const REGISTER mcp_addr, const bool ext, const uint32_t id)
{
uint16_t canid;
INT8U tbufdata[4];
uint8_t tbufdata[4];
canid = (uint16_t)(id & 0x0FFFF);
prepareId(tbufdata, ext, id);
if ( ext == 1)
{
tbufdata[MCP_EID0] = (INT8U) (canid & 0xFF);
tbufdata[MCP_EID8] = (INT8U) (canid >> 8);
setRegisterS(mcp_addr, tbufdata, 4);
}
void MCP_CAN::prepareId(uint8_t *buffer, const bool ext, const uint32_t id)
{
uint16_t canid = (uint16_t)(id & 0x0FFFF);
if (ext) {
buffer[MCP_EID0] = (uint8_t) (canid & 0xFF);
buffer[MCP_EID8] = (uint8_t) (canid >> 8);
canid = (uint16_t)(id >> 16);
tbufdata[MCP_SIDL] = (INT8U) (canid & 0x03);
tbufdata[MCP_SIDL] += (INT8U) ((canid & 0x1C) << 3);
tbufdata[MCP_SIDL] |= MCP_TXB_EXIDE_M;
tbufdata[MCP_SIDH] = (INT8U) (canid >> 5 );
buffer[MCP_SIDL] = (uint8_t) (canid & 0x03);
buffer[MCP_SIDL] += (uint8_t) ((canid & 0x1C) << 3);
buffer[MCP_SIDL] |= TXB_EXIDE_MASK;
buffer[MCP_SIDH] = (uint8_t) (canid >> 5 );
} else {
buffer[MCP_SIDH] = (uint8_t) (canid >> 3 );
buffer[MCP_SIDL] = (uint8_t) ((canid & 0x07 ) << 5);
buffer[MCP_EID0] = 0;
buffer[MCP_EID8] = 0;
}
else
{
tbufdata[MCP_SIDH] = (INT8U) (canid >> 3 );
tbufdata[MCP_SIDL] = (INT8U) ((canid & 0x07 ) << 5);
tbufdata[MCP_EID0] = 0;
tbufdata[MCP_EID8] = 0;
}
mcp2515_setRegisterS( mcp_addr, tbufdata, 4 );
}
/*********************************************************************************************************
** Function name: set CS
** Descriptions: init CS pin and set UNSELECTED
*********************************************************************************************************/
MCP_CAN::MCP_CAN(INT8U _CS, INT8U mode)
MCP_CAN::MCP_CAN(uint8_t _CS, MODE mode)
{
m_mode = mode;
SPICS = _CS;
@@ -467,182 +380,133 @@ MCP_CAN::MCP_CAN(INT8U _CS, INT8U mode)
** Function name: init
** Descriptions: init can and set speed
*********************************************************************************************************/
INT8U MCP_CAN::begin(INT8U speedset)
MCP_CAN::ERROR MCP_CAN::begin(const CAN_SPEED speedset)
{
INT8U res;
SPI.begin();
res = mcp2515_init(speedset);
if (res == MCP2515_OK) return CAN_OK;
else return CAN_FAILINIT;
return mcp2515_init(speedset);
}
/*********************************************************************************************************
** Function name: init_Mask
** Function name: initMask
** Descriptions: init canid Masks
*********************************************************************************************************/
INT8U MCP_CAN::init_Mask(INT8U num, bool ext, INT32U ulData)
MCP_CAN::ERROR MCP_CAN::initMask(uint8_t num, const bool ext, uint32_t ulData)
{
INT8U res = MCP2515_OK;
#if DEBUG_MODE
Serial.print("Begin to set Mask!!\r\n");
#else
delay(10);
#endif
res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
if(res > 0){
#if DEBUG_MODE
Serial.print("Enter setting mode fall\r\n");
#else
delay(10);
#endif
return res;
}
if (num == 0){
mcp2515_write_id(MCP_RXM0SIDH, ext, ulData);
ERROR res = setCANCTRL_Mode(MODE_CONFIG);
if (res != ERROR_OK){
delay(10);
return res;
}
else if(num == 1){
mcp2515_write_id(MCP_RXM1SIDH, ext, ulData);
}
else res = MCP2515_FAIL;
res = mcp2515_setCANCTRL_Mode(m_mode);
if(res > 0){
#if DEBUG_MODE
Serial.print("Enter normal mode fall\r\n");
#else
if (num == 0) {
write_id(MCP_RXM0SIDH, ext, ulData);
} else if (num == 1){
write_id(MCP_RXM1SIDH, ext, ulData);
} else {
//res = ERROR_FAIL;
}
res = setCANCTRL_Mode(m_mode);
delay(10);
#endif
return res;
}
#if DEBUG_MODE
Serial.print("set Mask success!!\r\n");
#else
delay(10);
#endif
return res;
}
/*********************************************************************************************************
** Function name: init_Filt
** Function name: initFilt
** Descriptions: init canid filters
*********************************************************************************************************/
INT8U MCP_CAN::init_Filt(INT8U num, bool ext, INT32U ulData)
MCP_CAN::ERROR MCP_CAN::initFilt(uint8_t num, const bool ext, uint32_t ulData)
{
INT8U res = MCP2515_OK;
#if DEBUG_MODE
Serial.print("Begin to set Filter!!\r\n");
#else
delay(10);
#endif
res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
if(res > 0)
{
#if DEBUG_MODE
Serial.print("Enter setting mode fall\r\n");
#else
delay(10);
#endif
return res;
ERROR res = setCANCTRL_Mode(MODE_CONFIG);
if (res != ERROR_OK) {
delay(10);
return res;
}
switch( num )
{
switch (num) {
case 0:
mcp2515_write_id(MCP_RXF0SIDH, ext, ulData);
write_id(MCP_RXF0SIDH, ext, ulData);
break;
case 1:
mcp2515_write_id(MCP_RXF1SIDH, ext, ulData);
write_id(MCP_RXF1SIDH, ext, ulData);
break;
case 2:
mcp2515_write_id(MCP_RXF2SIDH, ext, ulData);
write_id(MCP_RXF2SIDH, ext, ulData);
break;
case 3:
mcp2515_write_id(MCP_RXF3SIDH, ext, ulData);
write_id(MCP_RXF3SIDH, ext, ulData);
break;
case 4:
mcp2515_write_id(MCP_RXF4SIDH, ext, ulData);
write_id(MCP_RXF4SIDH, ext, ulData);
break;
case 5:
mcp2515_write_id(MCP_RXF5SIDH, ext, ulData);
write_id(MCP_RXF5SIDH, ext, ulData);
break;
default:
res = MCP2515_FAIL;
//res = ERROR_FAIL;
break;
}
res = mcp2515_setCANCTRL_Mode(m_mode);
if(res > 0)
{
#if DEBUG_MODE
Serial.print("Enter normal mode fall\r\nSet filter fail!!\r\n");
#else
delay(10);
#endif
return res;
}
#if DEBUG_MODE
Serial.print("set Filter success!!\r\n");
#else
res = setCANCTRL_Mode(m_mode);
delay(10);
#endif
return res;
}
/*********************************************************************************************************
** Function name: sendMsgBuf
** Descriptions: send buf
*********************************************************************************************************/
INT8U MCP_CAN::sendMessage(const INT32U id, const bool ext, const bool rtr, const INT8U len, const INT8U *buf)
MCP_CAN::ERROR MCP_CAN::sendMessage(const uint32_t id, const bool ext, const bool rtr, const uint8_t len, const uint8_t *buf)
{
INT8U txbuf_n = 0;
INT8U ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };
if (len > CAN_MAX_CHAR_IN_MESSAGE) {
return ERROR_FAILTX;
}
for (int i=0; i<MCP_N_TXBUFFERS; i++) {
INT8U ctrlval = mcp2515_readRegister( ctrlregs[i] );
if ( (ctrlval & MCP_TXB_TXREQ_M) == 0 ) {
txbuf_n = ctrlregs[i]+1;
const struct TXBn_REGS *txbuf = NULL;
for (int i=0; i<N_TXBUFFERS; i++) {
uint8_t ctrlval = readRegister(TXB[i].CTRL);
if ( (ctrlval & TXB_TXREQ) == 0 ) {
txbuf = &TXB[i];
break;
}
}
if (txbuf_n == 0) {
return CAN_GETTXBFTIMEOUT; /* get tx buff time out */
if (txbuf == NULL) {
return ERROR_FAILTX;
}
uint8_t data[13];
mcp2515_setRegisterS(txbuf_n+5, buf, len); /* write data bytes */
prepareId(data, ext, id);
INT8U dlc = len;
if (rtr) { /* if RTR set bit in byte */
dlc |= MCP_RTR_MASK;
}
mcp2515_setRegister(txbuf_n+4, dlc ); /* write the RTR and DLC */
mcp2515_write_id(txbuf_n, ext, id); /* write CAN id */
data[MCP_DLC] = rtr ? len | RTR_MASK : len;
memcpy(&data[MCP_DATA], buf, len);
mcp2515_modifyRegister( txbuf_n-1 , MCP_TXB_TXREQ_M, MCP_TXB_TXREQ_M );
setRegisterS(txbuf->SIDH, data, 5 + len);
return CAN_OK;
modifyRegister(txbuf->CTRL, TXB_TXREQ, TXB_TXREQ);
return ERROR_OK;
}
INT8U MCP_CAN::readMessage(const INT8U buffer_sidh_addr, INT32U *id, INT8U *dlc, INT8U buf[], bool *rtr, bool *ext) /* read can msg */
MCP_CAN::ERROR MCP_CAN::readMessage(const RXBn rxbn, uint32_t *id, uint8_t *dlc, uint8_t buf[], bool *rtr, bool *ext)
{
INT8U tbufdata[4];
const struct RXBn_REGS *rxb = &RXB[rxbn];
mcp2515_readRegisterS(buffer_sidh_addr, tbufdata, 4);
uint8_t tbufdata[5];
readRegisterS(rxb->SIDH, tbufdata, 5);
*id = (tbufdata[MCP_SIDH]<<3) + (tbufdata[MCP_SIDL]>>5);
if ( (tbufdata[MCP_SIDL] & MCP_TXB_EXIDE_M) == MCP_TXB_EXIDE_M ) {
if ( (tbufdata[MCP_SIDL] & TXB_EXIDE_MASK) == TXB_EXIDE_MASK ) {
*id = (*id<<2) + (tbufdata[MCP_SIDL] & 0x03);
*id = (*id<<8) + tbufdata[MCP_EID8];
*id = (*id<<8) + tbufdata[MCP_EID0];
@@ -651,46 +515,43 @@ INT8U MCP_CAN::readMessage(const INT8U buffer_sidh_addr, INT32U *id, INT8U *dlc,
*ext = false;
}
INT8U ctrl = mcp2515_readRegister( buffer_sidh_addr-1 );
*dlc = tbufdata[MCP_DLC] & DLC_MASK;
if (*dlc > CAN_MAX_CHAR_IN_MESSAGE) {
return ERROR_FAIL;
}
uint8_t ctrl = readRegister(rxb->CTRL);
if (ctrl & 0x08) {
*rtr = true;
} else {
*rtr = false;
}
INT8U mDlc = mcp2515_readRegister( buffer_sidh_addr+4 );
*dlc = mDlc & MCP_DLC_MASK;
if (*dlc > CAN_MAX_CHAR_IN_MESSAGE) {
return CAN_FAIL;
}
readRegisterS(rxb->DATA, buf, *dlc);
mcp2515_readRegisterS(buffer_sidh_addr+5, buf, *dlc);
switch (buffer_sidh_addr) {
case MCP_RXBUF_0:
mcp2515_modifyRegister(MCP_CANINTF, MCP_RX0IF, 0);
switch (rxbn) {
case RXB0:
modifyRegister(MCP_CANINTF, CANINTF_RX0IF, 0);
break;
case MCP_RXBUF_1:
mcp2515_modifyRegister(MCP_CANINTF, MCP_RX1IF, 0);
case RXB1:
modifyRegister(MCP_CANINTF, CANINTF_RX1IF, 0);
break;
}
return CAN_OK;
return ERROR_OK;
}
INT8U MCP_CAN::readMessage(INT32U *id, INT8U *len, INT8U buf[], bool *rtr, bool *ext)
MCP_CAN::ERROR MCP_CAN::readMessage(uint32_t *id, uint8_t *len, uint8_t buf[], bool *rtr, bool *ext)
{
INT8U rc;
INT8U stat = mcp2515_readStatus();
ERROR rc;
uint8_t stat = getStatus();
if ( stat & MCP_STAT_RX0IF ) {
readMessage(MCP_RXBUF_0, id, len, buf, rtr, ext);
rc = CAN_OK;
} else if ( stat & MCP_STAT_RX1IF ) {
readMessage(MCP_RXBUF_1, id, len, buf, rtr, ext);
rc = CAN_OK;
if ( stat & STAT_RX0IF ) {
rc = readMessage(RXB0, id, len, buf, rtr, ext);
} else if ( stat & STAT_RX1IF ) {
rc = readMessage(RXB1, id, len, buf, rtr, ext);
} else {
rc = CAN_NOMSG;
rc = ERROR_NOMSG;
}
return rc;
@@ -700,17 +561,13 @@ INT8U MCP_CAN::readMessage(INT32U *id, INT8U *len, INT8U buf[], bool *rtr, bool
** Function name: checkReceive
** Descriptions: check if got something
*********************************************************************************************************/
INT8U MCP_CAN::checkReceive(void)
bool MCP_CAN::checkReceive(void)
{
INT8U res;
res = mcp2515_readStatus(); /* RXnIF in Bit 1 and 0 */
if ( res & MCP_STAT_RXIF_MASK )
{
return CAN_MSGAVAIL;
}
else
{
return CAN_NOMSG;
uint8_t res = getStatus();
if ( res & STAT_RXIF_MASK ) {
return true;
} else {
return false;
}
}
@@ -718,42 +575,34 @@ INT8U MCP_CAN::checkReceive(void)
** Function name: checkError
** Descriptions: if something error
*********************************************************************************************************/
INT8U MCP_CAN::checkError(void)
bool MCP_CAN::checkError(void)
{
INT8U eflg = mcp2515_readRegister(MCP_EFLG);
uint8_t eflg = readRegister(MCP_EFLG);
if ( eflg & MCP_EFLG_ERRORMASK )
{
return CAN_CTRLERROR;
}
else
{
return CAN_OK;
if ( eflg & EFLG_ERRORMASK ) {
return true;
} else {
return false;
}
}
INT8U MCP_CAN::getInterrupts(void)
uint8_t MCP_CAN::getInterrupts(void)
{
return mcp2515_readRegister(MCP_CANINTF);
return readRegister(MCP_CANINTF);
}
void MCP_CAN::clearInterrupts(void)
{
mcp2515_setRegister(MCP_CANINTF, 0);
setRegister(MCP_CANINTF, 0);
}
INT8U MCP_CAN::getInterruptMask(void)
uint8_t MCP_CAN::getInterruptMask(void)
{
return mcp2515_readRegister(MCP_CANINTE);
return readRegister(MCP_CANINTE);
}
void MCP_CAN::clearTXInterrupts(void)
{
mcp2515_modifyRegister(MCP_CANINTF, MCP_TX_INT, 0);
}
INT8U MCP_CAN::getCanStat(void)
{
return mcp2515_readStatus();
modifyRegister(MCP_CANINTF, (CANINTF_TX0IF | CANINTF_TX1IF | CANINTF_TX2IF), 0);
}
mcp_can.h
+258 -75
View File
@@ -1,92 +1,275 @@
/*
mcp_can.h
2012 Copyright (c) Seeed Technology Inc. All right reserved.
Author:Loovee
Contributor: Cory J. Fowler
2014-1-16
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-
1301 USA
*/
#ifndef _MCP2515_H_
#define _MCP2515_H_
#include <SPI.h>
#include "mcp_can_dfs.h"
enum CAN_SPEED {
CAN_5KBPS,
CAN_10KBPS,
CAN_20KBPS,
CAN_31K25BPS,
CAN_33KBPS,
CAN_40KBPS,
CAN_50KBPS,
CAN_80KBPS,
CAN_83K3BPS,
CAN_95KBPS,
CAN_100KBPS,
CAN_125KBPS,
CAN_200KBPS,
CAN_250KBPS,
CAN_500KBPS,
CAN_1000KBPS
};
class MCP_CAN
{
public:
enum ERROR {
ERROR_OK = 0,
ERROR_FAIL = 1,
ERROR_ALLTXBUSY = 2,
ERROR_FAILINIT = 3,
ERROR_FAILTX = 4,
ERROR_NOMSG = 5
};
enum RXBn {
RXB0 = 0,
RXB1 = 1
};
enum /*class*/ MODE : uint8_t {
MODE_NORMAL = 0x00,
MODE_SLEEP = 0x20,
MODE_LOOPBACK = 0x40,
MODE_LISTENONLY = 0x60,
MODE_CONFIG = 0x80,
MODE_POWERUP = 0xE0
};
enum /*class*/ CANINTF : uint8_t {
CANINTF_RX0IF = 0x01,
CANINTF_RX1IF = 0x02,
CANINTF_TX0IF = 0x04,
CANINTF_TX1IF = 0x08,
CANINTF_TX2IF = 0x10,
CANINTF_ERRIF = 0x20,
CANINTF_WAKIF = 0x40,
CANINTF_MERRF = 0x80
};
private:
INT8U SPICS;
INT8U m_mode;
static const uint8_t MODE_MASK = 0xE0;
/*
* mcp2515 driver function
*/
// private:
private:
static const uint8_t TXB_EXIDE_MASK = 0x08;
static const uint8_t DLC_MASK = 0x0F;
static const uint8_t RTR_MASK = 0x40;
void mcp2515_reset(void); /* reset mcp2515 */
enum /*class*/ STAT : uint8_t {
STAT_RX0IF = (1<<0),
STAT_RX1IF = (1<<1)
};
INT8U mcp2515_readRegister(const INT8U address); /* read mcp2515's register */
static const uint8_t STAT_RXIF_MASK = STAT_RX0IF | STAT_RX1IF;
enum /*class*/ TXBnCTRL : uint8_t {
TXB_ABTF = 0x40,
TXB_MLOA = 0x20,
TXB_TXERR = 0x10,
TXB_TXREQ = 0x08,
TXB_TXIE = 0x04,
TXB_TXP = 0x03
};
enum /*class*/ EFLG : uint8_t {
EFLG_RX1OVR = (1<<7),
EFLG_RX0OVR = (1<<6),
EFLG_TXBO = (1<<5),
EFLG_TXEP = (1<<4),
EFLG_RXEP = (1<<3),
EFLG_TXWAR = (1<<2),
EFLG_RXWAR = (1<<1),
EFLG_EWARN = (1<<0)
};
static const uint8_t EFLG_ERRORMASK = EFLG_RX1OVR
| EFLG_RX0OVR
| EFLG_TXBO
| EFLG_TXEP
| EFLG_RXEP;
enum /*class*/ INSTRUCTION : uint8_t {
INSTRUCTION_WRITE = 0x02,
INSTRUCTION_READ = 0x03,
INSTRUCTION_BITMOD = 0x05,
INSTRUCTION_LOAD_TX0 = 0x40,
INSTRUCTION_LOAD_TX1 = 0x42,
INSTRUCTION_LOAD_TX2 = 0x44,
INSTRUCTION_RTS_TX0 = 0x81,
INSTRUCTION_RTS_TX1 = 0x82,
INSTRUCTION_RTS_TX2 = 0x84,
INSTRUCTION_RTS_ALL = 0x87,
INSTRUCTION_READ_RX0 = 0x90,
INSTRUCTION_READ_RX1 = 0x94,
INSTRUCTION_READ_STATUS = 0xA0,
INSTRUCTION_RX_STATUS = 0xB0,
INSTRUCTION_RESET = 0xC0
};
enum /*class*/ REGISTER : uint8_t {
MCP_RXF0SIDH = 0x00,
MCP_RXF0SIDL = 0x01,
MCP_RXF0EID8 = 0x02,
MCP_RXF0EID0 = 0x03,
MCP_RXF1SIDH = 0x04,
MCP_RXF1SIDL = 0x05,
MCP_RXF1EID8 = 0x06,
MCP_RXF1EID0 = 0x07,
MCP_RXF2SIDH = 0x08,
MCP_RXF2SIDL = 0x09,
MCP_RXF2EID8 = 0x0A,
MCP_RXF2EID0 = 0x0B,
MCP_CANSTAT = 0x0E,
MCP_CANCTRL = 0x0F,
MCP_RXF3SIDH = 0x10,
MCP_RXF3SIDL = 0x11,
MCP_RXF3EID8 = 0x12,
MCP_RXF3EID0 = 0x13,
MCP_RXF4SIDH = 0x14,
MCP_RXF4SIDL = 0x15,
MCP_RXF4EID8 = 0x16,
MCP_RXF4EID0 = 0x17,
MCP_RXF5SIDH = 0x18,
MCP_RXF5SIDL = 0x19,
MCP_RXF5EID8 = 0x1A,
MCP_RXF5EID0 = 0x1B,
MCP_TEC = 0x1C,
MCP_REC = 0x1D,
MCP_RXM0SIDH = 0x20,
MCP_RXM0SIDL = 0x21,
MCP_RXM0EID8 = 0x22,
MCP_RXM0EID0 = 0x23,
MCP_RXM1SIDH = 0x24,
MCP_RXM1SIDL = 0x25,
MCP_RXM1EID8 = 0x26,
MCP_RXM1EID0 = 0x27,
MCP_CNF3 = 0x28,
MCP_CNF2 = 0x29,
MCP_CNF1 = 0x2A,
MCP_CANINTE = 0x2B,
MCP_CANINTF = 0x2C,
MCP_EFLG = 0x2D,
MCP_TXB0CTRL = 0x30,
MCP_TXB0SIDH = 0x31,
MCP_TXB0SIDL = 0x32,
MCP_TXB0EID8 = 0x33,
MCP_TXB0EID0 = 0x34,
MCP_TXB0DLC = 0x35,
MCP_TXB0DATA = 0x36,
MCP_TXB1CTRL = 0x40,
MCP_TXB1SIDH = 0x41,
MCP_TXB1SIDL = 0x42,
MCP_TXB1EID8 = 0x43,
MCP_TXB1EID0 = 0x44,
MCP_TXB1DLC = 0x45,
MCP_TXB1DATA = 0x46,
MCP_TXB2CTRL = 0x50,
MCP_TXB2SIDH = 0x51,
MCP_TXB2SIDL = 0x52,
MCP_TXB2EID8 = 0x53,
MCP_TXB2EID0 = 0x54,
MCP_TXB2DLC = 0x55,
MCP_TXB2DATA = 0x56,
MCP_RXB0CTRL = 0x60,
MCP_RXB0SIDH = 0x61,
MCP_RXB0SIDL = 0x62,
MCP_RXB0EID8 = 0x63,
MCP_RXB0EID0 = 0x64,
MCP_RXB0DLC = 0x65,
MCP_RXB0DATA = 0x66,
MCP_RXB1CTRL = 0x70,
MCP_RXB1SIDH = 0x71,
MCP_RXB1SIDL = 0x72,
MCP_RXB1EID8 = 0x73,
MCP_RXB1EID0 = 0x74,
MCP_RXB1DLC = 0x75,
MCP_RXB1DATA = 0x76
};
static const int CAN_MAX_CHAR_IN_MESSAGE = 8;
static const uint32_t SPI_CLOCK = 10000000; // 10MHz
static const int N_TXBUFFERS = 3;
static const int N_RXBUFFERS = 2;
static const struct TXBn_REGS {
REGISTER CTRL;
REGISTER SIDH;
REGISTER DATA;
} TXB[N_TXBUFFERS];
static const struct RXBn_REGS {
REGISTER CTRL;
REGISTER SIDH;
REGISTER DATA;
} RXB[N_RXBUFFERS];
uint8_t SPICS;
MODE m_mode;
private:
void mcp2515_reset(void); /* reset mcp2515 */
uint8_t readRegister(const REGISTER reg); /* read mcp2515's register */
void readRegisterS(const REGISTER reg,
uint8_t values[],
const uint8_t n);
void setRegister(const REGISTER reg, /* set mcp2515's register */
const uint8_t value);
void setRegisterS(const REGISTER reg, /* set mcp2515's registers */
const uint8_t values[],
const uint8_t n);
void initCANBuffers(void);
void modifyRegister(const REGISTER reg,
const uint8_t mask,
const uint8_t data);
ERROR setCANCTRL_Mode(const MODE newmode);
ERROR configRate(const CAN_SPEED canSpeed);
ERROR mcp2515_init(const CAN_SPEED canSpeed);
void write_id(const REGISTER mcp_addr,
const bool ext,
const uint32_t id);
void mcp2515_readRegisterS(const INT8U address,
INT8U values[],
const INT8U n);
void mcp2515_setRegister(const INT8U address, /* set mcp2515's register */
const INT8U value);
void mcp2515_setRegisterS(const INT8U address, /* set mcp2515's registers */
const INT8U values[],
const INT8U n);
void prepareId(uint8_t *buffer, const bool ext, const uint32_t id);
void mcp2515_initCANBuffers(void);
void startSPI();
void endSPI();
void mcp2515_modifyRegister(const INT8U address, /* set bit of one register */
const INT8U mask,
const INT8U data);
INT8U mcp2515_readStatus(void); /* read mcp2515's Status */
INT8U mcp2515_setCANCTRL_Mode(const INT8U newmode); /* set mode */
INT8U mcp2515_configRate(const INT8U canSpeed); /* set boadrate */
INT8U mcp2515_init(const INT8U canSpeed); /* mcp2515init */
void mcp2515_write_id( const INT8U mcp_addr, /* write can id */
const bool ext,
const INT32U id );
void startSPI();
void endSPI();
public:
MCP_CAN(INT8U _CS, INT8U mode);
INT8U begin(INT8U speedset); /* init can */
INT8U init_Mask(INT8U num, bool ext, INT32U ulData); /* init Masks */
INT8U init_Filt(INT8U num, bool ext, INT32U ulData); /* init filters */
INT8U sendMessage(const INT32U id, const bool ext, const bool rtr, const INT8U len, const INT8U *buf); /* send buf */
INT8U readMessage(const INT8U buffer_sidh_addr, INT32U *id, INT8U *dlc, INT8U buf[], bool *rtr, bool *ext); /* read can msg */
INT8U readMessage(INT32U *ID, INT8U *len, INT8U buf[], bool *rtr, bool *ext); /* read buf with object ID */
INT8U checkReceive(void); /* if something received */
INT8U checkError(void); /* if something error */
INT8U getInterrupts(void);
INT8U getInterruptMask(void);
void clearInterrupts(void);
void clearTXInterrupts(void);
INT8U getCanStat(void);
public:
MCP_CAN(uint8_t _CS, MODE mode);
ERROR begin(const CAN_SPEED speedset); /* init can */
ERROR initMask(uint8_t num, bool ext, uint32_t ulData); /* init Masks */
ERROR initFilt(uint8_t num, bool ext, uint32_t ulData); /* init filters */
ERROR sendMessage(const uint32_t id, const bool ext, const bool rtr, const uint8_t len, const uint8_t *buf); /* send buf */
ERROR readMessage(const RXBn rxbn, uint32_t *id, uint8_t *dlc, uint8_t buf[], bool *rtr, bool *ext); /* read can msg */
ERROR readMessage(uint32_t *ID, uint8_t *len, uint8_t buf[], bool *rtr, bool *ext); /* read buf with object ID */
bool checkReceive(void); /* if something received */
bool checkError(void); /* if something error */
uint8_t getInterrupts(void);
uint8_t getInterruptMask(void);
void clearInterrupts(void);
void clearTXInterrupts(void);
uint8_t getStatus(void);
};
#endif
/*********************************************************************************************************
END FILE
*********************************************************************************************************/
mcp_can_dfs.h
+2 -292
View File
@@ -1,249 +1,22 @@
/*
mcp_can_dfs.h
2012 Copyright (c) Seeed Technology Inc. All right reserved.
Author:Loovee
Contributor: Cory J. Fowler
2014-1-16
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-
1301 USA
*/
#ifndef _MCP2515DFS_H_
#define _MCP2515DFS_H_
#include <Arduino.h>
#include <SPI.h>
#include <inttypes.h>
#ifndef INT32U
#define INT32U unsigned long
#endif
#ifndef INT8U
#define INT8U byte
#endif
// if print debug information
#define DEBUG_MODE 0
/*
* Begin mt
*/
#define TIMEOUTVALUE 50
#define MCP_SIDH 0
#define MCP_SIDL 1
#define MCP_EID8 2
#define MCP_EID0 3
#define MCP_DLC 4
#define MCP_DATA 5
#define MCP_TXB_EXIDE_M 0x08 /* In TXBnSIDL */
#define MCP_DLC_MASK 0x0F /* 4 LSBits */
#define MCP_RTR_MASK 0x40 /* (1<<6) Bit 6 */
#define MCP_RXB_RX_ANY 0x60
#define MCP_RXB_RX_EXT 0x40
#define MCP_RXB_RX_STD 0x20
#define MCP_RXB_RX_STDEXT 0x00
#define MCP_RXB_RX_MASK 0x60
#define MCP_RXB_BUKT_MASK (1<<2)
/*
** Bits in the TXBnCTRL registers.
*/
#define MCP_TXB_TXBUFE_M 0x80
#define MCP_TXB_ABTF_M 0x40
#define MCP_TXB_MLOA_M 0x20
#define MCP_TXB_TXERR_M 0x10
#define MCP_TXB_TXREQ_M 0x08
#define MCP_TXB_TXIE_M 0x04
#define MCP_TXB_TXP10_M 0x03
#define MCP_TXB_RTR_M 0x40 /* In TXBnDLC */
#define MCP_RXB_IDE_M 0x08 /* In RXBnSIDL */
#define MCP_RXB_RTR_M 0x40 /* In RXBnDLC */
#define MCP_STAT_RXIF_MASK (0x03)
#define MCP_STAT_RX0IF (1<<0)
#define MCP_STAT_RX1IF (1<<1)
#define MCP_EFLG_RX1OVR (1<<7)
#define MCP_EFLG_RX0OVR (1<<6)
#define MCP_EFLG_TXBO (1<<5)
#define MCP_EFLG_TXEP (1<<4)
#define MCP_EFLG_RXEP (1<<3)
#define MCP_EFLG_TXWAR (1<<2)
#define MCP_EFLG_RXWAR (1<<1)
#define MCP_EFLG_EWARN (1<<0)
#define MCP_EFLG_ERRORMASK (0xF8) /* 5 MS-Bits */
/*
* Define MCP2515 register addresses
*/
#define MCP_RXF0SIDH 0x00
#define MCP_RXF0SIDL 0x01
#define MCP_RXF0EID8 0x02
#define MCP_RXF0EID0 0x03
#define MCP_RXF1SIDH 0x04
#define MCP_RXF1SIDL 0x05
#define MCP_RXF1EID8 0x06
#define MCP_RXF1EID0 0x07
#define MCP_RXF2SIDH 0x08
#define MCP_RXF2SIDL 0x09
#define MCP_RXF2EID8 0x0A
#define MCP_RXF2EID0 0x0B
#define MCP_CANSTAT 0x0E
#define MCP_CANCTRL 0x0F
#define MCP_RXF3SIDH 0x10
#define MCP_RXF3SIDL 0x11
#define MCP_RXF3EID8 0x12
#define MCP_RXF3EID0 0x13
#define MCP_RXF4SIDH 0x14
#define MCP_RXF4SIDL 0x15
#define MCP_RXF4EID8 0x16
#define MCP_RXF4EID0 0x17
#define MCP_RXF5SIDH 0x18
#define MCP_RXF5SIDL 0x19
#define MCP_RXF5EID8 0x1A
#define MCP_RXF5EID0 0x1B
#define MCP_TEC 0x1C
#define MCP_REC 0x1D
#define MCP_RXM0SIDH 0x20
#define MCP_RXM0SIDL 0x21
#define MCP_RXM0EID8 0x22
#define MCP_RXM0EID0 0x23
#define MCP_RXM1SIDH 0x24
#define MCP_RXM1SIDL 0x25
#define MCP_RXM1EID8 0x26
#define MCP_RXM1EID0 0x27
#define MCP_CNF3 0x28
#define MCP_CNF2 0x29
#define MCP_CNF1 0x2A
#define MCP_CANINTE 0x2B
#define MCP_CANINTF 0x2C
#define MCP_EFLG 0x2D
#define MCP_TXB0CTRL 0x30
#define MCP_TXB1CTRL 0x40
#define MCP_TXB2CTRL 0x50
#define MCP_RXB0CTRL 0x60
#define MCP_RXB0SIDH 0x61
#define MCP_RXB1CTRL 0x70
#define MCP_RXB1SIDH 0x71
#define MCP_TX_INT 0x1C // Enable all transmit interrup ts
#define MCP_TX01_INT 0x0C // Enable TXB0 and TXB1 interru pts
#define MCP_RX_INT 0x03 // Enable receive interrupts
#define MCP_NO_INT 0x00 // Disable all interrupts
#define MCP_TX01_MASK 0x14
#define MCP_TX_MASK 0x54
/*
* Define SPI Instruction Set
*/
#define MCP_WRITE 0x02
#define MCP_READ 0x03
#define MCP_BITMOD 0x05
#define MCP_LOAD_TX0 0x40
#define MCP_LOAD_TX1 0x42
#define MCP_LOAD_TX2 0x44
#define MCP_RTS_TX0 0x81
#define MCP_RTS_TX1 0x82
#define MCP_RTS_TX2 0x84
#define MCP_RTS_ALL 0x87
#define MCP_READ_RX0 0x90
#define MCP_READ_RX1 0x94
#define MCP_READ_STATUS 0xA0
#define MCP_RX_STATUS 0xB0
#define MCP_RESET 0xC0
/*
* CANCTRL Register Values
*/
#define MODE_NORMAL 0x00
#define MODE_SLEEP 0x20
#define MODE_LOOPBACK 0x40
#define MODE_LISTENONLY 0x60
#define MODE_CONFIG 0x80
#define MODE_POWERUP 0xE0
#define MODE_MASK 0xE0
#define ABORT_TX 0x10
#define MODE_ONESHOT 0x08
#define CLKOUT_ENABLE 0x04
#define CLKOUT_DISABLE 0x00
#define CLKOUT_PS1 0x00
#define CLKOUT_PS2 0x01
#define CLKOUT_PS4 0x02
#define CLKOUT_PS8 0x03
/*
* CNF1 Register Values
*/
#define SJW1 0x00
#define SJW2 0x40
#define SJW3 0x80
#define SJW4 0xC0
/*
* CNF2 Register Values
*/
#define BTLMODE 0x80
#define SAMPLE_1X 0x00
#define SAMPLE_3X 0x40
/*
* CNF3 Register Values
*/
#define SOF_ENABLE 0x80
#define SOF_DISABLE 0x00
#define WAKFIL_ENABLE 0x40
#define WAKFIL_DISABLE 0x00
/*
* CANINTF Register Bits
*/
#define MCP_RX0IF 0x01
#define MCP_RX1IF 0x02
#define MCP_TX0IF 0x04
#define MCP_TX1IF 0x08
#define MCP_TX2IF 0x10
#define MCP_ERRIF 0x20
#define MCP_WAKIF 0x40
#define MCP_MERRF 0x80
/*
* speed 16M
*/
@@ -318,67 +91,4 @@
#define MCP_16MHz_5kBPS_CFG3 (0x87)
#define MCPDEBUG (0)
#define MCPDEBUG_TXBUF (0)
#define MCP_N_TXBUFFERS (3)
#define MCP_RXBUF_0 (MCP_RXB0SIDH)
#define MCP_RXBUF_1 (MCP_RXB1SIDH)
#define MCP2515_OK (0)
#define MCP2515_FAIL (1)
#define MCP_ALLTXBUSY (2)
#define CANDEBUG 1
#define CANUSELOOP 0
#define CANSENDTIMEOUT (200) /* milliseconds */
/*
* initial value of gCANAutoProcess
*/
#define CANAUTOPROCESS (1)
#define CANAUTOON (1)
#define CANAUTOOFF (0)
#define CAN_STDID (0)
#define CAN_EXTID (1)
#define CANDEFAULTIDENT (0x55CC)
#define CANDEFAULTIDENTEXT (CAN_EXTID)
#define CAN_5KBPS 1
#define CAN_10KBPS 2
#define CAN_20KBPS 3
#define CAN_31K25BPS 4
#define CAN_33KBPS 5
#define CAN_40KBPS 6
#define CAN_50KBPS 7
#define CAN_80KBPS 8
#define CAN_83K3BPS 9
#define CAN_95KBPS 10
#define CAN_100KBPS 11
#define CAN_125KBPS 12
#define CAN_200KBPS 13
#define CAN_250KBPS 14
#define CAN_500KBPS 15
#define CAN_1000KBPS 16
#define CAN_OK (0)
#define CAN_FAILINIT (1)
#define CAN_FAILTX (2)
#define CAN_MSGAVAIL (3)
#define CAN_NOMSG (4)
#define CAN_CTRLERROR (5)
#define CAN_GETTXBFTIMEOUT (6)
#define CAN_SENDMSGTIMEOUT (7)
#define CAN_FAIL (0xff)
#define CAN_MAX_CHAR_IN_MESSAGE (8)
#endif
/*********************************************************************************************************
END FILE
*********************************************************************************************************/