mcp_can.cpp

/*
  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"

#define spi_readwrite SPI.transfer
#define spi_read() spi_readwrite(0x00)

/*********************************************************************************************************
** Function name:           mcp2515_reset
** Descriptions:            reset the device
*********************************************************************************************************/
void MCP_CAN::mcp2515_reset(void)
{
	MCP2515_SELECT();
	spi_readwrite(MCP_RESET);
	MCP2515_UNSELECT();
	delay(10);
}

/*********************************************************************************************************
** Function name:           mcp2515_readRegister
** Descriptions:            read register
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_readRegister(const INT8U address)
{
	INT8U ret;

	MCP2515_SELECT();
	spi_readwrite(MCP_READ);
	spi_readwrite(address);
	ret = spi_read();
	MCP2515_UNSELECT();

	return ret;
}

/*********************************************************************************************************
** Function name:           mcp2515_readRegisterS
** Descriptions:            read registerS
*********************************************************************************************************/
void MCP_CAN::mcp2515_readRegisterS(const INT8U address, INT8U values[], const INT8U n)
{
	INT8U i;
	MCP2515_SELECT();
	spi_readwrite(MCP_READ);
	spi_readwrite(address);
	// mcp2515 has auto-increment of address-pointer
	for (i = 0; i < n; i++)
	{
		values[i] = spi_read();
	}
	MCP2515_UNSELECT();
}

/*********************************************************************************************************
** Function name:           mcp2515_setRegister
** Descriptions:            set register
*********************************************************************************************************/
void MCP_CAN::mcp2515_setRegister(const INT8U address, const INT8U value)
{
	MCP2515_SELECT();
	spi_readwrite(MCP_WRITE);
	spi_readwrite(address);
	spi_readwrite(value);
	MCP2515_UNSELECT();
}

/*********************************************************************************************************
** Function name:           mcp2515_setRegisterS
** Descriptions:            set registerS
*********************************************************************************************************/
void MCP_CAN::mcp2515_setRegisterS(const INT8U address, const INT8U values[], const INT8U n)
{
	INT8U i;
	MCP2515_SELECT();
	spi_readwrite(MCP_WRITE);
	spi_readwrite(address);

	for (i = 0; i < n; i++)
	{
		spi_readwrite(values[i]);
	}
	MCP2515_UNSELECT();
}

/*********************************************************************************************************
** Function name:           mcp2515_modifyRegister
** Descriptions:            set bit of one register
*********************************************************************************************************/
void MCP_CAN::mcp2515_modifyRegister(const INT8U address, const INT8U mask, const INT8U data)
{
	MCP2515_SELECT();
	spi_readwrite(MCP_BITMOD);
	spi_readwrite(address);
	spi_readwrite(mask);
	spi_readwrite(data);
	MCP2515_UNSELECT();
}

/*********************************************************************************************************
** Function name:           mcp2515_readStatus
** Descriptions:            read mcp2515's Status
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_readStatus(void)
{
	INT8U i;
	MCP2515_SELECT();
	spi_readwrite(MCP_READ_STATUS);
	i = spi_read();
	MCP2515_UNSELECT();

	return i;
}

/*********************************************************************************************************
** Function name:           mcp2515_setCANCTRL_Mode
** Descriptions:            set control mode
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_setCANCTRL_Mode(const INT8U newmode)
{
	INT8U i;

	mcp2515_modifyRegister(MCP_CANCTRL, MODE_MASK, newmode);

	i = mcp2515_readRegister(MCP_CANCTRL);
	i &= MODE_MASK;

	if (i == newmode)
	{
		return MCP2515_OK;
	}

	return MCP2515_FAIL;

}

/*********************************************************************************************************
** Function name:           mcp2515_configRate
** Descriptions:            set boadrate
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_configRate(const INT8U canSpeed, const INT8U clock)
{
	INT8U set, cfg1, cfg2, cfg3;
	set = 1;
	switch (clock)
	{
		case (MCP_16MHz) :
			switch (canSpeed)
			{
				case (CAN_5KBPS) :
					cfg1 = MCP_16MHz_5kBPS_CFG1;
					cfg2 = MCP_16MHz_5kBPS_CFG2;
					cfg3 = MCP_16MHz_5kBPS_CFG3;
					break;

				case (CAN_10KBPS) :
					cfg1 = MCP_16MHz_10kBPS_CFG1;
					cfg2 = MCP_16MHz_10kBPS_CFG2;
					cfg3 = MCP_16MHz_10kBPS_CFG3;
					break;

				case (CAN_20KBPS) :
					cfg1 = MCP_16MHz_20kBPS_CFG1;
					cfg2 = MCP_16MHz_20kBPS_CFG2;
					cfg3 = MCP_16MHz_20kBPS_CFG3;
					break;

				case (CAN_31K25BPS) :
					cfg1 = MCP_16MHz_31k25BPS_CFG1;
					cfg2 = MCP_16MHz_31k25BPS_CFG2;
					cfg3 = MCP_16MHz_31k25BPS_CFG3;
					break;

				case (CAN_40KBPS) :
					cfg1 = MCP_16MHz_40kBPS_CFG1;
					cfg2 = MCP_16MHz_40kBPS_CFG2;
					cfg3 = MCP_16MHz_40kBPS_CFG3;
					break;

				case (CAN_50KBPS) :
					cfg1 = MCP_16MHz_50kBPS_CFG1;
					cfg2 = MCP_16MHz_50kBPS_CFG2;
					cfg3 = MCP_16MHz_50kBPS_CFG3;
					break;

				case (CAN_80KBPS) :
					cfg1 = MCP_16MHz_80kBPS_CFG1;
					cfg2 = MCP_16MHz_80kBPS_CFG2;
					cfg3 = MCP_16MHz_80kBPS_CFG3;
					break;

				case (CAN_100KBPS) :                                             /* 100KBPS                  */
					cfg1 = MCP_16MHz_100kBPS_CFG1;
					cfg2 = MCP_16MHz_100kBPS_CFG2;
					cfg3 = MCP_16MHz_100kBPS_CFG3;
					break;

				case (CAN_125KBPS) :
					cfg1 = MCP_16MHz_125kBPS_CFG1;
					cfg2 = MCP_16MHz_125kBPS_CFG2;
					cfg3 = MCP_16MHz_125kBPS_CFG3;
					break;

				case (CAN_200KBPS) :
					cfg1 = MCP_16MHz_200kBPS_CFG1;
					cfg2 = MCP_16MHz_200kBPS_CFG2;
					cfg3 = MCP_16MHz_200kBPS_CFG3;
					break;

				case (CAN_250KBPS) :
					cfg1 = MCP_16MHz_250kBPS_CFG1;
					cfg2 = MCP_16MHz_250kBPS_CFG2;
					cfg3 = MCP_16MHz_250kBPS_CFG3;
					break;

				case (CAN_500KBPS) :
					cfg1 = MCP_16MHz_500kBPS_CFG1;
					cfg2 = MCP_16MHz_500kBPS_CFG2;
					cfg3 = MCP_16MHz_500kBPS_CFG3;
					break;

				case (CAN_1000KBPS) :
					cfg1 = MCP_16MHz_1000kBPS_CFG1;
					cfg2 = MCP_16MHz_1000kBPS_CFG2;
					cfg3 = MCP_16MHz_1000kBPS_CFG3;
					break;

				default:
					set = 0;
					break;
			}
			break;

		case (MCP_8MHz) :
			switch (canSpeed)
			{
				case (CAN_5KBPS) :
					cfg1 = MCP_8MHz_5kBPS_CFG1;
					cfg2 = MCP_8MHz_5kBPS_CFG2;
					cfg3 = MCP_8MHz_5kBPS_CFG3;
					break;

				case (CAN_10KBPS) :
					cfg1 = MCP_8MHz_10kBPS_CFG1;
					cfg2 = MCP_8MHz_10kBPS_CFG2;
					cfg3 = MCP_8MHz_10kBPS_CFG3;
					break;

				case (CAN_20KBPS) :
					cfg1 = MCP_8MHz_20kBPS_CFG1;
					cfg2 = MCP_8MHz_20kBPS_CFG2;
					cfg3 = MCP_8MHz_20kBPS_CFG3;
					break;

				case (CAN_31K25BPS) :
					cfg1 = MCP_8MHz_31k25BPS_CFG1;
					cfg2 = MCP_8MHz_31k25BPS_CFG2;
					cfg3 = MCP_8MHz_31k25BPS_CFG3;
					break;

				case (CAN_40KBPS) :
					cfg1 = MCP_8MHz_40kBPS_CFG1;
					cfg2 = MCP_8MHz_40kBPS_CFG2;
					cfg3 = MCP_8MHz_40kBPS_CFG3;
					break;

				case (CAN_50KBPS) :
					cfg1 = MCP_8MHz_50kBPS_CFG1;
					cfg2 = MCP_8MHz_50kBPS_CFG2;
					cfg3 = MCP_8MHz_50kBPS_CFG3;
					break;

				case (CAN_80KBPS) :
					cfg1 = MCP_8MHz_80kBPS_CFG1;
					cfg2 = MCP_8MHz_80kBPS_CFG2;
					cfg3 = MCP_8MHz_80kBPS_CFG3;
					break;

				case (CAN_100KBPS) :                                             /* 100KBPS                  */
					cfg1 = MCP_8MHz_100kBPS_CFG1;
					cfg2 = MCP_8MHz_100kBPS_CFG2;
					cfg3 = MCP_8MHz_100kBPS_CFG3;
					break;

				case (CAN_125KBPS) :
					cfg1 = MCP_8MHz_125kBPS_CFG1;
					cfg2 = MCP_8MHz_125kBPS_CFG2;
					cfg3 = MCP_8MHz_125kBPS_CFG3;
					break;

				case (CAN_200KBPS) :
					cfg1 = MCP_8MHz_200kBPS_CFG1;
					cfg2 = MCP_8MHz_200kBPS_CFG2;
					cfg3 = MCP_8MHz_200kBPS_CFG3;
					break;

				case (CAN_250KBPS) :
					cfg1 = MCP_8MHz_250kBPS_CFG1;
					cfg2 = MCP_8MHz_250kBPS_CFG2;
					cfg3 = MCP_8MHz_250kBPS_CFG3;
					break;

				case (CAN_500KBPS) :
					cfg1 = MCP_8MHz_500kBPS_CFG1;
					cfg2 = MCP_8MHz_500kBPS_CFG2;
					cfg3 = MCP_8MHz_500kBPS_CFG3;
					break;

				case (CAN_1000KBPS) :
					cfg1 = MCP_8MHz_1000kBPS_CFG1;
					cfg2 = MCP_8MHz_1000kBPS_CFG2;
					cfg3 = MCP_8MHz_1000kBPS_CFG3;
					break;

				default:
					set = 0;
					break;
			}
			break;

		default:
			set = 0;
			break;
	}

	if (set) {
		mcp2515_setRegister(MCP_CNF1, cfg1);
		mcp2515_setRegister(MCP_CNF2, cfg2);
		mcp2515_setRegister(MCP_CNF3, cfg3);
		return MCP2515_OK;
	}
	else {
		return MCP2515_FAIL;
	}
}

/*********************************************************************************************************
** Function name:           mcp2515_initCANBuffers
** Descriptions:            init canbuffers
*********************************************************************************************************/
void MCP_CAN::mcp2515_initCANBuffers(void)
{
	INT8U i, a1, a2, a3;

	INT8U std = 0;
	INT8U ext = 1;
	INT32U 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 */

	/* 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);

	/* 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);
}

/*********************************************************************************************************
** Function name:           mcp2515_init
** Descriptions:            init the device
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_init(const INT8U canSpeed, const INT8U clock)                       /* 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");
#endif
		return res;
	}
#if DEBUG_MODE
	Serial.print("Enter setting mode success \r\n");
#endif

	/* set boadrate                 */
	if (mcp2515_configRate(canSpeed, clock))
	{
#if DEBUG_MODE
		Serial.print("set rate fall!!\r\n");
#endif
		return res;
	}
#if DEBUG_MODE
	Serial.print("set rate success!!\r\n");
#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(MODE_NORMAL);
		if (res)
		{
#if DEBUG_MODE        
			Serial.print("Enter Normal Mode Fall!!\r\n");
#endif           
			return res;
		}


#if DEBUG_MODE
		Serial.print("Enter Normal Mode Success!!\r\n");
#endif

	}
	return res;

}

/*********************************************************************************************************
** Function name:           mcp2515_write_id
** Descriptions:            write can id
*********************************************************************************************************/
void MCP_CAN::mcp2515_write_id(const INT8U mcp_addr, const INT8U ext, const INT32U id)
{
	uint16_t canid;
	INT8U tbufdata[4];

	canid = (uint16_t)(id & 0x0FFFF);

	if (ext == 1)
	{
		tbufdata[MCP_EID0] = (INT8U)(canid & 0xFF);
		tbufdata[MCP_EID8] = (INT8U)(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);
	}
	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:           mcp2515_read_id
** Descriptions:            read can id
*********************************************************************************************************/
void MCP_CAN::mcp2515_read_id(const INT8U mcp_addr, INT8U* ext, INT32U* id)
{
	INT8U tbufdata[4];

	*ext = 0;
	*id = 0;

	mcp2515_readRegisterS(mcp_addr, tbufdata, 4);

	*id = (tbufdata[MCP_SIDH] << 3) + (tbufdata[MCP_SIDL] >> 5);

	if ((tbufdata[MCP_SIDL] & MCP_TXB_EXIDE_M) == MCP_TXB_EXIDE_M)
	{
		/* extended id                  */
		*id = (*id << 2) + (tbufdata[MCP_SIDL] & 0x03);
		*id = (*id << 8) + tbufdata[MCP_EID8];
		*id = (*id << 8) + tbufdata[MCP_EID0];
		*ext = 1;
	}
}

/*********************************************************************************************************
** Function name:           mcp2515_write_canMsg
** Descriptions:            write msg
*********************************************************************************************************/
void MCP_CAN::mcp2515_write_canMsg(const INT8U buffer_sidh_addr)
{
	INT8U mcp_addr;
	mcp_addr = buffer_sidh_addr;
	mcp2515_setRegisterS(mcp_addr + 5, m_nDta, m_nDlc);                  /* write data bytes             */
	if (m_nRtr == 1)                                                   /* if RTR set bit in byte       */
	{
		m_nDlc |= MCP_RTR_MASK;
	}
	mcp2515_setRegister((mcp_addr + 4), m_nDlc);                        /* write the RTR and DLC        */
	mcp2515_write_id(mcp_addr, m_nExtFlg, m_nID);                     /* write CAN id                 */

}

/*********************************************************************************************************
** Function name:           mcp2515_read_canMsg
** Descriptions:            read message
*********************************************************************************************************/
void MCP_CAN::mcp2515_read_canMsg(const INT8U buffer_sidh_addr)        /* read can msg                 */
{
	INT8U mcp_addr, ctrl;

	mcp_addr = buffer_sidh_addr;

	mcp2515_read_id(mcp_addr, &m_nExtFlg, &m_nID);

	ctrl = mcp2515_readRegister(mcp_addr - 1);
	m_nDlc = mcp2515_readRegister(mcp_addr + 4);

	if ((ctrl & 0x08)) {
		m_nRtr = 1;
	}
	else {
		m_nRtr = 0;
	}

	m_nDlc &= MCP_DLC_MASK;
	mcp2515_readRegisterS(mcp_addr + 5, &(m_nDta[0]), m_nDlc);
}

/*********************************************************************************************************
** Function name:           sendMsg
** Descriptions:            send message
*********************************************************************************************************/
void MCP_CAN::mcp2515_start_transmit(const INT8U mcp_addr)              /* start transmit               */
{
	mcp2515_modifyRegister(mcp_addr - 1, MCP_TXB_TXREQ_M, MCP_TXB_TXREQ_M);
}

/*********************************************************************************************************
** Function name:           sendMsg
** Descriptions:            send message
*********************************************************************************************************/
INT8U MCP_CAN::mcp2515_getNextFreeTXBuf(INT8U *txbuf_n)                 /* get Next free txbuf          */
{
	INT8U res, i, ctrlval;
	INT8U ctrlregs[MCP_N_TXBUFFERS] = { MCP_TXB0CTRL, MCP_TXB1CTRL, MCP_TXB2CTRL };

	res = MCP_ALLTXBUSY;
	*txbuf_n = 0x00;

	/* check all 3 TX-Buffers       */
	for (i = 0; i < MCP_N_TXBUFFERS; i++) {
		ctrlval = mcp2515_readRegister(ctrlregs[i]);
		if ((ctrlval & MCP_TXB_TXREQ_M) == 0) {
			*txbuf_n = ctrlregs[i] + 1;                                   /* return SIDH-address of Buffe */
			/* r                            */
			res = MCP2515_OK;
			return res;                                                 /* ! function exit              */
		}
	}
	return res;
}

/*********************************************************************************************************
** Function name:           set CS
** Descriptions:            init CS pin and set UNSELECTED
*********************************************************************************************************/
MCP_CAN::MCP_CAN(INT8U _CS)
{
	SPICS = _CS;
	pinMode(SPICS, OUTPUT);
	MCP2515_UNSELECT();
}

/*********************************************************************************************************
** Function name:           init
** Descriptions:            init can and set speed
*********************************************************************************************************/
INT8U MCP_CAN::begin(INT8U speedset, const INT8U clockset)
{
	INT8U res;

	SPI.begin();
	res = mcp2515_init(speedset, clockset);
	if (res == MCP2515_OK) return CAN_OK;
	else return CAN_FAILINIT;
}

/*********************************************************************************************************
** Function name:           init_Mask
** Descriptions:            init canid Masks
*********************************************************************************************************/
INT8U MCP_CAN::init_Mask(INT8U num, INT8U ext, INT32U ulData)
{
	INT8U res = MCP2515_OK;
#if DEBUG_MODE
	Serial.print("Begin to set Mask!!\r\n");
#endif
	res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
	if (res > 0){
#if DEBUG_MODE
		Serial.print("Enter setting mode fall\r\n");
#endif
		return res;
	}

	if (num == 0){
		mcp2515_write_id(MCP_RXM0SIDH, ext, ulData);

	}
	else if (num == 1){
		mcp2515_write_id(MCP_RXM1SIDH, ext, ulData);
	}
	else res = MCP2515_FAIL;

	res = mcp2515_setCANCTRL_Mode(MODE_NORMAL);
	if (res > 0){
#if DEBUG_MODE
		Serial.print("Enter normal mode fall\r\n");
#endif
		return res;
	}
#if DEBUG_MODE
	Serial.print("set Mask success!!\r\n");
#endif
	return res;
}

/*********************************************************************************************************
** Function name:           init_Filt
** Descriptions:            init canid filters
*********************************************************************************************************/
INT8U MCP_CAN::init_Filt(INT8U num, INT8U ext, INT32U ulData)
{
	INT8U res = MCP2515_OK;
#if DEBUG_MODE
	Serial.print("Begin to set Filter!!\r\n");
#endif
	res = mcp2515_setCANCTRL_Mode(MODE_CONFIG);
	if (res > 0)
	{
#if DEBUG_MODE
		Serial.print("Enter setting mode fall\r\n");
#endif
		return res;
	}

	switch (num)
	{
	case 0:
		mcp2515_write_id(MCP_RXF0SIDH, ext, ulData);
		break;

	case 1:
		mcp2515_write_id(MCP_RXF1SIDH, ext, ulData);
		break;

	case 2:
		mcp2515_write_id(MCP_RXF2SIDH, ext, ulData);
		break;

	case 3:
		mcp2515_write_id(MCP_RXF3SIDH, ext, ulData);
		break;

	case 4:
		mcp2515_write_id(MCP_RXF4SIDH, ext, ulData);
		break;

	case 5:
		mcp2515_write_id(MCP_RXF5SIDH, ext, ulData);
		break;

	default:
		res = MCP2515_FAIL;
	}

	res = mcp2515_setCANCTRL_Mode(MODE_NORMAL);
	if (res > 0)
	{
#if DEBUG_MODE
		Serial.print("Enter normal mode fall\r\nSet filter fail!!\r\n");
#endif
		return res;
	}
#if DEBUG_MODE
	Serial.print("set Filter success!!\r\n");
#endif

	return res;
}

/*********************************************************************************************************
** Function name:           setMsg
** Descriptions:            set can message, such as dlc, id, dta[] and so on
*********************************************************************************************************/
INT8U MCP_CAN::setMsg(INT32U id, INT8U ext, INT8U len, INT8U *pData)
{
	int i = 0;
	m_nExtFlg = ext;
	m_nID = id;
	m_nDlc = len;
	for (i = 0; i < MAX_CHAR_IN_MESSAGE; i++)
		m_nDta[i] = *(pData + i);
	return MCP2515_OK;
}

/*********************************************************************************************************
** Function name:           clearMsg
** Descriptions:            set all message to zero
*********************************************************************************************************/
INT8U MCP_CAN::clearMsg()
{
	m_nID = 0;
	m_nDlc = 0;
	m_nExtFlg = 0;
	m_nRtr = 0;
	m_nfilhit = 0;
	for (int i = 0; i < m_nDlc; i++)
		m_nDta[i] = 0x00;

	return MCP2515_OK;
}

/*********************************************************************************************************
** Function name:           sendMsg
** Descriptions:            send message
*********************************************************************************************************/
INT8U MCP_CAN::sendMsg()
{
	INT8U res, res1, txbuf_n;
	uint16_t uiTimeOut = 0;

	do {
		res = mcp2515_getNextFreeTXBuf(&txbuf_n);                       /* info = addr.                 */
		uiTimeOut++;
	} while (res == MCP_ALLTXBUSY && (uiTimeOut < TIMEOUTVALUE));

	if (uiTimeOut == TIMEOUTVALUE)
	{
		return CAN_GETTXBFTIMEOUT;                                      /* get tx buff time out         */
	}
	uiTimeOut = 0;
	mcp2515_write_canMsg(txbuf_n);
	mcp2515_start_transmit(txbuf_n);
	do
	{
		uiTimeOut++;
		res1 = mcp2515_readRegister(txbuf_n);  			                /* read send buff ctrl reg 	*/
		res1 = res1 & 0x08;
	} while (res1 && (uiTimeOut < TIMEOUTVALUE));
	if (uiTimeOut == TIMEOUTVALUE)                                       /* send msg timeout             */
	{
		return CAN_SENDMSGTIMEOUT;
	}
	return CAN_OK;

}

/*********************************************************************************************************
** Function name:           sendMsgBuf
** Descriptions:            send buf
*********************************************************************************************************/
INT8U MCP_CAN::sendMsgBuf(INT32U id, INT8U ext, INT8U len, INT8U *buf)
{
	setMsg(id, ext, len, buf);
	sendMsg();
}

/*********************************************************************************************************
** Function name:           readMsg
** Descriptions:            read message
*********************************************************************************************************/
INT8U MCP_CAN::readMsg()
{
	INT8U stat, res;

	stat = mcp2515_readStatus();

	if (stat & MCP_STAT_RX0IF)                                        /* Msg in Buffer 0              */
	{
		mcp2515_read_canMsg(MCP_RXBUF_0);
		mcp2515_modifyRegister(MCP_CANINTF, MCP_RX0IF, 0);
		res = CAN_OK;
	}
	else if (stat & MCP_STAT_RX1IF)                                   /* Msg in Buffer 1              */
	{
		mcp2515_read_canMsg(MCP_RXBUF_1);
		mcp2515_modifyRegister(MCP_CANINTF, MCP_RX1IF, 0);
		res = CAN_OK;
	}
	else
	{
		res = CAN_NOMSG;
	}
	return res;
}

/*********************************************************************************************************
** Function name:           readMsgBuf
** Descriptions:            read message buf
*********************************************************************************************************/
INT8U MCP_CAN::readMsgBuf(INT8U *len, INT8U buf[])
{
	readMsg();
	*len = m_nDlc;
	for (int i = 0; i < m_nDlc; i++)
	{
		buf[i] = m_nDta[i];
	}
}

/*********************************************************************************************************
** Function name:           checkReceive
** Descriptions:            check if got something
*********************************************************************************************************/
INT8U 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;
	}
}

/*********************************************************************************************************
** Function name:           checkError
** Descriptions:            if something error
*********************************************************************************************************/
INT8U MCP_CAN::checkError(void)
{
	INT8U eflg = mcp2515_readRegister(MCP_EFLG);

	if (eflg & MCP_EFLG_ERRORMASK)
	{
		return CAN_CTRLERROR;
	}
	else
	{
		return CAN_OK;
	}
}

/*********************************************************************************************************
** Function name:           getCanId
** Descriptions:            when receive something ,u can get the can id!!
*********************************************************************************************************/
INT32U MCP_CAN::getCanId(void)
{
	return m_nID;
}
/*********************************************************************************************************
  END FILE
  *********************************************************************************************************/