TC275 Multican代码示例

注：此代码可以直接使用
core0_main文件

int core0_main(void)
{
    /*
     * !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdog in the demo if it is required and also service the watchdog periodically
     * */


    /* Initialise the application state */
    

    /* Enable the global interrupts of this CPU */
    IfxCpu_enableInterrupts();
     GPIO_init();
    /* Demo init */
    //IfxStmDemo_init();
    CAN_int();
    /* background endless loop */
    while (TRUE)
    {

  // 	IfxStm_waitTicks(&MODULE_STM0, 20000000);
	//  IfxPort_togglePin(&MODULE_P33,0);

    	CAN_TEST();



		// IfxPort_setGroupState(&MODULE_P33, 0, 0xff,  rec.Data[0]);//读出送到8位LED显示


    }

    return 0;
}
``

can.c文件

 * can.c文件
 *
 *  Created on: 2020年6月9日
 *      Author: 在路上
 */


//注意：需要配置启动时钟为ILLD包自带时钟，不能使用hightec自带启动文件！！！否则波特率可能配置有问题！！！


#include "can.h"

IfxMultican_Can  can;
IfxMultican_Can_Node   can0NODE;
IfxMultican_Can_MsgObjConfig canMsgObjConfig;

IfxMultican_Can_MsgObj can0TxMsgObj0_EXT;                    //扩展发送
IfxMultican_Can_MsgObj can0TxMsgObj0_STD ;                   //标准发送
IfxMultican_Can_MsgObj can0RxMsgObj0;                             //接收

//CanRxMsg  rec;


volatile    CanRxMsg  rec;                          //需要加关键词volatile防止编译器优化，调试很久，找出原因！！！

int a[8]={0,0x1,0x2,0x3,0x4,0x5,0x6,0x07};

IFX_INTERRUPT(Can0RxISR, 0, IFX_INTPRIO_CAN0_RX )
{

	IfxMultican_Message  receive  ;


	//接收IDE位
    IfxMultican_MsgObjId objId;

    if (can0RxMsgObj0.msgObjCount > 1)
    {

        objId =can0RxMsgObj0.fifoPointer;
    }
    else
    {

        objId = can0RxMsgObj0.msgObjId;
    }
	Ifx_CAN_MO *hwObj = IfxMultican_MsgObj_getPointer(can0RxMsgObj0.node->mcan, objId);

	rec.IDE=hwObj->AR.B.IDE;


	//接收data
	IfxMultican_Can_MsgObj_readMessage(&can0RxMsgObj0,&receive);

    int m,n;
     for(m=0;m<2;m++)
     {
    	 for(n=0;n<4;n++)
    	 {
    		 rec.Data[n+m*4]=(receive.data[m]>>(8*n))&(0xFF);
    	 }
     }

     rec.DLC=receive.lengthCode;
     rec.ID=receive.id;

}


void CAN_int(void)
{
	 IfxMultican_Can_Config  canConfig;
	 IfxMultican_Can_NodeConfig canNodeConfig;

	 IfxMultican_Can_initModuleConfig(&canConfig, &MODULE_CAN);

	 canConfig.nodePointer[1].priority=IFX_INTPRIO_CAN0_RX;                       //需要配置接收中断服务请求节点
	 canConfig.nodePointer[1].typeOfService=IfxSrc_Tos_cpu0;

	 IfxMultican_Can_initModule(&can, &canConfig);                  //模块全局初始化     时钟来源spb，100MHZ


	 {
		IfxMultican_Can_Node_initConfig(&canNodeConfig, &can);
		canNodeConfig.baudrate=500000;                    //500 kBaud
		canNodeConfig.nodeId=IfxMultican_NodeId_0;         //节点0

		canNodeConfig.rxPin = &IfxMultican_RXD0B_P20_7_IN;                             //配置P20_7和P20_8为can节点0引脚
		canNodeConfig.rxPinMode = IfxPort_InputMode_pullUp;
		canNodeConfig.txPin = &IfxMultican_TXD0_P20_8_OUT;
		canNodeConfig.txPinMode = IfxPort_OutputMode_pushPull;

		IfxMultican_Can_Node_init  (&can0NODE, &canNodeConfig);                                     //CAN节点配置
	 }


	{             //标准帧消息对象配置
		IfxMultican_Can_MsgObj_initConfig(&canMsgObjConfig, &can0NODE);

		 canMsgObjConfig.messageId = 0x100;             //可忽略
		 canMsgObjConfig.acceptanceMask = 0x7FFFFFFFUL;
		 canMsgObjConfig.frame = IfxMultican_Frame_transmit;
		 canMsgObjConfig.control.messageLen = IfxMultican_DataLengthCode_8;
		 canMsgObjConfig.control.extendedFrame = FALSE;
		 canMsgObjConfig.control.matchingId = TRUE;

		canMsgObjConfig.msgObjId                         = TRANSMIT_OBJID;
		canMsgObjConfig.msgObjCount                      = TRANSMIT_FIFO_SIZE;

		IfxMultican_Can_MsgObj_init(&can0TxMsgObj0_STD,&canMsgObjConfig);                     //消息对象发送配置

	}



	{          //扩展帧消息对象配置
		IfxMultican_Can_MsgObj_initConfig(&canMsgObjConfig, &can0NODE);

		 canMsgObjConfig.messageId = 0x100;                                //可忽略
		 canMsgObjConfig.acceptanceMask = 0x7FFFFFFFUL;
		 canMsgObjConfig.frame = IfxMultican_Frame_transmit;
		 canMsgObjConfig.control.messageLen = IfxMultican_DataLengthCode_8;
		 canMsgObjConfig.control.extendedFrame = TRUE;
		 canMsgObjConfig.control.matchingId = TRUE;

		canMsgObjConfig.msgObjId                         = TRANSMIT_OBJID+TRANSMIT_FIFO_SIZE+1;
		canMsgObjConfig.msgObjCount                      = TRANSMIT_FIFO_SIZE;

		IfxMultican_Can_MsgObj_init(&can0TxMsgObj0_EXT,&canMsgObjConfig);                     //消息对象发送配置

	}


	{                   //消息对象接收配置
		 IfxMultican_Can_MsgObj_initConfig(&canMsgObjConfig, &can0NODE);


		 canMsgObjConfig.messageId = 0X09;
		 canMsgObjConfig.acceptanceMask = 0;
		 canMsgObjConfig.frame = IfxMultican_Frame_receive;
		 canMsgObjConfig.control.messageLen = IfxMultican_DataLengthCode_8;
		 canMsgObjConfig.control.extendedFrame = TRUE;
		 canMsgObjConfig.control.matchingId = FALSE;

		 canMsgObjConfig.msgObjId                         = RECEIVE_OBJID;
		 canMsgObjConfig.msgObjCount                      = RECEIVE_FIFO_SIZE;

#if CAN1_RX0_INT_ENABLE
		 canMsgObjConfig.rxInterrupt.enabled =TRUE ;                                                             //接收中断是否使能
		 canMsgObjConfig.rxInterrupt.srcId = IfxMultican_SrcId_1;                                          //选择中断输出线INT_O0


#endif
		 IfxMultican_Can_MsgObj_init(&can0RxMsgObj0,&canMsgObjConfig);                      //消息对象接收配置

#if CAN1_RX0_INT_ENABLE
		 int i=0;
		 for(i=0;i<RECEIVE_FIFO_SIZE;i++)
		 {
		       IfxMultican_MsgObj_setReceiveInterrupt(&MODULE_CAN.MO[RECEIVE_OBJID+i+1], TRUE);
		       IfxMultican_MsgObj_setReceiveInterruptNodePointer(&MODULE_CAN.MO[RECEIVE_OBJID+i+1],  canMsgObjConfig.rxInterrupt.srcId);

		 }
#endif

	}
}



void  can_send(CanRxMsg *message)
{

IfxMultican_Message msg;

 const unsigned dataLow = message->Data[0]|(message->Data[1]<<8)|(message->Data[2]<<16)|(message->Data[3]<<24);
 const unsigned dataHigh = message->Data[4]|(message->Data[5]<<8)|(message->Data[6]<<16)|(message->Data[7]<<24);

IfxMultican_Message_init(&msg,message->ID,  dataLow, dataHigh, message->DLC);
// Transmit Data
if(message->IDE)     //扩展为1 ；标准0
{
	while (IfxMultican_Can_MsgObj_sendMessage(&can0TxMsgObj0_EXT, &msg) == IfxMultican_Status_notSentBusy);
}
else
{
	while (IfxMultican_Can_MsgObj_sendMessage(&can0TxMsgObj0_STD, &msg) == IfxMultican_Status_notSentBusy);
}


}




void  CAN_TEST(void)
{
	CanRxMsg MES;
	int i=0;
	MES.ID=0x890;
	MES.IDE=1;
	MES.DLC=8;
   for( i=0;i<8;i++)
   {
	   MES.Data[i]=a[i];
   }
	can_send(&MES);

}



``

can.h 文件

 * can.h  文件
 *
 *  Created on: 2020年6月9日
 *      Author: 在路上
 */#ifndef CAN_H
#define CAN_H


#include "Multican/Can/IfxMultican_Can.h"
#include  "_Reg/IfxCan_regdef.h"
 #define IFX_INTPRIO_CAN0_RX  2
#define CAN1_RX0_INT_ENABLE 	1	       //1 启动接收中断        0 关闭接收中断

#define  TRANSMIT_OBJID      0                                     //发送标准对象  or  FIFO(基对象)

#define  TRANSMIT_FIFO_SIZE    3                      //fifo大小

#define  RECEIVE_FIFO_SIZE    3                      //fifo大小

#define  RECEIVE_OBJID      ( TRANSMIT_FIFO_SIZE+1)*2                                 //接收标准对象  or  FIFO(基对象)

typedef struct
{
	unsigned  long  ID;

	unsigned          char IDE;

	unsigned          char DLC;

	unsigned          char Data[8];

} CanRxMsg;

IFX_EXTERN volatile   CanRxMsg  rec;     //需要加关键词volatile防止编译器优化，调试很久，找出原因！！！

void CAN_int(void);

void  CAN_TEST(void);

void  can_send(CanRxMsg *message);


void test(void);

#endif /* 0_APPSW_TRICORE_DEMO_ILLD_CAN_H_ */