devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于STM32F4的CAN通信例程(库函数版)_can_initstructure.can_rflm=disable;

作者：花生_TL007 | 2024-04-30 10:06:37

赞

踩

can_initstructure.can_rflm=disable;

一、介绍

  实现STM32的CAN通信的时候，我们无需关注本身复杂的CAN通信协议许多细枝末节的东西已经被厂商封装起来，我们可以先让程序跑起来，再通过调整各个参数来熟悉STM32中的CAN通信的原理。

  实现CAN通信与实现SPI、I2C、串口等通信并无二致，都是先初始化引脚、片上外设、中断处理。然后在主函数中调用初始化，接着就可以当作通信使用，任何通信本质上都是接收receive)和发送(transmit).

  STM32中的CAN接收发送原型库函数。

  1. uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage)
  2. {
  3.   uint8_t transmit_mailbox = 0;
  4.   /* Check the parameters */
  5.   assert_param(IS_CAN_ALL_PERIPH(CANx));
  6.   assert_param(IS_CAN_IDTYPE(TxMessage->IDE));
  7.   assert_param(IS_CAN_RTR(TxMessage->RTR));
  8.   assert_param(IS_CAN_DLC(TxMessage->DLC));
  9.  
  10.   /* Select one empty transmit mailbox */
  11.   if ((CANx->TSR&CAN_TSR_TME0) == CAN_TSR_TME0)
  12.   {
  13.     transmit_mailbox = 0;
  14.   }
  15.   else if ((CANx->TSR&CAN_TSR_TME1) == CAN_TSR_TME1)
  16.   {
  17.     transmit_mailbox = 1;
  18.   }
  19.   else if ((CANx->TSR&CAN_TSR_TME2) == CAN_TSR_TME2)
  20.   {
  21.     transmit_mailbox = 2;
  22.   }
  23.   else
  24.   {
  25.     transmit_mailbox = CAN_TxStatus_NoMailBox;
  26.   }
  27.  
  28.   if (transmit_mailbox != CAN_TxStatus_NoMailBox)
  29.   {
  30.     /* Set up the Id */
  31.     CANx->sTxMailBox[transmit_mailbox].TIR &= TMIDxR_TXRQ;
  32.     if (TxMessage->IDE == CAN_Id_Standard)
  33.     {
  34.       assert_param(IS_CAN_STDID(TxMessage->StdId));  
  35.       CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->StdId << 21) | \
  36.                                                   TxMessage->RTR);
  37.     }
  38.     else
  39.     {
  40.       assert_param(IS_CAN_EXTID(TxMessage->ExtId));
  41.       CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->ExtId << 3) | \
  42.                                                   TxMessage->IDE | \
  43.                                                   TxMessage->RTR);
  44.     }
  45.     
  46.     /* Set up the DLC */
  47.     TxMessage->DLC &= (uint8_t)0x0000000F;
  48.     CANx->sTxMailBox[transmit_mailbox].TDTR &= (uint32_t)0xFFFFFFF0;
  49.     CANx->sTxMailBox[transmit_mailbox].TDTR |= TxMessage->DLC;
  50.  
  51.     /* Set up the data field */
  52.     CANx->sTxMailBox[transmit_mailbox].TDLR = (((uint32_t)TxMessage->Data[3] << 24) | 
  53.                                              ((uint32_t)TxMessage->Data[2] << 16) |
  54.                                              ((uint32_t)TxMessage->Data[1] << 8) | 
  55.                                              ((uint32_t)TxMessage->Data[0]));
  56.     CANx->sTxMailBox[transmit_mailbox].TDHR = (((uint32_t)TxMessage->Data[7] << 24) | 
  57.                                              ((uint32_t)TxMessage->Data[6] << 16) |
  58.                                              ((uint32_t)TxMessage->Data[5] << 8) |
  59.                                              ((uint32_t)TxMessage->Data[4]));
  60.     /* Request transmission */
  61.     CANx->sTxMailBox[transmit_mailbox].TIR |= TMIDxR_TXRQ;
  62.   }
  63.   return transmit_mailbox;
  64. }
  1. void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage)
  2. {
  3.   /* Check the parameters */
  4.   assert_param(IS_CAN_ALL_PERIPH(CANx));
  5.   assert_param(IS_CAN_FIFO(FIFONumber));
  6.   /* Get the Id */
  7.   RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONumber].RIR;
  8.   if (RxMessage->IDE == CAN_Id_Standard)
  9.   {
  10.     RxMessage->StdId = (uint32_t)0x000007FF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 21);
  11.   }
  12.   else
  13.   {
  14.     RxMessage->ExtId = (uint32_t)0x1FFFFFFF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 3);
  15.   }
  16.   
  17.   RxMessage->RTR = (uint8_t)0x02 & CANx->sFIFOMailBox[FIFONumber].RIR;
  18.   /* Get the DLC */
  19.   RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONumber].RDTR;
  20.   /* Get the FMI */
  21.   RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDTR >> 8);
  22.   /* Get the data field */
  23.   RxMessage->Data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDLR;
  24.   RxMessage->Data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 8);
  25.   RxMessage->Data[2] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 16);
  26.   RxMessage->Data[3] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 24);
  27.   RxMessage->Data[4] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDHR;
  28.   RxMessage->Data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 8);
  29.   RxMessage->Data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 16);
  30.   RxMessage->Data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 24);
  31.   /* Release the FIFO */
  32.   /* Release FIFO0 */
  33.   if (FIFONumber == CAN_FIFO0)
  34.   {
  35.     CANx->RF0R |= CAN_RF0R_RFOM0;
  36.   }
  37.   /* Release FIFO1 */
  38.   else /* FIFONumber == CAN_FIFO1 */
  39.   {
  40.     CANx->RF1R |= CAN_RF1R_RFOM1;
  41.   }
  42. }

使用它们时就是初始化参数，赋值参数然后调用函数。将以上步骤封装为函数。

二、完整代码

can.h

  1. #ifndef __STM32_CAN_H_
  2. #define __STM32_CAN_H_
  3.  
  4. #include "stm32f4xx.h"
  5.  
  6.  
  7. #define CAN_RX_INT_CONFIG 1 //配置CAN接收中断结构体
  8.  
  9. void CanTransPort_Init(void);
  10.  
  11. uint8_t sendMsgToCan(CanTxMsg *msg,uint8_t *data);//发送报文
  12. uint16_t CanRecMsg(uint8_t *msg); 	//接收报文
  13.  
  14.  
  15.  
  16. #endif
  17.

 can.c

  1. #include "stm32_can.h"
  2. #include "usart.h"
  3.  
  4. CanRxMsg rxMessage;
  5. CanTxMsg txMessage;
  6.  
  7. void CanTransPort_Init(void)
  8. {
  9. 	GPIO_InitTypeDef 			 GPIO_InitStructure;		//GPIO物理接口
  10. 	CAN_InitTypeDef        CAN_InitStructure;	//CAN外设初始结构体	规定CAN通信速率 策略
  11. 	CAN_FilterInitTypeDef  CAN_FilterInitStructure;	//CAN过滤器结构体 用于控制收发报文
  12. 	
  13. #if CAN_RX_INT_CONFIG
  14. 	NVIC_InitTypeDef NVIC_InitStructure;
  15. #endif
  16. 	//PD0 RX PD1 TX
  17. 	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE);
  18. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
  19. 	
  20. 	GPIO_PinAFConfig(GPIOD,GPIO_PinSource0,GPIO_AF_CAN1);
  21. 	GPIO_PinAFConfig(GPIOD,GPIO_PinSource1,GPIO_AF_CAN1);
  22. 	
  23. 	//Configure CAN1 TX
  24. 	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;
  25. 	GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;
  26. 	GPIO_InitStructure.GPIO_OType=GPIO_OType_PP;
  27. 	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF;
  28. 	GPIO_InitStructure.GPIO_Speed=GPIO_Fast_Speed;
  29. 	
  30. 	GPIO_Init(GPIOD,&GPIO_InitStructure);
  31. 	
  32. 	//Configure CAN1 RX
  33. 	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
  34. 	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF;
  35. 	GPIO_Init(GPIOD,&GPIO_InitStructure);
  36. 	
  37. 	//CAN外设初始化
  38. 	CAN_DeInit(CAN1);
  39. 	CAN_StructInit(&CAN_InitStructure);
  40. 	
  41. 	CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
  42. 	CAN_InitStructure.CAN_ABOM=ENABLE; //自动离线管理
  43. 	CAN_InitStructure.CAN_AWUM=ENABLE;	//自动唤醒
  44. 	//42MHZ / (1+4+2)/ 12 = 500kbps
  45. 	CAN_InitStructure.CAN_BS1=CAN_BS1_4tq;
  46. 	CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;
  47. 	CAN_InitStructure.CAN_SJW=CAN_SJW_2tq;
  48. 	CAN_InitStructure.CAN_Prescaler=12;
  49. 	CAN_InitStructure.CAN_RFLM=DISABLE; //锁定模式
  50. 	CAN_InitStructure.CAN_NART=DISABLE; //自动重传
  51. 	CAN_InitStructure.CAN_TTCM=DISABLE; //时间触发模式
  52. 	CAN_InitStructure.CAN_TXFP=DISABLE; //报文发送优先级判定方法
  53. 	
  54. 	CAN_Init(CAN1,&CAN_InitStructure);
  55. 	
  56. 	//CAN过滤器初始化
  57. 	CAN_FilterInitStructure.CAN_FilterNumber=0;
  58. 	CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
  59. 	CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FilterFIFO0; //安装过滤器
  60. 	CAN_FilterInitStructure.CAN_FilterIdHigh=0x00000000;
  61. 	CAN_FilterInitStructure.CAN_FilterIdLow=0x0000000;
  62. 	CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
  63. 	CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;	//过滤器使能
  64. 	
  65. 	CAN_FilterInit(&CAN_FilterInitStructure);
  66. 	
  67. #if CAN_RX_INT_CONFIG
  68. 	NVIC_InitStructure.NVIC_IRQChannel=CAN1_RX0_IRQn;
  69. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x01;
  70. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;
  71. 	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
  72. 	NVIC_Init(&NVIC_InitStructure);
  73. 	CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);
  74. #endif
  75.  
  76. }
  77. uint8_t Can_ReceiveMsg(uint8_t *MsgBuffer)
  78. {
  79. 	uint32_t i;
  80. 	CanRxMsg rxMsg;
  81. 	if(CAN_MessagePending(CAN1,CAN_FIFO0) == 0 ) return 0;
  82. 	CAN_Receive(CAN1,CAN_FIFO0,&rxMsg);
  83. 	for(i=0;i<8;i++)
  84. 	MsgBuffer[i] = rxMsg.Data[i];
  85. 	return rxMsg.DLC;
  86. 	
  87. }
  88.  
  89. #if CAN_RX_INT_CONFIG
  90.  
  91. void CAN1_RX0_IRQHandler(void)
  92. {	
  93. 	printf("enter CAN1_RX0_IRQHandler \r\n");
  94. //	if(CAN_GetFlagStatus(CAN1,CAN_IT_FMP0) != RESET)		//添加中断会发送程序会死循环在中断里
  95. //	{
  96. 			CAN_Receive(CAN1,CAN_FIFO0,&rxMessage);
  97. 			printf("Data:%s\r\n",rxMessage.Data);
  98. 			printf("ExtId:%d\r\n",rxMessage.ExtId);
  99. //		CAN_ClearITPendingBit(CAN1,CAN_IT_FMP0);
  100. //	}
  101. 	printf("exti CAN1_RX0_IRQHandler \r\n");
  102. }
  103.  
  104. #endif
  105.  
  106. uint8_t sendMsgToCan(CanTxMsg *msg,uint8_t *data)
  107. {
  108. 	uint16_t i = 0;
  109. 	uint8_t mailBox;
  110. 	msg->ExtId=0x1e2c;
  111. 	msg->IDE=CAN_Id_Extended;
  112. 	msg->RTR=CAN_RTR_Data;
  113. 	msg->DLC=8;
  114. 	
  115. 	for(i = 0;i<8;i++)
  116. 	{
  117. 		msg->Data[i] = data[i];
  118. 	}
  119. 	i=0;
  120. 	mailBox = CAN_Transmit(CAN1,msg);
  121. 	while(CAN_TransmitStatus(CAN1,mailBox) !=CAN_TxStatus_Ok && i <= 2000)
  122. 	{
  123. 		i++;
  124. 	}
  125. 	if(i >= 2000)
  126. 	{
  127. 		return 1;
  128. 	}
  129. 	else 
  130. 		return 0;
  131. }
  132.  
  133.

在主函数中使用CAN通信

main.c

  1. #include "stm32f4xx.h"
  2. #include "usart.h"
  3. #include "delay.h"
  4. #include "stm32_can.h"
  5.  
  6. extern CanRxMsg rxMessage;
  7. extern CanTxMsg txMessage;
  8.  
  9. int main(void)
  10. {	
  11. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  12. 	uint8_t txBuf[8];
  13. 	CanTransPort_Init();
  14. 	usart2_init(115200);
  15. 	delay_init(168);
  16. 	uint8_t i = 0;
  17. 	uint8_t cnt = 0;
  18. 	txBuf[0]=0x0e;
  19. 	txBuf[1]=0x1c;
  20. 	txBuf[2]=0xee;
  21. 	txBuf[3]=0xb0;
  22. 	txBuf[4]=0xe7;
  23. 	txBuf[5]=0xa1;
  24. 	txBuf[6]=0x99;
  25. 	txBuf[7]=0x35;
  26. 	
  27. 	USART2_printf("传输开始!\r\n");
  28. 	
  29. 	while(1)
  30. 	{
  31. //		CanSendMsg(txBuf,8,0x00000000);
  32. 		sendMsgToCan(&txMessage,txBuf);
  33. 		txBuf[i]++;
  34. 		i++;
  35. 		if(i%8 == 0)
  36. 		{
  37. 			i = 0;
  38. 			cnt++;
  39. 		}
  40. 		if(cnt%4 == 0)
  41. 		{
  42. 			cnt = 0;
  43. 			for(i=0;i<8;i++)
  44. 			{
  45. 				txBuf[i]-=0x1F;
  46. 			}
  47. 			i=0;
  48. 		}
  49. 		delay_ms(2000);
  50. 		
  51. 	}
  52. }
  53.  
  54.  
  55.

三、实验设备:

usart 转 CAN USB模块

STM32 F407

can硬件电路

四、实验现象

五、发送特定报文

查阅Ascii码表 

发送: 48 65 6C 6C 6F 43 61 6E 

对应: H  e     l    l     o   C   a  n

实验现象:

上位机

串口接收

六、工程代码地址

ZzlYang/STM32F4_CAN_Example: STM32F407 can example with usart_can model (github.com)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/512798
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号