FPGA实现CAN通信CRC校验

最新推荐文章于 2022-06-10 20:00:46 发布
最新推荐文章于 2022-06-10 20:00:46 发布
阅读量2.5k 收藏 25
点赞数 5
分类专栏： FPGA 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40052606/article/details/123440113
版权
该博客介绍了如何在FPGA中实现CAN通信的CRC校验，包括并行和串行两种计算方法。并行方案适用于网络通信的32位CRC校验，而串行方案遵循CAN2.0协议，考虑到数据收发中的翻转电平参与计算。文中提供了详细的C语言实现和FPGA Verilog代码示例，经过验证，这些方案已被证明有效。
摘要由CSDN通过智能技术生成

FPGA实现CAN通信CRC校验

检验本质上是CRC检验生成多项式
理解CRC校验，首先需要了解生成多项式的概念，生成多项式也就是发送方和接受方约定的一个除数而已，发送方和接收方都使用这一个相同的除数进行模2运算，计算结果相同则说明传输数据没有问题，而如果计算结果不同可能传输的数据就出现了问题，目的就是为了保证数据传输的可靠性。
上面提到的模二计算本质上就是异或运算，相同的位为0，不同的位为1，也就是不考虑进位、错位的二进制加减法运算，例如：10011011 + 11001010 = 01010001.
常见的生成多项式：
CRC8 = X8 + X5 + X4 +1
CRC12 = X12 + X11 + X3 + X2 + 1
CRC16 = X16 + X15 + X5 +1
CRC15 =X15 + X14 + X10 + X8 + X7 + X4 + X3 + X0.
CRC32 = X32 + X26 + X23 + X22 + X16 + X12 + X11 + X10 + X8 + X7 + X5 + X4 + X2 + X1 + 1
每一个生成多项式都是与一个代码相对应的，比如CRC8对应的代码就是100110001

比如在实现网络通信时C语言校验实现如下

uint cal_crc(uchar *ptr, uchar len) { 
    uint crc; 
    uchar i; 
    crc=0; 
    while (len--!=0) { 
        for (i=0x80; i!=0; i/=2) { 
            if ((crc&0x8000)!=0){
                crc*=2; crc^=0x1021;
            } else crc*=2; 
            if ((*ptr&i)!=0)
                crc^=0x1021; 
        } 
    ptr++; 
    } 
    return(crc); 
}

用FPGA实现32位网络通信CRC检验码并行计算如下


`timescale 1ns / 1ps
module crc (Clk, Reset, Data, Enable, Crc,CrcNext);
parameter Tp = 1;
input Clk;
input Reset;
input [0:3] Data;
input Enable;
output [31:0] Crc;
reg  [31:0] Crc;
output [31:0] CrcNext;
assign CrcNext[0] = Enable & (Data[0] ^ Crc[28]); 
assign CrcNext[1] = Enable & (Data[1] ^ Data[0] ^ Crc[28] ^ Crc[29]); 
assign CrcNext[2] = Enable & (Data[2] ^ Data[1] ^ Data[0] ^ Crc[28] ^ Crc[29] ^ Crc[30]); 
assign CrcNext[3] = Enable & (Data[3] ^ Data[2] ^ Data[1] ^ Crc[29] ^ Crc[30] ^ Crc[31]); 
assign CrcNext[4] = (Enable & (Data[3] ^ Data[2] ^ Data[0] ^ Crc[28] ^ Crc[30] ^ Crc[31])) ^ Crc[0]; 
assign CrcNext[5] = (Enable & (Data[3] ^ Data[1] ^ Data[0] ^ Crc[28] ^ Crc[29] ^ Crc[31])) ^ Crc[1]; 
assign CrcNext[6] = (Enable & (Data[2] ^ Data[1] ^ Crc[29] ^ Crc[30])) ^ Crc[ 2]; 
assign CrcNext[7] = (Enable & (Data[3] ^ Data[2] ^ Data[0] ^ Crc[28] ^ Crc[30] ^ Crc[31])) ^ Crc[3]; 
assign CrcNext[8] = (Enable & (Data[3] ^ Data[1] ^ Data[0] ^ Crc[28] ^ Crc[29] ^ Crc[31])) ^ Crc[4]; 
assign CrcNext[9] = (Enable & (Data[2] ^ Data[1] ^ Crc[29] ^ Crc[30])) ^ Crc[5]; 
assign CrcNext[10] = (Enable & (Data[3] ^ Data[2] ^ Data[0] ^ Crc[28] ^ Crc[30] ^ Crc[31])) ^ Crc[6]; 
assign CrcNext[11] = (Enable & (Data[3] ^ Data[1] ^ Data[0] ^ Crc[28] ^ Crc[29] ^ Crc[31])) ^ Crc[7]; 
assign CrcNext[12] = (Enable & (Data[2] ^ Data[1] ^ Data[0] ^ Crc[28] ^ Crc[29] ^ Crc[30])) ^ Crc[8]; 
assign CrcNext[13] = (Enable & (Data[3] ^ Data[2] ^ Data[1] ^ Crc[29] ^ Crc[30] ^ Crc[31])) ^ Crc[9]; 
assign CrcNext[14] = (Enable & (Data[3] ^ Data[2] ^ Crc[30] ^ Crc[31])) ^ Crc[10]; 
assign CrcNext[15] = (Enable & (Data[3] ^ Crc[31])) ^ Crc[11]; 
assign CrcNext[16] = (Enable & (Data[0] ^ Crc[28])) ^ Crc[12]; 
assign CrcNext[17] = (Enable & (Data[1] ^ Crc[29])) ^ Crc[13]; 
assign CrcNext[18] = (Enable & (Data[2] ^ Crc[30])) ^ Crc[14]; 
assign CrcNext[19] = (Enable & (Data[3] ^ Crc[31])) ^ Crc[15]; 
assign CrcNext[20] = Crc[16]; 
assign CrcNext[21] = Crc[17]; 
assign CrcNext[22] = (Enable & (Data[0] ^ Crc[28])) ^ Crc[18]; 
assign CrcNext[23] = (Enable & (Data[1] ^ Data[0] ^ Crc[29] ^ Crc[28])) ^ Crc[19]; 
assign CrcNext[24] = (Enable & (Data[2] ^ Data[1] ^ Crc[30] ^ Crc[29])) ^ Crc[20]; 
assign CrcNext[25] = (Enable & (Data[3] ^ Data[2] ^ Crc[31] ^ Crc[30])) ^ Crc[21]; 
assign CrcNext[26] = (Enable & (Data[3] ^ Data[0] ^ Crc[31] ^ Crc[28])) ^ Crc[22]; 
assign CrcNext[27] = (Enable & (Data[1] ^ Crc[29])) ^ Crc[23]; 
assign CrcNext[28] = (Enable & (Data[2] ^ Crc[30])) ^ Crc[24]; 
assign CrcNext[29] = (Enable & (Data[3] ^ Crc[31])) ^ Crc[25]; 
assign CrcNext[30] = Crc[26]; 
assign CrcNext[31] = Crc[27]; 


always @ (posedge Clk or posedge Reset)
begin
  if (Reset)
    Crc <= #1 32'hffffffff;
  else if(Enable)
    Crc <= CrcNext;
end


endmodule

在实现CAN通信时是采用15位校验码。由于CAN在数据的收发中存在插入一个翻转电平，这个翻转电平实际上也是参与CRC计算的，因此采用并行的计算方法存在一定的问题，根据CAN2.0协议提供的串行实现方案来用FPGA实现。
CAN协议C语言实现方案如下

U16 Can_FD_Analyzer::MakeCRC15(std::vector<BitState> &bits, U32 num_bits)
{
    //X15 + X14 + X10 + X8 + X7 + X4 + X3 + X0.
    U16 CRC[15] = { 0 };
    for (U32 i = 0; i < num_bits; i++) {
        U32 DoInvert = (bits[i] == mSettings->Recessive()) ^ CRC[14]; //XOR required?
        CRC[14] = (CRC[13] ^ DoInvert); //14
        CRC[13] = CRC[12];
        CRC[12] = CRC[11];
        CRC[11] = CRC[10];
        CRC[10] = (CRC[9] ^ DoInvert); //10
        CRC[9] = CRC[8];
        CRC[8] = (CRC[7] ^ DoInvert); //8
        CRC[7] = (CRC[6] ^ DoInvert); //7
        CRC[6] = CRC[5];
        CRC[5] = CRC[4];
        CRC[4] = (CRC[3] ^ DoInvert); //4
        CRC[3] = (CRC[2] ^ DoInvert); //3
        CRC[2] = CRC[1];
        CRC[1] = CRC[0];
        CRC[0] = DoInvert;
    }
 
    U16 result = 0; // CRC Result
    for (U32 i = 0; i < 15; i++) {
        result = result | (CRC[i] << i);
    }
    return (U16)result;
}

FPGA串行方案实现如下：
这个是采用标准帧格式，8个字节数据的发送。

//
CIC
	

always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
can_data_crc		<= 'b0							;
end else if (can_data_in_en==1'b1) begin
can_data_crc		<= {1'b0,in_can_id[11:1],1'b0,2'b0,in_can_dlc,in_can_data};
end	
	
end 


always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
can_crc_en_flag		<= 'b0							;
end else if (can_data_in_en==1'b1) begin
can_crc_en_flag		<= 1'b1							;
end	
else if (can_crc_cont>=can_crc_contdata) begin 
can_crc_en_flag		<= 1'b0							;
end		
end 

always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
can_crc_en_flag_t		<= 'b0							;
end else  begin
can_crc_en_flag_t		<= can_crc_en_flag				;
end	
end 


always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
can_crc_contdata		<= 18							;
end else if (can_data_in_en==1'b1) begin
can_crc_contdata		<= 18 + {in_can_dlc,3'b0};
end	
else if (can_crc_cont>=can_crc_contdata) begin 
can_crc_contdata		<= 18							;
end	
end 

always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
can_crc_cont		<= 1'b0							;
end else if (can_crc_en_flag==1'b1) begin
can_crc_cont		<= can_crc_cont + 1'b1			;
end	
else begin 
can_crc_cont		<= 1'b0							;
end	
end 


always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
can_data_crc_t		<= 1'b0							;
end else if (can_data_in_en==1'b1) begin
can_data_crc_t		<= {1'b0,in_can_id[11:1],1'b0,2'b0,in_can_dlc,in_can_data}			;
end
else if (can_crc_en_flag==1'b1) begin
can_data_crc_t		<= {can_data_crc_t[81:0],1'b1}			;
end	
else  begin 
can_data_crc_t		<= 1'b0							;
end	
end 

reg				[14:0]		crc_now_data			;

always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
crc_now_data		<= 1'b0							;
end else if (can_crc_en_flag==1'b1) begin
crc_now_data		<= crc_now_next			;
end
else  begin 
crc_now_data		<= 1'b0							;
end	
end


always @(posedge clk_100m or negedge rst_n )begin
if(rst_n==1'b0) begin
crc_now		<= 1'b0							;
end else if ((can_crc_en_flag==1'b0)&&(can_crc_en_flag_t==1'b1)) begin
crc_now		<= crc_now_data			;
end
else if (tx_eof_flag==1'b1) begin 
crc_now		<= 1'b0							;
end	
end


assign		crc_first     	   =can_data_crc_t[82] ^ crc_now_data[14] ; 
assign		crc_now_next[14]   =  (	crc_now_data[13] ^ crc_first) ; 
assign		crc_now_next[13]   =  	crc_now_data[12]				 ; 
assign		crc_now_next[12]   =  	crc_now_data[11]				 ; 
assign		crc_now_next[11]   =  	crc_now_data[10]				 ; 
assign		crc_now_next[10]   =  (	crc_now_data[9] ^ crc_first)	 ; 
assign		crc_now_next[9]    =  	crc_now_data[8]				 ; 
assign		crc_now_next[8]    =  (	crc_now_data[7] ^ crc_first)	 ; 
assign		crc_now_next[7]    =  (	crc_now_data[6] ^ crc_first)	 ; 
assign		crc_now_next[6]    =  	crc_now_data[5]				 ; 
assign		crc_now_next[5]    =  	crc_now_data[4]				 ; 
assign		crc_now_next[4]    =  (	crc_now_data[3] ^ crc_first)	 ; 
assign		crc_now_next[3]    =  (	crc_now_data[2] ^ crc_first)	 ; 
assign		crc_now_next[2]    =  	crc_now_data[1]				 ; 
assign		crc_now_next[1]    =  	crc_now_data[0]				 ; 
assign		crc_now_next[0]    =  crc_first					 ;

上述FPGA实现CAN串行方案和网络32位CRC检验已经过长时间验证，可以使用

撕裂的牛仔裤
关注
专栏目录
基于FPGA的CAN IP协议详解
宝沐熙的博客
09-09 665
b. 0x000C (Bit Timing Register)寄存器：配置TSJW、TSEG2、TSEG1这三个时间参数，TSJW在数据的[8:7] 位，TSEG2在数据的[6:4] 位，TSEG1在数据的[3:0] 位，高[31:9]位未使用；为1时表示该MESSAGE为扩展数据帧，ID标识符有29bit（即IDR的[31:21]+ IDR的[18:1]=29bit）；d） IDR的[18:1]位ID[17:0]是扩展数据帧的后18bit标识符，当上面的IDE为1时有效；而通常TSJW的值设为1）
FPGA实现CAN接口
最新发布
ZdqDeveloper的博客
09-24 738
TX_identifier和TX_data是要发送的消息的标识符和数据，RX_identifier和RX_data是接收到的消息的标识符和数据。常用的差分信号对是CAN_H和CAN_L，分别用于传输CAN总线上的高电平和低电平信号。物理层使用差分对来驱动和接收CAN总线的信号，而协议层使用状态机来处理消息的发送和接收。通过以上的物理层和协议层的实现，我们可以在FPGA中实现CAN接口，实现车辆电子系统中的数据通信。在FPGA中实现CAN的协议层，我们可以使用状态机来处理消息的发送和接收。
基于FPGA的CRC原理实现
u010791260的专栏
05-15 3621
module CRC10 (Clock, Data_In, CRC_En, CRC_Clr, CRC_Out); input Clock; input CRC_En; input CRC_Clr; output [9:0] CRC_Out; //reg [9:0] CRC_Out; input [31:0] Data_In; reg CRC_En_reg; reg CRC_
CAN协议中CRC编码的硬件实现
木牛的博客
06-06 7229
针对CAN协议中提出的串行CRC检验原理，给出其硬件实现方法及具体实现时应需注意的技术问题，给出了RTL级的VHDL代码。 　　为了提高CRC编码的生成速度和CRC检验的效率，介绍了CRC检验的并行原理，并针对CAN协议中CRC编码的生成多项式推导出了8位并行CRC编码的逻辑关系式。最后对串行和并行两种实现方式进行了性能对比，并给出了为满足CAN协议而进行CRC编码时应注意的问题。  
FPGA实现CAN接口（SJA1000）
01-20
学无止境，善于积累，每天积累一点点，成功就在眼前，加油！ 1 CAN总线简介 CAN(Controller Area Network，控制器局域网 )总线是一个多主机异步串行总线,也是国际上应用最广泛的现场总线之一。在现场总线中，它是惟一被ISO国际标准化组织批准的现场总线。由于其成本低、容错能力强、支持分布式控制、通信速率高等优点在汽车、工业控制、航天等领域得到广泛应用。特别是由于CAN总线具有抗干扰性强、高数据传输率及低成本等优点，在小卫星和微小卫星中得到了越来越广泛的应用。 2 CAN硬件设计 传统的CAN通信系统通常采用MCU + SJA1000 + CAN总线收发器的架构，但是单片机
FPGA实现CAN通讯的例子
07-18
很好的解释了如何用FPGA控制外部独立的CAN控制器，对于CAN通讯的理解有很大帮助。
FPGA实现CAN总线控制器开源代码.zip
08-22
本代码是FPGA实现CAN总线控制器的开源代码，工程文件可直接通过ISE调试！
CAN总线通信的CRC校验方法
01-19
数据校验是为保证数据的完整性进行的一种验证操作。CAN通信采用CRC校验作为一种重要的错误检测手段，是节点判断CAN帧信息的完整性并产生确认应答的依据。 　　在现场总线通信和控制的实际应用中，工业应用环境往往是极端的温度以及电磁噪声或是其他的恶劣环境，系统在这种条件下能否正常工作至关重要，试想一下倘若生产线设备发送的位置信息在传输过程出现了错误，轻则可能造成生产瘫痪，重则可能导致设备损坏甚至人员伤害。 　　在CAN总线通信过程中CAN控制器具备完整的错误检测能力，其中包含：位错误检测、格式错误检测、填充错误检测、应答错误检测和CRC错误检测。作为一种重要的错误检测手段，CRC错误检测是接收
LabView图形化编程语言之CRC校验计算.zip
04-02
描述中提到的"LabView图形化编程语言之CRC校验计算.zip"可能包含一个或多个LabView项目文件，这些文件展示了如何使用LabView来实现CRC校验计算。用户可以通过打开这些文件，学习和理解CRC校验的实现细节，同时也可以...
FPGA实现CAN总线控制器源码,can总线编程,VHDL
09-10
4. **错误处理**：CAN协议有强大的错误检测和恢复机制，如位错误、CRC错误等，FPGA实现时需要实现这些功能，以保证通信的可靠性。 5. **VHDL编程**：使用VHDL进行控制器的设计，需要编写描述逻辑功能的代码，并进行...
FPGA实现CAN总线控制器源码.7z_通用总线usb控制器驱动器
01-19
1. **CAN协议解析**：这部分代码负责解析CAN总线的数据帧格式，包括仲裁段、控制段、数据段和CRC校验。CAN协议规定了两种帧类型：数据帧和远程帧，以及标准ID（11位）和扩展ID（29位）的区别。 2. **位填充与移除**...
fpga实现can总线
08-19
fpga实现can总线 can总线功能的verilog描述
CAN控制器fpga实现
12-19
通过在FPGA上实现CAN控制器代码，含有英文注释，生成IP软核
fpga实现CAN总线源码
08-13
FPGA实现CAN总线源码，对学习FPGA和CAN总线协议很有帮助
FPGA实现CAN总线控制器源码
02-05
很好的资源哦，希望大家一起分享，有不对之处请多提提意见
can总线crc校验实现
08-04
在实现CAN通信时，CRC校验是通过串行实现的。根据CAN2.0协议提供的串行实现方案，可以使用FPGA来实现CRC校验。具体的实现方案可以使用C语言来编写，通过对数据位进行逐位的计算和异或操作，最终得到CRC校验结果。[3]...
基于FPGA的CPCI-CAN通信卡电路设计-综合文档
05-18
CAN通信协议规定了数据帧的结构，包括仲裁字段、控制字段、数据字段和CRC校验等部分。在FPGA中实现CAN控制器时，需要精确控制时序，确保数据的正确发送和接收。此外，FPGA还需要具备错误检测和恢复机制，以应对CAN...
FPGA实现CAN通信
HackEle的博客
06-10 4168
1、CAN物理层和协议层CAN与串口类似，都是异步通信，利用两根差分线来进行信号的传输。在多节点进行数据传输时主要分为遵循ISO11898标准的高速短距离闭环形式和遵循ISO11519标准的低速远距离开环网络。这两种形式主要是在硬件设计时根据实际应用情况加入120欧姆或者2.2千欧姆电阻。在CAN通信时信号逻辑和平时常用的电平表示不太一样，根据标准电平表示形式如下图：CA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值