I2C FPGA实现

最新推荐文章于 2024-06-03 15:52:49 发布
最新推荐文章于 2024-06-03 15:52:49 发布
阅读量2.9k 收藏 22
点赞数 1
分类专栏： FPGA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dataiyangnishuo/article/details/78144440
版权

近期，做SRIO switch 调试，需要用I2C接口来 读写switch的寄存器。现将I2C的代码整理如下。

module iic_wr_ctrl
(
	input								sys_clk,				
	input								rst_n,				
	input								key_wr,				
	input								key_rd,				
	inout								sda,					
	output	reg				 	scl,				
	output	   				 	clk,				
	output	   				 	ila_clk,				
	output	   				 	link_sda,				
	output	reg		[7:0] 	data,		
	output	reg		[7:0] 	data2,		
	output	         [7:0]	   state,  		
	output	         [3:0]	   count,  		
	output	         [7:0]	   eeprom_data,  		
//	input	            [6:0]	   IIC_ADDR,		
	input	            [23:0]	 IIC_ADDRESS	,
	input					[31:0]	write_data
);

	reg		[6:0]				cnt;			
	reg		[6:0]				cnt_1;			
	reg		[3:0]				count;
	reg							clk;
	reg							ila_clk;
	reg							wr;
	reg							rd;
	reg							link_sda;
	reg							sda_buf;
	reg		[7:0] 			eeprom_data;
	reg		[7:0] 			state;
	reg		[3:0] 			led;

	assign	sda = (link_sda)? sda_buf : 1'bz;
	
	always@(posedge sys_clk or negedge rst_n)
	begin
		if(!rst_n)
			begin
				cnt <= 0;
				clk <= 0;
			end
		else if(cnt < 125)
			begin
				cnt <= cnt + 1;
			end
		else
			begin
				cnt <= 0;
				clk <= ~clk;
			end
	end
	
	always@(posedge sys_clk or negedge rst_n)
	begin
		if(!rst_n)
			begin
				cnt_1 <= 0;
				ila_clk <= 0;
			end
		else if(cnt_1 < 62)
			begin
				cnt_1 <= cnt_1 + 1;
			end
		else
			begin
				cnt_1 <= 0;
				ila_clk <= ~ila_clk;
			end
	end
	
	always@(negedge clk or negedge rst_n)
	begin
		if(!rst_n)
			scl <= 0;
		else
			scl <= ~scl;
	end
	产生SCL时钟信号  
	
	
	always@(posedge clk or negedge rst_n)
	begin
		if(!rst_n)
			begin
				state <= 8'h0;
				wr <= 0;
				rd <= 0;
				count <= 0;
				link_sda <= 0;
				sda_buf <= 0;
				eeprom_data <= 0;
				data <= 0;
				data2 <= 0;
				led <= 4'b0000;
			end
		else
			begin
				case(state)
					8'h0: begin
							if(!key_rd)
								rd <= 1;
							else if(!key_wr)
								wr <= 1;																				
							else if(!scl && (rd || wr))
								begin
									link_sda <= 1;
									sda_buf <= 1;
									state <= 8'h1;
									data <= 0;
				               data2 <= 0;
								end
							else
								state <= 8'h0;
						end
					8'h1: begin
							if(scl)
								begin
									sda_buf <= 0;
									state <= 8'h2;
									eeprom_data <= {7'b1010111,1'b0};   //8'b1000_0100         //device ID
								end
							else
								state <= 8'h1;
						end
					8'h2: begin
							if(!scl && count < 8)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0], eeprom_data[7]};
									sda_buf <= eeprom_data[7];									
								end 
							else if(count == 8 && !scl)
								begin
									count <= 0;
								//	eeprom_data <= 0;
									link_sda <= 0;
									state <= 8'h3;
								end
							else
								state <= 8'h2;
					   end 
					8'h3: begin
							if(scl)
								begin
									if(!sda)
										begin
											state <= 8'h4;
											eeprom_data <= IIC_ADDRESS[23:16];							//addr [23:16]
										end
								end
						end
					8'h4: begin
							link_sda <= 1;
							if(count < 8 && !scl)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(count == 8 && !scl)
								begin
									count <= 0;
									state <= 8'h23;
									link_sda <= 0;
								end
							else
								state <= 8'h4;
						end
					8'h23: begin
							if(scl)
								begin
									if(!sda)
										begin
											state <= 8'h24;
											eeprom_data <= IIC_ADDRESS[15:8];   					addr [15:8]
										end
								end
						end
					8'h24: begin
							link_sda <= 1;
							if(count < 8 && !scl)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(count == 8 && !scl)
								begin
									count <= 0;
									state <= 8'h25;
									link_sda <= 0;
								end
							else
								state <= 8'h24;
						end
					8'h25: begin
							if(scl)
								begin
									if(!sda)
										begin
											state <= 8'h26;
											eeprom_data <= IIC_ADDRESS[7:0];   					addr [7:0]
										end
								end
						end
					8'h26: begin
							link_sda <= 1;
							if(count < 8 && !scl)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(count == 8 && !scl)
								begin
									count <= 0;
									state <= 8'h5;
									link_sda <= 0;
								end
							else
								state <= 8'h26;
						end
					8'h5: begin
							if(scl)
								begin
									if(!sda)
										begin
											if(wr == 1)
												begin
													state <= 8'h6;
													eeprom_data <= write_data[31:24];        //		data[31:24]
												end
											else if(rd == 1)
												begin
													state <= 8'h9;
												end
										end
								end
						end
					8'h6: begin
							link_sda <= 1;
							if(!scl && count < 8)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(!scl && count == 8)
								begin
									count <= 0;
									link_sda <= 0;
									state <= 8'h7;
								end
							else
								state <= 8'h6;
						end	
					8'h7: begin
							if(scl)
								begin
									if(!sda)
                           begin									
										state <= 8'h14;
										eeprom_data <=  write_data[23:16];						//data[23:16]
									end
								end
						end
						
						
					8'h14: begin
							link_sda <= 1;
							if(!scl && count < 8)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(!scl && count == 8)
								begin
									count <= 0;
									link_sda <= 0;
									state <= 8'h27;
								end
							else
								state <= 8'h14;
						end	
					8'h27: begin
							if(scl)
								begin
									if(!sda)
                           begin									
										state <= 8'h28;
										eeprom_data <= write_data[15:8];						//data[15:8]
									end
								end
						end
						
						
					8'h28: begin
							link_sda <= 1;
							if(!scl && count < 8)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(!scl && count == 8)
								begin
									count <= 0;
									link_sda <= 0;
									state <= 8'h29;
								end
							else
								state <= 8'h28;
						end					
					8'h29: begin
							if(scl)
								begin
									if(!sda)
                           begin									
										state <= 8'h2A;
										eeprom_data <= write_data[7:0];						//data[7:0]
									end
								end
						end
						
						
					8'h2A: begin
							link_sda <= 1;
							if(!scl && count < 8)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0],eeprom_data[7]};
									sda_buf <= eeprom_data[7];
								end
							else if(!scl && count == 8)
								begin
									count <= 0;
									link_sda <= 0;
									state <= 8'h8;
								end
							else
								state <= 8'h2A;
						end	
						
	
					8'h8: begin
							link_sda <= 1;
							sda_buf <= 0;
							if(scl)
								begin
									sda_buf <= 1;
									led <= 4'b0001;
									wr <= 0;
									state <= 8'h0;
								end
							else
								state <= 8'h8;	
						end
					8'h9: begin							
							if(!scl)
								begin
									link_sda <= 1;
									sda_buf <= 1;
									state <= 8'hA;
								end
							else
								state <= 8'h9;
						end
					8'hA: begin
							if(scl)
								begin
									sda_buf <= 0;
									state <= 8'hB;
									eeprom_data <= {7'b1010111,1'b1};  //8'b1000_0101;			//device ID
								end
							else
								state <= 8'hA;
						end
					8'hB:begin
							if(!scl && count < 8)
								begin
									count <= count + 1;
									eeprom_data <= {eeprom_data[6:0], eeprom_data[7]};
									sda_buf <= eeprom_data[7];									
								end 
							else if(count == 8 && !scl)
								begin
									count <= 0;
								//	eeprom_data <= 0;
									link_sda <= 0;
									state <= 8'hC;
								end
							else
								state <= 8'hB;
					   end 
					8'hC:begin
							if(scl)
								begin
									if(!sda)
										state <= 8'hD;																			
								end							
						end
					8'hD:begin
							if(scl && count < 7)														//rd_data[31:24]
								begin
									count <= count + 1;
									data[7 - count] <= sda;
								end
							else if(scl && count == 7)
								begin
									data[7 - count] <= sda;
									count <= 0;
								//	led <= 0;
									state <= 8'h13;
//									sda_buf <= 0;
//									link_sda <= 1;
								end
							else
								state <= 8'hD;
						end
						
					8'h13:begin
									sda_buf <= 0;
									link_sda <= 1;	
									state <= 8'hE;
						end
						
						//MASTER  应答信号
					8'hE:begin
							if(scl)
								begin
									state <= 8'h12;																			
								end							
						end
					8'h12:begin
									link_sda <= 0; //xinjia
//									if(!sda)
									state <= 8'h3D;																									
						end
						
					8'h3D:begin
							if(scl && count < 7)															//rd_data[23:16]
								begin
									count <= count + 1;
									data[7 - count] <= sda;
								end
							else if(scl && count == 7)
								begin
									data[7 - count] <= sda;
									count <= 0;
								//	led <= 0;
									state <= 8'h33;
//									sda_buf <= 0;
//									link_sda <= 1;
								end
							else
								state <= 8'h3D;
						end
						
					8'h33:begin
									sda_buf <= 0;
									link_sda <= 1;	
									state <= 8'h3E;
						end
						
						//MASTER  应答信号
					8'h3E:begin
							if(scl)
								begin
									state <= 8'h32;																			
								end							
						end
					8'h32:begin
									link_sda <= 0; //xinjia
//									if(!sda)
									state <= 8'h4D;																									
						end

						
					8'h4D:begin
							if(scl && count < 7)
								begin
									count <= count + 1;																			//rd_data[15:8]		
									data[7 - count] <= sda;
								end
							else if(scl && count == 7)
								begin
									data[7 - count] <= sda;
									count <= 0;
								//	led <= 0;
									state <= 8'h43;
//									sda_buf <= 0;
//									link_sda <= 1;
								end
							else
								state <= 8'h4D;
						end
						
					8'h43:begin
									sda_buf <= 0;
									link_sda <= 1;	
									state <= 8'h4E;
						end
						
						//MASTER  应答信号
					8'h4E:begin
							if(scl)
								begin
									state <= 8'h42;																			
								end							
						end
					8'h42:begin
									link_sda <= 0; //xinjia
//									if(!sda)
									state <= 8'hF;																									
						end
										
					8'hF:begin
							if(scl && count < 8)
								begin
									count <= count + 1;
									data2[7 - count] <= sda;
								end
							else if(count == 8)
								begin
									count <= 0;
								//	led <= 0;
									state <= 8'h10;
									sda_buf <= 1;
									link_sda <= 1;
								end
							else
								state <= 8'hF;
						end	
						
							
					8'h10:begin
							if(scl)
								begin
									sda_buf <= 1;
									state <= 8'h11;
							   end
							else
								state <= 8'h10;
						end
							
					8'h11:begin
							if(!scl)
								sda_buf <= 0;
							else if(scl)
								begin
									sda_buf <= 1;
									state <= 8'h0;
									rd <= 4'h0;
									led <= 4'b0000;
								end
							else
								state <= 8'h11;
						end
					default: state <= 8'h0;																																														
				endcase			
			end
	end		

endmodule
此模块主要完成I2C的 读写时序的生成。 

module CPS1432_signal(
		RESET,
		CLK,
		WR_START,
		RD_START,
		RD,
		WR,
		ADDR,
		ACK,
		DATA,
		sysclk,
		SCL,
		SDA,
		WR_START_temp,
		RD_START_temp,
		clk_cnt
		

    );

	input RESET;        //复位信号
	input	WR_START;
	input	RD_START;
	output CLK;          //时钟信号
	output RD,WR;        //读写信号
	output[23:0] ADDR;    //11位地址信号
	input ACK;           //读写周期的应答信号
	output[31:0] DATA;      //数据线
	input			sysclk;
	input			SCL;
	inout			SDA;
	
	output		WR_START_temp;
	output		RD_START_temp;
	output	[31:0] clk_cnt;

reg RD,WR;

wire	[23:0] 	ADDR;  
wire	[31:0]		DATA;

assign	ADDR	=		ADDR_USER_WR;
//assign DATA = (RD_START_VIO) ?  32'bz : DATA_USER ;
assign DATA = 	DATA_USER_WR;

//------------------------------------时钟信号输入------------------------------
	reg	[9:0]	sysclk_cnt;
	reg CLK = 1'b0;
	always @ (negedge sysclk ) 
	begin
      if(sysclk_cnt >= 10'd125)     
      begin
         sysclk_cnt   	<=  10'd0;
         CLK 				<=  !CLK;
      end
      else
      begin
         sysclk_cnt  	<=  sysclk_cnt + 1'b1;
         CLK 				<=  CLK;
      end 
	end
//
//	reg	[9:0]	sysclk_cnt1;
//	reg CLK1 = 1'b0;
//	always @ (negedge sysclk ) 
//	begin
//      if(sysclk_cnt1 >= 10'd249)     
//      begin
//         sysclk_cnt1   	<=  10'd0;
//         CLK1 				<=  !CLK1;
//      end
//      else
//      begin
//         sysclk_cnt1  	<=  sysclk_cnt1 + 1'b1;
//         CLK1 				<=  CLK1;
//      end 
//	end
//----------------------------------- 读写信号输入------------------------------
               
//-----------------------------------------写操作-----------------------------
	always @ (negedge CLK or posedge RESET)
	begin	
		if (RESET)
			WR	<=	1'b0;
		else if (WR_trig)
			WR <=	1'b1;
		else
			WR <=	1'b0;	
	end

	reg		WR_START_temp_r;
	wire		WR_trig;
	always @ (negedge CLK or posedge RESET)
	begin
		if (RESET)
			WR_START_temp_r	<=	1'b0;
		else 
			WR_START_temp_r	<=	WR_START_temp;
	end
	assign	WR_trig	=	WR_START_temp & ! WR_START_temp_r;
//----------------------------------------读操作----------------------------
	always @ (negedge CLK or posedge RESET)
	begin	
		if (RESET)
			RD	<=	1'b0;
		else if (RD_trig)
			RD <=	1'b1;
		else
			RD <=	1'b0;	
	end
	wire		RD_START;
	reg		RD_START_temp_r;
	wire		RD_trig;
	always @ (negedge CLK or posedge RESET)
	begin
		if (RESET)
			RD_START_temp_r	<=	1'b0;
		else 
			RD_START_temp_r	<=	RD_START_temp;
	end
	assign	RD_trig	=	RD_START_temp & ! RD_START_temp_r;


	reg				WR_START_temp;
	reg	[23:0]		ADDR_USER_WR;
	reg	[31:0]	DATA_USER_WR;
	reg	[31:0]	clk_cnt_WR;
	always @ (posedge  CLK or posedge RESET)
   begin
		if  (RESET)
      begin
			WR_START_temp			<=	1'b0;
			ADDR_USER_WR				<=	(24'hE0_0004 >>2);
			DATA_USER_WR				<=	32'h0000_0003;
         clk_cnt_WR         		<=  	32'd0;       
      end
		else if(!WR_START)
		begin
			WR_START_temp			<=	1'b0;
			ADDR_USER_WR				<=	(24'hE0_0004 >>2);
			DATA_USER_WR				<=	32'h0000_0003;
			clk_cnt_WR         		<=  	32'd0;   
		end
		else
      begin
			if(clk_cnt_WR >= 32'd0000 & clk_cnt_WR  <32'd300)
         begin
				WR_START_temp			<=	1'b1;
				clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;
         end
         else if(clk_cnt_WR >= 32'd300 & clk_cnt_WR  <32'd600)                       
         begin
				WR_START_temp		<=	1'b0;
				clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end
			else  if (clk_cnt_WR >= 32'd600     &    clk_cnt_WR < 32'd700  )
         begin
				WR_START_temp			<=	1'b1;
				ADDR_USER_WR			<=	(24'hE0_0008 >>2);
				DATA_USER_WR			<=	32'h0000_0007;
            clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end
         else  if (clk_cnt_WR >= 32'd700     &    clk_cnt_WR < 32'd1000   )
         begin
				WR_START_temp			<=	1'b0;
            clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end 
//			else if(clk_cnt_WR >= 32'd1000 & clk_cnt_WR  <32'd1100)                       
//         begin
//				WR_START_temp		<=	1'b0;
//				clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
//         end
			else  if (clk_cnt_WR >= 32'd1000     &    clk_cnt_WR < 32'd1200  )
         begin
				WR_START_temp			<=	1'b1;
				ADDR_USER_WR			<=	(24'h00_01BC >>2);
				DATA_USER_WR			<=	32'hD060_0001;
            clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end
         else  if (clk_cnt_WR >= 32'd1200     &    clk_cnt_WR < 32'd1700   )
         begin
				WR_START_temp			<=	1'b0;
            clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end 
			else  if (clk_cnt_WR >= 32'd1700     &    clk_cnt_WR < 32'd1900  )
         begin
				WR_START_temp			<=	1'b1;
				ADDR_USER_WR			<=	(24'h00_023C >>2);
				DATA_USER_WR			<=	32'hD060_0001;
            clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end
         else  if (clk_cnt_WR >= 32'd1900     &    clk_cnt_WR < 32'd2200   )
         begin
				WR_START_temp			<=	1'b0;
            clk_cnt_WR         	<=  clk_cnt_WR +   1'b1;   
         end 
         else  
			begin
				WR_START_temp			<=	1'b0;
            clk_cnt_WR         	<=  clk_cnt_WR ;   
			end
		end
	end	

	reg				RD_START_temp;
	reg	[23:0]		ADDR_USER_RD;
	reg	[31:0]	DATA_USER_RD;
	reg	[31:0]	clk_cnt_RD;	
always @ (posedge  CLK or posedge RESET)
   begin
		if  (RESET)
      begin
			RD_START_temp			<=	1'b0;
//			ADDR_USER_RD				<=	24'hE1_7044;
			ADDR_USER_RD				<=	ASYNC_OUT[26:3];
//			DATA_USER_RD				<=	32'h0000_0003;
         clk_cnt_RD         		<=  	32'd0;       
      end
		else if(!RD_START)
		begin
			RD_START_temp			<=	1'b0;
//			ADDR_USER_RD				<=	24'hE1_7044;
			ADDR_USER_RD				<=	ASYNC_OUT[26:3];
//			DATA_USER_RD				<=	32'h0000_0003;
			clk_cnt_RD         		<=  	32'd0;   
		end
		else
      begin
			if(clk_cnt_RD >= 32'd0000 & clk_cnt_RD  <32'd300)
         begin
				RD_START_temp		<=	1'b1;
				clk_cnt_RD         	<=  clk_cnt_RD +   1'b1;
         end
         else if(clk_cnt_RD >= 32'd300 & clk_cnt_RD  <32'd600)                       
         begin
				RD_START_temp		<=	1'b0;
				clk_cnt_RD         	<=  clk_cnt_RD +   1'b1;   
         end
			else  if (clk_cnt_RD >= 32'd600     &    clk_cnt_RD < 32'd700  )
         begin
//				ADDR_USER_RD			<=	24'hE1_3084;
				ADDR_USER_RD			<=	ASYNC_OUT[51:28];
				DATA_USER_RD			<=	32'h0000_0007;
            clk_cnt_RD         	<=  clk_cnt_RD +   1'b1;   
         end
         else  if (clk_cnt_RD >= 32'd700     &    clk_cnt_RD < 32'd1000   )
         begin
				RD_START_temp	<=	1'b1;
            clk_cnt_RD         	<=  clk_cnt_RD +   1'b1;   
         end 
         else  
			begin
				RD_START_temp	<=	1'b0;
            clk_cnt_RD         	<=  clk_cnt_RD ;   
			end
		end
	end
//
//	
//	
	wire  [35:0]	CONTROL0;
	wire  [35:0]	CONTROL1;
	wire  [79:0]	ASYNC_OUT;
	wire  [99:0]	ILA_DATA;
	wire  [7:0]		ILA_TRIG0;
	wire				RD_START_VIO;
	wire				ADDR_RD_1;
	wire				ADDR_RD_2;

endmodule
此模块生成I2C读写所需的地址信息和数据信息。 

module CPS1432_cfg(
			sysclk,			
			rst_n,
			CPS1432_SCL,
			CPS1432_SDA,
			WR_START,

			
			CPS1432_SPD,
			CPS1432_FSEL
			
//			WR_START_temp,
//			clk_cnt,
//			ADDR,
//			DATA
    );
	inout		CPS1432_SDA;
	output	CPS1432_SCL;
	input		sysclk;	
	input		rst_n;
	input		WR_START;

	output	[2:0]	CPS1432_SPD;
	output	[1:0]	CPS1432_FSEL;

	wire	WR_START_temp;
//	output	[31:0]	clk_cnt;
	wire	[23:0] ADDR;    //24位地址信号
	wire	[31:0] DATA;      //数据线
	
	assign	CPS1432_SPD	=	3'b101;
	assign	CPS1432_FSEL	=	2'b10;
	wire	[31:0]	clk_cnt;
	wire		[10:0] main_state;
	wire	[9:0] sh8in_state;
	wire		WR_START_VIO;
	wire		RD_START_VIO;
  CPS1432_signal         signal(
			.RESET(!rst_n),
			.CLK(CLK),
			.RD(RD),
         .WR(WR),
			.ADDR(ADDR),
			.DATA(DATA),
			.sysclk(sysclk),
//			.SDA(CPS1432_SDA),
//			.SCL(CPS1432_SCL),
			
//			.WR_trig(WR_trig),
//			.RD_trig(RD_trig),
//			.SYSCLK_cnt(sysclk_cnt),
			
			.WR_START(WR_START ),
			.RD_START(RD_START_VIO),
			
//			.ADDR_VIO(ADDR_VIO),
//			.DATA_VIO(DATA_VIO)
			.WR_START_temp(WR_START_temp),
			.RD_START_temp(RD_START_temp),
			.clk_cnt(clk_cnt)
			
			
			);
	wire		[7:0]      rd_data;
	wire		[7:0]      rd_data2;
	wire		[7:0]      eeprom_data;
	wire                rst_n;
	wire                key_wr;
	wire                key_rd;
	wire                clk;
	wire                ila_clk;
	wire                link_sda;
	wire    [4:0]       state;
	wire    [3:0]       count;
	
//	wire    [6:0]       IIC_ADDR;
	wire    [23:0]       IIC_ADDRESS;
	wire		[31:0]		write_data;
	assign	key_wr = !WR_START_temp;
	assign	key_rd = !RD_START_temp;
	iic_wr_ctrl iic_wr_ctrl
	(
	.sys_clk(sysclk),
	.clk(clk),
	.ila_clk(ila_clk),
	.state(state),
	.rst_n(rst_n),
	.key_rd(key_rd),
	.key_wr(key_wr),
	.sda(CPS1432_SDA),
	.scl(CPS1432_SCL),
	.link_sda(link_sda),
	.eeprom_data(eeprom_data),
	.data(rd_data),
	.data2(rd_data2),
	.count(count),
//	.IIC_ADDR(IIC_ADDR),
	.IIC_ADDRESS(ADDR),
	.write_data(DATA)
	);
	wire      [35:0]       CONTROL0;
	wire      [35:0]       CONTROL1;
	wire      [79:0]       ASYNC_OUT;
	wire      [99:0]       data_group;
	
	icon icon_test
	(
    .CONTROL0(CONTROL0), // INOUT BUS [35:0]
    .CONTROL1(CONTROL1)  // INOUT BUS [35:0]
   );
   

	vio vio (
    .CONTROL(CONTROL0), // INOUT BUS [35:0]
    .ASYNC_OUT(ASYNC_OUT) // OUT BUS [79:0]
);

ila ila (
    .CONTROL(CONTROL1), // INOUT BUS [35:0]
    .CLK(ila_clk), // IN
    .TRIG0(data_group) // IN BUS [99:0]
);
  /
  assign       WR_START_VIO =  ASYNC_OUT[0] ;
  assign       RD_START_VIO =  ASYNC_OUT[1] ;
//  assign       key_wr =  ASYNC_OUT[1] ;
//  assign       key_rd =  ASYNC_OUT[2] ;
//  assign       IIC_ADDRESS =  ASYNC_OUT[26:3] ;
//  assign       write_data =  ASYNC_OUT[58:27] ;
  
  
  /
  assign       data_group[0] 		= CPS1432_SCL;
  assign       data_group[1] 		= CPS1432_SDA;
  assign       data_group[2] 		= key_rd;
  assign       data_group[3] 		= key_wr;
  assign       data_group[4] 		= rst_n;
  assign       data_group[12:5] 	= rd_data;
  assign       data_group[20:13] = state;
  assign       data_group[44:21] = ADDR;
  assign       data_group[76:45] = DATA;
  assign       data_group[77] 	= WR_START_VIO;
  assign       data_group[78] 	= WR_START_temp;  
  assign       data_group[79] 	= RD_START_VIO;
  assign       data_group[80] 	= RD_START_temp;
	

endmodule



此模块主要实现两个模块的调用。


使用时只要将WR_START 信号拉高，即可实现写数据。



普若赛瑟
关注
  • 1
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FPGA实现IIC接口（2）--IIC接口芯片的实际使用
孤独的单刀
10-15 3万+
通过本文您会学到：如何用EEPROM来实现IIC接口。
i2c的vhdl实现代码
09-02
i2c的vhdl实现代码
I2C_slave FPGA实现
03-30
自己写的I2C_SLAVE希望对大家有用，可以参考
I2C总线上实现透传
最新发布
MHD0815的博客
06-03 379
在I2C总线上实现透传（也称为中继或直通）意味着从一个设备（如A处理器）接收到的数据直接转发到下一个设备（如C处理器），而中间设备（如B处理器）不存储或处理这些数据。
FPGA——I2C读写控制模块
weixin_44448586的博客
06-22 2399
（在这里只负责讲解I2C控制模块的讲解，底层数据传输模块，请大家观看我之前的文章） 之前I2C底层数据传输模块已经讲解完成，数据传输模块实现一个字节的写操作是可以非常简单的，但是实际的应用中我们不可能只写一个字节数据，而是需要通过多个这样单字节数据的读写操作组合起来实现完整的I2C读写数据功能。这样的话单靠单字节传输模块用来连续读写就些不方便了，从上面的仿真代码中就能看出来，为了实现一个读写操作，我们需要多次使用传输模块才能实现，所以我们需要一个上层模块来多次控制数据传输模块执行不同和传输不同的数据，进而
Verilog 代码编写 IIC通信-主到从向芯片写入数据
qq_46132759的博客
01-20 1696
题目： 根据课堂讲授的基本原理，自己尝试编写一个 IIC 控制逻辑，FPGA 的输入时钟为 10MHz，IIC 的通信频率为 400KHz，要求 FPGA 向 AD 芯片写入控制指令，AD 芯片的地址为 0000123（改为十进制 123，即 01111011），AD 芯片中有三个地址连续的寄存器， 地址为 0x48，配置数据为 0x55，地址为 0x49，配置数据为 0xAA，地址为 0x50，配置数据为 0xCC，试画出电路连接框图、状态转移图、完成代码编写并仿真。 分析...
FPGA学习笔记：I2C读写控制模块设计
李敏儿oc的博客
08-29 932
之前设计了I2C最小单元读写模块，本文设计控制模块，多次调用最小单元模块，只需输入对应的器件地址、存储器地址，即可实现I2C读写操作。
利用FPGA实现简单的iic通信协议
SLAM_masterFei的博客
09-02 3685
最近博主马不停蹄的学习FPGA就是为了可以尽快用FPGA来实现图像处理，好让我们的博客恢复正常内容哈哈哈，我说几句题外话，其实关于图像处理，工程应用和写论文是完全不一样的，如果是以找工作为目的，在牛逼的算法其实很难进行实际运用，归结到底就是速度以及实际效果。所以如果是以找工作为目的的小伙伴们其实不妨把时间花在积累工程经验中来，毕业论文啥的随便找两个算法复现了调调参就可以了。当然我这么说，读博的朋友...
基于FPGA的I2C通信（一）
phflovelt的博客
06-06 6653
一、I2C通信协议 1.I2C总线介绍 I2C总线是由Philips公司开发的一种简单、双向二线制同步串行总线。它只需要两根线即可在连接于总线上的器件之间传送信息。 主器件用于启动总线传送数据，并产生时钟以开放传送的器件，此时任何被寻址的器件均被认为是从器件．在总线上主和从、发和收的关系不是恒定的，而取决于此时数据传送方向。如果主机要发送数据给从器件，则主机首先寻址从器件，然后主动发送数据至从器件，最后由主机终止数据传送；如果主机要接收从器件的数据，首先由主器件寻址从器件．然后主机接收从器件发送的数据
FPGA的I2C实现
08-02
在电子设计领域，FPGA（Field-Programmable Gate Array）是一种可...提供的"i2c_master_slave"文件很可能包含了完成这一过程所需的所有资源，包括源代码、配置文件和测试向量，对于学习和应用FPGA实现的I2C非常有价值。
i2c.rar_FPGA I2C
09-24
总的来说，FPGA实现I2C是一项挑战性但实用的技术，它可以帮助你深入理解串行通信协议的细节，同时提供了一个灵活的平台，可以根据需要调整和扩展I2C接口的功能。这个实验不仅适用于学术研究，也是工程实践中的宝贵...
I2c-Switch芯片手册
01-27
PCA9546A芯片手册,一款I2cSwitech,Switch拥有4个通道,最多可以同时打开,分别选择将哪个通道的I2c设备挂载到I2c总线.
verilog-i2c:用于 FPGA 实现的 Verilog I2C 接口
05-30
Verilog I2C 接口 有关更多信息和更新： : GitHub 存储库： : 介绍 I2C 接口组件。 包括带有智能总线协同仿真端点的完整 MyHDL 测试平台。 文档 i2c_init 模块 通过 I2C 进行外设初始化的模板模块。 当一个或多个外围设备（即 PLL 芯片、抖动衰减器、时钟复用器等）需要在上电时初始化而不使用通用处理器时使用。 i2c_master 模块 I2C 主模块带有 AXI 流接口来控制逻辑。 i2c_master_axil 模块 具有 32 位 AXI lite 从接口的 I2C 主模块。 i2c_master_wbs_8 模块 具有8位Wishbone从接口的I2C主模块。 i2c_master_wbs_16 模块 带有 16 位 Wishbone 从接口的 I2C 主模块。 i2c_slave 模块 带有 AXI 流接口以控制逻辑的 I2C
FPGA实现IIC通信.zip
06-29
文档中包含iic_wr_ctrl.v主文件，iic_wr_ctrl_tb.v测试文件，以及代码说明文档非常适合初学者学习
用FPGA实现I2C通信
10-28
本主题将详细介绍如何利用FPGA实现I2C通信，以及涉及的关键知识点。 首先，理解I2C协议是关键。I2C协议采用主从架构，主设备（如FPGA）发起通信，而从设备（如传感器或存储器）响应。该协议有标准（100kbps）、快速...
I2C接口的KSZ9897 Switch
OpenWrt/WLAN/驱动/Android/嵌入式开发总结
09-19 3790
1： I2C配置接口的9897 DTS /* imx8mm 中AR8031的默认DTS的配置，与PHY的配置接口为：MDIO &fec1 { pinctrl-names = "default"; pinctrl-0 = <&pinctrl_fec1>; phy-mode = "rgmii-id"; phy-handle = <&ethphy0>; fsl,magic-packe
I2C总线通讯协议中主机模块的FPGA实现
热门推荐
shen_you的博客
11-29 1万+
有关于I2C通讯用FPGA实现的一些部分
FPGA常见接口及逻辑实现（二）—— I2C
alexmercer12138的博客
04-09 2300
介绍了I2C接口及其Verilog实现
FPGA I2C接口实现
03-30
FPGA是一种可编程逻辑器件，可以用于实现各种数字电路和接口。I2C是一种串行通信协议，用于连接微控制器和外部设备。在FPGA中实现I2C接口可以方便地与各种外部设备进行通信。 以下是FPGA实现I2C接口的步骤： 1. 确定I2C总线的时钟频率和通信速率。I2C总线的时钟频率通常为100kHz或400kHz，通信速率取决于所连接的设备。 2. 实现I2C总线的物理层接口。I2C总线需要两条信号线：SCL时钟线和SDA数据线。FPGA可以通过GPIO口或专门的I2C接口模块来实现这些信号线的驱动和接收。 3. 实现I2C总线的数据传输协议。I2C总线的数据传输协议包括开始信号、地址字节、数据字节和停止信号等。FPGA可以通过状态机或专门的I2C控制器模块来实现这些协议。 4. 编写I2C通信的应用程序。FPGA可以通过C语言、Verilog HDL或其他编程语言来编写应用程序，实现与外部设备的数据交换和控制。 通过以上步骤，FPGA可以实现与各种I2C设备的通信，包括温度传感器、光敏传感器、EEPROM等。在实际应用中，还需要考虑信号电平、信号滤波、时序控制等问题，以确保可靠的通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值