嵌入式系统作业7

最新推荐文章于 2024-09-03 17:19:22 发布

nf_126

最新推荐文章于 2024-09-03 17:19:22 发布

阅读量892

点赞数 24

文章标签：嵌入式硬件 stm32 单片机

本文链接：https://blog.csdn.net/m0_71952604/article/details/139827442

版权

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

CAN通信的实现原理：

CAN 控制器根据两根线（CAN_H（CAN High）和CAN_L（CAN Low））上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。

CAN通信采用CSMA/CD（Carrier Sense Multiple Access with Collision Detection）的工作原理。这意味着每个节点都可以在总线上发送消息，但在发送之前需要先监听总线上的通信情况。

当一个节点要发送消息时，首先会监听总线，如果没有其他节点正在发送消息，它就可以开始发送。如果同时有多个节点尝试发送消息，就会发生冲突。在CAN总线上使用的是非毁坏性冲突检测机制，冲突的节点会立即停止发送，并在发送完自己的消息后再次来检测冲突。

CAN通信中还使用了位定时传输方式，即总线上的每个位都有固定的时间段。发送节点将每个位的电平保持一段时间，接收节点则在相应的时间段内检测位的电平。这种位定时传输方式确保了数据的同步和准确性。

此外，CAN通信还通过帧的优先级来管理消息的传输。较低优先级的帧会在总线上等待较高优先级的帧发送完毕后再发送，确保重要消息的及时传输。

教材图10-1（不接收发器芯片的CAN总线电路连接）如下：

连线：（如下图）

工程文件：（请注意：不同ID！！！）

我（04-Software\CH10\CAN_nodeB-STM32L431-20211116）

通信队友（04-Software\CH10\CAN_nodeA-STM32L431-20211116）

代码：

#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*)"NIFEI") != 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）======主循环部分（结尾）========================================
}   //main函数（结尾）

打开运行，结果如下：

已成功用CAN通信向对方发送我的名字(NIFEI)，也成功接收到对方发过来的名字（lyy）。

成功的关键在于连线一定要准确，因为老师已经给出可以直接运行的工程文件。另外需要注意的是，通信双方不能是同一个ID。比如我的ID是0A，那么对方可以是0B、0C等。

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

打开工程文件04-Software\CH08\ADC-STM32L431-20220613

修改后的代码：

//======================================================================
//文件名称：main.c（应用工程主函数）
//框架提供：SD-Arm（sumcu.suda.edu.cn）
//版本更新：20191108-20200419
//功能描述：见本工程的..\01_Doc\Readme.txt
//移植规则：【固定】
//======================================================================
#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)
{
    //（1）======启动部分（开头）==========================================
    //（1.1）声明main函数使用的局部变量
    uint32_t mMainLoopCount;  //主循环次数变量
    uint8_t  mFlag;           //灯的状态标志
    uint32_t mCount;			//延时的次数
    uint32_t mLightCount;     //灯的状态切换次数
    uint16_t num_AD1;	
    uint16_t num_AD2;
    uint16_t num_AD3;
    uint16_t exttemp;
    uint16_t mcutemp;
    //（1.2）【不变】关总中断
    DISABLE_INTERRUPTS;
    
    //（1.3）给主函数使用的局部变量赋初值
    mMainLoopCount=0;    //主循环次数变量
    mFlag='A'; 
    mLightCount=0;       //灯的闪烁次数
    mCount=0;//记次数
    
    //（1.4）给全局变量赋初值
    
    //（1.5）用户外设模块初始化
    gpio_init(LIGHT_BLUE,GPIO_OUTPUT,LIGHT_ON);	//初始化蓝灯
    adc_init(ADC_CHANNEL_1,AD_DIFF);			    //初始化ADC通道1，
    adc_init(ADC_CHANNEL_15,AD_DIFF);			    //初始化ADC通道15
    adc_init(ADC_CHANNEL_TEMPSENSOR,AD_SINGLE);	//初始化ADC通道：内部温度
    
    emuart_init(UART_User,115200);
    //（1.6）使能模块中断
    uart_enable_re_int(UART_User);
    
    //（1.7）【不变】开总中断
    ENABLE_INTERRUPTS;
    
    printf("------------------------------------------------------\n"); 
    printf(" 这是nifei的实验4——显示芯片内部温度和当前温度。\n");
 //   printf("金葫芦提示：                                           \n"); 
 //   printf("（1）目的：ADC单端输入与差分输入测试                    \n"); 
 //   printf("（2）单端：内部温度传感器，通道号17，无需引脚对应        \n");
 //   printf("     差分：GEC引脚47、46（通道1、2）                  \n");
 //   printf("           GEC引脚12、11（通道15、16                  \n");
 //   printf("（3）测试方法：单端：手摸芯片表面，A/D值增大，不要摸    \n");
 //   printf("                    到引脚，静电可能损坏芯片           \n");
 //   printf("              差分：将引脚47接地、46接3.3V,观察通道1情况\n");
 //   printf("                    将引脚46接地、47接3.3V,观察通道1情况\n");
 //   printf("             类似方法，观察通道15                      \n");
    printf("------------------------------------------------------\n"); 
     
    //（1）======启动部分（结尾）==========================================
    
    //（2）======主循环部分（开头）========================================
    for(;;)   //for(;;)（开头）
    {
        //（2.1）主循环次数变量+1
        mMainLoopCount++;
        //（2.2）未达到主循环次数设定值，继续循环
        //延时1秒
        if (mMainLoopCount<=3000000)  continue;
        //（2.3）达到主循环次数设定值，执行下列语句，进行灯的亮暗处理
        //（2.3.1）清除循环次数变量
        mMainLoopCount=0;
        //（2.3.2）如灯状态标志mFlag为'L'，灯的闪烁次数+1并显示，改变灯状态及标志
		if (mFlag=='L')                    //判断灯的状态标志
		{
			mLightCount++;  
			mFlag='A';                       //灯的状态标志
			gpio_set(LIGHT_BLUE,LIGHT_ON);  //灯“亮”
			Delay_ms(1000);
		}
        //（2.3.3）如灯状态标志mFlag为'A'，改变灯状态及标志
		else
		{
			mFlag='L';                       //灯的状态标志
			gpio_set(LIGHT_BLUE,LIGHT_OFF); //灯“暗”
			Delay_ms(1000);
		}
        num_AD1 = adc_ave(ADC_CHANNEL_1,8);
        num_AD2 = adc_ave(ADC_CHANNEL_15,8);
        num_AD3 = adc_ave(ADC_CHANNEL_TEMPSENSOR,8);
        exttemp=Regression_Ext_Temp(num_AD2);
        mcutemp=Regression_MCU_Temp(num_AD3);
        
        printf("通道1(GEC47、46)的A/D值： %d\r\n",num_AD1);
        printf("通道15(GEC12、11）的A/D值：%d\r\n",num_AD2);
        printf("内部温度传感器的A/D值：%d\r\n\n",num_AD3);
        printf("芯片内部温度：%d\r\n\n",mcutemp);
        printf("当前环境温度：%d\r\n\n",exttemp);
        mCount++;      
    }  //for(;;)结尾
    //（2）======主循环部分（结尾）========================================
}   //main函数（结尾）


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

//======================================================================
//功能概要：连续判断三次GPIO的输入引脚，大部分为0，则认为有触摸
//参数说明：GPIO引脚
//函数返回：1：有触摸，0：无触摸
//原理概要：当GPIO引脚被定义为无上下拉输入功能时，容易收到外界干扰，本程序
//         把这个特性转为有用的功能，由于人体相当于一个大电阻，手触摸这个
//         引脚会使得引脚状态发生随机性改变，利用这种变化可以被视为有触摸，
//         实现了无触摸功能引脚的触摸功能
//======================================================================



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

运行结果：

（1）不触摸：

（2）用手触摸后：

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

能写入新数据。验证如下：

（1）打开工程文件04-Software\CH08\Flash-STM32L431-20220330

（2）修改代码

（逻辑读： 1.1擦除扇区 1.2不擦除）

（物理读： 1.1擦除扇区 1.2不擦除）

代码：

//======================================================================
//文件名称：main.c（应用工程主函数）
//框架提供：SD-Arm（sumcu.suda.edu.cn）
//版本更新：20191108-20200419
//功能描述：见本工程的..\01_Doc\Readme.txt
//移植规则：【固定】
//======================================================================
#define GLOBLE_VAR
#include "includes.h"      //包含总头文件

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

//----------------------------------------------------------------------
//主函数，一般情况下可以认为程序从此开始运行（实际上有启动过程，参见书稿）
int main(void)
{
//（1）======启动部分（开头）==========================================
//（1.1）声明main函数使用的局部变量
	uint32_t mMainLoopCount;  //主循环次数变量
	uint8_t  mFlag;           //灯的状态标志
	uint32_t mLightCount;     //灯的状态切换次数
	uint8_t mK1[32];	  //按照逻辑读方式从指定flash区域中读取的数据
	uint8_t mK2[32];      //按照物理读方式从指定flash区域中读取的数据
    
    uint8_t flash_test[32]={'A','B','C','D','E','F','G',' ','t',
                            'o',' ','S','o','o','c','h','o','w',' ',
                            'U','n','i','v','e','r','s','i','t','y','!'};
	uint8_t result;    //判断扇区是否为空标识
//（1.2）【不变】关总中断
	DISABLE_INTERRUPTS;

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

//（1.4）给全局变量赋初值
   
//（1.5）用户外设模块初始化
	gpio_init(LIGHT_BLUE,GPIO_OUTPUT,LIGHT_ON);	//初始化蓝灯

//（1.6）使能模块中断
   
   
//（1.7）【不变】开总中断
	ENABLE_INTERRUPTS;


    printf("------------------------------------------------------\n"); 
    printf("金葫芦提示：                                           \n"); 
    printf(" 这是nifei的实验4——扇区测试。                        \n");
    printf("（1）目的：flash扇区读写数据测试                       \n"); 
    printf("（2）测试过程：两种读写数据方式                        \n");
    printf("     第一种：使用flash_write向50扇区写入一串字符串     \n");
    printf("     再用flash_read_logic将字符串读出，并用printf打印  \n");
    printf("     第二种：使用flash_write_physical向32扇区写入一串字符串\n");
    printf("     再用flash_read_physical将字符串读出，并用printf打印  \n");
    printf("------------------------------------------------------\n");
       
//（1）======启动部分（结尾）==========================================
    
    //擦除第50扇区
	flash_erase(50);
	result = flash_isempty(50,MCU_SECTORSIZE); // 判断第50扇区是否为空
	printf("第50扇区是否为空，1表示空，0表示不空:%d\n",result);
	
	printf(" 第一种：逻辑读  \n");
	//1.1、擦除第50扇区
	flash_erase(50);
	
    //向50扇区第0偏移地址开始写32个字节数据
    flash_write(50,0,32,(uint8_t *) "NIFEI666126");
	flash_read_logic(mK1,50,0,32); //从50扇区读取32个字节到mK1中
	printf("逻辑读方式读取50扇区的32字节的内容:  %s\n",mK1);
	result = flash_isempty(50,MCU_SECTORSIZE); // 判断第50扇区是否为空
	printf("第50扇区是否为空，1表示空，0表示不空:%d\n",result);
	
	//1.2、不擦除第50扇区
	//flash_erase(50);

    //向50扇区第0偏移地址开始写32个字节数据
    flash_write(50,0,32,(uint8_t *) "NIFEI888126");
	flash_read_logic(mK1,50,0,32); //从50扇区读取32个字节到mK1中
	printf("逻辑读方式读取50扇区的32字节的内容:  %s\n",mK1);
	
	
	printf("  第二种：物理读  \n");
	printf("第50扇区是否为空，1表示空，0表示不空:%d\n",result);
	//2.1擦除第50扇区
	flash_erase(50);
	//向50扇区写32个字节数据
	flash_write_physical(0x8019000,32,"NIFEI666126");
	flash_read_physical(mK2,0x8019000,32);      //从50扇区读取32个字节到mK2中
	printf("物理读方式读取50扇区的32字节的内容:  %s\n",mK2);
	
	result = flash_isempty(50,MCU_SECTORSIZE); // 判断第50扇区是否为空
	printf("第50扇区是否为空，1表示空，0表示不空:%d\n",result);
	
	//2.2不擦除第50扇区
	//flash_erase(50);
	//向50扇区写32个字节数据
	flash_write_physical(0x8019000,32,"NIFEI888126");
	flash_read_physical(mK2,0x8019000,32);      //从50扇区读取32个字节到mK2中
	printf("物理读方式读取50扇区的32字节的内容:  %s\n",mK2);
	
	result = flash_isempty(50,MCU_SECTORSIZE); // 判断第50扇区是否为空
	printf("第50扇区是否为空，1表示空，0表示不空:%d\n",result);
	
//（2）======主循环部分（开头）========================================
	for(;;)   //for(;;)（开头）
	{
//（2.1）主循环次数变量+1
        mMainLoopCount++;
//（2.2）未达到主循环次数设定值，继续循环
		if (mMainLoopCount<=12888999)  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_BLUE,LIGHT_ON);  //灯“亮”
			printf(" LIGHT_BLUE:ON--\n");   //串口输出灯的状态
		}
//（2.3.3）如灯状态标志mFlag为'A'，改变灯状态及标志
		else
		{
			mFlag='L';                       //灯的状态标志
			gpio_set(LIGHT_BLUE,LIGHT_OFF); //灯“暗”
			printf(" LIGHT_BLUE:OFF--\n");  //串口输出灯的状态
		}
	}  //for(;;)结尾
//（2）======主循环部分（结尾）========================================
}   //main函数（结尾）

运行结果如下：

4、对于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;                //2024.6(1)
	// 设置CAN模式为正常模式。
	// 这里，CAN_MODE_NORMAL是一个宏定义或枚举值，代表CAN通信的正常工作模式。
	// 在不同的CAN控制器和库中，这个值可能有不同的具体含义，但一般来说，
	// 它指的是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)
{
	// 检查目标ID是否在有效范围内，如果超出范围则直接返回错误码1
	if(DestID > 0x1FFFFFFFU) return 1;
	uint8_t send_length;// 用于存储每次发送的数据长度
	for(int i = len; i > 0; i = i-8) // 循环直到所有数据都被发送
	{
		send_length = (i>8)?8:i;// 计算每次发送的数据长度，每次最多发送8字节
		
		// 调用can_send_once函数进行单次数据发送
        // 传入参数包括CAN编号canNo，目标ID DestID，数据长度send_length
        // 以及指向当前要发送数据的指针(buff+len-i)
        // 如果can_send_once返回1，表示发送失败，直接返回错误码1
		if(can_send_once(canNo,DestID,send_length,buff+len-i) == 1)   //2024.6(2)
		{
			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）判断哪个邮箱收到了报文信息
	// 检查接收到的报文信息是在哪个CAN接收FIFO中
	if(RxFifo == CAN_RX_FIFO0)// 如果是CAN接收FIFO0
	{
	 // 检查FIFO0中的消息数量，判断是否有新消息
    // CAN_ARR是指向CAN寄存器的数组，canNo是当前CAN控制器的编号
    // RF0R是接收FIFO 0的寄存器，FMP0表示FIFO 0的消息数量
    // 如果FMP0为0，表示FIFO 0是空的，没有新的消息
		if ((CAN_ARR[canNo-1]->RF0R & CAN_RF0R_FMP0) == 0U)   //2024.6(3)
		{
			return 1;
		}
	}
	else
	{
		if ((CAN_ARR[canNo-1]->RF1R & CAN_RF1R_FMP1) == 0U)
		{
			return 1;
		}
	}
	//（2）获取数据长度
	 // 从CAN接收数据0寄存器（CAN_RDT0R）中提取数据长度控制（DLC）字段，该字段表示CAN帧的数据字段长度。
	  // 读取指定CAN控制器和FIFO的接收数据寄存器（RDTR）中的值。
	   // 通过右移位操作将DLC字段移动到最低位，以便于直接使用。
    len = (CAN_RDT0R_DLC & CAN_ARR[canNo-1]->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos;  //2024.6(4)
    
    //（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数组中指定CAN控制器的RF0R寄存器的RFOM0位。
    // CAN_RF0R_RFOM0位对应于CAN接收FIFO 0的消息接收完成标志。
    // 当设置此位后，表示FIFO 0中的消息已被处理，可以接收新的消息。
      SET_BIT(CAN_ARR[canNo-1]->RF0R, CAN_RF0R_RFOM0);  //2024.6(5)
    }
    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接收FIFO编号的变量
    
    // 初始化Can_Rx_FifoNo为CAN_RX_FIFO0
	Can_Rx_FifoNo = CAN_RX_FIFO0;
	// 检查是否是CAN_RX_FIFO0
	if(Can_Rx_FifoNo == CAN_RX_FIFO0)
		// 如果是CAN_RX_FIFO0，设置对应的中断使能位
        // IER寄存器用于使能CAN中断，FMPIE0位用于使能FIFO 0的接收中断
		SET_BIT(CAN_ARR[canNo-1]->IER, CAN_IER_FMPIE0);    //2024.6(6)
	else
		 // 如果不是CAN_RX_FIFO0，可能是CAN_RX_FIFO1，设置对应的中断使能位
        // FMPIE1位用于使能FIFO 1的接收中断
		SET_BIT(CAN_ARR[canNo-1]->IER,CAN_IER_FMPIE1);
		
		 // 根据FIFO编号，从中断向量表中获取对应的CAN中断向量号
    // 并使用NVIC_EnableIRQ函数启用该中断
	NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]);     //2024.6(7)
}

//=====================================================================
//函数名称：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))
    {
      	// 使用按位与操作符(&)和CAN_TSR_CODE宏来从TSR寄存器中提取邮箱代码。
        // 邮箱代码指示当前哪个邮箱正在尝试传输或等待传输完成。
        // 使用右移位操作符(>>)来将邮箱代码移至最低位，从而便于进一步处理。
        // CAN_TSR_CODE_Pos宏定义了邮箱代码在TSR寄存器中的起始位置。
    	transmit_mailbox = (register_tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos;     //2024.6(8)
    	if(transmit_mailbox > 2U)
    	{
    		return 1;
    	}

        //（2.1）判断并设置发送帧为标准帧还是扩展帧
        if(DestID <= 0x7FFU)    //2024.6检查目标CAN节点的标识符 DestID 是否小于等于标准帧的最大标识符 0x7FFU。如果满足条件，说明 DestID 是一个标准帧的标识符
        {
            CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_STID_Pos)|CAN_ID_STD|rtr);  //2024.6设置发送邮箱的传输标识符（TIR）为标准帧格式
        }
        else
        {
            CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_EXID_Pos)|CAN_ID_EXT|rtr);  //2024.6设置发送邮箱的传输标识符（TIR）为扩展帧格式
        }
        //（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,   //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));
        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设置发送邮箱的传输标识符（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;   //2024.6使用按位或运算符将RCC模块中的APB1外设时钟使能寄存器1的CAN1时钟使能位设置为逻辑高。这样可以启用CAN1模块的时钟，使其可以正常工作
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
        GPIOA->MODER &= ~(GPIO_MODER_MODE11|GPIO_MODER_MODE12);
        GPIOA->MODER |= (GPIO_MODER_MODE11_1|GPIO_MODER_MODE12_1);  //2024.6清除GPIOA引脚11和引脚12的模式位，并将其设置为复用功能模式
        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清除GPIOA引脚11和引脚12的复用功能位，并将其设置为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);    //2024.6清除CAN控制器的睡眠位，使其进入工作模式
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_SLAK) != 0U)   //2024.6检查CAN控制器是否成功退出睡眠模式
    {
        if(i++ > 0x30000)
        {
            return 1;
        }
    }

    SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ);    //2024.6设置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);   //2024.6清除CAN控制器的时间触发通信模式位
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_ABOM);   //2024.6清除CAN控制器的自动离线管理位
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_AWUM);   //2024.6清除CAN控制器的自动唤醒模式位
    SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_NART);     //2024.6设置CAN控制器的非自动重传模式位
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_RFLM);    //2024.6清除CAN控制器的接收FIFO锁定模式位
    CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_TXFP);    //2024.6清除CAN控制器的发送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);    //2024.6设置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);    //2024.6清除CAN控制器的初始化请求位，使其退出初始化模式
    i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) != 0U)    //2024.6检查CAN控制器的初始化模式确认位是否为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;    //2024.6将CanID左移CAN_TI0R_STID_Pos位，按位左移相当于乘以2的位数次幂，用于设置标识寄存器的标识符字段

    FilterIdHigh = (CanID >> 16) & 0xFFFF;    //2024.6获取CanID的高16位
    FilterIdLow = (CanID & 0xFFFF);    //2024.6获取CanID的低16位
    FilterMaskIdHigh = 0xFFE0;    //2024.6过滤器掩码的高16位，用于掩码模式
    FilterMaskIdLow = 0x0000;    //2024.6过滤器掩码的低16位，用于掩码模式
    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关闭指定过滤器组的过滤器
    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)    //2024.6检查过滤器的位数是否为32位
    {
      SET_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);    //2024.6设置过滤器模式寄存器中对应过滤器组的位，表示使用32位过滤器模式
      CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR1 =    //2024.6 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)    //2024.6 检查过滤器的模式是否为ID掩码模式
    {
      CLEAR_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);    //2024.6掩码模式
    }
    else
    {
      SET_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);
    }
    if (Can_Rx_FifoNo == CAN_FILTER_FIFO0)     //2024.6检查CAN接收FIFO编号是否等于FIFO0
    {
      CLEAR_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);   //2024.6邮箱号为0的邮箱
    }
    else
    {
      SET_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);
    }
    if (IsActivate == 1)    //2024.6检查是否激活（Activate）的标志位是否为1
    {
      SET_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);   //2024.6激活过滤器
    }
    //退出过滤器初始化模式 (FINIT=0)
    CLEAR_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    //2024.6清除过滤器模式寄存器中的过滤器初始化位（FINIT）

    return 0;
}

nf_126

关注

24
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
嵌入式系统作业7

这意味着每个节点都可以在总线上发送消息，但在发送之前需要先监听总线上的通信情况。当一个节点要发送消息时，首先会监听总线，如果没有其他节点正在发送消息，它就可以开始发送。在CAN总线上使用的是。发送节点将每个位的电平保持一段时间，接收节点则在相应的时间段内检测位的电平。较低优先级的帧会在总线上等待较高优先级的帧发送完毕后再发送，确保重要消息的及时传输。已成功用CAN通信向对方发送我的名字(NIFEI)，也成功接收到对方发过来的名字（lyy）。，冲突的节点会立即停止发送，并在发送完自己的消息后再次来检测冲突。
复制链接

扫一扫