嵌入式作业6

一、实验内容：

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

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

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

4、对CAN 里main代码进行注释，尤其是2024.6。

二、实验代码：

1、

#define GLOBLE_VAR

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

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

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

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

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

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

int main(void)

{

//（1）======启动部分（开头）==========================================

//（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;

//（1）======启动部分（结尾）==========================================

//（2）======主循环部分（开头）========================================

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

printf("灯的闪烁次数 mLightCount = %d\n",mLightCount);

mFlag='A';                       //灯的状态标志

gpio_set(LIGHT_RED,LIGHT_ON);  //灯“亮”

printf(" LIGHT_RED:ON--\n");   //串口输出灯的状态

//【***CAN模块发送一帧数据***】

if(can_send(CAN_1, txMsgID, 8, (uint8_t*)"I am 周锦铭) != 0) printf("failed\r\n");

}

//（2.3.3）如灯状态标志mFlag为'A'，改变灯状态及标志

else

{

mFlag='L';                       //灯的状态标志

gpio_set(LIGHT_RED,LIGHT_OFF); //灯“暗”

printf(" LIGHT_RED:OFF--\n");  //串口输出灯的状态

}

}  //for(;;)结尾

//（2）======主循环部分（结尾）

2、ADC实验：

#define GLOBLE_VAR

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

void Delay_ms(uint16_t u16ms);

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

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

int main(void)

{

    // 声明main函数使用的局部变量

    uint16_t num_AD2;

    uint16_t num_AD3;

    

    // 关总中断

    DISABLE_INTERRUPTS;

    // 用户外设模块初始化

    adc_init(ADC_CHANNEL_15,AD_DIFF);    //初始化ADC通道15，差分mode

    adc_init(ADC_CHANNEL_TEMPSENSOR,AD_SINGLE); //初始化ADC通道：内部温度，单端mode

    

    emuart_init(UART_User,115200);

    // 使能模块中断

    uart_enable_re_int(UART_User);

    

    // 开总中断

    ENABLE_INTERRUPTS;

    

    // 主循环

    for(;;)

    {

Delay_ms(2000); // 延时2s

        num_AD2 = adc_ave(ADC_CHANNEL_15,8);

        num_AD3 = adc_ave(ADC_CHANNEL_TEMPSENSOR,8);

        printf("————————zjm————————————\r\n");

        printf("通道15(GEC12、11）的A/D值：%d\r\n",num_AD2);

        printf("通道15(GEC12、11）的温度值（即环境温度）：%f\r\n",Regression_Ext_Temp(num_AD2));

        printf("内部温度传感器的A/D值：%d\r\n",num_AD3);

        printf("内部温度传感器的温度值（即芯片内部温度）：%f\r\n",adc_mcu_tempmain(num_AD3));

        printf("————————zjm————————————\r\n");

    }

}

//======以下为主函数调用的子函数===========================================

//函数名称：Delay_ms，延时 - 毫秒级

void Delay_ms(uint16_t u16ms)

{

    uint32_t u32ctr;

    for(u32ctr = 0; u32ctr < 8000*u16ms; u32ctr++)

    {

        __ASM("NOP");

    }

}

//将读到的环境温度AD值转换为实际温度，mpAD：通过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;

}

//将读到的芯片内部mcu温度AD值转换为实际温度，mcu_temp_AD：通过adc_read函数得到的AD值

float adc_mcu_tempmain(uint16_t mcu_temp_AD)

{

float mcu_temp_result;

mcu_temp_result=(float)(6+55+(100*((float)(mcu_temp_AD) - AD_CAL1))/(AD_CAL2 - AD_CAL1));

return mcu_temp_result;

}

3、flash编程：

#define GLOBLE_VAR

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

int main(void)

{

// 定义变量

uint8_t mK1[32];  //按照逻辑读方式从指定flash区域中读取的数据

uint8_t result;      //判断扇区是否为空标识

// 关总中断

DISABLE_INTERRUPTS;

// Flash初始化

flash_init();

   

// 开总中断

ENABLE_INTERRUPTS;

    

    // 擦除第99扇区

flash_erase(99);   

result = flash_isempty(99,MCU_SECTORSIZE); // 判断第99扇区是否为空

printf("—————————zjm———————————\n");

printf("第99扇区是否为空，1表示空，0表示不空: %d\n",result);

// 第一次写入

flash_write(99,0,32,(uint8_t *) "zjm 32106200099 ");

flash_read_logic(mK1,99,0,32); //从99扇区读取32个字节到mK1中

printf("第一次: %s\n",mK1);

result = flash_isempty(99,MCU_SECTORSIZE); // 判断第99扇区是否为空

printf("第99扇区是否为空，1表示空，0表示不空: %d\n",result);

// 第二次写入

flash_write(99,0,32,(uint8_t *) "zjm。32106200099！");

flash_read_logic(mK1,99,0,32); //从99扇区读取32个字节到mK1中

printf("第二次: %s\n",mK1);

printf("—————————zjm———————————\n");

// 请在第一次运行之后找到flash.c的函数flash_write，里面有一个擦除扇区操作，注释掉在编译运行一次

}

三、实验结果：

一、CAN：

1. 
2. 
4. 二、

三、

四、实验分析：

can代码注释分析：

//======================================================================
//文件名称：can.c
//功能概要：uart底层驱动构件源文件
//版权所有：苏州大学嵌入式系统与物联网研究所(sumcu.suda.edu.cn)
//更新记录：2021-02-03 V1.0  JJL
//======================================================================
#include "can.h"  // 包含CAN通信的头文件，定义了与CAN通信相关的结构体、宏和函数原型

// 定义一个指向CAN外设基地址的指针数组，初始值为CAN1_BASE
CAN_TypeDef *CAN_ARR[] = {(CAN_TypeDef*)CAN1_BASE};

// 定义一个中断请求枚举类型数组，表示CAN1接收FIFO0和FIFO1的中断号
IRQn_Type table_irq_can[2] = {CAN1_RX0_IRQn, CAN1_RX1_IRQn};

/**
 * @brief 发送一次CAN消息
 * @param canNo CAN通道号
 * @param DestID 目的ID
 * @param len 数据长度
 * @param buff 数据缓冲区指针
 * @return 操作结果，0表示成功，非0表示失败
 */
uint8_t can_send_once(uint8_t canNo, uint32_t DestID, uint16_t len ,uint8_t* buff);

/**
 * @brief 硬件初始化CAN
 * @param CANChannel CAN通道号
 * @return 操作结果，0表示成功，非0表示失败
 */
uint8_t CAN_HWInit(uint8_t CANChannel);

/**
 * @brief 软件初始化CAN入口
 * @param canNo CAN通道号
 * @return 操作结果，0表示成功，非0表示失败
 */
uint8_t CAN_SWInit_Entry(uint8_t canNo);

/**
 * @brief 配置CAN控制模式
 * @param canNo CAN通道号
 */
void CAN_SWInit_CTLMode(uint8_t canNo);

/**
 * @brief 配置CAN波特率和模式
 * @param canNo CAN通道号
 * @param CANMode CAN模式
 * @param Prescaler 波特率预分频器
 */
void CAN_SWInit_BT(uint8_t canNo, uint32_t CANMode, uint32_t Prescaler);

/**
 * @brief 退出软件初始化
 * @param canNo CAN通道号
 * @return 操作结果，0表示成功，非0表示失败
 */
uint8_t CAN_SWInit_Quit(uint8_t canNo);

/**
 * @brief 配置CAN过滤器
 * @param canNo CAN通道号
 * @param canID CAN ID
 * @param FilterBank 过滤器组编号
 * @param Can_Rx_FifoNo 接收FIFO编号
 * @param IsActivate 是否激活过滤器
 * @param FilterMode 过滤器模式
 * @param FilterScale 过滤器比例
 * @return 操作结果，0表示成功，非0表示失败
 */
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;           // 存储CAN总线模式的变量
uint32_t CANFilterBank;     // 存储CAN过滤器的编号
uint32_t CANFiltermode;     // 存储CAN过滤器模式的变量
uint32_t CAN_Filterscale;    // 存储CAN过滤器比例的变量

//给Init函数使用的局部变量赋初值
CANMode = CAN_MODE_NORMAL;            // 将CAN总线模式设置为正常模式
CANFilterBank = CANFilterBank0;       // 使用预定义的CAN过滤器编号
CANFiltermode = CAN_FILTERMODE_IDMASK;  // 使用基于标识符掩码的过滤器模式
CAN_Filterscale = CAN_FILTERSCALE_32BIT;  // 使用32位的过滤器比例

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

//=====================================================================
//函数名称：can_send
//函数返回：0=正常，1=错误
//参数说明：canNo：模块号，本芯片只有CAN_1
//          DestID：目标CAN节点的唯一标识，例如按照CANopen协议给出
//          len：待发送数据的字节数
//          buff：待发送数据发送缓冲区首地址
//功能概要：CAN模块发送数据
//=====================================================================
/**
 * @brief 通过CAN总线发送数据
 * @param canNo CAN通道号
 * @param DestID 目的ID
 * @param len 数据长度
 * @param buff 数据缓冲区指针
 * @return 操作结果，0表示成功，非0表示失败
 */
uint8_t can_send(uint8_t canNo, uint32_t DestID, uint16_t len ,uint8_t* buff)
{
    // 检查目的ID是否有效，CAN标准ID范围为0x00000000到0x1FFFFFFF
    if (DestID > 0x1FFFFFFFU) return 1;

    uint8_t send_length;
    
    // 循环发送数据，每次最多发送8个字节
    for (int i = len; i > 0; i = i - 8)
    {
        // 计算当前发送的数据长度，最多8个字节
        send_length = (i > 8) ? 8 : i;
        
        // 调用can_send_once函数发送数据，如果返回1则表示发送失败
        if (can_send_once(canNo, DestID, send_length, buff + len - i) == 1)   //2024.6
        {
            return 1;
        }
    }
    
    // 全部数据发送成功，返回0
    return 0;
}

//=====================================================================
//函数名称：can_recv
//函数返回：接收到的字节数
//参数说明：canNo：模块号，本芯片只有CAN_1
//          buff：接收到的数据存放的内存区首地址
//功能概要：在CAN模块接收中断中调用本函数接收已经到达的数据
//=====================================================================
/**
 * @brief 通过CAN总线接收数据
 * @param canNo CAN通道号
 * @param buff 数据缓冲区指针，用于存储接收到的数据
 * @return 接收到的数据长度，如果接收失败则返回1
 */
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)   //2024.6
        {
            return 1; // FIFO0 中没有报文，接收失败
        }
    }
    else
    {
        if ((CAN_ARR[canNo-1]->RF1R & CAN_RF1R_FMP1) == 0U)
        {
            return 1; // FIFO1 中没有报文，接收失败
        }
    }

//（2）获取数据长度
len = (CAN_RDT0R_DLC & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos;  // 2024.6 从接收邮箱的控制寄存器中读取数据长度代码，并右移至正确位置

//（3）获取数据帧中的数据
buff[0] = (uint8_t)((CAN_RDL0R_DATA0 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA0_Pos);  // 从接收邮箱的数据低位寄存器中提取第0字节数据
buff[1] = (uint8_t)((CAN_RDL0R_DATA1 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA1_Pos);  // 从接收邮箱的数据低位寄存器中提取第1字节数据
buff[2] = (uint8_t)((CAN_RDL0R_DATA2 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA2_Pos);  // 从接收邮箱的数据低位寄存器中提取第2字节数据
buff[3] = (uint8_t)((CAN_RDL0R_DATA3 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA3_Pos);  // 从接收邮箱的数据低位寄存器中提取第3字节数据
buff[4] = (uint8_t)((CAN_RDH0R_DATA4 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA4_Pos);  // 从接收邮箱的数据高位寄存器中提取第4字节数据
buff[5] = (uint8_t)((CAN_RDH0R_DATA5 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA5_Pos);  // 从接收邮箱的数据高位寄存器中提取第5字节数据
buff[6] = (uint8_t)((CAN_RDH0R_DATA6 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA6_Pos);  // 从接收邮箱的数据高位寄存器中提取第6字节数据
buff[7] = (uint8_t)((CAN_RDH0R_DATA7 & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA7_Pos);  // 从接收邮箱的数据高位寄存器中提取第7字节数据

    //（4）清除标志位，等待接收下一帧数据
if (RxFifo == CAN_RX_FIFO0)
{
    SET_BIT(CAN_ARR[canNo-1]->RF0R, CAN_RF0R_RFOM0);  // 2024.6 设置CAN接收邮箱0的释放标志位
}
else
{
    SET_BIT(CAN_ARR[canNo-1]->RF1R, CAN_RF1R_RFOM1);  // 设置CAN接收邮箱1的释放标志位
}

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接收邮箱0满中断使能位
    }
    else
    {
        SET_BIT(CAN_ARR[canNo - 1]->IER, CAN_IER_FMPIE1);  // 设置CAN接收邮箱1满中断使能位
    }
    NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]);  // 使能CAN接收邮箱中断
}
//=====================================================================
//函数名称：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);  // 清除CAN接收邮箱0满中断使能位
    }
    else
    {
        CLEAR_BIT(CAN_ARR[canNo - 1]->IER, CAN_IER_FMPIE1);  // 清除CAN接收邮箱1满中断使能位
    }
    NVIC_DisableIRQ(table_irq_can[Can_Rx_FifoNo]);  // 禁止CAN接收邮箱中断
}

//=====================================================================
//函数名称：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
 // 如果 CAN 发送寄存器（TSR）的任一发送邮箱为空（表示可以发送）
if (((register_tsr & CAN_TSR_TME0) != 0U) ||    
    ((register_tsr & CAN_TSR_TME1) != 0U) ||
    ((register_tsr & CAN_TSR_TME2) != 0U))
{
    // 获取空的发送邮箱编号（0、1 或 2），TSR_CODE 位包含了该信息
    transmit_mailbox = (register_tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos;   //2024.6

    // 如果获取到的发送邮箱编号不在 0 到 2 的范围内，则返回错误码 1
    if(transmit_mailbox > 2U)
    {
        return 1;
    }

    // 判断并设置发送帧为标准帧（11 位 ID）还是扩展帧（29 位 ID）
    if(DestID <= 0x7FFU) // 如果目标 ID 在 11 位范围内
    {
        // 填写标准帧的 ID 和其他控制位到 TIR 寄存器
        CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_STID_Pos)|CAN_ID_STD|rtr);
    }
    else // 否则为扩展帧
    {
        // 填写扩展帧的 ID 和其他控制位到 TIR 寄存器
        CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_EXID_Pos)|CAN_ID_EXT|rtr);
    }

    // 设置发送帧的数据长度（DLC）
    CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDTR = len;

    // 设置发送帧的数据，高四字节写入 TDHR 寄存器
    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));

    // 低四字节写入 TDLR 寄存器
    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));

    // 发送 CAN 数据报，设置 TXRQ 位请求发送
    SET_BIT(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR, CAN_TI0R_TXRQ);  

    // 发送成功，返回 0
    return 0;
}
else
{
    // 如果没有可用的发送邮箱，返回错误码 1
    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)
{
    // 检查 CAN 通道编号是否有效
    if(CANChannel < 0 || CANChannel > 2)
    {
        return 1;  // 如果通道编号无效，返回错误码 1
    }
    // 配置各个 CAN 通道对应的 GPIO 和时钟
    if(CANChannel == 0)
    {
        // 启用 CAN1 的时钟
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        // 启用 GPIOA 的时钟
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
        // 配置 GPIOA 引脚 11 和 12 为复用模式
        GPIOA->MODER &= ~(GPIO_MODER_MODE11|GPIO_MODER_MODE12);
        GPIOA->MODER |= (GPIO_MODER_MODE11_1|GPIO_MODER_MODE12_1);
        // 配置 GPIOA 引脚 11 和 12 的复用功能为 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);
    }
    else if(CANChannel == 1)
    {
        // 启用 CAN1 的时钟
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        // 启用 GPIOB 的时钟
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
        // 配置 GPIOB 引脚 8 和 9 为复用模式
        GPIOB->MODER &= ~(GPIO_MODER_MODE8|GPIO_MODER_MODE9);
        GPIOB->MODER |= (GPIO_MODER_MODE8_1|GPIO_MODER_MODE9_1);
        // 配置 GPIOB 引脚 8 和 9 的复用功能为 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 的时钟
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        // 启用 GPIOD 的时钟
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIODEN;
        // 配置 GPIOD 引脚 0 和 1 为复用模式
        GPIOD->MODER &= ~(GPIO_MODER_MODE0|GPIO_MODER_MODE1);
        GPIOD->MODER |= (GPIO_MODER_MODE0_1|GPIO_MODER_MODE1_1);
        // 配置 GPIOD 引脚 0 和 1 的复用功能为 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));
    }
    return 0;  // 返回 0 表示初始化成功
}

//=====================================================================
//函数名称：CAN_SWInit_Entry
//函数返回：0=正常，1=错误
//参数说明：canNo:模块基地址号，本芯片只有CAN_1,
//功能概要：进入初始化模式
//=====================================================================
c
uint8_t CAN_SWInit_Entry(uint8_t canNo)
{
    int i;

    // 清除 MCR 寄存器中的 SLEEP 位，以退出睡眠模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_SLEEP);    //2024.6

    // 等待 SLAK 位清零，表示 CAN 退出睡眠模式
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_SLAK) != 0U)   //2024.6
    {
        if(i++ > 0x30000) // 超时处理，防止无限循环
        {
            return 1; // 返回错误码 1 表示超时
        }
    }

    // 设置 MCR 寄存器中的 INRQ 位，申请进入初始化模式
    SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ);    //2024.6

    // 等待 INAK 位被置位，表示 CAN 进入初始化模式
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) == 0U)
    {
        if(i++ > 0x30000) // 超时处理，防止无限循环
        {
            return 1; // 返回错误码 1 表示超时
        }
    }

    return 0; // 返回 0 表示成功
}

//=====================================================================
//函数名称：CAN_SWInit_CTLMode
//函数返回：无
//参数说明：canNo:模块基地址号，本芯片只有CAN_1,
//功能概要：CAN总线模式设置
//=====================================================================
void CAN_SWInit_CTLMode(uint8_t canNo)
{
    // 清除 MCR 寄存器中的 TTCM 位，禁用时间触发通信模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_TTCM);   //2024.6
    
    // 清除 MCR 寄存器中的 ABOM 位，禁用自动离线管理
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_ABOM);   //2024.6
    
    // 清除 MCR 寄存器中的 AWUM 位，禁用自动唤醒模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_AWUM);   //2024.6
    
    // 设置 MCR 寄存器中的 NART 位，启用无自动重传模式
    SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_NART);     //2024.6
    
    // 清除 MCR 寄存器中的 RFLM 位，禁用接收 FIFO 锁定模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_RFLM);   //2024.6
    
    // 清除 MCR 寄存器中的 TXFP 位，禁用发送 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)
{
    // 配置 BTR 寄存器，包括预分频器、同步跳转宽度、时间段 1 和时间段 2 以及 CAN 操作模式
    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;

    // 清除 CAN_MCR 寄存器中的初始化请求位 (INRQ) 来退出初始化模式
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ);    //2024.6

    i = 0;
    // 等待 CAN 控制器退出初始化模式，即等待 CAN_MSR 寄存器的初始化挂起位 (INAK) 清零
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) != 0U)    //2024.6
    {
        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;

    // 如果 CAN ID 是标准标识符 (11位)
    if (CanID <= 0x7FFU)
    {
        // 左移以适应标准标识符位置
        CanID = CanID << CAN_TI0R_STID_Pos;
    }

    // 分离高16位和低16位的过滤器ID
    FilterIdHigh = (CanID >> 16) & 0xFFFF;
    FilterIdLow = (CanID & 0xFFFF);

    // 设置默认的过滤器掩码（高16位和低16位）
    FilterMaskIdHigh = 0xFFE0;
    FilterMaskIdLow = 0x0000;

    // 计算过滤器编号对应的位位置
    filternbrbitpos = (uint32_t)1 << (FilterBank & 0x1FU);

    // 进入过滤器初始化模式
    SET_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);

    // 禁用过滤器
    CLEAR_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);

    // 如果过滤器比例为16位
    if (FilterScale == CAN_FILTERSCALE_16BIT)
    {
        // 清除过滤器比例寄存器中的相应位
        CLEAR_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);
        // 配置过滤器寄存器 FR1 和 FR2
        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)
    {
        // 设置过滤器比例寄存器中的相应位
        SET_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);
        // 配置过滤器寄存器 FR1 和 FR2
        CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR1 =
            ((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);
    }

    // 配置接收 FIFO
    if (Can_Rx_FifoNo == CAN_FILTER_FIFO0)
    {
        // 清除过滤器 FIFO 分配寄存器中的相应位
        CLEAR_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);
    }
    else
    {
        // 设置过滤器 FIFO 分配寄存器中的相应位
        SET_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);
    }

    // 激活过滤器
    if (IsActivate == 1)
    {
        // 设置过滤器激活寄存器中的相应位
        SET_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);
    }

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

    // 返回成功
    return 0;
}
 

1、CAN实验：

结果：成功实现了多个节点间的信息传递。

每个节点都能正确接收到其他节点发送的姓名信息。

CAN通信稳定可靠，数据传输无误。

总结：

通过此次实验，验证了基本原理性电路下CAN通信的可行性，掌握了CAN总线的基本配置和编程技巧。实验中需要特别注意节点的同步和错误处理机制，以确保通信的稳定性。

2ADC实验：

实验结果：

触摸芯片表面时，ADC值发生变化，温度显示随之变化，能反映芯片内部温度的升高。

通过对热敏电阻加热，ADC值也发生变化，且温度显示能够正确反映当前温度。

总结：

该实验成功实现了温度测量功能，进一步理解了ADC工作原理及其在温度传感中的应用。实验表明，利用热敏电阻结合ADC可以较准确地测量温度，并通过简单的计算公式将ADC值转换为实际温度。

3:FLASH实验：

结果：

在未擦除的情况下，尝试写入新数据后，发现数据未能正确写入，存储内容仍为初始数据或出现部分数据损坏现象。

总结：

实验表明，对于Flash存储器，在未进行擦除操作的情况下，无法直接写入新数据。这是由于Flash存储器的特性决定的：写入操作只能将位翻转为0，而不能将已经为0的位翻转为1。因此，在进行新的数据写入前必须先执行擦除操作，以确保数据的正确性。