stm32 CAN通信 TJA1040

系统管理员 2022-06-10 12:07 553阅读 0赞

![1][]

## CAN协议特点 ##

`1.多主控制`  
所有单元都可以发送消息，根据标识符（Identifier简称ID）决定优先级。仲裁获胜（被判定为优先级最高）的单元可继续发送消息，仲裁失利的单元则立刻停止发送而进行接收工作

`2.系统的柔软性`  
与总线相连的单元没有类似于“地址”的信息。因此在总线上增加单元时，连接在总线上的其它单元的软硬件及应用层都不需要改变

`3.通信速度较快，通信距离远`  
最高 1Mbps（距离小于40M），最远可达10KM（速率低于5Kbps）

`4.具有错误检测、错误通知和错误恢复功能`  
所有单元都可以检测错误（错误检测功能），检测出错误的单元会立即同时通知其他所有单元（错误通知功能），正在发送消息的单元一旦检测出错误，会强制结束当前的发送。强制  
结束发送的单元会不断反复地重新发送此消息直到成功发送为止（错误恢复功能）

`5.故障封闭功能`  
CAN可以判断出错误的类型是总线上暂时的数据错误（如外部噪声等）还是持续的数据错误（如单元内部故障、驱动器故障、断线等）。由此功能，当总线上发生持续数据错误时，可将引起此故障的单元从总线上隔离出去

`6. 连接节点多`  
CAN 总线是可同时连接多个单元的总线。可连接的单元总数理论上是没有限制的。但实际上可连接的单元数受总线上的时间延迟及电气负载的限制

**总线拓扑**  
总线电平分为显性电平和隐性电平两种。“显性”具有“优先”的意味，只要有一个单元输出显性电平，总线上即为显性电平。并且，“隐性”具有“包容”的意味，只有所有的单元都输出隐性电平，总线上才为隐性电平  
![1][1 1]

## 帧的种类 ##

**帧的种类及用途**  
![1][1 2]  
**数据帧的构成**  
![1][1 3]

> 帧起始：数据帧开始  
> 仲裁段：该帧优先级  
> 控制段：数据的字节数及保留位  
> 数据段：数据的内容，可发送0～8个字节的数据  
> CRC段：检查帧的传输错误  
> ACK段：确认正常接收  
> 帧结束：数据帧结束

**遥控帧的构成**  
遥控帧没有数据帧的数据段  
![1][1 4]  
**错误帧**  
![1][1 5]

> 错误标志：包括主动错误标志和被动错误标志两种。主动错误标志为6位的显性位；被动错误标志为6位的隐性位  
> 错误界定符：由8位的隐性位构成

**过载帧**  
![2][]

> 过载标志：6位的显性位（与主动错误标志的构成相同）  
> 过载界定符：8位的隐性位（与错误界定符的构成相同）

**帧间隔**  
![3][]

> 间隔：3位的隐性位  
> 延迟传送：8位的隐性位  
> 总线空闲：隐性电平，无长度限制（0 亦可）

## 数据帧 ##

**帧起始**  
标准、扩展格式相同。1位的显性位  
![1][1 6]  
**仲裁段**  
![1][1 7]  
扩展帧的仲裁段有29位，可以出现229种报文。标准帧的仲裁段是11位，可以出现211种报文。扩展帧能扩展更多的CAN节点，更好地支持上层协议

**控制段**  
![1][1 8]  
`数据长度码和字节数的关系:`  
![2][2 1]  
“D”为显性电平；“R”为隐性电平

**数据段**  
数据段可包含0～8个字节的数据。从MSB（最高位）开始输出  
![1][1 9]  
**CRC段**  
由15位的CRC顺序和1位的CRC界定符（用于分隔的位）构成  
![1][1 10]  
**ACK段**  
由ACK槽(ACK Slot)和ACK界定符2位构成  
![1][1 11]  
**帧结束**  
由7位的隐性位构成  
![1][1 12]

## 优先级的决定 ##

连续输出显性电平最多的单元可继续发送

![1][1 13]  
**数据帧和遥控帧的优先级**  
具有相同ID 的数据帧和遥控帧在总线上竞争时，仲裁段的最后一位（RTR）为显性位的数据帧具有优先权，可继续发送  
![1][1 14]  
**标准格式和扩展格式的优先级**  
标准格式的RTR位为显性位的具有优先权，可继续发送  
![1][1 15]

## bxCAN工作模式 ##

bxCAN有3个主要的工作模式：初始化、正常和睡眠模式

**初始化模式**  
设置CAN\_MCR寄存器的INRQ位为’1’，请求bxCAN进入初始化模式，然后等待硬件对CAN\_MSR寄存器的INAK位置’1’来进行确认

**正常模式**  
软件对CAN\_MCR寄存器的INRQ位清’0’，来请求从初始化模式进入正常模式，然后等待硬件对CAN\_MSR寄存器的INAK位置’1’的确认

**睡眠模式**  
软件对CAN\_MCR寄存器的SLEEP位置’1’，来请求进入这一模式

## 测试模式 ##

通过对CAN\_BTR寄存器的SILM和LBKM配置

**静默模式**（CAN\_Mode\_Silent）  
通过对CAN\_BTR寄存器的SILM位置’1’，来选择静默模式  
![1][1 16]  
**环回模式**（CAN\_Mode\_LoopBack）  
通过对CAN\_BTR寄存器的LBKM位置’1’，来选择环回模式  
![1][1 17]  
**环回静默模式**（CAN\_Mode\_Silent\_LoopBack）  
通过对CAN\_BTR寄存器的LBKM和SILM位同时置’1’，可以选择环回静默模式  
![1][1 18]

## 超过8字节数据发送 ##

可以采取拆包、组包方法。记录包id和是否为结尾包标识。接收方如果未接收完整个包，直到接收完整包再进行处理  
`详细参考：`uavcan

## CAN配置步骤 ##

> 1.使能CAN时钟  
> 2.使能GPIO端口时钟  
> 3.GPIO端口模式设置  
> 4.配置CAN工作模式、波特率等  
> 5.配置CAN筛选器  
> 6.选择CAN中断类型，开启中断  
> 7.初始化NVIC外设  
> 8.编写CAN中断处理函数  
> 9.CAN发送和接收消息  
> 10.CAN状态获取

![1][1 19]

## 硬件设计 ##

![1][1 20]  
![2][2 2]

## 举例 ##

![1][1 21]  
![2][2 3]

typedef struct
    { 
    	uint32_t StdId; //标准标识符
    	uint32_t ExtId; //扩展标识符
    	uint8_t IDE; //标识符选择
    	uint8_t RTR; //远程发送请求
    	uint8_t DLC; //发送数据长度
    	uint8_t Data[8]; //数据字节
    } CanTxMsg;
    
    void CAN_transmit(u8 *data, u8 len)
    { 
    	u8 i = 0, box;
    	CanTxMsg msg = { 0};
    	
    	msg.StdId = 0x12;
    	msg.ExtId = 0x12;
    	msg.IDE = CAN_Id_Standard; //使用标准标识符
    	msg.RTR = CAN_RTR_Data; //数据帧
    	msg.DLC = len;
    	
    	for(i = 0; i < len; i++)
    	{ 
    		msg.Data[i] = data[i];
    	}
    	
    	box = CAN_Transmit(CAN1, &msg);
    
    	while(CAN_TransmitStatus(CAN1, box) == CAN_TxStatus_Failed);
    	
    	return;
    }
    
    u8 CAN_receive(u8 *data)
    { 
    	u8 i = 0;
    	CanRxMsg msg = { 0};
    
    	if(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)
    	{ 
    		return 0;
    	}
    
    	CAN_Receive(CAN1, CAN_FIFO0, &msg);
    
    	for(i = 0; i < msg.DLC; i++)
    	{ 
    		 data[i] = msg.Data[i];
    	}
    
    	return msg.DLC;
    }
    
    #ifdef CAN_IT
    void USB_LP_CAN1_RX0_IRQHandler()
    { 
    	u8 data[8], len;
    	
    	if(CAN_GetITStatus(CAN1, CAN_IT_FMP0) == SET)
    	{ 
    		len = CAN_receive(data);
    
    		CAN_transmit(data, len);
    
    		led1 = ~led1;	
    	}
    
    	CAN_ClearFlag(CAN1, CAN_IT_FMP0);
    }
    #endif
    
    typedef struct
    { 
    	uint16_t CAN_Prescaler; //波特率分频器
    	uint8_t CAN_Mode; //测试模式
    	uint8_t CAN_SJW; //重新同步跳跃宽度
    	uint8_t CAN_BS1; //时间段1
    	uint8_t CAN_BS2; //时间段2
    	FunctionalState CAN_TTCM; //时间触发通信模式
    	FunctionalState CAN_ABOM; //自动离线管理
    	FunctionalState CAN_AWUM; //自动唤醒模式
    	FunctionalState CAN_NART; //禁止报文自动重传 
    	FunctionalState CAN_RFLM; //接收FIFO锁定模式
    	FunctionalState CAN_TXFP; //发送FIFO优先级
    } CAN_InitTypeDef;
    
    typedef struct
    { 
    	uint16_t CAN_FilterIdHigh;
    	uint16_t CAN_FilterIdLow;
    	uint16_t CAN_FilterMaskIdHigh;
    	uint16_t CAN_FilterMaskIdLow;
    	uint16_t CAN_FilterFIFOAssignment; //过滤器位宽设置
    	uint8_t CAN_FilterNumber;
    	uint8_t CAN_FilterMode; //过滤器模式
    	uint8_t CAN_FilterScale; //过滤器位宽设置
    	FunctionalState CAN_FilterActivation; //过滤器激活
    } CAN_FilterInitTypeDef;
    
    void CAN_init()
    { 
    	GPIO_InitTypeDef gpio11 = 
    	{ 
    		GPIO_Pin_11,
    		GPIO_Speed_50MHz,
    		GPIO_Mode_IPU
    	};	
    
    	GPIO_InitTypeDef gpio12 = 
    	{ 
    		GPIO_Pin_12,
    		GPIO_Speed_50MHz,
    		GPIO_Mode_AF_PP
    	};	
    
    	CAN_InitTypeDef can = { 0};
    	CAN_FilterInitTypeDef can_filter = { 0};
    
    	NVIC_InitTypeDef nvic = 
        { 
            USB_LP_CAN1_RX0_IRQn,
            2,
            2,
            ENABLE
        };
    
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
    	GPIO_Init(GPIOA, &gpio11);
    	GPIO_Init(GPIOA, &gpio12);
    
    	can.CAN_Prescaler = 4;
    	can.CAN_Mode = CAN_Mode_LoopBack; //环回模式
    	can.CAN_SJW = CAN_SJW_1tq; //占用1个时间单元
    	can.CAN_BS1 = CAN_BS1_9tq; //占用9个时间单元
    	can.CAN_BS2 = CAN_BS2_8tq; //占用8个时间单元
    	can.CAN_TTCM = DISABLE; //详见上图
    	can.CAN_ABOM = DISABLE;
    	can.CAN_AWUM = DISABLE;
    	can.CAN_NART = ENABLE;
    	can.CAN_RFLM = DISABLE;
    	can.CAN_TXFP = DISABLE;
    	CAN_Init(CAN1, &can);
    
    	can_filter.CAN_FilterIdHigh = 0;
    	can_filter.CAN_FilterIdLow = 0;
    	can_filter.CAN_FilterMaskIdHigh = 0;
    	can_filter.CAN_FilterMaskIdLow = 0;
    	can_filter.CAN_FilterFIFOAssignment = CAN_FilterFIFO0; //过滤器被关联到FIFO0
    	can_filter.CAN_FilterNumber = 0;
    	can_filter.CAN_FilterMode = CAN_FilterMode_IdMask; //过滤器组x的2个32位寄存器工作在标识符屏蔽位模式
    	can_filter.CAN_FilterScale = CAN_FilterScale_32bit;  //过滤器位宽为单个32位
    	can_filter.CAN_FilterActivation = ENABLE; //过滤器被激活
    	CAN_FilterInit(&can_filter);
    
    #ifdef CAN_IT
    	CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
    
    	NVIC_Init(&nvic);
    #endif
    }
    
    int main(void)
    { 
    	CAN_init();
    
    	for(i = 0; i < 8; i++)
    	{ 
    		txbuf[i] = i;
    	}
    	while(1)
    	{ 
    		led1 = ~led1;
    
    		CAN_transmit(txbuf, 8);
    		
    		res = CAN_receive(rxbuf);
    		if(res)
    		{ 
    			for(i = 0; i < 8; i++)
    			{ 
    				rxbuf[i] = rxbuf[i] + 0x30;
    			}
    			printf("CAN_receive len %d, %s\n", res, rxbuf);
    		}
    
    		delay_ms(1000);
    	}
    }

CAN过滤器组配置：[http://blog.csdn.net/zhangxuechao\_/article/details/78488603][http_blog.csdn.net_zhangxuechao_article_details_78488603]

[1]: /images/20220610/95267c7f0179427ea02d2352914dfc71.png
[1 1]: /images/20220610/876d00aeab2a41f4b866c65132bb7933.png
[1 2]: /images/20220610/4259022aa8e64b6d953510bc3650c6b3.png
[1 3]: /images/20220610/2e9b33848c704aeab0c3b8e6f15ebf06.png
[1 4]: /images/20220610/f6fc6e902ba3464ba474bef873bdd050.png
[1 5]: /images/20220610/26bd44269c97460d8d7f33654a083423.png
[2]: /images/20220610/9eb9893bc2574818a83876c64a81e770.png
[3]: /images/20220610/a81b2939d2474374852e0a0c6f6b180d.png
[1 6]: /images/20220610/181eddd822104e65aed3f7d84d274973.png
[1 7]: /images/20220610/98051c03ea9849f6845be7c98094dc42.png
[1 8]: /images/20220610/aff6d90c71984e96a42abfa280936019.png
[2 1]: /images/20220610/0667c114342443bca7b55249bffcf26c.png
[1 9]: /images/20220610/07865730b55b4d73993634c488832682.png
[1 10]: /images/20220610/36b38c7151ec4d21a8f08fbf95b8f551.png
[1 11]: /images/20220610/4bc737b516a64e4a923d6a530c7f04b2.png
[1 12]: /images/20220610/7704472c593f4ddab2574f87ff35f80d.png
[1 13]: /images/20220610/22ecb91bcbfc422598db9380222b18c2.png
[1 14]: /images/20220610/4d28872fdaaf426588e992ac6f1cfd10.png
[1 15]: /images/20220610/1b4bf67699af4d37b1816e7257157f0d.png
[1 16]: /images/20220610/0f791d10b72248629a4a93be82ce0e00.png
[1 17]: /images/20220610/4603d45111024f52b589dc8428cad5e8.png
[1 18]: /images/20220610/e54be3e4067148ef9ee1082f307217e4.png
[1 19]: /images/20220610/e6ba6c48d5a24394b5060212de4276ce.png
[1 20]: /images/20220610/484fa2ac115a4f6bb0465f3f9d182b6b.png
[2 2]: /images/20220610/df45eb7662784012a38186ec36fd4192.png
[1 21]: /images/20220610/010e31d6556045bc962615b1d6a90ee0.png
[2 3]: /images/20220610/72cb8f21b66a4319aae0f4f9c741e27e.png
[http_blog.csdn.net_zhangxuechao_article_details_78488603]: http://blog.csdn.net/zhangxuechao_/article/details/78488603