08嵌入式第八次作业

好想睡觉_--

已于 2024-06-27 01:02:08 修改

阅读量424

点赞数 5

分类专栏：嵌入式-stm32 文章标签： stm32 嵌入式硬件单片机

于 2024-06-17 01:02:20 首次发布

本文链接：https://blog.csdn.net/m0_60872990/article/details/139625217

版权

嵌入式-stm32 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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

//======================================================================
//文件名称：can.c
//功能概要：uart底层驱动构件源文件
//版权所有：苏州大学嵌入式系统与物联网研究所(sumcu.suda.edu.cn)
//更新记录：2024-06-16 cqh版
//======================================================================
#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;	//2024.6 CANMode:CAN总线工作模式，为正常模式(CAN_MODE_NORMAL) #define 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;
	//循环处理待发送数据，每次最多发8个字节
	for(int i = len; i > 0; i = i-8)
	{
		send_length = (i>8)?8:i;//大于8字节则仅发8字节，否则发送剩余字节
		if(can_send_once(canNo,DestID,send_length,buff+len-i) == 1)	//2024.6 调用 can_send_once 函数发送数据，发送成功则返回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）判断哪个邮箱收到了报文信息
	// 判断接收的FIFO是FIFO0还是FIFO1
	if(RxFifo == CAN_RX_FIFO0)
	{
		// 检查FIFO0是否有消息，RF0R寄存器的FMP0字段为0时表示没有消息
		if ((CAN_ARR[canNo-1]->RF0R & CAN_RF0R_FMP0) == 0U)   //2024.6
		{
			return 1;// 如果没有消息，则返回1，表示接收失败
		}
	}
	else
	{	
		// 检查FIFO1是否有消息，RF1R寄存器的FMP1字段为0时表示没有消息
		if ((CAN_ARR[canNo-1]->RF1R & CAN_RF1R_FMP1) == 0U)
		{
			return 1;// 如果没有消息，则返回1，表示接收失败
		}
	}
	//（2）获取数据长度
	//从接收FIFO的邮箱中获取数据长度
    len = (CAN_RDT0R_DLC & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos;  //2024.6
    //（3）获取数据帧中的数据
    //从接收FIFO的邮箱中读取数据帧的每个字节，并存储到缓冲区buff中
    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)
    {
      //清除对应FIFO的消息挂起标志位，以便接收下一帧数据
      SET_BIT(CAN_ARR[canNo-1]->RF0R, CAN_RF0R_RFOM0);  //2024.6
    }
    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_FifoNo = CAN_RX_FIFO0;// 将接收邮箱号设为FIFO0
	
	 // 判断接收邮箱号是否为FIFO0
	if(Can_Rx_FifoNo == CAN_RX_FIFO0)
		// 如果是FIFO0，设置对应的中断使能位（FMPIE0），开启FIFO0接收消息中断
		SET_BIT(CAN_ARR[canNo-1]->IER, CAN_IER_FMPIE0);    //2024.6
	else
		// 如果是FIFO1，设置对应的中断使能位（FMPIE1），开启FIFO1接收消息中断
		SET_BIT(CAN_ARR[canNo-1]->IER,CAN_IER_FMPIE1);
	// 启用对应的NVIC中断，table_irq_can数组中存储了每个接收邮箱的中断号
	NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]);     //2024.6
}

//=====================================================================
//函数名称：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; // 用于存储TSR寄存器的值
    uint32_t rtr; // 用于存储RTR位的值
    rtr = CAN_RTR_DATA; // 设置rtr为数据帧标志
    register_tsr = READ_REG(CAN_ARR[canNo-1]->TSR); // 读取TSR寄存器的值

    //（2）判断3个邮箱中是否有空闲邮箱，若有，选取其中一个进行发送，选取顺序为1，2，3
    if (((register_tsr & CAN_TSR_TME0) != 0U) ||    // 判断邮箱0是否空闲
        ((register_tsr & CAN_TSR_TME1) != 0U) ||    // 判断邮箱1是否空闲
        ((register_tsr & CAN_TSR_TME2) != 0U))      // 判断邮箱2是否空闲
    {
        // 获取空闲邮箱的编号
        transmit_mailbox = (register_tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos;     //2024.6
        if(transmit_mailbox > 2U) // 检查编号是否合法（应小于等于2）
        {
            return 1; // 如果编号不合法，返回1表示错误
        }

        //（2.1）判断并设置发送帧为标准帧还是扩展帧
        if(DestID <= 0x7FFU)    //2024.6
        {
            // 设置标准帧
            CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_STID_Pos)|CAN_ID_STD|rtr);  //2024.6
        }
        else
        {
            // 设置扩展帧
            CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_EXID_Pos)|CAN_ID_EXT|rtr);  //2024.6
        }
        //（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）设置发送帧的数据
        // 设置高4字节数据
        WRITE_REG(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDHR,   //2024.6
                  ((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));
        // 设置低4字节数据
        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);   //2024.6
        return 0; // 发送成功，返回0
    }
    else
    {
        return 1; // 没有空闲邮箱，返回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)
{
    // 检查CANChannel是否在有效范围内，如果不是，返回1表示错误
    if(CANChannel < 0 || CANChannel > 2)
    {
        return 1;
    }

    // 根据不同的CANChannel进行引脚初始化
    if(CANChannel == 0)
    {
        // 使能CAN1和GPIOA的时钟
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;   //2024.6
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;

        // 配置PA11和PA12为复用功能模式
        GPIOA->MODER &= ~(GPIO_MODER_MODE11|GPIO_MODER_MODE12);
        GPIOA->MODER |= (GPIO_MODER_MODE11_1|GPIO_MODER_MODE12_1);  //2024.6

        // 配置PA11和PA12的复用功能为CAN功能
        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);   //2024.6
    }
    else if(CANChannel == 1)
    {
        // 使能CAN1和GPIOB的时钟
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;

        // 配置PB8和PB9为复用功能模式
        GPIOB->MODER &= ~(GPIO_MODER_MODE8|GPIO_MODER_MODE9);
        GPIOB->MODER |= (GPIO_MODER_MODE8_1|GPIO_MODER_MODE9_1);

        // 配置PB8和PB9的复用功能为CAN功能
        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
    {
        // 使能CAN1和GPIOD的时钟
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIODEN;

        // 配置PD0和PD1为复用功能模式
        GPIOD->MODER &= ~(GPIO_MODER_MODE0|GPIO_MODER_MODE1);
        GPIOD->MODER |= (GPIO_MODER_MODE0_1|GPIO_MODER_MODE1_1);

        // 配置PD0和PD1的复用功能为CAN功能
        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));
    }

    // 初始化成功，返回0
    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);    //2024.6

    // 等待退出休眠模式成功
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_SLAK) != 0U)   //2024.6
    {
        if(i++ > 0x30000)  // 如果等待时间超过0x30000，则返回错误
        {
            return 1;
        }
    }

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

    // 等待进入初始化模式成功
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) == 0U)
    {
        if(i++ > 0x30000)  // 如果等待时间超过0x30000，则返回错误
        {
            return 1;
        }
    }

    // 初始化成功，返回0
    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);   //2024.6

    // 禁用自动离线管理
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_ABOM);   //2024.6

    // 禁用自动唤醒模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_AWUM);   //2024.6

    // 启用非自动重传
    SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_NART);     //2024.6

    // 禁用接收FIFO锁定模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_RFLM);    //2024.6

    // 禁用传输FIFO优先级
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_TXFP);    //2024.6
}

//函数名称：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);    //2024.6
}

//=====================================================================
//函数名称：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);    //2024.6

    // 等待确认退出初始化模式
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) != 0U)    //2024.6
    {
        // 如果等待时间超过0x30000，则返回错误
        if (i++ > 0x30000)
        {
            return 1;
        }
    }

    // 退出初始化模式成功，返回0
    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;

    // 如果CanID小于等于0x7FF，则进行左移操作，表示标准帧ID
    if(CanID <= 0x7FFU) CanID = CanID << CAN_TI0R_STID_Pos;    //2024.6

    // 计算过滤器ID高16位和低16位
    FilterIdHigh = (CanID >> 16) & 0xFFFF;    //2024.6
    FilterIdLow = (CanID & 0xFFFF);    //2024.6

    // 设置过滤器掩码ID的高16位和低16位
    FilterMaskIdHigh = 0xFFE0;    //2024.6
    FilterMaskIdLow = 0x0000;    //2024.6

    // 计算过滤器组的位位置
    filternbrbitpos = (uint32_t)1 << (FilterBank & 0x1FU);    //2024.6

    // 设置过滤器初始化模式 (FINIT=1)，在此模式下可以进行过滤器初始化
    SET_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    //2024.6

    // 清除过滤器组激活位
    CLEAR_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);    //2024.6

    // 如果过滤器位数为16位
    if (FilterScale == CAN_FILTERSCALE_16BIT)
    {
        // 设置为16位过滤器
        CLEAR_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);

        // 设置过滤器寄存器1和寄存器2的值
        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);
    }

    // 如果过滤器位数为32位
    if (FilterScale == CAN_FILTERSCALE_32BIT)    //2024.6
    {
        // 设置为32位过滤器
        SET_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);    //2024.6

        // 设置过滤器寄存器1和寄存器2的值
        CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR1 =    //2024.6
            ((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)    //2024.6 
    {
        // 设置为掩码模式
        CLEAR_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);    //2024.6
    }
    else
    {
        // 设置为列表模式
        SET_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);
    }

    // 设置过滤器使用的FIFO
    if (Can_Rx_FifoNo == CAN_FILTER_FIFO0)     //2024.6
    {
        // 使用FIFO0
        CLEAR_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);   //2024.6
    }
    else
    {
        // 使用FIFO1
        SET_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);
    }

    // 如果激活过滤器
    if (IsActivate == 1)    //2024.6
    {
        // 激活过滤器
        SET_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);   //2024.6
    }

    // 退出过滤器初始化模式 (FINIT=0)
    CLEAR_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    //2024.6

    return 0;
}

1、2个或以上同学相互连接，利用CAN通信，向对方发送带有本人姓名的信息。连线方式：按基本原理性电路（不带收发器芯片）连接，参考教材图10-1。

main.c

#define GLOBLE_VAR
#include "includes.h"   
int main(void)
{
	//======启动部分=======
	//声明main函数使用的局部变量
	uint32_t localMsgID;
	uint32_t txMsgID;
	uint32_t BitRate;


	//关总中断
	DISABLE_INTERRUPTS;

	//给主函数使用的局部变量赋初值
	localMsgID = 0x0AU;
	txMsgID = 0x0BU;
	BitRate = 36;

	//用户外设模块初始化
    //【***CAN模块初始化***】
    can_init(CAN_1,localMsgID,BitRate);

    //使能模块中断
    //【***使能CAN模块中断***】
    can_enable_recv_int(CAN_1);
    
    //开总中断
	ENABLE_INTERRUPTS;

	//======主循环部分（开头）========================================
	for(;;)   //for(;;)（开头）
	{
		//【***CAN模块发送一帧数据***】
		if(can_send(CAN_1, txMsgID, 16, (uint8_t*)"32107800030_CQH") != 0) printf("failed\r\n");

	} 
}

isr.c

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;
}

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

main.c

#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)
{
    //声明main函数使用的局部变量
    uint16_t num_AD1;	
    uint16_t num_AD2;
    uint16_t num_AD3;
    float ext_temp;  //外部温度
    float mcu_temp;  //MCU温度
    
    //关总中断
    DISABLE_INTERRUPTS;
    
    //用户外设模块初始化
    adc_init(ADC_CHANNEL_15,AD_DIFF);			    //初始化ADC通道15：热敏电阻
    adc_init(ADC_CHANNEL_TEMPSENSOR,AD_SINGLE);	//初始化ADC通道：内部温度
   
    //开总中断
    ENABLE_INTERRUPTS;
    
    printf("------------------------------------------------------\n"); 
    printf("分别通过触摸芯片表面和热敏电阻，引起A/D值变化            \n"); 
    printf("显示芯片内部温度和热敏电阻当前温度          \n");
    printf("------------------------------------------------------\n"); 
	
	while(1){
		num_AD2 = adc_ave(ADC_CHANNEL_15,8);            // 读取通道15的平均AD值
	    num_AD3 = adc_ave(ADC_CHANNEL_TEMPSENSOR,8);    // 读取内部温度传感器的平均AD值
	
	    ext_temp = Regression_Ext_Temp(num_AD2);        // 计算热敏温度
	    mcu_temp = Regression_MCU_Temp(num_AD3);        // 计算MCU温度
	
	    printf("热敏电阻的A/D值：%d\n", num_AD2);
	    printf("热敏电阻的温度: %.2f°C\n", ext_temp);
	    printf("内部温度传感器的A/D值：%d\n", num_AD3);
	    printf("芯片内部温度: %.2f°C\r\n\n", mcu_temp);
	    
	    Delay_ms(3000);  // 延时3秒
	}
}  

//======以下为主函数调用的子函数===========================================
//======================================================================
//函数名称：Delay_ms
//函数返回：无
//参数说明：无
//功能概要：延时 - 毫秒级
//======================================================================
void Delay_ms(uint16_t u16ms)
{
    uint32_t u32ctr;
    for(u32ctr = 0; u32ctr < 8000*u16ms; u32ctr++)
    {
        __ASM("NOP");
    }
}

//============================================================================
//函数名称：Regression_Ext_Temp
//功能概要：将读到的环境温度AD值转换为实际温度
//参数说明：tmpAD：通过adc_read函数得到的AD值
//函数返回：实际温度值
//============================================================================
float Regression_Ext_Temp(uint16_t tmpAD)
{
    float Vtemp,Rtemp,temp;
    if(tmpAD<=72)
    {
       return -274;
    }
    Vtemp = (tmpAD*3300.0)/4096;
    Rtemp = Vtemp/(3300.0 - Vtemp)*10000.0;
    temp = (1/(log(Rtemp/10000.0)/3950.0 + (1/(273.15 + 25)))) - 273.15 + 0.5; 
    return temp; 
}


//============================================================================
//函数名称：Regression_MCU_Temp
//功能概要：将读到的mcu温度AD值转换为实际温度
//参数说明：mcu_temp_AD：通过adc_read函数得到的AD值
//函数返回：实际温度值
//============================================================================
float Regression_MCU_Temp(uint16_t mcu_temp_AD)
{
	float mcu_temp_result;
	mcu_temp_result=(float)(55+(100*((float)(mcu_temp_AD) - AD_CAL1))/(AD_CAL2 - AD_CAL1));
	return mcu_temp_result;
}

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

实验结果

main.c

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

int main(void)
{
//声明main函数使用的局部变量
	uint8_t mK1[32];	  //读取32字节数据
	uint8_t mK2[65];      //读取65字节数据
	
//关总中断
	DISABLE_INTERRUPTS;
   
//开总中断
	ENABLE_INTERRUPTS;

    printf("------------------------------------------------------\n"); 
    printf("验证对于有数据的某扇区，如果没有擦除（Flash_erase），可否写入新数据\n"); 
    printf("------------------------------------------------------\r\n");
        
    //擦除第50扇区
	flash_erase(50);   
    //向50扇区第0偏移地址开始写32个字节数据
    printf("向50扇区写入32个字节数据...\n");
    flash_write(50,0,32,(uint8_t *) "32107800030_CQH");
	flash_read_logic(mK1,50,0,32); //从50扇区读取32个字节到mK1中
	printf("读取50扇区的32字节的内容:  %s\n",mK1);
	
    //向50扇区第33偏移地址开始写32个字节数据
    printf("不擦除继续向50扇区写入32个字节数据...\n");
    flash_write(50,33,65,(uint8_t *) "test NO flsah_erase");
	flash_read_logic(mK2,50,0,65); //从50扇区读取65个字节到mK2中
	printf("读取50扇区的65字节的内容:  %s\n",mK2);
}

实验总结

查看芯片热敏电阻对应引脚为11和12，根据STM32L431芯片的ADC引脚表，可以知道通道15对应的GEC为12即热敏电阻，因此需要对通道15进行初始化并实验。同样可得通道17为ADC_CHANNEL_TEMPSENSOR即内部温度传感器。
物理量回归：读取通道15和17平均AD值后，需要调用函数Regression_Ext_Temp()与Regression_MCU_Temp()将AD值转化为实际温度值，以便更直观的观察实验效果。
根据实验结果可以看到，在没有执行擦除操作，继续向扇区写入“test NO flash_erase”数据，然后读取还是原来的数据，表明，没有擦除不能向原来的扇区写入新数据。

好想睡觉_--

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
08嵌入式第八次作业

查看芯片热敏电阻对应引脚为11和12，根据STM32L431芯片的ADC引脚表，可以知道通道15对应的GEC为12即热敏电阻，因此需要对通道15进行初始化并实验。同样可得通道17为ADC_CHANNEL_TEMPSENSOR即内部温度传感器。物理量回归：读取通道15和17平均AD值后，需要调用函数Regression_Ext_Temp()与Regression_MCU_Temp()将AD值转化为实际温度值，以便更直观的观察实验效果。
复制链接

扫一扫