嵌入式技术基础与实践-第十章学习作业

月海鱼鱼猫

已于 2024-06-18 23:09:10 修改

阅读量109

点赞数 1

分类专栏：嵌入式技术基础学习文章标签：学习

于 2024-06-18 23:08:06 首次发布

本文链接：https://blog.csdn.net/weixin_62903092/article/details/139784701

版权

嵌入式技术基础学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

实验完成后，将结果截图、连线照片、实验原理图和CAN原理介绍，放入博客中。

连线图

代码

can_NodeB

main.c文件

#define GLOBLE_VAR
#include "includes.h"      //包含总头文件

int main(void)
{
	//（1.1）声明main函数使用的局部变量
	vuint32_t mMainLoopCount;  //主循环次数变量
	uint8_t  mFlag;           //灯的状态标志
	uint32_t mLightCount;     //灯的状态切换次数
	uint32_t localMsgID;
	uint32_t txMsgID;
	uint32_t BitRate;


	//（1.2）【不变】关总中断
	DISABLE_INTERRUPTS;

	//（1.3）给主函数使用的局部变量赋初值
    mMainLoopCount=0;    //主循环次数变量
	mFlag='A';           //灯的状态标志
	mLightCount=0;       //灯的闪烁次数
	localMsgID = 0x0BU;
	txMsgID = 0x0AU;
	BitRate = 36;

	//（1.4）给全局变量赋初值

	//（1.5）用户外设模块初始化
	gpio_init(LIGHT_RED,GPIO_OUTPUT,LIGHT_ON);	//初始化蓝灯
    emuart_init(UART_User,115200);
    uart_init(UART_3,115200);
    //【***CAN模块初始化***】
    can_init(CAN_1,localMsgID,BitRate);

    //（1.6）使能模块中断
    uart_enable_re_int(UART_User);
    uart_enable_re_int(UART_3);
    //【***使能CAN模块中断***】
    can_enable_recv_int(CAN_1);
    //（1.7）【不变】开总中断
	ENABLE_INTERRUPTS;

	for(;;)   //for(;;)（开头）
	{
		//（2.1）主循环次数变量+1
        mMainLoopCount++;
        //（2.2）未达到主循环次数设定值，继续循环
		if (mMainLoopCount<=12889000)  continue;
		//（2.3）达到主循环次数设定值，执行下列语句，进行灯的亮暗处理
		//（2.3.1）清除循环次数变量
		mMainLoopCount=0;
		//（2.3.2）如灯状态标志mFlag为'L'，灯的闪烁次数+1并显示，改变灯状态及标志
		if (mFlag=='L')                    //判断灯的状态标志
		{
			mLightCount++;
			mFlag='A';                       //灯的状态标志
			gpio_set(LIGHT_RED,LIGHT_ON);  //灯“亮”
			//【***CAN模块发送一帧数据***】
			if(can_send(CAN_1, txMsgID, 15, (uint8_t*)"liuxinyang\r\n") != 0) printf("failed\r\n");
		}
		//（2.3.3）如灯状态标志mFlag为'A'，改变灯状态及标志
		else
		{
			mFlag='L';                       //灯的状态标志
			gpio_set(LIGHT_RED,LIGHT_OFF); //灯“暗”
		}
	}  //for(;;)结尾
}

isr.c文件

#include "includes.h"
void User_SysFun(uint8_t ch);
void UART_User_Handler(void)
{
	//（1）变量声明
    uint8_t flag,ch;
    DISABLE_INTERRUPTS;      //关总中断
    //（2）未触发串口接收中断，退出
    if(!uart_get_re_int(UART_User)) goto UART_User_Handler_EXIT;
    //（3）收到一个字节，读出该字节数据
    ch = uart_re1(UART_User,&flag);        //调用接收一个字节的函数
    if(!flag) goto UART_User_Handler_EXIT; //实际未收到数据，退出
  //（4）以下代码根据是否使用模板提供的User串口通信帧结构，及是否利用User串口
    //     进行带有设备序列号的进行程序更新而选择
    //（4.1）【自行组帧使用（开始)】
        uart_send1(UART_User,ch);     //例如，收到一个字节回发一个字节
       //    【自行组帧使用（结束)】
    //（4.2）【使用模板提供的User串口通信帧结构（开始)】
    /*
       User_SysFun(ch);          //利用User串口进行程序更新
       if (gcRecvLen == 0) goto UART_User_Handler_EXIT; 
       //至此，不仅收到完整帧，且序号比较也一致，可以根据命令字节gcRecvBuf[16]进行编程
       switch(gcRecvBuf[16])  //帧标识
       {
           case 1:  //0之外的数据，自身命令
           break;
           default:
           break;
        }
        gcRecvLen = 0;   //帧已经使用完毕，下次若收到一个字节，可以继续组帧
        //【使用模板提供的User串口通信帧结构（结束)】
     */
    //（5）【公共退出区】
UART_User_Handler_EXIT:
    ENABLE_INTERRUPTS;//开总中断
}

void CAN1_RX0_IRQHandler(void)
{
	uint8_t buff[8];
	uint8_t len = 0;
	DISABLE_INTERRUPTS;
	//【***CAN模块接收一帧数据***】
	len = can_recv(CAN_1, buff);
	if(len >= 0)
	{
		uart_sendN(UART_Debug, len, buff);
	}
	ENABLE_INTERRUPTS;
}

void CAN1_RX1_IRQHandler(void)
{
	DISABLE_INTERRUPTS;
	printf("CAN1 Interrupt Once.....");
	ENABLE_INTERRUPTS;
}

//内部函数
void User_SysFun(uint8_t ch)
{
    //（1）收到的一个字节参与组帧
    if(gcRecvLen == 0)  gcRecvLen =useremuart_frame(ch,(uint8_t*)gcRecvBuf);
    //（2）字节进入组帧后，判断gcRecvLen=0？若为0，表示组帧尚未完成，
    //     下次收到一个字节，再继续组帧
    if(gcRecvLen == 0) goto User_SysFun_Exit;
    //（3）至此，gcRecvLen≠0,表示组帧完成，gcRecvLen为帧的长度,校验序列号后（与
    //     根据Flash中倒数一扇区开始的16字节进行比较）
    //     gcRecvBuf[16]进行跳转
    if(strncmp((char *)(gcRecvBuf),(char *)((MCU_SECTOR_NUM-1)*MCU_SECTORSIZE+
       MCU_FLASH_ADDR_START),16) != 0)
    {
        gcRecvLen = 0;         //恢复接收状态
        goto User_SysFun_Exit;
    }
    //（4）至此，不仅收到完整帧，且序号比较也一致， 根据命令字节gcRecvBuf[16]进行跳转
    //若为User串口程序更新命令，则进行程序更新
    switch(gcRecvBuf[16])  //帧标识
    {
        case 0:
            SYSTEM_FUNCTION((uint8_t *)(gcRecvBuf+17));
            gcRecvLen = 0;         //恢复接收状态
        break;
        default:
        break;
    }
User_SysFun_Exit:
    return;
}

对于can的驱动函数文件加注释。在can（加注释）.c中标了“//2024.6”的语句加以理解并写出注释。放入博客中。

//======================================================================
//文件名称：can.c
//功能概要：uart底层驱动构件源文件
//版权所有：苏州大学嵌入式系统与物联网研究所(sumcu.suda.edu.cn)
//更新记录：2021-02-03 V1.0  JJL
//======================================================================
#include "can.h"

CAN_TypeDef *CAN_ARR[] = {(CAN_TypeDef*)CAN1_BASE};
IRQn_Type table_irq_can[2] = {CAN1_RX0_IRQn, CAN1_RX1_IRQn};

uint8_t can_send_once(uint8_t canNo, uint32_t DestID, uint16_t len ,uint8_t* buff);
uint8_t CAN_HWInit(uint8_t CANChannel);
uint8_t CAN_SWInit_Entry(uint8_t canNo);
void CAN_SWInit_CTLMode(uint8_t canNo);
void CAN_SWInit_BT(uint8_t canNo, uint32_t CANMode, uint32_t Prescaler);
uint8_t CAN_SWInit_Quit(uint8_t canNo);
uint8_t CANFilterConfig(uint8_t canNo, uint32_t canID, uint32_t FilterBank, uint32_t Can_Rx_FifoNo, uint8_t IsActivate, uint32_t FilterMode, uint32_t FilterScale);

//=====================================================================
//函数名称：can_init
//函数返回：无
//参数说明：canNo：模块号，本芯片只有CAN_1
//		    canID：自身CAN节点的唯一标识，例如按照CANopen协议给出
//          BitRate：位速率
//功能概要：初始化CAN模块
//=====================================================================
void can_init(uint8_t canNo, uint32_t canID, uint32_t BitRate)
{
	//声明Init函数使用的局部变量
	uint32_t CANMode;
	uint32_t CANFilterBank;
	uint32_t CANFiltermode;
	uint32_t CAN_Filterscale;

	//给Init函数使用的局部变量赋初值
	CANMode = CAN_MODE_NORMAL;                // 设置can工作模式为正常模式
	CANFilterBank = CANFilterBank0;
	CANFiltermode = CAN_FILTERMODE_IDMASK;
	CAN_Filterscale = CAN_FILTERSCALE_32BIT;

	//（1）CAN总线硬件初始化
	CAN_HWInit(CAN_CHANNEL);
	//（2）CAN总线进入软件初始化模式
	CAN_SWInit_Entry(canNo);
	//（3）CAN总线模式设置
	CAN_SWInit_CTLMode(canNo);
	//（4）CAN总线位时序配置
	CAN_SWInit_BT(canNo,CANMode,BitRate);
	//（5）CAN总线过滤器初始化
    CANFilterConfig(canNo, canID, CANFilterBank, CAN_RX_FIFO0, 1, CANFiltermode, CAN_Filterscale);
    //（6）CAN总线退出软件初始化模式，进入正常模式
    CAN_SWInit_Quit(canNo);
}

//=====================================================================
//函数名称：can_send
//函数返回：0=正常，1=错误
//参数说明：canNo：模块号，本芯片只有CAN_1
//          DestID：目标CAN节点的唯一标识，例如按照CANopen协议给出
//          len：待发送数据的字节数
//          buff：待发送数据发送缓冲区首地址
//功能概要：CAN模块发送数据
//=====================================================================
uint8_t can_send(uint8_t canNo, uint32_t DestID, uint16_t len ,uint8_t* buff)
{
	if(DestID > 0x1FFFFFFFU) return 1;
	uint8_t send_length;
	for(int i = len; i > 0; i = i-8)
	{
		send_length = (i>8)?8:i;
		if(can_send_once(canNo,DestID,send_length,buff+len-i) == 1)   // 发送一次数据，若发送失败则立即返回错误码1
		{
			return 1;
		}
	}
	return 0;
}

//=====================================================================
//函数名称：can_recv
//函数返回：接收到的字节数
//参数说明：canNo：模块号，本芯片只有CAN_1
//          buff：接收到的数据存放的内存区首地址
//功能概要：在CAN模块接收中断中调用本函数接收已经到达的数据
//=====================================================================
uint8_t can_recv(uint8_t canNo, uint8_t *buff)
{
	uint8_t len;
	uint32_t RxFifo = CAN_RX_FIFO0;
	//（1）判断哪个邮箱收到了报文信息
	if(RxFifo == CAN_RX_FIFO0)
	{
		if ((CAN_ARR[canNo-1]->RF0R & CAN_RF0R_FMP0) == 0U)   // CAN_ARR[canNo-1]->RF0R指的是寄存器FIFO 0,判断邮箱是否有数据
		{
			return 1;
		}
	}
	else
	{
		if ((CAN_ARR[canNo-1]->RF1R & CAN_RF1R_FMP1) == 0U)
		{
			return 1;
		}
	}
	//（2）获取数据长度
    len = (CAN_RDT0R_DLC & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos;  // 获取数据长度
    //（3）获取数据帧中的数据
    buff[0] = (uint8_t)((CAN_RDL0R_DATA0 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA0_Pos);
    buff[1] = (uint8_t)((CAN_RDL0R_DATA1 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA1_Pos);
    buff[2] = (uint8_t)((CAN_RDL0R_DATA2 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA2_Pos);
    buff[3] = (uint8_t)((CAN_RDL0R_DATA3 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA3_Pos);
    buff[4] = (uint8_t)((CAN_RDH0R_DATA4 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA4_Pos);
    buff[5] = (uint8_t)((CAN_RDH0R_DATA5 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA5_Pos);
    buff[6] = (uint8_t)((CAN_RDH0R_DATA6 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA6_Pos);
    buff[7] = (uint8_t)((CAN_RDH0R_DATA7 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA7_Pos);
    //（4）清除标志位，等待接收下一帧数据
    if (RxFifo == CAN_RX_FIFO0)
    {
      SET_BIT(CAN_ARR[canNo-1]->RF0R, CAN_RF0R_RFOM0);  // 即RF0R|=CAN_RF0R_RFOM0，设置RF0R寄存器的RFOM0位，准备接收下一条消息
    }
    else
    {
      SET_BIT(CAN_ARR[canNo-1]->RF1R, CAN_RF1R_RFOM1);
    }
	return len;
}

//=====================================================================
//函数名称：CAN_enable_re_int
//函数返回：无
//参数说明：canNo:模块基地址号，Can_Rx_FifoNo:中断使用的邮箱号
//功能概要：CAN接收中断开启
//=====================================================================
void can_enable_recv_int(uint8_t canNo)
{
	uint8_t Can_Rx_FifoNo;
	Can_Rx_FifoNo = CAN_RX_FIFO0;
	if(Can_Rx_FifoNo == CAN_RX_FIFO0)
		SET_BIT(CAN_ARR[canNo-1]->IER, CAN_IER_FMPIE0);    // 设置CAN_IER寄存器中的FMPIE0位，启用寄存器FIFO0中断
	else
		SET_BIT(CAN_ARR[canNo-1]->IER,CAN_IER_FMPIE1);
	NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]);    // 使能FIFO对应的NVIC中断请求
}

//=====================================================================
//函数名称：can_disable_recv_int
//函数返回：无
//参数说明：canNo：模块号，本芯片只有CAN_1
//功能概要：关闭CAN接收中断
//=====================================================================
void can_disable_recv_int  (uint8_t canNo)
{
	uint8_t Can_Rx_FifoNo;
	Can_Rx_FifoNo = CAN_RX_FIFO0;
	if(Can_Rx_FifoNo == CAN_RX_FIFO0)
		CLEAR_BIT(CAN_ARR[canNo-1]->IER, CAN_IER_FMPIE0);
	else
		CLEAR_BIT(CAN_ARR[canNo-1]->IER,CAN_IER_FMPIE1);
	NVIC_DisableIRQ(table_irq_can[Can_Rx_FifoNo]);
}

//=====================================================================
//函数名称：can_send_once
//函数返回：0=正常，1=错误
//参数说明：canNo：模块号，本芯片只有CAN_1
//          DestID：目标CAN节点的唯一标识，例如按照CANopen协议给出
//          len：待发送数据的字节数
//          buff：待发送数据发送缓冲区首地址
//功能概要：CAN模块发送一次数据
//=====================================================================
uint8_t can_send_once(uint8_t canNo, uint32_t DestID, uint16_t len ,uint8_t* buff)
{
	//（1）定义Can发送函数所需要用到的变量
	uint32_t transmit_mailbox;
	uint32_t register_tsr;
	uint32_t rtr;
	rtr = CAN_RTR_DATA;
	register_tsr = READ_REG(CAN_ARR[canNo-1]->TSR);

	//（2）判断3个邮箱中是否有空闲邮箱，若有，选取其中一个进行发送，选取顺序为1，2，3
    if (((register_tsr & CAN_TSR_TME0) != 0U) ||    
        ((register_tsr & CAN_TSR_TME1) != 0U) ||
        ((register_tsr & CAN_TSR_TME2) != 0U))
    {
    	transmit_mailbox = (register_tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos;     // 获取当前空闲邮箱号
    	if(transmit_mailbox > 2U)
    	{
    		return 1;
    	}

    	//（2.1）判断并设置发送帧为标准帧还是扩展帧
    	if(DestID <= 0x7FFU)    // 标准帧使用11位标识符，范围是0x000到0x7FF
    	{
    		CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_STID_Pos)|CAN_ID_STD|rtr);  // 设置标准帧标识符
    	}
    	else
    	{
    		CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_EXID_Pos)|CAN_ID_EXT|rtr);  // 设置扩展帧标识符
    	}
    	//（2.2）设置发送帧的数据长度
    	CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDTR = len;
        //SET_BIT(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDTR, CAN_TDT0R_TGT);
        //（2.3）设置发送帧的数据
        WRITE_REG(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDHR,   // 数据依次左移，然后写入到TDHR寄存器
                  ((uint32_t)buff[7] << CAN_TDH0R_DATA7_Pos) |
                  ((uint32_t)buff[6] << CAN_TDH0R_DATA6_Pos) |
                  ((uint32_t)buff[5] << CAN_TDH0R_DATA5_Pos) |
                  ((uint32_t)buff[4] << CAN_TDH0R_DATA4_Pos));
        WRITE_REG(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDLR,
                  ((uint32_t)buff[3] << CAN_TDL0R_DATA3_Pos) |
                  ((uint32_t)buff[2] << CAN_TDL0R_DATA2_Pos) |
                  ((uint32_t)buff[1] << CAN_TDL0R_DATA1_Pos) |
                  ((uint32_t)buff[0] << CAN_TDL0R_DATA0_Pos));
        //（2.4）发送Can数据报
        SET_BIT(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR, CAN_TI0R_TXRQ);   // 设置TIR寄存器中的TXRQ位，启动发送
        return 0;
    }
    else
    {
    	return 1;
    }
}

//=====================================================================
//函数名称：CAN_HWInit
//函数返回：0=正常，1=错误
//参数说明：CANChannel:硬件引脚组号，共有3组，分别为PTA11&PTA12(CAN_CHANNEL0),PTB8&PTB9(CAN_CHANNEL1),PTD0&PTD1(2)
//功能概要：CAN模块引脚初始化
//=====================================================================
uint8_t CAN_HWInit(uint8_t CANChannel)
{
	if(CANChannel < 0 || CANChannel > 2)
	{
		return 1;
	}
	if(CANChannel == 0)
	{
		RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;   // 使能CAN1时钟
		RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
		GPIOA->MODER &= ~(GPIO_MODER_MODE11|GPIO_MODER_MODE12);
		GPIOA->MODER |= (GPIO_MODER_MODE11_1|GPIO_MODER_MODE12_1);  // 设置引脚模式为复用
		GPIOA->AFR[1] &= ~(GPIO_AFRH_AFSEL11|GPIO_AFRH_AFSEL12);
		GPIOA->AFR[1] |= (GPIO_AFRH_AFSEL11_0|GPIO_AFRH_AFSEL11_3)|(GPIO_AFRH_AFSEL12_0|GPIO_AFRH_AFSEL12_3);   // 设置复用功能
	}
	else if(CANChannel == 1)
	{
		RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
		RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
		GPIOB->MODER &= ~(GPIO_MODER_MODE8|GPIO_MODER_MODE9);
		GPIOB->MODER |= (GPIO_MODER_MODE8_1|GPIO_MODER_MODE9_1);
		GPIOB->AFR[1] &= ~(GPIO_AFRH_AFSEL8|GPIO_AFRH_AFSEL9);
		GPIOB->AFR[1] |= ((GPIO_AFRH_AFSEL8_0|GPIO_AFRH_AFSEL8_3)|
						  (GPIO_AFRH_AFSEL9_0|GPIO_AFRH_AFSEL9_3));
	}
	else
	{
		RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
		RCC->AHB2ENR |= RCC_AHB2ENR_GPIODEN;
		GPIOD->MODER &= ~(GPIO_MODER_MODE0|GPIO_MODER_MODE1);
		GPIOD->MODER |= (GPIO_MODER_MODE0_1|GPIO_MODER_MODE1_1);
		GPIOD->AFR[0] &= ~(GPIO_AFRL_AFSEL0|GPIO_AFRL_AFSEL1);
		GPIOD->AFR[0] |= ((GPIO_AFRL_AFSEL0_0 | GPIO_AFRL_AFSEL0_3)|
						  (GPIO_AFRL_AFSEL1_0 | GPIO_AFRL_AFSEL1_3));
	}
	return 0;
}

//=====================================================================
//函数名称：CAN_SWInit_Entry
//函数返回：0=正常，1=错误
//参数说明：canNo:模块基地址号，本芯片只有CAN_1,
//功能概要：进入初始化模式
//=====================================================================
uint8_t CAN_SWInit_Entry(uint8_t canNo)
{
	int i;
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_SLEEP);    // 清除睡眠模式
	i = 0;
	while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_SLAK) != 0U)   // 等待，等待时间过长报错
	{
		if(i++ > 0x30000)
		{
			return 1;
		}
	}

	SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ);    // 设置MCR中的INRQ位，进入初始化模式
	i = 0;
	while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) == 0U)
	{
		if(i++ > 0x30000)
		{
			return 1;
		}
	}
	return 0;
}

//=====================================================================
//函数名称：CAN_SWInit_CTLMode
//函数返回：无
//参数说明：canNo:模块基地址号，本芯片只有CAN_1,
//功能概要：CAN总线模式设置
//=====================================================================
void CAN_SWInit_CTLMode(uint8_t canNo)
{
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_TTCM);   // 禁用时间触发通信模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_ABOM);   // 禁用自动离线管理
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_AWUM);   // 禁用自动唤醒模式
	SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_NART);     // 启用了非自动重传模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_RFLM);    // 禁用了接收FIFO锁定模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_TXFP);    // 清除FIFO优先级模式
}

//函数名称：CAN_SWInit_CTLMode
//函数返回：无
//参数说明：canNo:模块基地址号，本芯片只有CAN_1,
//			CANMode:CAN总线工作模式，分别为正常模式(CAN_MODE_NORMAL)、回环模式(CAN_MODE_LOOPBACK)、
//										    静默模式(CAN_MODE_SILENT)以及回环与静默组合模式(CAN_MODE_SILENT_LOOPBACK)
//功能概要：CAN总线位时序配置
void CAN_SWInit_BT(uint8_t canNo, uint32_t CANMode, uint32_t Prescaler)
{
	CAN_ARR[canNo-1]->BTR |= ((uint32_t)(Prescaler-1)|CAN_SJW_1TQ|CAN_BTR_TS1_1|CAN_BTR_TS1_0|CAN_BTR_TS2_2|CANMode);    // 配置CAN控制器的位时序和工作模式
}

//=====================================================================
//函数名称：CAN_SWInit_Quit
//函数返回：0=正常，1=错误
//参数说明：canNo:模块基地址号
//功能概要：退出初始化模式，进入正常模式
//=====================================================================
uint8_t CAN_SWInit_Quit(uint8_t canNo)
{
	int i;
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ);    // 清除初始化请求
	i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) != 0U)    // 不断检查MSR寄存器中的INAK位，等待时间过长报错
    {
      if (i++ > 0x30000)
      {
        return 1;
      }
    }
    return 0;
}

//=====================================================================
//函数名称： CANFilterConfig
//函数返回：0=正常，1=错误
//参数说明： canNo:模块基地址号，
//		    canID：自身CAN节点的唯一标识，例如按照CANopen协议给出
//		    Can_Rx_FifoNo:中断使用的邮箱号，
//			IsActivate:是否激活过滤器
//			CANFilterBank:CAN总线过滤器组选择,共有28个,(CANFilterBank0~CANFilterBank27)
//			CANFiltermode:CAN总线过滤器模式，分别为掩码模式(CAN_FILTERMODE_IDMASK)和列表模式(CAN_FILTERMODE_IDLIST)
//			CAN_Filterscale:CAN总线过滤器位数，分别为32位(CAN_FILTERSCALE_32BIT)和16位(CAN_FILTERSCALE_16BIT)
//功能概要：CAN接收中断开启
//=====================================================================
uint8_t CANFilterConfig(uint8_t canNo, uint32_t CanID, uint32_t FilterBank, uint32_t Can_Rx_FifoNo, uint8_t IsActivate, uint32_t FilterMode, uint32_t FilterScale)
{
	uint32_t FilterIdHigh, FilterIdLow, FilterMaskIdHigh, FilterMaskIdLow, filternbrbitpos;
	if(CanID <= 0x7FFU) CanID = CanID << CAN_TI0R_STID_Pos;    // 转换为标准的ID格式

	FilterIdHigh = (CanID >> 16) & 0xFFFF;    // 得到高位CanID
	FilterIdLow = (CanID & 0xFFFF);    // 得到低位CanID
	FilterMaskIdHigh = 0xFFE0;    // 设置高位ID过滤器
	FilterMaskIdLow = 0x0000;    // 设置低位ID过滤器
	filternbrbitpos = (uint32_t)1 << (FilterBank & 0x1FU);    // 计算过滤器编号

	//设置过滤器初始化模式 (FINIT=1),在此模式下可以进行过滤器初始化
	SET_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    // 设置过滤器初始化模式，允许配置过滤器
	CLEAR_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);    // 禁用过滤器
	if (FilterScale == CAN_FILTERSCALE_16BIT)
	{
	  CLEAR_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);
	  CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR1 =
		((0x0000FFFFU & (uint32_t)FilterMaskIdLow) << 16U) |
		(0x0000FFFFU & (uint32_t)FilterIdLow);
	  CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR2 =
		((0x0000FFFFU & (uint32_t)FilterMaskIdHigh) << 16U) |
		(0x0000FFFFU & (uint32_t)FilterIdHigh);
	}
	if (FilterScale == CAN_FILTERSCALE_32BIT)    // 如果使用32位过滤器
	{
	  SET_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);    // 配置为32位模式
	  CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR1 =    // 设置过滤器寄存器1和2
		((0x0000FFFFU & (uint32_t)FilterIdHigh) << 16U) |
		(0x0000FFFFU & (uint32_t)FilterIdLow);
	  CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR2 =
		((0x0000FFFFU & (uint32_t)FilterMaskIdHigh) << 16U) |
		(0x0000FFFFU & (uint32_t)FilterMaskIdLow);
	}
	if (FilterMode == CAN_FILTERMODE_IDMASK)    // 如果使用掩码模式
	{
	  CLEAR_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);    // 配置为掩码模式
	}
	else
	{
	  SET_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);
	}
	if (Can_Rx_FifoNo == CAN_FILTER_FIFO0)     // 如果使用FIFO0
	{
	  CLEAR_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);   // 清除FIFO0
	}
	else
	{
	  SET_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);
	}
	if (IsActivate == 1)    // 如果需要激活过滤器
	{
	  SET_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);   // 设置激活过滤器
	}
	//退出过滤器初始化模式 (FINIT=0)
	CLEAR_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    // 退出过滤器初始化模式

	return 0;
}