FPGA实现CAN通信

最新推荐文章于 2024-06-07 11:35:20 发布
最新推荐文章于 2024-06-07 11:35:20 发布
阅读量1.5w 收藏 281
点赞数 56
分类专栏： FPGA 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40052606/article/details/115896679
版权

FPGA实现CAN通信
1、CAN协议物理层和协议层
2、传输的波特率
3、FPGA实现思路
4、FPGA实现代码

1、CAN物理层和协议层
CAN与串口类似，都是异步通信，利用两根差分线来进行信号的传输。
在多节点进行数据传输时主要分为遵循ISO11898标准的高速短距离闭环形式和遵循ISO11519标准的低速远距离开环网络。这两种形式主要是在硬件设计时根据实际应用情况加入120欧姆或者2.2千欧姆电阻。
在CAN通信时信号逻辑和平时常用的电平表示不太一样，根据标准电平表示形式如下图：
在这里插入图片描述
在这里插入图片描述
CAN报文类型有5种，分别是数据帧、遥控帧、错误帧、过载帧、帧间隔。而我们常用的是数据帧，数据帧分为标准数据帧和扩展数据帧两种。数据帧结构如下图：
在这里插入图片描述
数据帧是以一个下降沿的电平来开始界定开始的。以7个连续隐性电平结束的。数据帧中间包含帧起始、仲裁段、控制段、数据段、CRC段、ACK段和帧结束段。
帧起始SOF段(Start Of Frame)，帧起始信号只有一个数据位，是一个显性电平，它用于监测数据传输的开始，通过电平跳变沿来进行数据起始位的确定。
仲裁段：内容是数据帧的ID信息，标准帧ID长度是11位，扩展帧为18位。CAN 协议不对挂载在它之上的节点分配优先级和地址，对总线的占有权是由帧的ID决定的，对于重要信息给与一个优先级较高的ID，这样数据就能及时的发送出去。而ID优先级的仲裁原则是由物理层决定的，总线状态总是显性电平掩盖隐形电平，因此显性ID优先级较高。
仲裁段还包括（1）RTR 位(Remote Transmission Request Bit)，译作远程传输请求位，它是用于区分数据帧和遥控帧的，当它为显性电平时表示数据帧，隐性电平时表示遥控帧。
(2) IDE 位(Identifier Extension Bit)，译作标识符扩展位，它是用于区分标准格式与扩展格式，当它为显性电平时表示标准格式，隐性电平时表示扩展格式。
(3) SRR 位(Substitute Remote Request Bit)，只存在于扩展格式，它用于替代标准格式中的
RTR 位。由于扩展帧中的SRR 位为隐性位，RTR 在数据帧为显性位，所以在两个ID相同的标准格式报文与扩展格式报文中，标准格式的优先级较高。
控制段：在控制段中的r1 和r0 为保留位，默认设置为显性位。它最主要的是DLC 段(Data
Length Code)，译为数据长度码，它由4 个数据位组成，用于表示本报文中的数据段含有多
少个字节，DLC 段表示的数字为0~8。
数据段：数据段为数据帧的核心内容，它是节点要发送的原始信息，由0~8 个字节组成，MSB先行。
CRC 段：为了保证报文的正确传输，CAN 的报文包含了一段15 位的CRC 校验码，一旦接收节点算出的CRC 码跟接收到的CRC 码不同，则它会向发送节点反馈出错信息，利用错误帧请求它重新发送。CRC 部分的计算一般由CAN 控制器硬件完成，出错时的处理则由软件控制最大重发数。
ACK 段：ACK 段包括一个ACK 槽位，和ACK 界定符位。类似I2C 总线，在ACK 槽位中，发送节点发送的是隐性位，而接收节点则在这一位中发送显性位以示应答。在ACK 槽和帧结束之间由ACK 界定符间隔开。
帧结束EOF 段(End Of Frame)，帧结束段由发送节点发送的7 个隐性位表示结束。

2、传输的波特率
CAN由于是异步通信，通信波特率与串口波特率定义类似，波特率的定义有每个子的长度来确定的。CAN的通信距离与波特率存在负相关关系，波特率越高，传输距离越短。CAN通信波特率与传输距离关系如下图：
在这里插入图片描述
3、FPGA实现思路
在进行FPGA实现时主要是实现一个完备的状态转移状态机。在设计状态机时需要对最复杂的包格式进行设计。通过对控制段进行判断来跳转到不同类型帧格式的状态，根据数据长度来完成对数据的接收和发送。由于FPGA实现完备的CAN收发驱动并不是所有项目所必须的，因此根据不同项目来进行特定包数据的收发。
通过上面描述对CAN数据格式有了一个基本上认识，下面是通过示波器抓取CAN标准数据帧波形，示波器正连接CANH端，示波器负极连接CANL端。波特率是10Kbps，有效数据长度8字节。
在这里插入图片描述

CAN数据收发架构设计如下图：
在这里插入图片描述
4、FPGA实现代码

在实现波特率可调的数据收发控制时需要注意的是每个波特数据的采样点。CAN数据采样时序如下图所示，一般采样点都是在数据稳当的中间点位置，因此在设计FPGA中CAN模块的时钟频率应当是数据波特率的20倍。
在这里插入图片描述
在以10Kbps采样率位例，CAN收发模块时钟设计如下：

//	
//数据速率位10Kbps，一个数据位时间为10us.数据采集在5us时刻。	
CAN波特率设置	
reg			[7:0]		can_div			;		//500倍分频，一个数据位分为20份
reg						can_clk			;	

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

//时钟经过BUFG缓冲
wire				can_clk_o		;  
BUFG   can_clk_obuf (.I(can_clk), .O(can_clk_o));

数据的收发需要根据实际的项目情况进行组包控制，这里就不进行细致描述了。
CAN实现数据的收发两个过程中对应FPGA来说由于接收相对复杂，就以接收模块进行描述。
数据的接收过程就按照一般的状态机进行设计就行，需要注意的是不同类型帧的跳转是在控制段进行了，因此在控制段会发生状态的跳转。CAN接收状态的状态机实现如下图：
在这里插入图片描述

这个状态机的实现并不复杂，主要是对帧类型进行判断。然后根据数据长度把数据解析出来。下面是实现CAN数据接收代码：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    
// Design Name: 
// Module Name:    can_rx 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module can_rx(

input   	wire		                can_clk	    				,
input   	wire		                rst_n       				,
				
input		wire						can_rx						,
		
output		reg							can_ack_out_low				,
output		reg							can_id_out_en				,
output		reg			[10:0]			can_id_out					,
output		reg							can_data_out_en				,
output		reg			[63:0]			can_data_out		
		
    );		
		
reg					[8:0]			state							;
reg									can_rx_t						;
reg									error_state						;
reg					[9:0]			error_data						;
reg					[4:0]			one_bit_cont					;
reg					[10:0]			can_id							;
reg					[6:0]			bit_cont						;
reg									id_en_flag						;
reg									contral_flag					;
reg									data_en_flag					;
reg									cic_en_flag						;
reg									can_rx_en_flag					;
reg									can_rx_unen_flag				;
reg					[4:0]			can_continuity_data				;
reg									can_continuity_data_flag		;
reg					[4:0]			can_id_data_cont				;
reg					[3:0]			can_contral_data_cont			;
reg					[6:0]			can_data_data_cont				;
reg					[4:0]			can_cic_data_cont				;


always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_rx_t	<= 'b0							;
end else  begin
can_rx_t	<= can_rx						;
end	
end 


parameter			state_idle		 = 9'b000000000			;			//状态机初始化
parameter			state_start		 = 9'b000000001			;			//监测到开始标志
parameter			state_sof		 = 9'b000000010			;           //开始帧头第一位SOF
parameter			state_id		 = 9'b000000100			;           //包ID
parameter			state_control	 = 9'b000001000			;           //标准帧控制段
parameter			state_data		 = 9'b000010000			;           //数据段
parameter			state_crc		 = 9'b000100000			;           //CRC段
parameter			state_ack		 = 9'b001000000			;           //ACK段
parameter			state_eof		 = 9'b010000000			;           //帧结束段
parameter			state_end		 = 9'b100000000			;           //状态机结束状态

parameter			bit_flag_no		 = 5'b10011				;		


always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
state						<= 'b0							;
one_bit_cont				<= 'b0							;
bit_cont					<= 'b0							;
id_en_flag					<= 'b0							;
contral_flag				<= 'b0							;
data_en_flag                <= 'b0							;
cic_en_flag					<= 'b0							;
can_rx_en_flag              <= 'b0							;
can_ack_out_low				<= 'b1							;
end   else case(state) 
		state_idle:		begin if ((can_rx_t==1'b1)&&(can_rx==1'b0))	begin
							state						<= state_sof					;
							one_bit_cont				<= 'b0							;
							can_rx_en_flag              <= 'b1							;
					end else begin
							state						<= state_idle					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
							id_en_flag					<= 'b0							;
							contral_flag                <= 'b0							;
							data_en_flag				<= 'b0							;
							cic_en_flag	                <= 'b0							;
							can_rx_en_flag              <= 'b0							;
							can_ack_out_low				<= 'b1							;
					end 
					end 
		state_sof:		begin if ((one_bit_cont==bit_flag_no)&&(can_rx==1'b0))	begin
							state						<= state_id						;
							id_en_flag					<= 'b1							;
							one_bit_cont				<= 'b0							;
					end else if ((one_bit_cont<bit_flag_no)&&(can_rx==1'b0)) begin
							state						<= state_sof					;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end 
					end 
		state_id:		begin if ((one_bit_cont==bit_flag_no)&&(bit_cont==can_id_data_cont))	begin
							state						<= state_control				;
							id_en_flag					<= 'b0							;
							contral_flag				<= 'b1							;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
					end else if ((one_bit_cont==bit_flag_no)&&(bit_cont<can_id_data_cont)) begin
							state						<= state_id						;
							one_bit_cont				<= 'b0							;
							bit_cont					<= bit_cont + 1'b1				;
					end else if (one_bit_cont<bit_flag_no) begin
							state						<= state_id						;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end else begin
							state						<= state_idle					;
					end 
					end 
		state_control:	begin if ((one_bit_cont==bit_flag_no)&&(bit_cont==can_contral_data_cont))	begin
							state						<= state_data					;
							contral_flag				<= 'b0							;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
							data_en_flag                <= 'b1							;
					end else if ((one_bit_cont==bit_flag_no)&&(bit_cont<can_contral_data_cont)) begin
							state						<= state_control				;
							one_bit_cont				<= 'b0							;
							bit_cont					<= bit_cont + 1'b1				;
					end else if (one_bit_cont<bit_flag_no) begin
							state						<= state_control				;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end else begin
							state						<= state_idle					;
					end 
					end 
		state_data:	begin if ((one_bit_cont==bit_flag_no)&&(bit_cont==can_data_data_cont))	begin
							state						<= state_crc					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
							data_en_flag                <= 'b0							;
							cic_en_flag					<= 'b1							;
					end else if ((one_bit_cont==bit_flag_no)&&(bit_cont<can_data_data_cont)) begin
							state						<= state_data					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= bit_cont + 1'b1				;
					end else if (one_bit_cont<bit_flag_no) begin
							state						<= state_data					;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end else begin
							state						<= state_idle					;
					end 
					end 
		state_crc:	begin if ((one_bit_cont==bit_flag_no)&&(bit_cont==can_cic_data_cont))	begin
							state						<= state_ack					;
							can_ack_out_low				<= 'b0							;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
							cic_en_flag					<= 'b0							;
					end else if ((one_bit_cont==bit_flag_no)&&(bit_cont<can_cic_data_cont)) begin
							state						<= state_crc					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= bit_cont + 1'b1				;
					end else if (one_bit_cont<bit_flag_no) begin
							state						<= state_crc					;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end else begin
							state						<= state_idle					;
					end 
					end 
		state_ack:	begin if ((one_bit_cont==bit_flag_no)&&(bit_cont==1))	begin
							state						<= state_eof					;
							can_ack_out_low				<= 'b1							;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
					end else if ((one_bit_cont==bit_flag_no)&&(bit_cont<1)) begin
							state						<= state_ack					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= bit_cont + 1'b1				;
					end else if (one_bit_cont<bit_flag_no) begin
							state						<= state_ack					;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end else begin
							state						<= state_idle					;
					end 
					end 
		state_eof:	begin if ((one_bit_cont==bit_flag_no)&&(bit_cont==5))	begin
							state						<= state_end					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
					end else if ((one_bit_cont==bit_flag_no)&&(bit_cont<5)) begin
							state						<= state_eof					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= bit_cont + 1'b1				;
					end else if (one_bit_cont<bit_flag_no) begin
							state						<= state_eof					;
							one_bit_cont				<= one_bit_cont + 1'b1			;
					end else begin
							state						<= state_idle					;
					end 
					end 
		state_end:		begin 
							state						<= state_idle					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
							id_en_flag					<= 'b0							;
							contral_flag                <= 'b0							;
							data_en_flag				<= 'b0							;
							cic_en_flag	                <= 'b0							;
							can_rx_en_flag              <= 'b0							;
							can_ack_out_low				<= 'b1							;
					end 			
		default:		begin 
							state						<= state_idle					;
							one_bit_cont				<= 'b0							;
							bit_cont					<= 'b0							;
							id_en_flag					<= 'b0							;
							contral_flag                <= 'b0							;
							data_en_flag				<= 'b0							;
							cic_en_flag	                <= 'b0							;
							can_rx_en_flag              <= 'b0							;
							can_ack_out_low				<= 'b1							;
					end 	 
		endcase
end 

//always @(posedge can_clk or negedge rst_n )begin
//if(rst_n==1'b0) begin
//error_data	<= 'b0									;
//end else if (can_rx_en_flag==1) begin
//error_data	<= {error_data[9:0],can_rx	}				;
//end	else if (one_bit_cont==11) begin
//can_rx_unen_flag	<= 1'b0									;
//end else if (can_rx_en_flag==0)
//can_rx_unen_flag	<= 'b0									;
//end 



always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_continuity_data			<= 5'b11111								;
can_continuity_data_flag	<= 'b0									;
end else if ((one_bit_cont==9)&&(can_rx_en_flag==1)) begin
can_continuity_data			<= {can_continuity_data[3:0],can_rx}	;
can_continuity_data_flag	<= 'b0												;
end	else if (((can_continuity_data==0)||(can_continuity_data==5'b11111))&&(one_bit_cont==10)&&(cic_en_flag==0)) begin
can_continuity_data_flag	<= 'b1									;
end else if (((can_continuity_data==0)||(can_continuity_data==5'b11111))&&(one_bit_cont==10)&&(cic_en_flag==1)&&(bit_cont<14)) begin
can_continuity_data_flag	<= 'b1									;
end else if (can_rx_en_flag==0) begin
can_continuity_data			<= 5'b11111								;
can_continuity_data_flag	<= 'b0									;
end else begin
can_continuity_data_flag	<= 'b0									;
end
end  


always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_rx_unen_flag	<= 'b0									;
end else if ((can_rx_en_flag==1)&&(can_continuity_data_flag==1)&&(cic_en_flag==0)) begin
can_rx_unen_flag	<= 1'b1									;
end	 else if ((can_rx_en_flag==1)&&(can_continuity_data_flag==1)&&(cic_en_flag==1)&&(bit_cont<14)) begin
can_rx_unen_flag	<= 1'b1									;
end else if (one_bit_cont==11) begin
can_rx_unen_flag	<= 1'b0									;
end else if (can_rx_en_flag==0)
can_rx_unen_flag	<= 'b0									;
end 


always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_id_data_cont			<= 'd10									;
end else if ((id_en_flag==1)&&(can_continuity_data_flag==1)) begin
can_id_data_cont			<= can_id_data_cont			+ 1'b1		;
end	else if (id_en_flag==0)  
can_id_data_cont			<= 'd10									;
end 

always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_contral_data_cont		<= 'd6									;
end else if ((contral_flag==1)&&(can_continuity_data_flag==1)) begin
can_contral_data_cont		<= can_contral_data_cont	+ 1'b1		;
end	else if (contral_flag==0) 
can_contral_data_cont		<= 'd6									;
end 

always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_data_data_cont			<= 'd63									;
end else if ((data_en_flag==1)&&(can_continuity_data_flag==1)) begin
can_data_data_cont			<= can_data_data_cont		+ 1'b1		;
end	else if (data_en_flag==0)  
can_data_data_cont			<= 'd63									;
end 

always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_cic_data_cont			<= 'd15									;
end else if ((cic_en_flag==1)&&(can_continuity_data_flag==1)) begin
can_cic_data_cont			<= can_cic_data_cont		+ 1'b1		;
end	 else if (cic_en_flag==0) 
can_cic_data_cont			<= 'd15									;
end 

///

always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_id_out	<= 'b0										;
end else if ((one_bit_cont==9)&&(id_en_flag==1)&&(can_rx_unen_flag==0)) begin
can_id_out	<= {can_id_out[9:0],can_rx	}				;
end	
end 

always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_id_out_en	<= 'b0									;
end else if ((one_bit_cont==9)&&(bit_cont==can_id_data_cont)&&(id_en_flag==1)) begin
can_id_out_en	<= 1'b1									;
end	else 
can_id_out_en	<= 'b0									;
end 


always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_data_out	<= 'b0										;
end else if ((one_bit_cont==9)&&(data_en_flag==1)&&(can_rx_unen_flag==0)) begin
can_data_out	<= {can_data_out[62:0],can_rx	}				;
end	
end 

always @(posedge can_clk or negedge rst_n )begin
if(rst_n==1'b0) begin
can_data_out_en	<= 'b0									;
end else if ((bit_cont==can_data_data_cont)&&(one_bit_cont==9)&&(data_en_flag==1)) begin
can_data_out_en	<= 1'b1									;
end	else 
can_data_out_en	<= 'b0									;
end 

/


endmodule

在完成上述代码编写后通过CAN收发器发送数据然后利用chipscop进行数据的抓取。
数据发送如下图所示：
在这里插入图片描述

对上述代码测试时抓取到数据波形如下图：
在这里插入图片描述
从图中可以看出接收了一包完整的标准数据帧。在通过CAN调试工具进行数据的发送测试时：CAN调试工具每秒发送60包，测试了一个小时，没有出现接收数据错误。
然而在实现CAN通信时在满足一般的代码编写的情况下有两点需要特别的注意：
1、CAN2.0的协议规定，连续5个显性/隐性电平后，要填充一位隐性/显性电平。
2、在can协议中将CAN_H和CAN_L的差值为高电平时定义为显性，逻辑上表示为0，为低电平时定义为隐形，逻辑上表示为1。
（有需要代码的可以复制）

撕裂的牛仔裤
关注
  • 56
    点赞
  • 踩
  • 281
    收藏
    觉得还不错? 一键收藏
  • 68
    评论
专栏目录
FPGA实现CAN接口（SJA1000）
01-20
学无止境，善于积累，每天积累一点点，成功就在眼前，加油！ 1 CAN总线简介 CAN(Controller Area Network，控制器局域网 )总线是一个多主机异步串行总线,也是国际上应用最广泛的现场总线之一。在现场总线中，它是惟一被ISO国际标准化组织批准的现场总线。由于其成本低、容错能力强、支持分布式控制、通信速率高等优点在汽车、工业控制、航天等领域得到广泛应用。特别是由于CAN总线具有抗干扰性强、高数据传输率及低成本等优点，在小卫星和微小卫星中得到了越来越广泛的应用。 2 CAN硬件设计 传统的CAN通信系统通常采用MCU + SJA1000 + CAN总线收发器的架构，但是单片机
基于FPGA的CAN通讯verilog代码设计
weixin_48245999的博客
04-26 2703
verilog编写can通讯 并在fpga板子上实现数据传输
基于FPGA和VHDL编写的SJA1000控制器实现CAN通信，通过上位机发送指令，实现遥测数据的返回，使用FPGA和VHDL编写SJA1000的CAN通信模块，实现通过上位机发送数据并实现遥测返回功
最新发布
oizFamOamp的博客
06-07 428
CAN通信协议的可靠性和高效性，以及SJA1000芯片在FPGA中的优越性能，使得这样的系统具备了较好的实时性和可扩展性。在未来的工作中，我们可以进一步研究和开发基于SJA1000和FPGA的CAN通信系统，为工业和汽车电子领域提供更加可靠和高效的解决方案。SJA1000芯片是一种常用的CAN控制器，它可以与FPGA等逻辑器件相结合，实现高性能的CAN通信系统。SJA1000是一种广泛应用于CAN通信的芯片，它的出现为各种工业控制系统和汽车电子系统提供了方便和高效的数据传输解决方案。
基于FPGA的CAN通信：实现标准帧与扩展帧的驱动，详解CAN SJA1000T芯片代码
pSBiRBll的博客
04-29 370
基于FPGA的CAN通信系统的设计流程如下：首先，需要对CAN通信的硬件连接进行设计，包括CAN控制器、CAN收发器以及外部电路的设计与布线。在编写驱动代码的过程中，需要考虑CAN帧的发送和接收、CAN帧的过滤和屏蔽等功能的实现。通过FPGA驱动SJA1000T芯片的代码，可以实现对CAN总线的全面控制和管理，实现标准帧与扩展帧的通信。已经将该系统上板并调通，验证了其可靠性和性能。基于FPGA的CAN通信，FPGA驱动SJA1000T芯片代码，实现标准帧与扩展帧的通信驱动，已上板调通，价格美丽，欢迎咨询。
【科普】CAN总线介绍及FPGA实现方案简介
HackEle的博客
01-22 448
点击蓝字关注我们关注、星标公众号，精彩内容每日送达 来源：网络素材【科普】CAN总线介绍及FPGA实现方案简介这里我们先逆推一下CAN总线的一些特点。第一，CAN总线分层结构我们根据can总线具有的一些特性可知：CAN总线肯定具有分层结构，而且参考OSI模型（OSI参考模型介绍）是肯定的，我们可以看一下相关的文档可知：CAN遵从OSI模型。上面这一点大部分人都是熟知的。第二、CAN总线分为哪几层根...
基于FPGA的CAN通信，FPGA驱动SJA1000T芯片代码，实现标准帧与扩展帧的通信驱动，已上板调通
eETkyiunW的博客
11-20 870
在CAN通信中，数据是通过数据帧进行传输的。总之，基于FPGA的CAN通信，FPGA驱动SJA1000T芯片代码的实现，可以实现标准帧与扩展帧的通信驱动。需要注意的是，在实现过程中，需要对CAN通信的原理、FPGA编程、数据处理等方面有深入的了解，才能实现高效、可靠的通信。本文将从多个角度对基于FPGA的CAN通信进行分析，并介绍如何使用FPGA驱动SJA1000T芯片实现标准帧与扩展帧的通信驱动。基于FPGA的CAN通信，FPGA驱动SJA1000T芯片代码，实现标准帧与扩展帧的通信驱动，已上板调通。
基于FPGA的CAN总线通信系统的设计.pdf
07-13
基于FPGA的CAN总线通信系统的设计.pdf
基于FPGA的CAN接口开发
皇甫春云的博客
06-28 8288
基于Xilinx的A7系列FPGA的CAN总线协议开发 一、CAN总线协议介绍 CAN是 Controller Area Network 的缩写（以下称为 CAN ），是 ISO 国际标准化的串行通信协议。可以用来满足“多总线通信时，线束的数量过多”、“通过多个 LAN ，进行大量数据的高速通信”的需要。它的出现为分布式控制系统实现各节点之间实时、可靠的数据通信提供了强有力的技术支持。 CAN控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发送方通过使总线电平发生变化
CAN协议FPGA篇
weixin_66634995的博客
12-26 1564
CAN（Controller Area Network）总线，即控制器局域网总线，是一种功能丰富的车用总线标准。该协议最初是由德国博世（Bosch）公司在1983年制定的，之后在美国密歇根州底特律举行的汽车工程师协会(SAE) 会议上正式发布推出。1987年，Intel公司推出的首款CAN总线芯片（82526）上市销售。1991年，奔驰汽车发布的第一款基于CAN总线的多路布线系统汽车——W140量产，1993年，国际标准化组织（ISO）发布了CAN标准ISO 11898。
用FPGA实现SPI通信
csdnqiang的博客
09-01 5234
SPI是串行外设接口(Serial Peripheral Interface)的缩写。它是Motorola公司推出的一种高速、全双工的同步串行通信总线技术。 SPI的通信接口为：SDI或MISO（数据输入），SDO或MOSI（数据输出），SCK（时钟），CS（片选）。 另外，可以通过设置CPOL（时钟极性）和CPHA（时钟相位）来配置主控设备的通信模式。其中时钟极性CPOL用来配置SCLK的空闲态或者有效态电平，时钟相位CPHA 用来配置数据采样是在第几个边沿： CPOL=0，表示SCLK的空闲态电平为0，
FPGA 之串口通信协议
Leexiao1933的博客
06-14 4668
串口通信协议串口通信（UART）是一种用两线（Rx【发送端】 、Tx【接收端】）实现的异步、全双工通信方式。由于串口通信没有时钟信号线，由此而出现波特率（BaundRate），即接收和发送双方规定好相同的波特率；以此来保证传送的数据的正确性；                ※波特率：一秒钟内传送的字节数目。如下图1是串口通信协议（UART Protocol），分为五个阶段分别为：起始位（Start...
FPGA实现CAN总线控制器源码_CAN-verilog_fpga_fpga实现CAN_SAj1000连接fpga_
10-01
在本项目中，我们将关注如何使用FPGA（Field-Programmable Gate Array）来实现CAN控制器，具体是基于Verilog硬件描述语言实现SAJ1000 CAN控制器。 首先，Verilog是一种用于数字逻辑设计的硬件描述语言，它允许...
基于FPGA实现CAN数据传输与验证.pdf
03-21
通过 FPGA 控制 SJA1000 实现 CAN 总线通信。 CAN 总线高达 1Mbit/s通讯速率已经进行实际验证。
FPGA实现CAN总线控制器源码,can总线编程,Verilog
09-10
本主题聚焦于如何利用FPGA（Field-Programmable Gate Array）来实现CAN总线控制器的源码设计，这涉及到硬件描述语言Verilog的编程知识。 首先，了解CAN总线的基本原理是必要的。CAN总线采用多主站方式工作，通过...
一种高速1553B总线通信接口模块
测试专家的专栏
10-12 441
一种高速1553B总线通信接口模块的设计与实现方法。该模块不仅具有高可靠性、实时性和可扩展性，同时还具备良好的维护性能和使用体验。
FPGA实现的CAN控制器Verilog，节省电路板面积，提供完整资料包及仿真激励文件
PDMNxGfLhWG的博客
05-01 68
通过FPGA控制器Verilog的应用，可以实现CAN控制器的功能，并且有效地节省了电路板的面积。本文将详细介绍FPGA控制器的Verilog代码、仿真激励文件testbench以及相关工程的提供情况，同时提供了Quartus II 13.0的安装包和破解方式。本文通过对FPGA控制器Verilog的研究与开发，成功实现了CAN控制器的功能，并且在电路板中进行了有效验证。本文提供了FPGA控制器Verilog的详细代码，通过对这些代码的研究和理解，可以更好地应用于实际项目中。
（44）FPGA实现CAN接口（一）
m0_46498597的博客
02-06 411
（a）IIC 即 Inter-Integrated Circuit（集成电路总线），这种总线类型是由飞利浦半导体公司在八十年代初设计出来的一种简单、双向、二线制、同步串行总线。（b）IIC 总线是一种串行数据总线，只有二根信号线，一根是双向的数据线 SDA，另一根是时钟线 SCL，两条线可以挂多个设备。I²C 设备（绝大多数）里有个固化的地址，只有在两条线上传输的值等于 I²C 设备的固化地址时，其才会作出响应。
fpga实现can通信协议
12-07
FPGA（Field Programmable Gate Array）是一种可编程逻辑设备，可以在硬件级别上定义和重新配置数字逻辑电路。CAN（Controller Area Network）是一种常用的网络通信协议，广泛应用于汽车和工业领域。 FPGA实现CAN通信协议的过程主要分为两个步骤：硬件设计和软件开发。 在硬件设计方面，首先需要将CAN协议的控制器部分实现在FPGA中。控制器负责管理发送和接收CAN消息的过程。它包括了CAN协议的帧解析、错误检测和错误处理等功能。这些功能需要通过FPGA的逻辑电路来实现。根据CAN协议的规范，可以使用状态机设计来描述控制器的不同工作状态，并通过逻辑电路来实现状态转换和相关功能逻辑。 在软件开发方面，需要编写控制器的驱动程序。驱动程序可以通过FPGA的配置界面进行编程，与硬件部分进行通信，控制CAN消息的发送和接收。驱动程序还需提供CAN消息的解析和打包的功能，以及与其他设备（如处理器或外部存储器）进行数据传输的接口。 在实现CAN通信协议时，还需要考虑到数据的实时性和可靠性。数据的实时性是指在CAN总线上传输的数据时序要符合CAN协议要求，以确保数据的及时性和准确性。数据的可靠性则是指要进行错误检测和纠正，以防止数据传输过程中的错误。 总之，FPGA实现CAN通信协议涉及硬件和软件两个方面的设计和开发工作。通过将CAN协议的控制器部分实现在FPGA中，以及编写相关的驱动程序，可以实现高性能、可靠的CAN通信功能。
评论 68
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值