28335的CAN总线学习笔记

最新推荐文章于 2024-08-14 18:34:08 发布
置顶 最新推荐文章于 2024-08-14 18:34:08 发布
阅读量1.6w 收藏 176
点赞数 31
分类专栏： CAN TMS320F28335 文章标签： CAN TMS320F28335
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ad596142041/article/details/84980655
版权

在调试28335的CAN的发送时出现的问题：

1、接口用错导致一直失败；

2、注意28335的CAN总线波特率计算，如下所述：

ECanaShadow.CANBTC.bit.BRPREG = 9;

ECanaShadow.CANBTC.bit.TSEG2REG = 2;

ECanaShadow.CANBTC.bit.TSEG1REG = 10;

以上代码是配置28335的CAN总线模块波特率，最后的波特率为：

按照上面的参数计算最后的波特率为500k;

同时还需要注意28335的CAN总线中比较特殊的说明,如下所述：

1、是关于波特率配置的描述：

 2、关于CAN网络的说明：

 必须保证在网络中有一个设备和当前节点配置为同样的波特率，但是不一定要设置为接收模式；

附：最后的配置程序：

void InitECana(void)		// 初始化CAN总线模块
{
/* Create a shadow register structure for the CAN control registers. This is
 needed, since only 32-bit access is allowed to these registers. 16-bit access
 to these registers could potentially corrupt the register contents or return
 false data. This is especially true while writing to/reading from a bit
 (or group of bits) among bits 16 - 31 */


struct ECAN_REGS ECanaShadow;


	EALLOW;		// EALLOW enables access to protected bits


/* Configure eCAN RX and TX pins for CAN operation using eCAN regs*/


    ECanaShadow.CANTIOC.all = ECanaRegs.CANTIOC.all;
    ECanaShadow.CANTIOC.bit.TXFUNC = 1;
    ECanaRegs.CANTIOC.all = ECanaShadow.CANTIOC.all;


    ECanaShadow.CANRIOC.all = ECanaRegs.CANRIOC.all;
    ECanaShadow.CANRIOC.bit.RXFUNC = 1;
    ECanaRegs.CANRIOC.all = ECanaShadow.CANRIOC.all;


/* Configure eCAN for HECC mode - (reqd to access mailboxes 16 thru 31) */
									// HECC mode also enables time-stamping feature


	ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
	ECanaShadow.CANMC.bit.SCB = 1;
	ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;


/* Initialize all bits of 'Master Control Field' to zero */
// Some bits of MSGCTRL register come up in an unknown state. For proper operation,
// all bits (including reserved bits) of MSGCTRL must be initialized to zero


    ECanaMboxes.MBOX0.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX1.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX2.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX3.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX4.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX5.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX6.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX7.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX8.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX9.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX10.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX11.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX12.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX13.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX14.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX15.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX16.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX17.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX18.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX19.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX20.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX21.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX22.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX23.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX24.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX25.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX26.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX27.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX28.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX29.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX30.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX31.MSGCTRL.all = 0x00000000;


// TAn, RMPn, GIFn bits are all zero upon reset and are cleared again
//	as a matter of precaution.


	ECanaRegs.CANTA.all	= 0xFFFFFFFF;	/* Clear all TAn bits */


	ECanaRegs.CANRMP.all = 0xFFFFFFFF;	/* Clear all RMPn bits */


	ECanaRegs.CANGIF0.all = 0xFFFFFFFF;	/* Clear all interrupt flag bits */
	ECanaRegs.CANGIF1.all = 0xFFFFFFFF;




/* Configure bit timing parameters for eCANA*/
	ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
	ECanaShadow.CANMC.bit.CCR = 1 ;            // Set CCR = 1
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;


    ECanaShadow.CANES.all = ECanaRegs.CANES.all;


    do
	{
	    ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    } while(ECanaShadow.CANES.bit.CCE != 1 );  		// Wait for CCE bit to be set..


    ECanaShadow.CANBTC.all = 0;


    #if (CPU_FRQ_150MHZ)                 
//初始化通信波特率
/*
具体的波特率计算：
波特率=系统时钟/(2*(BRPREG+TSEG2REG+TSEG1REG+3)),同时需要确保TSEG1REG > TSEG2REG 


*/
			ECanaShadow.CANBTC.bit.BRPREG = 9;
			ECanaShadow.CANBTC.bit.TSEG2REG = 2;
			ECanaShadow.CANBTC.bit.TSEG1REG = 10;
    #endif
    ECanaShadow.CANBTC.bit.SAM = 1;

    ECanaRegs.CANBTC.all = ECanaShadow.CANBTC.all;
    ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
	ECanaShadow.CANMC.bit.CCR = 0 ;            // Set CCR = 0
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
    ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    do
    {
       ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    } while(ECanaShadow.CANES.bit.CCE != 0 ); 		// Wait for CCE bit to be  cleared..


/* Disable all Mailboxes  */
 	ECanaRegs.CANME.all = 0;		// Required before writing the MSGIDs


    EDIS;
}






void InitECanGpio(void)
{
   InitECanaGpio();
#if (DSP28_ECANB)
   InitECanbGpio();
#endif // if DSP28_ECANB
}


void InitECanaGpio(void)
{
   EALLOW;
/* Enable internal pull-up for the selected CAN pins */
// Pull-ups can be enabled or disabled by the user.
// This will enable the pullups for the specified pins.
// Comment out other unwanted lines.
	GpioCtrlRegs.GPAPUD.bit.GPIO18 = 0;	    // Enable pull-up for GPIO18 (CANRXA)
	GpioCtrlRegs.GPAPUD.bit.GPIO19 = 0;	    // Enable pull-up for GPIO19 (CANTXA)


/* Set qualification for selected CAN pins to asynch only */
// Inputs are synchronized to SYSCLKOUT by default.
// This will select asynch (no qualification) for the selected pins.
    GpioCtrlRegs.GPAQSEL2.bit.GPIO18 = 3;   // Asynch qual for GPIO18 (CANRXA)
/* Configure eCAN-A pins using GPIO regs*/
// This specifies which of the possible GPIO pins will be eCAN functional pins.
    GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 3;	// Configure GPIO18 for CANRXA operation
    GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 3;	// Configure GPIO19 for CANTXA operation


    EDIS;
}


#if (DSP28_ECANB)
void InitECanbGpio(void)
{
   EALLOW;
/* Enable internal pull-up for the selected CAN pins */
// Pull-ups can be enabled or disabled by the user.
// This will enable the pullups for the specified pins.
// Comment out other unwanted lines.
    GpioCtrlRegs.GPAPUD.bit.GPIO12 = 0;   // Enable pull-up for GPIO12 (CANTXB)
    GpioCtrlRegs.GPAPUD.bit.GPIO13 = 0;   // Enable pull-up for GPIO13 (CANRXB)
/* Set qualification for selected CAN pins to asynch only */
// Inputs are synchronized to SYSCLKOUT by default.
// This will select asynch (no qualification) for the selected pins.
// Comment out other unwanted lines.
    GpioCtrlRegs.GPAQSEL1.bit.GPIO13 = 3; // Asynch qual for GPIO13 (CANRXB)
/* Configure eCAN-B pins using GPIO regs*/
    GpioCtrlRegs.GPAMUX1.bit.GPIO12 = 2;  // Configure GPIO12 for CANTXB operation
    GpioCtrlRegs.GPAMUX1.bit.GPIO13 = 2;  // Configure GPIO13 for CANRXB operation




    EDIS;
}
#endif // if DSP28_ECANB

具关于CAN总线中的收发问题：

1、发送：

 

.具体描述参见上图，配置程序如下所示：

//发送一帧数据
/*
CAN总线发送数据结构体
typedef struct
{
      unsigned short int StdId;  //标准帧ID,值为0x000到0x7FFF;
      unsigned long int ExtId; //扩展帧ID,值为0到0x1FFFFFFF
      unsigned char SAE_J1939_Flag;//表示是否使用SAE J1939协议
      SAE_ID SAE_J1939_ID;
      unsigned char IDE;   //帧类型,可为：CAN_ID_STD(标准帧),CAN_ID_EXT(扩展帧)
      unsigned char DLC;  //数据长度，可为0到8;
      unsigned char MBox_num;//邮箱编号,可为0到31;
      unsigned short int Tx_timeout_cnt;
      CAN_MSG_DATA CAN_Tx_msg_data; /*!< 帧消息内容,共8字节 */
} CanTxMsg;
*/
void CAN_Send_Msg(CanTxMsg *can_tx_msg)//发送一帧数据
{
	Uint16 time_cnt;
	Uint32 mbox_enable_temp = 0x0000;
	Uint32 mbox_disable_temp = 0x0000;
	Uint32 mbox_dir_temp = 0x0000;
	mbox_enable_temp = 1<<(can_tx_msg->MBox_num);
	mbox_disable_temp = ~(1<<(can_tx_msg->MBox_num));
	mbox_dir_temp = ~(1<<(can_tx_msg->MBox_num));
	struct ECAN_REGS ECanaShadow;
	volatile struct MBOX *Mailbox;
	Mailbox = &ECanaMboxes.MBOX0+can_tx_msg->MBox_num;


	ECanaShadow.CANME.all  = ECanaRegs.CANME.all;
	ECanaShadow.CANME.all &= mbox_disable_temp;
	ECanaRegs.CANME.all    = ECanaShadow.CANME.all;
	if(can_tx_msg->IDE == CAN_ID_STD)
	{


		Mailbox->MSGID.all = can_tx_msg->StdId; //standard identifier
		Mailbox->MSGID.bit.IDE = can_tx_msg->IDE;
	}
	else if(can_tx_msg->IDE == CAN_ID_EXT)
	{
		if(can_tx_msg->SAE_J1939_Flag == 0)
		{
			Mailbox->MSGID.all = can_tx_msg->ExtId; //extended identifier.
			Mailbox->MSGID.bit.IDE = can_tx_msg->IDE;
		}
		else
		{
			Mailbox->MSGID.all = can_tx_msg->SAE_J1939_ID.id; //extended identifier.
			Mailbox->MSGID.bit.IDE = can_tx_msg->IDE;
		}
	}
   ECanaShadow.CANMD.all = ECanaRegs.CANMD.all;
   ECanaShadow.CANMD.all &=mbox_dir_temp;//设置邮箱工作方向,0表示邮箱工作于发送,1表示工作于接收
   ECanaRegs.CANMD.all = ECanaShadow.CANMD.all;
   ECanaShadow.CANME.all = ECanaRegs.CANME.all;
   ECanaShadow.CANME.all |= mbox_enable_temp;//使能邮箱
   ECanaRegs.CANME.all = ECanaShadow.CANME.all;
   Mailbox->MSGCTRL.bit.DLC = can_tx_msg->DLC;//数据长度
   Mailbox->MDL.byte.BYTE0 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte0;
   Mailbox->MDL.byte.BYTE1 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte1;
   Mailbox->MDL.byte.BYTE2 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte2;
   Mailbox->MDL.byte.BYTE3 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte3;
   Mailbox->MDH.byte.BYTE4 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte4;
   Mailbox->MDH.byte.BYTE5 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte5;
   Mailbox->MDH.byte.BYTE6 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte6;
   Mailbox->MDH.byte.BYTE7 = can_tx_msg->CAN_Tx_msg_data.msg_Byte.byte7;
   ECanaShadow.CANTRS.all = 0;
   ECanaShadow.CANTRS.all |= mbox_enable_temp;             // Set TRS for mailbox under test
   ECanaRegs.CANTRS.all = ECanaShadow.CANTRS.all;
   do
	{
	ECanaShadow.CANTA.all = ECanaRegs.CANTA.all;
	time_cnt++;
	} while(((ECanaShadow.CANTA.all&mbox_enable_temp) == 0 )&&(time_cnt<100));   // Wait for TA5 bit to be set..
   ECanaShadow.CANTA.all = 0;
   ECanaShadow.CANTA.all = mbox_enable_temp;     	   // Clear TA5
   ECanaRegs.CANTA.all = ECanaShadow.CANTA.all;


}

 接收相关配置：（数据接受通常会采用中断来接收数据),具体配置程序如下，包括中断的相关配置；

void CAN_Rx_Config(void)//接收配置函数，程序中相关备注
{


	struct ECAN_REGS ECanaShadow;
	ECanaShadow.CANME.all = ECanaRegs.CANME.all;
	ECanaShadow.CANME.bit.ME1 = 0;//不使能邮箱1
	ECanaShadow.CANME.bit.ME31 = 0;//不使能邮箱31
	ECanaRegs.CANME.all = ECanaShadow.CANME.all;
	/*----------以下代码是配置接受邮箱的相关代码------------*/
	//邮箱1相关配置
	ECanaMboxes.MBOX1.MSGCTRL.bit.DLC = 8;//配置数据长度，应该是没意义的;
	ECanaMboxes.MBOX1.MSGID.all = 0x07909ADC;//设置接收消息的有效ID
	ECanaMboxes.MBOX1.MSGID.bit.AME =1;//屏蔽使能位,如果需要使用屏蔽,必须将该位置1
	ECanaMboxes.MBOX1.MSGID.bit.IDE = CAN_ID_EXT;
	/*
		LAMn[28:0]
		这些位启用一个进入消息的任意标识符位的屏蔽。
		1 针对接受到的标识符的相应位， 接受一个 0 或 1（ 无关） 。
		0 接收到的标识符位值必须与 MSGID 寄存器的相应标识符位相匹配。
	*/


	ECanaLAMRegs.LAM1.all = 0x000000F;//
	 /*
		LAMI 本地接受屏蔽标识符扩展位
		1 可以接收标准和扩展帧。 在扩展帧的情况下， 标识符的所有 29 位被存储在邮箱中， 本地接受屏        蔽寄存器的所有 29 位被过滤器使用。 在一个标准帧的情况下， 只有标识符的头 11 个位（ 28 至         18 位）
		和本地接受屏蔽被使用。
		0 存储在邮箱中的标识符扩展位决定了哪些消息应该被接收到
	*/
	ECanaLAMRegs.LAM1.bit.LAMI = 1;
	//邮箱31相关配置
	ECanaMboxes.MBOX31.MSGCTRL.bit.DLC = 8;//配置数据长度，应该是没意义的;
	ECanaMboxes.MBOX31.MSGID.all = 0x07909ABC;//设置接收消息的有效ID
	ECanaMboxes.MBOX31.MSGID.bit.AME =1;//屏蔽使能位,
	ECanaMboxes.MBOX31.MSGID.bit.IDE = CAN_ID_EXT;
	/*
		LAM[28:0]
		这些位启用一个进入消息的任意标识符位的屏蔽。
		1 针对接受到的标识符的相应位， 接受一个 0 或 1（ 无关） 。
		0 接收到的标识符位值必须与 MSGID 寄存器的相应标识符位相匹配。
	*/


	ECanaLAMRegs.LAM31.all = 0x000000F;//
/*
		LAMI 本地接受屏蔽标识符扩展位
		1 可以接收标准和扩展帧。 在扩展帧的情况下， 标识符的所有 29 位被存储在邮箱中,本地接受屏蔽寄
		存器的所有 29 位被过滤器使用。 在一个标准帧的情况下， 只有标识符的头 11 个位（ 28 至 18 位）
		和本地接受屏蔽被使用。
		0 存储在邮箱中的标识符扩展位决定了哪些消息应该被接收到

*/
	ECanaLAMRegs.LAM31.bit.LAMI = 1;
	ECanaRegs.CANRMP.all      = 0xFFFFFFFF;
	ECanaShadow.CANMD.all     = ECanaRegs.CANMD.all;
	ECanaShadow.CANMD.bit.MD1 = 1;
	ECanaShadow.CANMD.bit.MD31 = 1;
	ECanaRegs.CANMD.all       = ECanaShadow.CANMD.all;


	ECanaShadow.CANME.all       = ECanaRegs.CANME.all;
	ECanaShadow.CANME.bit.ME1   = 1;//使能邮箱1
	ECanaShadow.CANME.bit.ME31  = 1;//使能邮箱1
	ECanaRegs.CANME.all         = ECanaShadow.CANME.all;
}
void CAN_Rx_IT_Concig(void)//邮箱中断相关配置
{
	EALLOW;
	ECanaRegs.CANMIM.bit.MIM1 = 1;//使能中断邮箱1的中断;
	ECanaRegs.CANMIL.bit.MIL1 = 1;//将中断1连接至中断1;
	ECanaRegs.CANMIM.bit.MIM31 = 1;//使能中断邮箱31的中断;
	ECanaRegs.CANMIL.bit.MIL31 = 1;//将中断1连接至中断1;
	ECanaRegs.CANGIM.bit.I1EN = 1;//使能中断1;
	EDIS;
}
//具体的中断函数,在清除GMIF1标志位时,不能通过向GMIF1写1来清除,只能通过向RMPn来清除该标志位 
/*
CAN总线接收数据的结构体
typedef struct
{
  unsigned short int StdId;  //标准帧ID,值为0x000到0x7FFF;
  unsigned long int ExtId; //扩展帧ID,值为0到0x1FFFFFFF
  unsigned char SAE_J1939_Flag;//表示是否使用SAE J1939协议
  SAE_ID SAE_J1939_ID;
  unsigned char IDE;   //帧类型,可为：CAN_ID_STD(标准帧),CAN_ID_EXT(扩展帧)
  unsigned char DLC;  //数据长度，可为0到8
  unsigned char MBox_num;//发送所用邮箱编号
  unsigned short int Rx_timeout_cnt;
  CAN_MSG_DATA CAN_Rx_msg_data; /*!< 帧消息内容,共8字节 */
} CanRxMsg;
*/
__interrupt void Ecana_isr1(void)
{
	if(ECanaRegs.CANGIF1.bit.GMIF1 == 1)
	{
		if(ECanaRegs.CANRMP.bit.RMP1 == 1)
		{
//读取该位是知道当前哪一个邮箱收到数据,

			can_rx_msg.MBox_num = ECanaRegs.CANGIF1.bit.MIV1;
			can_rx_msg.DLC = ECanaMboxes.MBOX1.MSGCTRL.bit.DLC;
			can_rx_msg.IDE = ECanaMboxes.MBOX1.MSGID.bit.IDE;
			if(can_rx_msg.IDE == CAN_ID_EXT)
			{
				can_rx_msg.ExtId = ECanaMboxes.MBOX1.MSGID.all&0x1FFFFFFF;
				can_rx_msg.SAE_J1939_ID.id = can_rx_msg.ExtId;
			}
			else if(can_rx_msg.IDE == CAN_ID_STD)
			{
				can_rx_msg.StdId = ECanaMboxes.MBOX1.MSGID.bit.STDMSGID;
			}
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte0 = ECanaMboxes.MBOX1.MDL.byte.BYTE0;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte1 = ECanaMboxes.MBOX1.MDL.byte.BYTE1;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte2 = ECanaMboxes.MBOX1.MDL.byte.BYTE2;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte3 = ECanaMboxes.MBOX1.MDL.byte.BYTE3;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte4 = ECanaMboxes.MBOX1.MDH.byte.BYTE4;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte5 = ECanaMboxes.MBOX1.MDH.byte.BYTE5;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte6 = ECanaMboxes.MBOX1.MDH.byte.BYTE6;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte7 = ECanaMboxes.MBOX1.MDH.byte.BYTE7;
		   ECanaRegs.CANRMP.bit.RMP1 = 1;
		}
		else if(ECanaRegs.CANRMP.bit.RMP31 == 1)
		{
			can_rx_msg.MBox_num = ECanaRegs.CANGIF1.bit.MIV1;
			can_rx_msg.DLC = ECanaMboxes.MBOX31.MSGCTRL.bit.DLC;
			can_rx_msg.IDE = ECanaMboxes.MBOX31.MSGID.bit.IDE;
			if(can_rx_msg.IDE == CAN_ID_EXT)
			{
				can_rx_msg.ExtId = ECanaMboxes.MBOX31.MSGID.all&0x1FFFFFFF;
				can_rx_msg.SAE_J1939_ID.id = can_rx_msg.ExtId;
			}
			else if(can_rx_msg.IDE == CAN_ID_STD)
			{
				can_rx_msg.StdId = ECanaMboxes.MBOX31.MSGID.bit.STDMSGID;
			}
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte0 = ECanaMboxes.MBOX31.MDL.byte.BYTE0;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte1 = ECanaMboxes.MBOX31.MDL.byte.BYTE1;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte2 = ECanaMboxes.MBOX31.MDL.byte.BYTE2;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte3 = ECanaMboxes.MBOX31.MDL.byte.BYTE3;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte4 = ECanaMboxes.MBOX31.MDH.byte.BYTE4;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte5 = ECanaMboxes.MBOX31.MDH.byte.BYTE5;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte6 = ECanaMboxes.MBOX31.MDH.byte.BYTE6;
		   can_rx_msg.CAN_Rx_msg_data.msg_Byte.byte7 = ECanaMboxes.MBOX31.MDH.byte.BYTE7;
		   ECanaRegs.CANRMP.bit.RMP31 = 1;
		}
	}
	PieCtrlRegs.PIEACK.bit.ACK9 = 1;
}

下面是部分宏定义和结构体定义

/*
 * CANA.h
 *
 *  Created on: 2017年4月16日
 *      Author: admin
 */

#ifndef BSP_INC_CANA_H_
#define BSP_INC_CANA_H_
#include "include.h"
#include "stdint.h"
#define USE_CANA  1
#define USE_CANB  1
#define CAN_Id_Standard   0//表示标准帧
#define CAN_Id_Extended   1//表示扩展帧
#define CAN_ID_STD      CAN_Id_Standard
#define CAN_ID_EXT      CAN_Id_Extended
#define TXCOUNT 100
typedef enum _CAN_Num
{
	Null = 0,
	CANA = 1,
	CANB = 2,
} CAN_Num;
typedef enum _UPDATE_State
{
	NON_CHANGE = 0,
	UPDATE = 1,
} UPDATE_State;
typedef union _SAE_ID
{
	unsigned long int all;
	 struct
	{
		unsigned short int SA :8;
		unsigned short int PS :8;
		unsigned short int PF :8;
		unsigned short int DP :1;
		unsigned short int R :1;
		unsigned short int Priority :3;
		unsigned short int resved :3;
	} bit;
} SAE_ID;
typedef struct _CAN_MSG_byte
{
	unsigned char data[8];
} CAN_MSG_byte;
typedef struct _CAN_MSG_BYTE
{
	unsigned char byte0;
	unsigned char byte1;
	unsigned char byte2;
	unsigned char byte3;
	unsigned char byte4;
	unsigned char byte5;
	unsigned char byte6;
	unsigned char byte7;
} CAN_MSG_BYTE;
typedef union _CAN_MSG_DATA
{
	CAN_MSG_byte msg_byte;
	CAN_MSG_BYTE msg_Byte;
} CAN_MSG_DATA;
typedef struct _CanTxMsg
{
	union
	{
		unsigned short int all;
		struct
		{
			unsigned short int StdId :11;
			unsigned short int resved :5;
		} bit;
	} StdId; //标准帧ID
	union
	{
		unsigned long int all;
		struct
		{
			unsigned long int ExtId :29;
			unsigned long int resved :3;
		} bit;
	} ExtId; //扩展帧ID
	unsigned char SAE_J1939_Flag; //表示是否使用SAE J1939协议
	SAE_ID SAE_J1939_ID;
	unsigned char IDE;   //帧类型,可为：CAN_ID_STD(标准帧),CAN_ID_EXT(扩展帧)
	unsigned char DLC;  //数据长度，可为0到8;
	unsigned char MBox_num;  //邮箱编号,0-31
	unsigned short int Tx_timeout_cnt;
	CAN_Num CAN_num;
	UPDATE_State tx_update;
	CAN_MSG_DATA CAN_Tx_msg_data; /*!< 帧消息内容,共8字节 */

} CanTxMsg;
typedef struct _CanRxMsg
{
	union
	{
		unsigned short int all;
		struct
		{
			unsigned short int StdId :11;
			unsigned short int resved :5;
		} bit;
	} StdId; 标准帧ID,值为0x000到0x7FFF;
	union
	{
		unsigned long int all;
		struct
		{
			unsigned long int ExtId :29;
			unsigned long int resved :3;
		} bit;
	} ExtId; 扩展帧ID,值为0到0x1FFFFFFF
	unsigned char SAE_J1939_Flag; //表示是否使用SAE J1939协议
	SAE_ID SAE_J1939_ID;
	unsigned char IDE;   //帧类型,可为：CAN_ID_STD(标准帧),CAN_ID_EXT(扩展帧)
	unsigned char DLC;  //数据长度，可为0到8;
	unsigned char MBox_num;  //发送所用邮箱编号
	unsigned short int Rx_timeout_cnt;
	CAN_MSG_DATA CAN_Rx_msg_data; /*!< 帧消息内容,共8字节 */
	CAN_Num CAN_num;
	UPDATE_State rx_update;
} CanRxMsg;
typedef struct _CANBus_Baudrate
{
	Uint16  BRPREG:   8; // 23:16 Baudrate prescaler register value
	Uint16  TSEG2REG: 3; // 2:0   TSEG2 register value
	Uint16  TSEG1REG: 4; // 6:3   TSEG1 register value
	unsigned short int  BaudRate;
}CANBus_Baudrate;
void CAN_GPIO_Config(CAN_Num CAN);
void CAN_Config(CAN_Num CAN,unsigned short int  BaudRate);
void CAN_Tx_Msg(CanTxMsg *can_tx_msg);  //发送消息
void CAN_Rx_Msg(CanRxMsg *can_rx_msg);  //接收消息
#if USE_CANA
static void CANA_RX_Config(void);
#endif
#if USE_CANB
static void CANB_RX_Config(void);
#endif
void CAN_Rx_Config(void);
void CAN_Rx_IT_Concig(void);
int CAN_GetBaudRateNum(unsigned int BaudRate);
__interrupt void Ecana_isr1(void);
__interrupt void Ecanb_isr1(void);
extern CanTxMsg can_tx_msg;
extern CanRxMsg can_rx_msg;
extern CANBus_Baudrate CANBus_Baudrate_table[27];
#endif /* BSP_INC_CANA_H_ */

皇甫仁和
关注
专栏目录
DSP28335的CAN总线通讯
weixin_41986942的博客
10-22 2万+
本文将演示DSP28335的CAN通讯，并用示波器验证CAN总线、CAN模块的RX、TX管脚的电压波形。话不多说，直接上代码 Uint32 TestMbox1 = 0;//用来接收mailbox里面的值 Uint32 TestMbox2 = 0; Uint32 TestMbox3 = 0; Uint32 TestMbox4 = 0; Uint32 TestMbox5 = 0; Uint3...
CAN总线学习笔记二：CAN自收发程序解读
08-14
　花了一整个下午的时间，彻头彻尾的把 PIAE小组提供的CAN自收发源程序解读了一遍。解读别人的程序是一件挺费时费力的一件事，但是在对某项技术或者说某个芯片的入门阶段参考别人的程序又是一项必不可少的任务。
DSP28335 CAN模块详解
weixin_43716668的博客
10-27 8030
DSP28335的ECAN模块，描述CAN2.0B协议的组成以及数据帧格式；DSP28335 CAN邮箱示例代码，CAN消息发送和接收代码示例
CAN总线详解-理论知识部分
最新发布
w123456789ABCDEF的博客
08-14 3227
CAN总线详细介绍，包括CAN总线硬件电路、CAN总线帧格式、CAN总线位时序、CAN总线硬同步、CAN总线再同步、CAN总线先占先得和非破坏性仲裁、CAN总线错误处理
F28335 CAN总线
10-22
f28335 can通信，代码可以参考，配置自己需要的功能。
28335的CAN总线学习笔记.pdf
08-19
个人对TMS320F28335的CAN总线学习笔记
DSP28335 CAN通讯实验
热门推荐
EnzoReventon是一个正在努力学习的社会主义好青年
07-05 2万+
《DSP从零开始学习历程》@EnzoReventon DSP 28335 CAN通讯实验 1. 实验目的： 实现开发板上同一个CAN口的数据收发，mail0发送数据，mail1接收数据。 2. 硬件设备 “研旭 三兄弟”DSP28335开发板 研旭YXDSP-XDS100V3 仿真器 周立功ZLG USBCANFD200U，USB-CAN转换器，用于电脑与设备间的CAN数据收发 3. 软件准备 Code Composer Studio 6.1.3，用于编写，调试DSP程序。 ZCANPRO，
DSP F28335：CAN配置[DSP CAN]
weixin_41648964的博客
12-26 7723
本文为dsp ecan功能的相关介绍，主要包括eCAN功能介绍，eCAN功能配置，发送接收邮箱配置，发送接收数据操作等。
CAN总线学习笔记四：CAN总线通信
08-14
CAN总线学习笔记四：CAN总线通信 在学习CAN总线的自通信程序后，探讨CAN总线间的相互通信变得容易了许多。在理解了CAN总线的自通信程序后，再来探讨CAN总线间的相互通信变得容易了许多。对于是自通信还是相互通信，...
CAN总线学习笔记一：CAN总线的相关概念
08-14
在这信息爆炸的年代，学习一样新的知识，尤其是IT技术的学习，网络是必不可少的。一阵狂搜过后，发现基于CAN总线的介绍确实不少，但是大多好像都雷同了，也许是不断转贴的结果吧。
DSP28335 CAN通信程序
06-14
DSP28335 CAN通信程序，可以借鉴下思路
dsp 28335 CAN通信 可用 已配置好
09-25
DSP 28335 CAN通信 可用 已配置好
28335 的ECAN模块
07-14
28335 的ECAN模块 具体介绍这个模块 英文的
DSP28335 can.rar_CAN_CAN总线28335_can 28335 控制_dsp 28335 can_dsp
07-14
DSP 28335 CAN总线通许程序，CAN设置，收发控制
基于TI 28335的CAN接收模型
10-25
可以直接编译下载到芯片中执行,传输速率1M~250K可以调整.
TMS320F28335(DSP28335),CAN通讯
m0_51984346的博客
04-12 2335
有32个消息邮箱，传输消息时根据消息优先级进行传输，如果超过一个邮箱的消息有相同的优先级，则先传输高编号邮箱中的消息。SCC模式：邮箱结构：寄存器访问应一次访问多少宽度的数据（8位、16位、32位）：上面提到一些寄存器只能32位读写，下面举例当需要检查寄存器中某一位状态时应用do-while，而不要直接用while。
基于DSP28335的CAN通信(附代码)
m0_47323029的博客
02-21 8211
记录了基于DSP28335的CAN通信常见问题，并给出了配置代码和接收中断代码
dsp28335的CAN升级方案，在dsp28335中集成CAN接口和BootLoader，通过上位机进行固件升级
iEScMBwE的博客
12-17 1782
结论： 本文介绍了一种基于dsp28335的CAN升级方案，通过在dsp28335中集成CAN接口和BootLoader，实现了在不使用仿真器的情况下通过上位机进行固件升级的功能。4.如果烧录程序卡住了，报文信息也没有的话：这个看起来像两个还没有建立正常的通信，只是上位机和can盒正常建立了链接，但是没有和dsp正常通信，请把boot超市屏蔽了，让他定时发送can报文，然后链接上位机，看上位机收到了不，首先需要保证dsp和盒子是通的(操作正确，设备正确的话是不会这样的)确保安装过程中不进行任何选项的修改。
CAN 总线学习笔记
01-18
CAN总线学习笔记主要包括CAN总线的相关概念和CAN自收发程序的解读。这些学习笔记可以帮助初学者了解CAN总线的基本原理和应用。 在CAN总线学习笔记一中，作者提到了学习新知识时网络的重要性，尤其是IT技术的学习。作者指出，虽然关于CAN总线的介绍很多，但大多雷同，可能是因为不断转贴的结果。这篇学习笔记可能会介绍CAN总线的基本概念，如CAN总线的工作原理、通信方式、帧格式等。 在CAN总线学习笔记二中，作者提到了解读别人的程序是一项费时费力的任务，但对于初学者来说，参考别人的程序是必不可少的。这篇学习笔记可能会解读一个CAN自收发程序，帮助初学者理解CAN总线的数据收发过程和相关编程技巧。 总的来说，CAN总线学习笔记可以帮助初学者快速入门CAN总线技术，并了解如何使用CAN总线进行数据通信和编程。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值