i2c Slave

已于 2024-01-15 19:01:47 修改
阅读量397 收藏 10
点赞数 7
文章标签： fpga开发
于 2024-01-11 19:57:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71028423/article/details/135537402
版权

基于一个github项目自己修改编写的，对于一些信号进行了整理，方便读者的理解。已通过FPGA上板测试，写操作无误。

module i2c_slave (scl,sda,rst_n,reg_data_rd,reg_data_wr,reg_addr,wen);
	input scl;//rx from FPGA's peripheral
	inout sda;
	input rst_n;
	input [7:0] reg_data_rd;//rx from regs
	
	output [7:0] reg_data_wr;//tx to regs
	output [1:0] reg_addr;//tx to regs
	output wen;//tx to regs
	
	parameter I2C_ADDR = 7'h27;//device's static addr
	
inout setting
wire sda_in;
reg output_ctrl;

assign sda_in = sda ;
assign sda = output_ctrl ? 1'bz : 1'b0; 
	
start detect
reg start_detect;//when SCL keep high,SDA pull low
reg start_resetter;
wire start_rst;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

assign start_rst = ~rst_n | start_resetter;

	always@(posedge start_rst or negedge sda)begin//trigger condition 
		if(start_rst)
			start_detect <= 1'b0;
		else
			start_detect <= scl;
	end
	
	always@(posedge scl or negedge rst_n)begin
		if(!rst_n)
			start_resetter <= 1'b0;
		else
			start_resetter <= start_detect;
	end

stop detect
reg stop_detect;//when SCL keep high,SDA pull high
reg stop_resetter;//
wire stop_rst;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

assign stop_rst = ~rst_n | stop_resetter;

	always@(posedge stop_rst or posedge sda)begin
		if(stop_rst)
			stop_detect <= 1'b0;
		else
			stop_detect <= scl;
	end
	
	always@(posedge scl or negedge rst_n)begin
		if(!rst_n)
			stop_resetter <= 1'b0;
		else
			stop_resetter <= stop_detect;
	end

counting bit number
reg [3:0] bit_cnt;

wire lsb_bit = (bit_cnt==4'h7) && !start_detect;//the LSB bit is the 8th bit sent
wire ack_bit = (bit_cnt==4'h8) && !start_detect;//the ACK bit is the 9th bit sent

always@(negedge scl)begin
	if(ack_bit || start_detect)
		bit_cnt <= 4'h0;
	else
		bit_cnt <= bit_cnt + 4'h1;
end

address detect
reg [7:0] rx_shift;

always@(posedge scl)begin
	if(!ack_bit)
		rx_shift <= {rx_shift[6:0],sda};
	else 
		rx_shift <= rx_shift;
end

wire addr_detect;
wire rd_or_wr;//(static addr + 'rd_or_wr' + ack/nack )

assign addr_detect = (rx_shift[7:1]==I2C_ADDR) ? 1'b1 : 1'b0 ;
assign rd_or_wr = rx_shift[0];

master's ack/nack detect 
reg sda_from_mst;

always@(posedge scl)begin
	if(ack_bit)
		sda_from_mst <= sda_in;
end

FSM for RX from SDA and TX to reg_core
localparam IDLE 		= 3'b000;//0
localparam DEV_ADDR 	= 3'b001;//1
localparam READ 		= 3'b011;//3
localparam IDX_PTR 	    = 3'b101;//5
localparam WRITE 		= 3'b111;//7

reg [2:0] cstate;
reg [2:0] nstate;

always@(negedge scl or negedge rst_n)begin
	if(!rst_n )
		cstate <= IDLE;
	else if(start_detect)//for restart function
	    cstate <= DEV_ADDR;
	else if(stop_detect)
	    cstate <= IDLE;
	else if(ack_bit)//9bit done, state change
		cstate <= nstate;
end

always@(*)begin
	case(cstate)
	IDLE:begin
		if(start_detect)
			nstate <= DEV_ADDR;
		else
			nstate <= IDLE;
	end
	DEV_ADDR:begin
		if(!addr_detect)
			nstate <= IDLE;
		else if(rd_or_wr)//write --> bit = 0 ;read --> bit = 1
			nstate <= READ;
		else 
			nstate <= IDX_PTR;
	end
	READ:begin
        if(sda_from_mst)// for NACK
			nstate <= IDLE;
		else
			nstate <= READ;
	end
	IDX_PTR:begin
		nstate <= WRITE;
	end
	WRITE:begin
        nstate <= WRITE;
	end
	default:begin
		nstate <= IDLE;
	end
	endcase
end

//regs' pointer
reg [1:0] pointer;

always@(negedge scl or negedge rst_n)begin
	if(!rst_n)
		pointer <= 2'd0;
	else if(stop_detect)
		pointer <= 2'd0;
	else begin
		case(cstate)
			IDLE:begin
				pointer <= 2'd0;
			end
			DEV_ADDR:begin
				if(ack_bit)
					pointer <= pointer + 1'b1;//when 8 bit finished, will restore the tx_shift,so must positioning the pointer early
			end
			READ:begin
				if(ack_bit)
					pointer <= pointer + 1'b1;//姣忎紶瀹?8bit鏁版嵁鍚庯紝鍦板潃+1锛屼緵鍐呴儴绉讳綅瀵勫瓨鍣ㄦ彁鍓嶅瓨鍌ㄦ暟鎹??
			end
			IDX_PTR:begin
				if(ack_bit)
					pointer <= rx_shift[1:0];//as a tester,shall set the first DATA = 8'b0;
			end
			WRITE:begin
				if(ack_bit)
					pointer <= pointer + 1'b1;
			end
			default:begin
				pointer <= 2'd0;
			end
		endcase
	end
end

//slave tx data to bus && ack/nack
reg [7:0] tx_shift;

always@(negedge scl)begin
	if(lsb_bit)
		tx_shift <= reg_data_rd;//when 8 bit finished, restore the tx_shift
	else 
		tx_shift <= {tx_shift[6:0],1'b0};//when 8 bit unfinished, shift bit for tx 
end

always@(negedge scl or negedge rst_n)begin
	if(!rst_n)
		output_ctrl <= 1'b1;
	else begin
		case(cstate)
			IDLE:begin
				output_ctrl <= 1'b1;
			end
			DEV_ADDR:begin
				if(lsb_bit)begin//after negedge sample lsb_bit, slave active on sda bus
					if(addr_detect)
						output_ctrl <= 1'b0;//indicate ack
					else
						output_ctrl <= 1'b1;
				end
				else if (ack_bit)begin
				    if(addr_detect && rd_or_wr)
				        output_ctrl <= tx_shift[7]; Deliver the first bit of DATA in DEV_ADDR. !!important!!
				    else 
				        output_ctrl <= 1'b1;
				end
				else begin
				    output_ctrl <= 1'b1;
				end
			end
			READ:begin
			     if(ack_bit )begin//consider 9bit's master ACK/NACK 
			         if(!sda_from_mst)
			             output_ctrl <= tx_shift[7];//if master ACK
			         else
			             output_ctrl <= 1'b1;//if master NACK
			     end  
			     else begin//other bit
					output_ctrl <= tx_shift[7];//MSB fisrt
				 end
			end
			IDX_PTR:begin
				if(lsb_bit)
					output_ctrl <= 1'b0;//indicate ack
				else
					output_ctrl <= 1'b1;
			end
			WRITE:begin
				if(lsb_bit)
					output_ctrl <= 1'b0;//indicate ack
				else
					output_ctrl <= 1'b1;
			end
			default:begin
				output_ctrl <= 1'b1;
			end
		endcase
	end
end

output assignment
assign reg_addr = pointer;
assign wen = (cstate == WRITE) && ack_bit;
assign reg_data_wr = rx_shift;

endmodule

 原项目                                                                                                                                             Robust I2C slave without a sampling clock

小土真
关注
i2c_slave.v
10-22
i2c slave 程序 经过项目验证。verilog语言
i2c slave接口
05-20
I2C Slave（FPGA 代码），已经验证过，可以用
I2C Slave
ChinaSanDuo的专栏
03-06 3824
使用I2C Slave与I2C Master通信。 同步级别：不受保护。 I2CSlave类引用 Public Member Functions I2CSlave(PinName sda, PinName scl) 创建一个I2CSlave接口，连接到指定的引脚。更多 void frequency(int hz) 设置I2C接口的频率...
i2c_SLAVE
GGbao_的博客
08-03 857
下图仅仅为数据分析线程。如果是10bitADDR，先判断地址高两位是否一致，不一致则回复NACK，一致的话，回复ACK并判断读写位，是写，则接收第二byte数据判断是否匹配，不匹配则回复NACK，匹配的话，就回复ACK并释放总线，（如果是读，那么这里主机会产生RS，收集数据这里就不会执行）接收总线上传来的数据。如果是DEVICE_ID，回ACK，然后判断读写位是1还是0，是0 的话，continue，接着从forever头开始执行，等待START。匹配回复ACK，如果是写，释放总线，接收SDA上数据。
Linux内核学习：I2C_SLAVE_FORCE
tomxue0126的专栏
11-30 1万+
在Linux内核源代码include/linux/i2c-dev.h文件内，有如下定义： #define I2C_SLAVE 0x0703 /* Use this slave address */ #define I2C_SLAVE_FORCE 0x0706 /* Use this slave address, even if it is already in use by
基于FPGA的I2C SLAVE模式总线的设计.pdf
07-13
本文档详细介绍了如何基于现场可编程门阵列（FPGA）设计一个符合I2C SLAVE模式总线接口。I2C总线是一种串行通信协议，广泛应用于低速外围设备与主板CPU或嵌入式系统的通讯。在本设计中，将利用FPGA来实现SLAVE模式，...
i2c slave module_salve_i2c_i2cslave_verilog_breakfastubc
09-11
标题中的“i2c slave module_salve_i2c_i2cslave_verilog_breakfastubc”指的是一个基于Verilog语言实现的I2C从设备模块。这个模块是为电子系统设计中的I2C通信协议而编写的，I2C（Inter-Integrated Circuit）是一种...
STM32F030C8-IIC-Slave-master.zip_STM32F030 寄存器_i2c slave_stm32f0
07-14
HAL库提供了高级的API函数，如HAL_I2C_Slave_Receive_IT()，用于从I2C从机模式接收数据，而LL库则提供底层的低级驱动，可以更直接地访问和控制寄存器。 总的来说，这个项目涉及到STM32F030C8的I2C从机功能实现，...
兼容opencores.org的I2C slave的rtl代码
08-24
最近一个项目需要做I2C的slave，在opencores.org上面找到了一个I2C的代码，不过是master的。 下载来看看，发现里面有一个I2C slave的行为级代码。 于是自己根据这个代码改写了一个I2C slave RTL的代码，并修改了...
I2C.zip_I2c slave linux
09-21
标题"I2C.zip_I2c slave linux"指向的是一个关于Linux环境下I2C从设备（slave）模拟模型的压缩包，包含对I2C协议及其在Linux系统中的应用的介绍。这里，我们将深入探讨I2C协议以及如何在Linux中实现I2C从设备。 I2C...
I2C slave SOPC
03-09
一个I2c个 slave 模块，做成IP核挂在AVALON总线上，可通过niosII访问
I2C_Slave-STM32f10x
05-10
I2C_从站-STM32f10x 这是用于STM32F10x芯片组的基本软件I2C从设备。 它使用SDA线上的中断来检测从主机发送的启动条件。 它使用PA0作为SDA线，使用PA1作为SCL线。 它有一个256字节的data_register，主机和从机都可以在其中读写。 它使用以下标准写入顺序：开始位，7位从机地址，1位RW = 0，从机ACK，8位寄存器地址，从机ACK，每个字节后n个字节以及从机ACK，停止位到结束传输 它使用以下标准读取顺序：起始位，7位从机地址，1位RW = 0，从机ACK，8位寄存器地址，从机ACK，重复起始位，从机地址，从机ACK，从机从主机发送n位和ACK直到从机无法从主机接收到ACK为止。
模拟I2C程序 slave 接收
09-07
实现用IO口模拟I2C slave程序，采用中断处理；
I2C Slave Verilog
11-28
网上找的一些I2C从设备代码都没用起来，于是自己写了一个。能实现读取和写入任意一个字节的功能。功能上目前已经够用，连续读取和写入多个字节的就没有加了。
I2C_slave FPGA实现
03-30
自己写的I2C_SLAVE希望对大家有用，可以参考
STM32 I2C Slave(SMBUS)模式软件参考设计
热门推荐
masterbee的博客
07-05 2万+
I2C大家都很熟悉，总共2根线，CLK和DATA，stm32的I2C相信大家就更熟悉了，采用写控制器的方式，直接由控制器去完成I2C时序操作，用户无需关心具体产生的逻辑。然而，大部分情况下，使用的都是I2C Master模式，即主设备模式，很少当成slave模式即从设备模式来用，这篇文章讲的是如何把stm32 I2C当成slave模式来使用，更严格来说，本篇讲的是smbus模式。 从官网stm...
i2c slave 模块设计
weixin_46163885的博客
07-06 5837
首先就不啰嗦iic协议了，网上有不少资料都是叙述此协议的。 下面将是我本次设计的一些局部设计汇总，如果对读者有借鉴意义那最好，如果没有的话也无所谓，互相交流而已。（这是我早期的版本，注释比较少，代码编写比较混乱，读者自便） 希望读者发现问题可在下方留言，我会及时回答或者修改。 下面将会以图片为主。 结构图 结构图 ​​​ master结构图 slave结构图 ​​​​​​ iic_slave.v sync.v wr_fsm.v ...
STM32F407硬件I2C Slave
发呆健将的博客
05-20 4588
MCU:STM32F407ZET6 IDE:STM32CubeIDE HAL库 硬件I2C当作Slave,模拟EEPROM行为 测试工具：树莓派为I2C主机，使用I2C-tools进行测试 配置I2C为Slave，从机地址直接在代码中修改，开启中断 以下为main.c中的程序 /* Includes ------------------------------------------------------------------*/ #include "main.h" /* P.
STM32F103硬件I2C Slave
发呆健将的博客
05-21 3750
MCU:STM32F103 IDE:STM32CubeIDE HAL库 硬件I2C当作Slave,模拟EEPROM行为 测试工具：树莓派为I2C主机，使用I2C-tools进行测试 配置I2C:从机地址可直接在代码中修改，记得开启中断 main.c代码： /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #includ
mcu 模拟 i2c slave
最新发布
12-26
模拟I2C slave是指MCU可以模拟成I2C总线上的从设备。 在实际应用中，MCU模拟I2C slave可以充当各种外围设备，比如传感器、存储器、显示器等，来与其他主设备进行通信。通过模拟I2C slave，MCU可以接收来自主设备的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小土真

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值