使用verilog完成对IIC总线的编写，采用三段式状态机，完成测试

最新推荐文章于 2023-06-28 14:17:28 发布
最新推荐文章于 2023-06-28 14:17:28 发布
阅读量1.8k 收藏 30
点赞数 5
文章标签： verilog 时序模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CMT_103_/article/details/120351912
版权

一、IIC总线开始状态
IIC开始状态
IIC总线开始状态应该是SCL在高电平的期间，SDA出现下降沿，表示为开始状态

二、IIC总线结束状态
IIC结束状态
IIC总线结束状态应该是在SCL为高电平期间，SDA出现上升沿，表示结束状态

三、数据传输状态

写数据状态
在这里插入图片描述
读数据状态

总线数据传输
IIC总线对于数据传输的要求为在SCL为低电平的情况下进行数据的改变，因此为了避免产生误差，选择在SCL低电平的中间位置进行数据的写入，在SCL为高电平的时候进行数据的保持

四、读写状态的状态转换图
写状态状态转移图
读状态状态转移图
五、测试结果

写状态开始状态
写状态开始状态
写状态写入从机地址
写状态写入从机地址
写状态写入寄存器地址
写状态写入寄存器地址
写状态写入数据
写状态写入数据
写状态停止状态
写状态停止状态
读状态第一个开始信号
读状态第一个开始信号
读状态第一次写从机地址
读状态第一次写从机地址
读状态写入寄存器地址
读状态写入寄存器地址
读状态第一次停止
读状态第一次停止
读状态第二次开始
读状态第二次开始
读状态第二次写入从机地址
读状态第二次写入从机地址]
读状态读数据
读状态读数据
读状态第二次停止
读状态第二次停止
测试过程中我选择的从机地址是7’h3c，寄存器地址是8‘h00，写入的数据是8’h10，根据测试结果可以看到不仅成功的将数据写入到了寄存器之中，并且将写入的数据读取了出来，完成了整体的设计

六、代码

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2021/09/14 19:45:40
// Design Name: 
// Module Name: IIC_CODE
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module IIC_Code(

	input wire clk_i,
	input wire rst_i,
	input wire send_i,					//IIC开始信号
	input wire wr_i,					//读写控制信号，1为写，0为读
	input wire [6:0] Slv_Addr_i,			//从机的地址数据
	input wire [7:0] Reg_Addr_i,			//寄存器的地址数据
	input wire [7:0] Data_i,				//将要写入的数据
	output reg IIC_Busy_o,				//IIC工作标志信号
	output reg [7:0] IIC_Read_Data_o,		//IIC读出来的数据
	inout wire sda,
	inout wire scl
    );

parameter DIV = 2500;					//分频计数器的分频系数
parameter T1 = DIV / 4;					//第一个标志位
parameter T2 = DIV *3/4;				//第二个标志位

reg [11:0] cnt_clk;						//clk计数器
reg [3:0] cnt_scl;						//scl计数器，表示传送数据的位数
reg sda_tri;							//三态控制信号
reg sda_o;								//sda总线传输数据的寄存器
reg scl_o;								//scl时钟总线
reg [4:0] current_state;				//当前状态
reg [4:0] next_state;					//下个状态

assign sda = sda_tri ? 1'bz : sda_o;
assign scl = scl_o;

parameter IDLE 			= 5'd0;
parameter W_START 		= 5'd1;
parameter W_SLV_ADDR 	= 5'd2;
parameter W_WR 			= 5'd3;
parameter W_ACK1 		= 5'd4;
parameter W_REG_ADDR 	= 5'd5;
parameter W_ACK2 		= 5'd6;
parameter W_DATA 		= 5'd7;
parameter W_ACK3 		= 5'd8;
parameter W_STOP 		= 5'd9;
parameter R_START1 		= 5'd10;
parameter R_SLV_ADDR1	= 5'd11;
parameter R_WR1			= 5'd12;
parameter R_ACK1		= 5'd13;
parameter R_REG_ADDR	= 5'd14;
parameter R_ACK2		= 5'd15;
parameter R_STOP1		= 5'd16;
parameter R_START2		= 5'd17;
parameter R_SLV_ADDR2	= 5'd18;
parameter R_WR2			= 5'd19;
parameter R_ACK3		= 5'd20;
parameter R_DATA 		= 5'd21;
parameter R_ACK4		= 5'd22;
parameter R_STOP2		= 5'd23;

always@(posedge clk_i)
begin 
	if(rst_i == 1'b1)
		current_state <= IDLE;
	else
		current_state <= next_state;
end

always@(*)
begin
	case(current_state)
		IDLE:
			begin
				if((send_i == 1'b1) && (wr_i == 1'b1))
					next_state <= W_START;
				else if((send_i == 1'b1) && (wr_i == 1'b0))
					next_state <= R_START1;
				else
					next_state <= current_state;
			end
		W_START:
			begin
				if(cnt_clk == 12'b0)
					next_state <= W_SLV_ADDR;
				else
					next_state <= current_state;
			end
		W_SLV_ADDR:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b0111))
					next_state <= W_WR;
				else
					next_state <= current_state;
			end
		W_WR:
			begin
				if(cnt_clk == 12'b0)
					next_state <= W_ACK1;
				else
					next_state <= current_state;
			end
		W_ACK1:
			begin
				if(cnt_clk == 12'b0)
					next_state <= W_REG_ADDR;
				else
					next_state <= current_state;
			end
		W_REG_ADDR:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b1000))
					next_state <= W_ACK2;
				else
					next_state <= current_state;
			end
		W_ACK2:
			begin
				if(cnt_clk == 12'b0)
					next_state <= W_DATA;
				else
					next_state <= current_state;
			end
		W_DATA:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b1000))
					next_state <= W_ACK3;
				else
					next_state <= current_state;
			end
		W_ACK3:
			begin
				if(cnt_clk == 12'b0)
					next_state <= W_STOP;
				else
					next_state <= current_state;
			end
		W_STOP:
			begin
				if(cnt_clk == 12'b0)
					next_state <= IDLE;
				else
					next_state <= current_state;
			end
		R_START1:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_SLV_ADDR1;
				else
					next_state <= current_state;
			end
		R_SLV_ADDR1:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b0111))
					next_state <= R_WR1;
				else
					next_state <= current_state;
			end
		R_WR1:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_ACK1;
				else
					next_state <= current_state;
			end
		R_ACK1:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_REG_ADDR;
				else
					next_state <= current_state;
			end
		R_REG_ADDR:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b1000))
					next_state <= R_ACK2;
				else
					next_state <= current_state;
			end
		R_ACK2:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_STOP1;
				else
					next_state <= current_state;
			end
		R_STOP1:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_START2;
				else
					next_state <= current_state;
			end
		R_START2:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_SLV_ADDR2;
				else
					next_state <= current_state;
			end
		R_SLV_ADDR2:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b0111))
					next_state <= R_WR2;
				else
					next_state <= current_state;
			end
		R_WR2:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_ACK3;
				else
					next_state <= current_state;
			end
		R_ACK3:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_DATA;
				else
					next_state <=current_state;
			end
		R_DATA:
			begin
				if((cnt_clk == 12'b0) && (cnt_scl == 4'b1000))
					next_state <= R_ACK4;
				else
					next_state <= current_state;
			end
		R_ACK4:
			begin
				if(cnt_clk == 12'b0)
					next_state <= R_STOP2;
				else
					next_state <= current_state;
			end
		R_STOP2:
			begin
				if(cnt_clk == 12'b0)
					next_state <= IDLE;
				else
					next_state <= current_state;
			end
		default: next_state <= IDLE;
	endcase 
end

always@(posedge clk_i)
begin
	if(rst_i == 1'b1)
		begin
			sda_tri 	<= 1'b0;
			scl_o 		<= 1'b1;
			sda_o 		<= 1'b1;
			cnt_clk 	<= 12'b0;
			IIC_Busy_o 	<= 1'b0;
			cnt_scl 	<= 4'b0;
		end
	else 
		begin
			case (next_state)
				IDLE:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= 1'b1;
						sda_o 		<= 1'b1;
						cnt_clk 	<= 12'b0;
						IIC_Busy_o 	<= 1'b0;
						cnt_scl 	<= 4'b0;
					end
				W_START:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T2) ? 1'b1 : 1'b0; 
						sda_o 		<= (cnt_clk<T1) ? 1'b1 : 1'b0; 
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						IIC_Busy_o 	<= 1'b1;
						cnt_scl 	<= 4'b0;
					end
				W_SLV_ADDR:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= Slv_Addr_i[6-cnt_scl]; 
						IIC_Busy_o 	<= 1'b1; 
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1; 
						cnt_scl 	<= (cnt_clk>=DIV-1) ? cnt_scl+ 1 : cnt_scl;
					end
				W_WR:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= 1'b0;
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				W_ACK1:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				W_REG_ADDR:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= Reg_Addr_i[7- cnt_scl];
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= (cnt_clk>=DIV-1) ? cnt_scl+ 1 : cnt_scl;
					end
				W_ACK2:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				W_DATA:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= Data_i[7- cnt_scl];
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= (cnt_clk>=DIV-1) ? cnt_scl+ 1 : cnt_scl;
					end
				W_ACK3:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0);  
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				W_STOP:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : 1'b1; 
						sda_o 		<= (cnt_clk<T2) ? 1'b0 : 1'b1; 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_START1:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T2) ? 1'b1 : 1'b0; 
						sda_o 		<= (cnt_clk<T1) ? 1'b1 : 1'b0; 
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						IIC_Busy_o 	<= 1'b1;
						cnt_scl 	<= 4'b0;
					end
				R_SLV_ADDR1:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= Slv_Addr_i[6-cnt_scl]; 
						IIC_Busy_o 	<= 1'b1; 
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1; 
						cnt_scl 	<= (cnt_clk>=DIV-1) ? cnt_scl+ 1 : cnt_scl;
					end
				R_WR1:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= 1'b0;
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_ACK1:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_REG_ADDR:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= Reg_Addr_i[7- cnt_scl];
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= (cnt_clk>=DIV-1) ? cnt_scl+ 1 : cnt_scl;
					end
				R_ACK2:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_STOP1:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : 1'b1; 
						sda_o 		<= (cnt_clk<T2) ? 1'b0 : 1'b1; 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_START2:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T2) ? 1'b1 : 1'b0; 
						sda_o 		<= (cnt_clk<T1) ? 1'b1 : 1'b0; 
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						IIC_Busy_o 	<= 1'b1;
						cnt_scl 	<= 4'b0;
					end
				R_SLV_ADDR2:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= Slv_Addr_i[6-cnt_scl]; 
						IIC_Busy_o 	<= 1'b1; 
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1; 
						cnt_scl 	<= (cnt_clk>=DIV-1) ? cnt_scl+ 1 : cnt_scl;
					end
				R_WR2:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						sda_o 		<= 1'b1;
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_ACK3:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_DATA:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= (cnt_clk==DIV/2-1) ? cnt_scl+ 1 : cnt_scl;
						case(cnt_scl)
							4'b0000: IIC_Read_Data_o[7] <= sda;
							4'b0001: IIC_Read_Data_o[6] <= sda;
							4'b0010: IIC_Read_Data_o[5] <= sda;
							4'b0011: IIC_Read_Data_o[4] <= sda;
							4'b0100: IIC_Read_Data_o[3] <= sda;
							4'b0101: IIC_Read_Data_o[2] <= sda;
							4'b0110: IIC_Read_Data_o[1] <= sda;
							4'b0111: IIC_Read_Data_o[0] <= sda;
							default: ;
						endcase
					end
				R_ACK4:
					begin
						sda_tri 	<= 1'b1;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : (cnt_clk<T2 ? 1'b1 : 1'b0); 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				R_STOP2:
					begin
						sda_tri 	<= 1'b0;
						scl_o 		<= (cnt_clk<T1) ? 1'b0 : 1'b1; 
						sda_o 		<= (cnt_clk<T2) ? 1'b0 : 1'b1; 
						IIC_Busy_o 	<= 1'b1;
						cnt_clk 	<= (cnt_clk>=DIV-1) ? 0 : cnt_clk+1;
						cnt_scl 	<= 4'b0;
					end
				default : 
							begin
								sda_tri    <= 1'b0;
								scl_o      <= 1'b1;
								sda_o      <= 1'b1;
								cnt_clk    <= 12'b0;
								IIC_Busy_o <= 1'b0;
								cnt_scl    <= 4'b0;
							end
			endcase
		end
end


endmodule
二哈是笨狗
关注
  • 5
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
学习笔记-Verilog实现IIC总线协议
weixin_42958843的博客
12-26 2167
学习笔记-Verilog实现IIC总线协议 1 IIC总线协议原理 1.1开始和结束 IIC总线只有两根线，适合低速传输。可工作在100kb/s，400kb/s，1Mb/s和3.4Mb/s。串行总线中SPI和MIPI会有更高的传输速率。 IIC总线中SCL为时钟信号，SDA为数据信号。IIC总线的地址分为7位和10位两种，本文用的是7位地址。由于自带始终，工作频率可以不准确。 IIC总线的SCL和SDA必须上拉。 1.2数据传输 所有数据都是在时钟SCL位低电平时变化，高电平时采样数据。 每次传输9位数据
Verilog描述三段式有限状态机
wty_A1的博客
03-03 810
#有限状态机的三段式描述方法 FPGA可编程器件区别于MCU等处理器的最大特点就是在于其高度并行化。使用Verilog HDL硬件描述语言描述的模块在器件内部都是并存的，可以同时、独立的去工作；而在MCU等含有中央处理单元的器件中，其核心处理单元数量是有限的，早期的单核处理器，到现在常见的双核，四核心，八核心乃至更多，其处理单元数量有限，对于指令的执行，在工作频率下，单一核心顺序执行软件代码，所以...
基于Verilog的I2C_MASTER模块设计
LMYKcat的博客
08-03 2074
基于Verilog的I2C_MASTER模块设计
基于FPGA的协议IIC（verilog）
03-23
基于Verilog的IIC分析+代码
Verilog | I2C详解与Verilog实现
qq_45776815的博客
11-28 1万+
​ IIC(Inter-Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，是一种同步、半双工的通信总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，最初为音频和视频设备开发，如今主要在服务器管理中使用，其中包括单个组件状态的通信。例如管理员可对各个组件进行查询，以管理系统的配置或掌握组件的功能状态，如电源和系统风扇。可随时监控内存、硬盘、网络、系统温度等多个参数，增加了系统的安全性，方便了管理。IIC数据传输速率。
IIC总线的原理与Verilog实现
ToFPGA的博客
07-27 1万+
IIC总线的原理与Verilog实现1、 软件平台与硬件平台2、 原理介绍2.1 IIC总线的特点：2.2 IIC总线协议详解：2.2.1 IIC主机往从机里面写入数据的步骤2.2.2 IIC主机从从机里面读出数据的步骤2.2.3 通信状态空闲状态起始状态和结束状态有效的数据位传输应答信号与非应答信号2.2.4 读写过程**主机通过IIC总线往从机里面写数据**主机通过IIC总线从从机里面读数据3、 目标任务4、 设计思路及Verilog代码编写4.1 IIC发送模块的接口定义与整体设计4.2 IIC接收
I2C协议简介 & Verilog实现
qq_43557686的博客
03-21 5507
IIC 协议是三种最常用的串行通信协议（I2C，SPI，UART）之一，接口包含 SDA（串行数据线）和 SCL（串行时钟线），均为双向端口。I2C 仅使用两根信号线，极大地减少了连接线的数量，支持多主多从，且具有应答机制，因此在片间通信有较多的应用。
IIC 总线协议（Verilog）
qq_53433410的博客
08-14 2162
IIC 总线协议（Verilog）
verilog三段式状态机
03-27
在本项目“verilog三段式状态机”中，我们主要探讨的是如何使用Verilog来实现一种经典的三段式状态机模型。 状态机是控制逻辑的核心组成部分，用于管理系统的状态转换。它按照预定义的规则从一个状态转变到另一个...
FPGA三段式状态机的思维陷阱.docx
11-26
有些设计者习惯于使用一段式状态机，后来才将其转换为三段式，这样容易导致思维混乱和代码混乱。 在实现三段式状态机时，需要注意以下几点： 首先，需要正确理解三段式状态机的工作原理。三段式状态机将状态机分为...
IIC通信协议的Verilog实现
07-18
刚刚花了几天时间把 IIC 总算搞懂了一些，查了很多资料，也纠结过于很多细节，不过只要耐着性子，一点点的去理解，去尝试，终会得到你想要的结果，人生不也是吗，嘿嘿~，不闲扯了，下面就写写我的理解以及方法，算是一个总结~
verilog经典三段式状态机设计实例.docx
07-26
三段式状态机是一种常见的设计方法，它将状态机分为当前状态、下一状态和输出三个部分来描述。 在给定的文档中，有两个状态机实现的例子，分别是Moore型和Mealy型。这两种类型的状态机主要区别在于输出的计算时机...
serial_number_check.zip_三段式状态机
09-24
在这个“serial_number_check.zip_三段式状态机”案例中，我们聚焦于一个特定的设计模式——三段式状态机，它在序列检测任务中扮演着重要角色。三段式状态机是一种结构化设计方法，有助于简化复杂状态机的实现和理解...
fsm.rar_Verilog状态机_fsm verilog_二段式verilog_有限状态机_状态机
09-14
在数字电路设计中，有限状态机（Finite State Machine, FSM）是一种重要的逻辑设计...在提供的`fsm`文件中，可能包含了关于如何使用Verilog实现二段式状态机的详细示例和解释，这有助于进一步加深对这一主题的理解。
verilog 实现 IIC
热门推荐
苍白的手漆黑的刀
04-08 2万+
verilog 实现IIC协议 算是一个简单的IP核,本来是挂在AXI总线上,可以通过microblaze对其进行配置。最近在弄ADV7511,用到IIC来配置它.直接上代码： `timescale 1ns / 1ps //////////////////////////////////////////////////////////////////////////////////
基于Verilog语言在FPGA7系列上实现IIC协议(附完整代码)
最新发布
ic2121的博客
06-28 927
完整代码在下面，该代码包括了IIC总线的主设备和从设备的实现。其中，主设备代码实现了状态机的各个状态和信号的控制，用于向从设备发送数据。从设备代码实现了状态机的各个状态和信号的控制，用于接收主设备发送的数据并返回ACK信号。这两部分代码结合起来可以实现一个完整的IIC协议通信系统。在FPGA中实现IIC协议，需要编写Verilog代码来实现IIC总线的主设备和从设备。IIC协议主要用于在集成电路中连接微控制器和其他外设，比如温度传感器、EEPROM、LCD等，这些外设可以作为IIC总线的从设备。
IIC总线协议Verilog实现
xiyieba的博客
03-15 7430
IIC协议是一种数据双向、二线制总线标准的总线协议。多用于主机（master）从机（slave）在数据量不大且传输距离短的场合下使用，比如对EEPROM的读写操作，就需要采用IIC协议实现读写操作（两线串行接口的双向数据传输协议）。主机（PC）启动总线，并产生时钟用于传输数据，此时任何接受数据的器件都被认为是从机。 IIC总线是由数据线SDA和时钟线SCL构成的，发送接收数据都行，在主从机之间进行双向数据传输，各种被控器件（从机）均并联在总线上，通过器件地址（SLAVE ADDR）识别。 如上图可知，当总
【verilog】一主多从模式下的IIC驱动(三段状态机法)(fpga)
helloworld573的博客
03-09 2849
有关IIC时序部分：链接 上一篇，一段状态机的iic驱动：链接 MIAN /* iic freq = 250khz fpga freq = 50Mhz 向内部寄存器地址位数为8的从机写数据:1->3->4->7 need:type16_type8=0,read1_write0=0. 向内部寄存器地址位数为16的从机写数据:1->2->3->4->7 need:type16_type8=
Verilog4-IIC总线的原理与Verilog实现
d_b_的博客
10-10 1801
文章目录IIC总线的原理与Verilog实现一、原理介绍IIC总线在通信中的几种状态1、空闲状态2、起始状态和结束状态3、有效的树位传输4、应答信号与非应答信号IIC 总线的读写过程1、主机通过 IIC 总线往从机中**写数据**2、主机通过 IIC 总线从 从机中**读数据**三、设计举例1、IIC 发送模块 设计结构、输出、输入结构发送过程时序抽象出状态机之后，写代码前分析一下代码中要注意的一些关键点：2、IIC 接收模块设计接收模块端口及框图接收一个字节数据时序接收模块注意事项 IIC总线的原理与Ve
使用verilog语言写一个自动售货机的三段式状态机代码
05-18
以下是一个简单的自动售货机的三段式状态机代码，使用 Verilog 语言实现： ``` module vending_machine ( input clk, rst, coin, btn, output reg [1:0] state, output reg vend ); // 定义状态 parameter IDLE = 2'b00; parameter WAIT = 2'b01; parameter VEND = 2'b10; // 定义状态转移条件 reg [1:0] next_state; always @ (state or coin or btn) begin case (state) IDLE: if (coin) next_state = WAIT; else next_state = IDLE; WAIT: if (btn) next_state = VEND; else next_state = WAIT; VEND: next_state = IDLE; endcase end // 定义状态输出 always @ (state or next_state) begin case (state) IDLE: vend = 0; WAIT: vend = 0; VEND: vend = 1; endcase state <= next_state; end endmodule ``` 该代码使用了三个状态，分别为 IDLE（空闲）、WAIT（等待用户按下按钮）和 VEND（售货）。状态转移条件由 coin（硬币输入）和 btn（按钮输入）控制，当硬币被投入时进入 WAIT 状态，当按钮被按下时进入 VEND 状态，当售货完成后回到 IDLE 状态。在每个状态下，vend 输出信号表示售货机是否正在售货。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值