嵌入式作业七

Kylian_c

已于 2024-06-19 23:37:39 修改

阅读量249

点赞数 6

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

于 2024-06-19 22:50:57 首次发布

本文链接：https://blog.csdn.net/m0_63844603/article/details/139814708

版权

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

接线按照这个方式进行连接：

其电路的原理图为：

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

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

//----------------------------------------------------------------------
//主函数，一般情况下可以认为程序从此开始运行（实际上有启动过程，参见书稿）
int main(void)
{
	uint32_t localMsgID;
	uint32_t txMsgID;
	uint32_t BitRate;


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


	localMsgID = 0x0AU;
	txMsgID = 0x0BU;
	BitRate = 36;

	//（1.4）给全局变量赋初值
    emuart_init(UART_User,115200);
    uart_init(UART_3,115200);
    //【***CAN模块初始化***】
    can_init(CAN_1,localMsgID,BitRate);

    //（1.6）使能模块中断
    uart_enable_re_int(UART_User);
    uart_enable_re_int(UART_3);
    //【***使能CAN模块中断***】
    can_enable_recv_int(CAN_1);
    //（1.7）【不变】开总中断
	ENABLE_INTERRUPTS;
	for(;;)   //for(;;)（开头）
	{
		if(can_send(CAN_1, txMsgID, 8, (uint8_t*)"Iam zjt") != 0) printf("failed\r\n");
		printf("\n");
	}  //for(;;)结尾
}

实验结果为：

可以看到通信是正常进行的，能够互相接收和发送。

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

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

int main(void)
{
	uint32_t localMsgID;
	uint32_t txMsgID;
	uint32_t BitRate;


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

	localMsgID = 0x0AU;
	txMsgID = 0x0BU;
	BitRate = 36;

	//（1.4）给全局变量赋初值
    emuart_init(UART_User,115200);
    uart_init(UART_3,115200);
    //【***CAN模块初始化***】
    can_init(CAN_1,localMsgID,BitRate);

    //（1.6）使能模块中断
    uart_enable_re_int(UART_User);
    uart_enable_re_int(UART_3);
    //【***使能CAN模块中断***】
    can_enable_recv_int(CAN_1);
    //（1.7）【不变】开总中断
	ENABLE_INTERRUPTS;
	for(;;)   //for(;;)（开头）
	{
		if(can_send(CAN_1, txMsgID, 8, (uint8_t*)"Iam zjt") != 0) printf("failed\r\n");
		printf("\n");
	}  //for(;;)结尾
}  

2.

#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）======启动部分（开头）==========================================
    uint16_t num_AD2;
    uint16_t num_AD3;
    //（1.2）【不变】关总中断
    DISABLE_INTERRUPTS;
        
    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("---32106100049---计科211张锦涛---\n"); 
    for(;;)   //for(;;)（开头）
    {
    	Delay_ms(2000);	// 延时2s
        num_AD2 = adc_ave(ADC_CHANNEL_15,8);
        num_AD3 = adc_ave(ADC_CHANNEL_TEMPSENSOR,8);
        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",Regression_MCU_Temp(num_AD3));  
        printf("\n");
    }  //for(;;)结尾
    //（2）======主循环部分（结尾）========================================
}   //main函数（结尾）
void Delay_ms(uint16_t u16ms)
{
    uint32_t u32ctr;
    for(u32ctr = 0; u32ctr < 8000*u16ms; u32ctr++)
    {
        __ASM("NOP");
    }
}

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

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

实验结果：

可以看到初始时通道15环境的AD值为2439左右利用AD值变换公式置换成温度则大概在17度左右

而内部温度传感器的AD值为890左右利用AD值变换公式置换成温度则大概在11~12度左右

然后我们把手指放到热敏电阻和CPU上

可以得出当用手触摸热敏电阻时可以很明显的看到通道15的温度升到了32度

用手触摸芯片时可以很明显的看到内部温度传感器的温度升到了15度

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

在进行实验之前必须要先对要进行操作的扇区判断是否已经存放了系统内容否则将导致实验出现问题：

除此之外要想得到相应扇区的物理地址需要去定义函数中查看并计算

可以看出在进行物理写入时，若要写入到第49扇区则可以通过初始扇区物理地址0x08000000 + 2048 * 49 = 0x08018800

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

int main(void)
{
//（1）======启动部分（开头）==========================================
//（1.1）声明main函数使用的局部变量
	uint8_t mK1[32];	 //按照逻辑读方式从指定flash区域中读取的数据
	uint8_t mK2[32];      //按照物理读方式从指定flash区域中读取的数据
    
	uint8_t result;    //判断扇区是否为空标识
//（1.2）【不变】关总中断
	DISABLE_INTERRUPTS;

//（1.6）使能模块中断
   flash_init(); //初始化flash
   
//（1.7）【不变】开总中断
	ENABLE_INTERRUPTS;


    printf("---计科211---32106100049---张锦涛---\n"); 
       
    //首先对扇区进行擦除   
    flash_erase(49);
    
    //进行第一次写入
    flash_write(49,0,32,(uint8_t *) "zhangjintao-1");
	flash_read_logic(mK1,49,0,32); //从49扇区读取32个字节到mK1中
	printf("逻辑读方式读取49扇区的32字节的内容: 第一次写: %s\n",mK1);
	result = flash_isempty(49,MCU_SECTORSIZE); // 判断第49扇区是否为空
    printf("第一次写入时判断第49扇区是否为空，1表示空，0表示不空: %d\n",result);
    
    //进行第二次写入
    flash_write(49,0,32,(uint8_t *) "zhangjintao-2");
	flash_read_logic(mK2,49,0,32); //从49扇区读取32个字节到mK2中
	printf("逻辑读方式读取49扇区的32字节的内容: 第二次写: %s\n",mK2);
	result = flash_isempty(49,MCU_SECTORSIZE); // 判断第49扇区是否为空
    printf("第二次写入时判断第49扇区是否为空，1表示空，0表示不空: %d\n",result);
    
    
    //进行第一次物理写入
    flash_erase(49);  
	flash_write_physical(0x8018800,32,"zhangjintao-3");
	flash_read_physical(mK1,0x8018800,32);      //从49扇区读取32个字节到mK1中
	printf("物理读方式读取50扇区的32字节的内容: 第一次写: %s\n",mK1);
	result = flash_isempty(49,MCU_SECTORSIZE); // 判断第49扇区是否为空
    printf("第一次物理写入之后判断第49扇区是否为空，1表示空，0表示不空: %d\n",result);
    
    //进行第二次物理写入
	flash_write_physical(0x8018800,32,"zhangjintao-4");
	flash_read_physical(mK2,0x8018800,32);      //从50扇区读取32个字节到mK2中
	printf("物理读方式读取49扇区的32字节的内容: 第二次写: %s\n",mK2);
	result = flash_isempty(49,MCU_SECTORSIZE); // 判断第49扇区是否为空
    printf("第二次物理写入之后判断第49扇区是否为空，1表示空，0表示不空: %d\n",result);
    
	
 }

可以看出貌似第二次未进行擦除时也能成功写入，但我们是直接调用了flash_write()所以我们必须要去该函数查看是如何进行写入的

进入到函数中可以发现无论是物理写入还是逻辑写入其方法本质是一样的，都是先对扇区进行擦除再进行写入，所以要验证不擦除是否能直接写入到扇区则必须将擦除扇区的操作进行注解，查看是否还能写入到扇区。

从结果来看可以看出如果扇区里的数据不为空的时候，数据是没办法正常写入的，原数据无法覆盖，所以必须要先对其扇区的数据进行擦除才可以将数据写入到相应的扇区之中。

先前已经看出了物理地址写入其实就是计算了扇区再调用写入函数，其本质是一样的，依旧是未擦除无法写入。

总结：

在本次实验中完成了简单的CAN通信并且能够成功的进行相互间的通信，但在实验的过程中我发现即使给出了实验的原理电路图在接线的问题上还是花费了过长的时间，原因是缺少这方面的知识，所以希望在接下来的学习中多多增强动手能力，除此之外在ADC实验中我发现了一个问题就是当用手触摸热敏电阻时其温度的变化非常大，将手放在热敏电阻上时温度会忽大忽小，具体原因还没有分析出来，希望在接下来的学习中对这方面进行了解。最后在Flash实验中完成了对扇区的写入操作开始逐步了解falsh存储的基本原理，相信在未来的学习中能够更加快速且熟练的运用这些知识点

can.c分析：

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

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

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

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

	//给Init函数使用的局部变量赋初值
	CANMode = CAN_MODE_NORMAL;                //是将CAN(控制器区域网络)设置为正常模式
	CANFilterBank = CANFilterBank0;
	CANFiltermode = CAN_FILTERMODE_IDMASK;
	CAN_Filterscale = CAN_FILTERSCALE_32BIT;

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

//=====================================================================
//函数名称：can_send
//函数返回：0=正常，1=错误
//参数说明：canNo：模块号，本芯片只有CAN_1
//          DestID：目标CAN节点的唯一标识，例如按照CANopen协议给出
//          len：待发送数据的字节数
//          buff：待发送数据发送缓冲区首地址
//功能概要：CAN模块发送数据
//=====================================================================
uint8_t can_send(uint8_t canNo, uint32_t DestID, uint16_t len ,uint8_t* buff)
{
	if(DestID > 0x1FFFFFFFU) return 1;
	uint8_t send_length;
	for(int i = len; i > 0; i = i-8)
	{
		send_length = (i>8)?8:i;
		if(can_send_once(canNo,DestID,send_length,buff+len-i) == 1)   //判断canNO通道向DestID发送缓冲区中send_length即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)   //检查寄存器中是否还存在未读取的数据
		{
			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;  //获取接收到的can报文长度
    //（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);  //清除CAN接收FIFO的消息已读标志位
    }
    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);    //开启第canNo-1个CAN控制器FIFO消息挂起中断
	else
		SET_BIT(CAN_ARR[canNo-1]->IER,CAN_IER_FMPIE1);
	NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]);     //使能对应的NVIC中断，当CAN控制器的中断触发时,CPU就会进入相应的中断服务程序进行处理
}

//=====================================================================
//函数名称：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)    //若小于0x7FFU,则用于标准帧
    	{
    		CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_STID_Pos)|CAN_ID_STD|rtr);  //设置发送邮箱的标准帧ID寄存器(TIR)
    	}
    	else
    	{
    		CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_EXID_Pos)|CAN_ID_EXT|rtr);  //设置发送邮箱的扩展帧ID寄存器(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,   //往发送邮箱的数据寄存器高字节写入数据
                  ((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管脚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);   //配置GPIOA管脚11和12的复用功能为CAN1
	}
	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)   //等待CAN外设退出睡眠模式，不能等过久否则退出
	{
		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);   //关闭TTCM，即时间触发通信模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_ABOM);   //关闭自动总线关闭模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_AWUM);   //关闭自动唤醒模式
	SET_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_NART);     //开启非自动重传模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_RFLM);    //关闭接收 FIFO 锁定模式
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_TXFP);    //关闭发送 FIFO 优先级
}

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

//=====================================================================
//函数名称：CAN_SWInit_Quit
//函数返回：0=正常，1=错误
//参数说明：canNo:模块基地址号
//功能概要：退出初始化模式，进入正常模式
//=====================================================================
uint8_t CAN_SWInit_Quit(uint8_t canNo)
{
	int i;
	CLEAR_BIT(CAN_ARR[canNo-1]->MCR, CAN_MCR_INRQ);    //清除CAN外设的初始化请求标志位
	i = 0;
    while ((CAN_ARR[canNo-1]->MSR & CAN_MSR_INAK) != 0U)    //等待CAN外设确认已经退出初始化模式
    {
      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;    //判断CanID是否在标准帧ID的范围内

	FilterIdHigh = (CanID >> 16) & 0xFFFF;    //提取高16位的值可以用于设置CAN过滤器的高字节部分
	FilterIdLow = (CanID & 0xFFFF);    //提取低16位的值可以用于设置过滤器的低字节部分
	FilterMaskIdHigh = 0xFFE0;    //设置高位过滤器掩码
	FilterMaskIdLow = 0x0000;    //设置低位过滤器掩码
	filternbrbitpos = (uint32_t)1 << (FilterBank & 0x1FU);    //计算当前过滤器在过滤器组中的位置

	//设置过滤器初始化模式 (FINIT=1),在此模式下可以进行过滤器初始化
	SET_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    //设置CAN控制器的过滤器初始化模式
	CLEAR_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);    //清除CAN控制器的第 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)    //检查CAN过滤器的比特位宽度，若为32位时
	{
	  SET_BIT(CAN_ARR[canNo-1]->FS1R, filternbrbitpos);    //设置CAN控制器过滤器的比特位宽度为32位
	  CAN_ARR[canNo-1]->sFilterRegister[FilterBank].FR1 =    //配置CAN控制器的过滤器的ID高16位和低16位
		((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)    //检查CAN过滤器的工作模式是否为ID掩码模式
	{
	  CLEAR_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);    //将指定的CAN过滤器的工作模式设置为ID列表模式
	}
	else
	{
	  SET_BIT(CAN_ARR[canNo-1]->FM1R, filternbrbitpos);
	}
	if (Can_Rx_FifoNo == CAN_FILTER_FIFO0)     //检查当前接收到的CAN帧是否来自CAN控制器的FIFO 0接收缓存区
	{
	  CLEAR_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);   //将指定的CAN过滤器的关联FIFO设置为FIFO0
	}
	else
	{
	  SET_BIT(CAN_ARR[canNo-1]->FFA1R, filternbrbitpos);
	}
	if (IsActivate == 1)    //判断是否需要激活
	{
	  SET_BIT(CAN_ARR[canNo-1]->FA1R, filternbrbitpos);   //设置CAN的过滤器的FIFO关联
	}
	//退出过滤器初始化模式 (FINIT=0)
	CLEAR_BIT(CAN_ARR[canNo-1]->FMR, CAN_FMR_FINIT);    //退出CAN控制器的初始化模式

	return 0;
}

can模式

Kylian_c

关注

6
点赞
踩
2

收藏

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

进入到函数中可以发现无论是物理写入还是逻辑写入其方法本质是一样的，都是先对扇区进行擦除再进行写入，所以要验证不擦除是否能直接写入到扇区则必须将擦除扇区的操作进行注解，查看是否还能写入到扇区。从结果来看可以看出如果扇区里的数据不为空的时候，数据是没办法正常写入的，原数据无法覆盖，所以必须要先对其扇区的数据进行擦除才可以将数据写入到相应的扇区之中。先前已经看出了物理地址写入其实就是计算了扇区再调用写入函数，其本质是一样的，依旧是未擦除无法写入。用手触摸芯片时可以很明显的看到内部温度传感器的温度升到了15度。
复制链接

扫一扫