最后一次作业

最新推荐文章于 2024-09-04 14:54:41 发布

qing_zun

最新推荐文章于 2024-09-04 14:54:41 发布

阅读量1.5k

点赞数 20

分类专栏：嵌入式系统作业文章标签：嵌入式硬件

本文链接：https://blog.csdn.net/qing_zun/article/details/139796518

版权

嵌入式系统作业专栏收录该内容

6 篇文章 0 订阅

订阅专栏

实验内容：

1、2个或以上同学相互连接，利用CAN通信，向对方发送带有本人姓名的信息。

nt main() // 主函数的开始，程序的入口点

{

uint32_t mMainLoopCount; // 定义一个无符号32位整数变量，用于计数主循环的次数

uint32_t localMsgID; // 定义一个无符号32位整数变量，用于存储本地消息ID

uint32_t txMsgID; // 定义一个无符号32位整数变量，用于存储要发送的消息ID

uint32_t BitRate; // 定义一个无符号32位整数变量，用于存储CAN总线的比特率

localMsgID = 0x0BU; // 将本地消息ID设置为0x0BU（十进制11）

txMsgID = 0x0AU; // 将发送消息ID设置为0x0AU（十进制10）

BitRate = 36; // 设置CAN总线的比特率为36

DISABLE_INTERRUPTS; // 禁用中断，通常用于防止初始化过程中的中断干扰

emuart_init(UART_User,115200); // 初始化扩展的UART（用户定义的），波特率为115200

uart_init(UART_3,115200); // 初始化UART_3，波特率为115200

can_init(CAN_1,localMsgID,BitRate); // 初始化CAN_1接口，使用本地消息ID和比特率

uart_enable_re_int(UART_User); // 启用UART_User的接收中断

uart_enable_re_int(UART_3); // 启用UART_3的接收中断

can_enable_recv_int(CAN_1); // 启用CAN_1的接收中断

ENABLE_INTERRUPTS; // 启用中断，允许中断处理

while(1) // 无限循环，主循环

{

mMainLoopCount++; // 每次循环递增计数器

if (mMainLoopCount<=12889000) continue; // 如果计数器小于或等于12889000，跳过下面的代码，继续循环

mMainLoopCount=0; // 重置计数器为0

can_send(CAN_1, txMsgID, 10, (uint8_t*)"蔡潮嘉"); // 发送CAN消息，使用CAN_1接口，消息ID为txMsgID，数据长度为10字节，数据为"蔡潮嘉"

printf("\n"); // 打印换行符，通常用于调试或日志记录

}

2、在ADC实验中，结合热敏电阻，分别通过触摸芯片表面和热敏电阻，引起A/D值变化，显示芯片内部温度和当前温度。

#define GLOBLE_VAR

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

//----------------------------------------------------------------------

//声明使用到的内部函数

//main.c使用的内部函数声明处

void Delay_ms(uint16_t u16ms);

float Regression_Ext_Temp(uint16_t tmpAD); //环境温度AD值转为实际温度

float Regression_MCU_Temp(uint16_t mcu_temp_AD); //MCU温度AD值转为实际温度

//----------------------------------------------------------------------

//主函数，一般情况下可以认为程序从此开始运行（实际上有启动过程，参见书稿）

int main(void)

{

float a15=0,a17=0;

uint16_t d15=0,d17=0;

adc_init(15,AD_SINGLE);

adc_init(17,AD_SINGLE);

while(1)

{

Delay_ms(2000);

d15=adc_read(15);

Delay_ms(100);

d17=adc_read(17);

a15=tempRegression(d15);

a17=adc_mcu_temp(d17);

printf("温度AD值%d：",d15);

printf("温度为%6.2f：",a15);

printf("芯片AD值%d：",d17);

printf("芯片温度为%6.2f：\n",a17);

}

3、用实验验证，对于有数据的某扇区，如果没有擦除（Flash_erase），可否写入新数据？注：扇区号为学号后2位，数据文本中要有姓名。

#define GLOBLE_VAR

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

//----------------------------------------------------------------------

//声明使用到的内部函数

//main.c使用的内部函数声明处

//----------------------------------------------------------------------

//主函数，一般情况下可以认为程序从此开始运行（实际上有启动过程，参见书稿）

int main(void)

{

uint8_t str_r[20], str_w[20]="蔡潮嘉"; // 定义两个20字节的uint8_t数组，str_r用于读取数据，str_w初始化为"蔡潮嘉"。

flash_init(); // 初始化闪存。

flash_erase(44); // 擦除扇区号为44的扇区

printf("擦除数据\n"); // 打印提示信息，表示数据已被擦除。

flash_write(44,0,10, str_w); // 向扇区号为44的扇区的起始位置写入str_w数组的前10个字节。

flash_read_logic(str_r,44,0,20); // 从扇区号为44的扇区的起始位置读取20个字节到str_r数组。

printf("%s\n",str_r); // 打印str_r数组的内容

printf("---------------------------\n"); // 打印分隔线。

printf("没有擦除数据\n"); // 打印提示信息，表示接下来的操作是在没有擦除数据的情况下写入数据。

flash_write(44,0,20,str_w); // 如果没有擦除，直接向扇区号为44的扇区的起始位置写入str_w数组的全部20个字节。

flash_read_logic(str_r,44,0,20); // 再次从扇区号为44的扇区的起始位置读取20个字节到str_r数组。

printf("%s\n",str_r);

}

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

//======================================================================

//文件名称：can.c

//功能概要：uart底层驱动构件源文件

//更新记录：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; //(0x00000000U) //正常模式

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) //依据DestID向目标CAN节点发送缓冲区内长度为len的数据，每次发送8字节

{

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) //FIFO0寄存器，检查否有数据

{

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; //从RDTR获取寄存器内数据长度

//（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清除

}

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); //interrupt enable register 启用寄存器允许中断

else

SET_BIT(CAN_ARR[canNo-1]->IER,CAN_IER_FMPIE1);

NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]); //开中断控制器IRQ中断

}

//=====================================================================

//函数名称：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) //发送标准帧

{

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, //逐位写入数据，寄存器的高位

((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置位，请求发送数据

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); //设置引脚为CAN复用功能

}

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); //清除CAN模块的SLEEP位，使其从休眠模式唤醒

i = 0;

while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_SLAK) != 0U) //如果等待时间过长（超过0x30000次循环），则返回错误

{

if(i++ > 0x30000)

{

return 1;

}

SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ); //将使CAN模块进入初始化模式

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模块的BTR寄存器，设置同步跳转宽度为1个时间量子，控制采样点，设置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); //清除CAN模块的MCR寄存器中的INRQ位，以退出初始化请求模式

i = 0;

while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) != 0U) //不断检查MSR寄存器中的INAK位，直到其变为0

{

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; //将CAN ID拆分为高低两部分

FilterIdLow = (CanID & 0xFFFF); //将CAN ID拆分为高低两部分

FilterMaskIdHigh = 0xFFE0; //设置高位过滤器掩码

FilterMaskIdLow = 0x0000; //设置地位过滤器掩码

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 = //配置过滤器的高32位和低32位

((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) //根据接收FIFO选择配置过滤器关联的FIFO

{

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

return 0;

}

作业2、结果截图、连线照片、实验原理图和CAN原理介绍。

连线照片、结果截图见上文内容。

CAN协议具有以下特点：

无主从结构的多主控制机制：与I2C协议不同，CAN协议中并不区分主设备和从设备。任何设备在总线空闲时都可以发起消息传输（实现多主控制）。当多个设备同时尝试发送消息时，最先开始发送的设备将获得传输权，不论其他设备的消息优先级如何。如果多个设备同时开始发送，具有更高优先级ID的消息将获得发送权，这一规则仅在设备同时发送时适用。
消息发送机制：在CAN协议中，消息的标识符（ID）并不是用作地址，而是用来表示消息优先级的一种标识。所有消息都按照统一的格式进行发送。当两个或多个设备同时开始发送消息时，会根据每个消息的ID进行优先级判定，通过逐位比较ID来决定优先级。在仲裁过程中，优先级最高的设备可以继续发送其消息，而优先级较低的设备则必须停止发送，转而进入接收状态。