• IIC学习笔记（参考小梅哥教程）

    基本知识

    IIC: inter-integrated circuit bus ,即 集成电路总线，串行通信，多主从架构，半双工（对讲机），小数据量场合，短距离传输。

    速率：100kb/s 、 400kb/s 、 3.4Mkb/s

    传输单位：8位（一个字节）（双向）

    架构：每个IIC器件都可作为主/从器件，一个时间只有一个主设备

    两条总线线路：SCL（串行时钟线）、 SDA（串行数据线）总线拓扑结构如图

           图中，每个IIC器件拥有唯一地址（识别码）。

           主机往总线上发送地址，所有的从机都能接收到主机发出的地址，然后每个从机都将主机发出的地址与自己的地址比较，如果匹配上了，这个从机就会向总线发出一个响应信号。主机收到响应信号后，开始向总线上发送数据，与这个从机的通讯就建立起来了。如果主机没有收到响应信号，则表示寻址失败。

    IIC帧格式

    默认规定：SCL高电平时，SDA稳定；SCL低电平时，SDA变化。（依此设定SDA的数据变化时刻，在SCL的低电平中点变化较为靠谱）.在scl高电平时读/写数据。

    响应位：当 IIC 主机（不一定是发送端还是接受端）将8位数据或命令传出后， SDA释放，即设置为输入，然后等待从机应答（低电平 0 表示应答，1 表示非 应答），此时的时钟仍然是主机提供的。

    起始信号：SCL高且SDA出现下降沿。

    停止信号：SCL高且SDA出现上升沿。

    器件地址

            每个I2C器件都有一个器件地址，有的器件地址在出厂时地址就设置好了，用户不可以 更改（例如 OV7670 器件地址为固定的 0x42），有的确定了几位，剩下几位由硬件确定（比 如常见的I2C接口的EEPROM存储器，留有3个控地址的引脚，由用户自己在硬件设计时确定）。

            对于AT24C64这样一颗EEPROM器件，其器件地址为1010加3位的片选信号。3位片选信号由硬件连接设定。当硬件电路上分别将这三个引脚连接到 GND 或 VCC 时，就可以设置不同的片选地址。

            I2C传输时，按照从高到低的位序进行传输。控制字节的最低位为读写控制位，当该位 为0时表示主机对从机进行写操作，当该位为1时表示主机对从机进行读操作。

            在某些IIC器件中，A2 A1 A0可以当作存储单元地址来用。存储器地址一般为1或2字节。取决于IIC器件容量。

    IIC写时序

    时序：

    1、主机设置 SDA 为输出；发送起始信号；

    3、主机传输器件地址字节，其中最低位为 0，表明为写操作；

    4、主机设置 SDA 为三态门输入，读取从机应答信号；

    5、读取应答信号成功，主机设置 SDA 为输出，传输地址数据高字节；

    6、主机设置 SDA 为三态门输入，读取从机应答信号；

    7、读取应答信号成功，主机设置 SDA 为输出，传输地址数据低字节；

    8、设置 SDA 为三态门输入，读取从机应答信号；

    9、读取应答信号成功，主机设置 SDA 为输出，传输待写入的数据；

    10、设置 SDA 为三态门输入，读取从机应答信号；

    11、读取应答信号成功，主机产生 STOP 位，终止传输。

    IIC页写时序（连续写）

    主机连续写多个字节数据到从机，I2C连续写时序仅部分器件支持。

    时序类似上面，只是变成了连续写n个数据。

    IIC读时序

    注意：虽然是读时序，但是这里先用了写信号告诉从机要读的存储器地址，然后再换成读信号把该地址的数据读到主机。

    1、主机设置 SDA 为输出；发送起始信号；

    3、主机传输器件地址字节，其中最低位为 0，表明为写操作；

    4、主机设置 SDA 为三态门输入，读取从机应答信号；

    5、读取应答信号成功，主机设置 SDA 为输出，传输地址数据高字节；

    6、主机设置 SDA 为三态门输入，读取从机应答信号；

    7、读取应答信号成功，主机设置 SDA 为输出，传输地址数据低字节；

    8、设置 SDA 为三态门输入，读取从机应答信号；

    9、读取应答信号成功，主机发起起始信号；

    10、主机传输器件地址字节，其中最低位为 1，表明为读操作；

    11、设置 SDA 为三态门输入，读取从机应答信号；

    12、读取应答信号成功，主机设置 SDA 为三态门输入，读取 SDA 总线上的一个字节的 数据；

    13、主机设置 SDA 输出，产生无应答信号（高电平）（不想继续读数据了）（无需设置为输出高电平，因为总线会被自动拉高）；

    14、主机产生 STOP 位，终止传输。

    IIC页读时序

    读数据时用ACK应答，不想继续读时用NOACK应答即可。

    IIC控制器设计

    对完整的读和写时序进行分析，可以总结为五种情况：

    每段在传输的时候，只需要确定当前这个字节的传输 之前是否需要加入起始位，以及当前这个字节的传输结束后是否需要加入停止位就结束了。

    注意事项：

    verilog inout类型设计要点：三态门：用   x = ctrl ？ A : 1'bz  即可控制为输出或者高阻态（成为输入）

    对于IIC器件，由于芯片无法输出高电平(防止多个芯片同时产生高电平，导致冲突)，故需在电路上连接上拉电阻与电源，然后让芯片输出高阻态来实现高电平，故逻辑设计为：IIC_SDA = ctrl ？( a ? 1'bz : 0 ) : 1'bz  （这是inout类型的最好写法）化简合并：IIC_SDA = （ ctrl && ！a ）1‘b0 : 1'bz 

    如果不修改，直接用   x = ctrl ？ A : 1'bz  ，可能出现冲突的情况如下：

    仿真时可以在testbench文件中用pullup() 或者 pulldown() 来模拟上拉和下拉。（高阻态时即被上拉或者下拉）

    Modelsim仿真时，如果有模块只在testbench文件中存在，没有在quartus中编译（如：引用别人的模块），则需要把该模块文件加入modelsim的编译中，如下图：

                                            verilog设计

    1.时钟设计

            根据IIC时序图，设计时钟需要从两点出发：

    ①在IIC_scl高电平中点读取数据，则我们需要在IIC_scl低电平中点改变数据，从而保证读取数据时数据的稳定性。

    ②起始信号和终止信号是指在IIC_scl高电平时IIC_sda出现变化沿。

                          

    所以，我们需要用比IIC_scl频率更高的时钟来设计IIC_sda的输出。

    IIC_scl的时钟为100kb/s、400kb/s和3.4Mb/s，这里分别用400kb/s、1600kb/s来设计IIC_sda（即4倍时钟频率）。

    由于IIC_sda数据的变化点在IIC_scl的前一个周期（当前周期数据需要稳定可读取），而变化沿的产生又在同一个周期（设定），如果直接用IIC_scl来设计状态机的话，会出现如图情况（即需要在start_bit_state状态里同时设计上升沿和第一个要写的数据，非常不方便）。为了状态机的书写方便，用于设计状态机的驱动时钟相对IIC_scl移相90°（这样就可以在start_bit_state状态只设计上升沿，所有要写的数据都在wr_data_state状态里设计），具体看图（可以先看状态机再回头看这儿）

    2.架构设计

            IIC协议的目的是为了：

    1.向某个IIC器件的某个存储单元写入数据；

    2.从某个IIC器件的某个存储单元读出数据；

    2.1 驱动逻辑模块

    为了实现这两个功能，需要根据时序图，用两个线性序列机分别设计读和写的状态顺序和时序。其中，写控制信息、写存储单元地址、写数据均可以归结为写数据一个状态，具体状态划分如下：

                                                    

    写逻辑：空闲 --> 产生起始位 --> 写控制信息 --> 检查应答 --> 写存储器高位地址 --> 检查应答 --> 写存储器低位地址 --> 检查应答 --> 写数据 --> 检查应答 --> 产生结束位 --> 空闲

    即： idel_state --> start_bit_state --> wr_data_state --> ack_check_state --> wr_data_state --> ack_check_state --> wr_data_state --> ack_check_state --> wr_data_state --> ack_check_state --> stop_bit_state --> idel_state_state

    读逻辑：空闲 --> 产生起始位 --> 写控制信息 --> 检查应答 --> 写存储器高位地址 --> 检查应答 --> 写存储器低位地址 --> 检查应答 --> 产生起始位 --> 写控制信息 --> 检查应答 --> 读数据 --> 产生应答 -->产生结束位 --> 空闲

    即： idel_state --> start_bit_state --> wr_data_state --> ack_check_state --> wr_data_state --> ack_check_state --> wr_data_state --> ack_check_state --> start_bit_state --> wr_data_state --> ack_check_state --> rd_data_state --> gen_noack_state--> stop_bit_state --> idel_state

    从而，IIC的驱动模块架构如下：

                         

            其中，根据wr_sig / rd_sig 来产生开启一次读/写的完整操作，由cmd控制状态，通过时序逐个把IIC_id、wr_addr、rd_addr、wr_data通过write_data输出，通过接受trans_done信号来结束一次读/写操作。

    2.2 底层逻辑模块

            这一层模块用于接受驱动模块发出的命令（即状态指令），根据指令对接受的wr_data进行输出；设计8种状态需要对IIC_sda总线的输出和输入进行的操作。根据时序图，结合线性序列机和状态机进行编写即可，重点在于数据变化的时刻以及IIC_scl这种inout三态门的输入输出设计（前面已经介绍）。

                                            

    3.代码设计

    1. module IIC_design(
    2. 	input fpga_clk,//50MHz
    3. 	input rst_n ,
    4. 	input rate_sel ,
    5. 	input read_pulse ,
    6. 	input write_pulse ,
    7. 	input [7:0]write_data ,
    8. 	input [7:0]IIC_id ,
    9. 	input [15:0]wr_addr ,
    10. 	input [15:0]rd_addr ,
    11. 	
    12. 	output trans_done ,
    13. 	output [7:0]read_data ,
    14. 	output IIC_scl ,
    15. 	inout IIC_sda
    16. );
    17.  
    18.  
    19.  
    20. //*******   IIC_scl设计      ******* //
    21. wire clk_16M ;	//
    22. wire clk_4M ;
    23. wire clk_4M90 ;
    24. wire clk_1M ;
    25. wire clk_1M90 ;
    26. wire clk_1600k ;
    27. wire clk_400k ;//对应 scl 400kb/s 速率
    28. wire clk_400k108 ;
    29. wire clk_100k ;//对应 scl 100kb/s 速率
    30. wire clk_100k108 ;
    31. wire sda_clk ;//控制时序的时钟
    32. wire drive_clk ; //产生cmd的时钟
    33. //锁相环分频
    34.  pll pll_inst1(
    35. 	.inclk0(fpga_clk),
    36. 	.c0(clk_16M),
    37. 	.c1(clk_4M),
    38. 	.c2(clk_1M)
    39. 	);
    40. //10分频
    41. fenpin_10 fenpin_10_inst1(
    42. 	.clk(clk_4M),
    43. 	.rst_n(rst_n),
    44. 	.outClk(clk_400k)
    45. );	
    46. fenpin_10 fenpin_10_inst2(
    47. 	.clk(clk_1M),
    48. 	.rst_n(rst_n),
    49. 	.outClk(clk_100k)
    50. );	
    51. fenpin_10 fenpin_10_inst3(
    52. 	.clk(clk_16M),
    53. 	.rst_n(rst_n),
    54. 	.outClk(clk_1600k)
    55. );	
    56.  
    57. fenpin_10_108du fenpin_10_108du_inst1(
    58. 	.clk(clk_4M),
    59. 	.rst_n(rst_n),
    60. 	.outClk(clk_400k108)
    61. );
    62. fenpin_10_108du fenpin_10_108du_inst2(
    63. 	.clk(clk_1M),
    64. 	.rst_n(rst_n),
    65. 	.outClk(clk_100k108)
    66. );
    67.  
    68. //设置IIC总线时钟 400kb/s 或 100kb/s
    69. assign IIC_scl = rate_sel ? clk_400k : clk_100k ;
    70. assign sda_clk = rate_sel ? clk_1600k : clk_400k  ;
    71. assign drive_clk = rate_sel ? clk_400k108 : clk_100k108 ;
    72. //**********************************//
    73.  
    74. wire [7:0]rd_data ;
    75. wire ack_result ;
    76. wire [7:0]command ;
    77. wire [7:0]wr_data ;
    78. IIC_drive IIC_drive_inst(
    79. 	.fpga_clk(fpga_clk) ,//50MHz
    80. 	.drive_clk(drive_clk),
    81. 	.rst_n(rst_n) ,
    82. 	.wr_sig(write_pulse) ,
    83. 	.rd_sig(read_pulse) ,
    84. 	.wr_data(write_data) ,
    85. 	.rd_data(rd_data) ,
    86. 	.IIC_id(IIC_id) ,
    87. 	.wr_addr(wr_addr) ,
    88. 	.rd_addr(rd_addr) ,
    89. 	.trans_done(trans_done) ,
    90. 	.ack_result(ack_result) ,
    91. 	
    92. 	.cmd(command) ,
    93. 	.read_data(read_data) ,
    94. 	.write_data(wr_data)
    95. 	
    96. );
    97.  
    98. IIC_underlying_logic IIC_underlying_logic_inst(
    99. 	
    100. 	.sda_clk(sda_clk) ,//
    101. 	.rst_n(rst_n) ,
    102. 	.cmd(command) ,
    103. 	.wr_data(wr_data) ,
    104. 		
    105. 	.rd_data(rd_data) ,
    106. 	.ack_result(ack_result) ,
    107. 	.trans_done(trans_done) ,
    108. 	.IIC_sda(IIC_sda)
    109.  
    110. );
    111.  
    112. endmodule
    1. module IIC_drive(
    2. 	input fpga_clk ,//50MHz
    3. 	input drive_clk,
    4. 	input rst_n ,
    5. 	input wr_sig ,
    6. 	input rd_sig ,
    7. 	input [7:0]wr_data ,
    8. 	input [7:0]rd_data ,
    9. 	input [7:0]IIC_id ,
    10. 	input [15:0]wr_addr ,
    11. 	input [15:0]rd_addr ,
    12. 	input trans_done ,
    13. 	input ack_result ,
    14. 	
    15. 	output reg [7:0]cmd ,
    16. 	output reg [7:0]read_data ,
    17. 	output reg [7:0]write_data
    18. 	
    19. );
    20. reg rd_pulse_reg ;
    21. reg wr_pulse_reg ;
    22. always@(posedge fpga_clk)
    23. begin
    24. 	wr_pulse_reg <= wr_sig ;
    25. 	rd_pulse_reg <= rd_sig ;
    26. end
    27.  
    28. reg read_sig ;
    29. reg write_sig ;
    30. always@(posedge fpga_clk or negedge rst_n)
    31. if(!rst_n)
    32. 	begin
    33. 		read_sig <= 0 ;
    34. 	end
    35. else if( rd_pulse_reg == 0 && rd_sig == 1 )
    36. 		read_sig <= 1 ;
    37. else if( trans_done )
    38. 		read_sig <= 0 ;
    39. 	
    40. always@(posedge fpga_clk or negedge rst_n)
    41. if(!rst_n)
    42. 	begin
    43. 		write_sig <= 0 ;
    44. 	end
    45. else if( wr_pulse_reg == 0 && wr_sig == 1 )
    46. 		write_sig <= 1 ;
    47. else if(trans_done)
    48. 		write_sig <= 0 ;
    49.  
    50. //定义状态机7个状态参数
    51. localparam idel_state 		= 8'b10000000 ;  //空闲态:释放sda控制权
    52. localparam start_bit_state = 8'b01000000 ; //产生起始位
    53. localparam wr_data_state   = 8'b00100000 ; // 写数据
    54. localparam rd_data_state   = 8'b00010000 ; // 读数据
    55. localparam ack_check_state = 8'b00001000 ; //检查响应
    56. localparam stop_bit_state  = 8'b00000100 ; //产生停止位
    57. localparam gen_ack_state   = 8'b00000010 ; //产生停止位
    58. localparam gen_noack_state = 8'b00000001 ; //产生停止位
    59. 		
    60. //写逻辑
    61. reg [5:0]write_cnt ;
    62. //读逻辑
    63. reg [5:0]read_cnt ;
    64. always@(posedge drive_clk or negedge rst_n)
    65. if(!rst_n)
    66. 	begin
    67. 		cmd <= idel_state ;
    68. 		write_cnt <= 0 ;
    69. 		write_data <= 0 ;
    70. 		read_cnt <= 0 ;
    71. 		read_data <= 0 ;
    72. 	end
    73. else if( write_sig == 1 )
    74. 	begin
    75. 		write_cnt <= write_cnt + 1 ;
    76. 		if(ack_result)
    77. 			begin
    78. 				cmd <= ack_check_state ;
    79. 				write_cnt <= 0 ;
    80. 			end
    81. 		else
    82. 			begin
    83. 				if(write_cnt == 1)
    84. 					cmd <= idel_state ;//进入空闲态
    85. 				else if ( write_cnt == 2 )
    86. 					begin
    87. 						cmd <= start_bit_state ;//产生起始位
    88. 					end
    89. 				else if ( write_cnt == 3 )
    90. 					begin
    91. 						cmd <= wr_data_state ;
    92. 						write_data <= IIC_id ;//发送IIC器件ID
    93. 					end
    94. 				else if ( write_cnt == 11)
    95. 					begin
    96. 						cmd <= ack_check_state ;
    97. 					end
    98. 				else if ( write_cnt == 12 )
    99. 					begin
    100. 						cmd <= wr_data_state ;
    101. 						write_data <= wr_addr[15:8] ;//写存储器高位地址
    102. 					end
    103. 				else if ( write_cnt == 20 )
    104. 					begin
    105. 						cmd <= ack_check_state ;
    106. 					end
    107. 				else if ( write_cnt == 21 )
    108. 					begin
    109. 						cmd <= wr_data_state ;
    110. 						write_data <= wr_addr[7:0] ;//写存储器低位地址
    111. 					end
    112. 				else if ( write_cnt == 29 )
    113. 					begin
    114. 						cmd <= ack_check_state ;
    115. 					end
    116. 				else if ( write_cnt == 30 )
    117. 					begin
    118. 						cmd <= wr_data_state ;
    119. 						write_data <= wr_data ; //写数据
    120. 					end
    121. 				else if ( write_cnt == 38 )
    122. 					begin
    123. 						cmd <= ack_check_state ;
    124. 					end
    125. 				else if ( write_cnt == 39 )
    126. 					begin
    127. 						cmd <= stop_bit_state ;//产生停止位
    128. 					end
    129. 				else if ( write_cnt == 40 )
    130. 					begin
    131. 						cmd <= idel_state ;//进入空闲态
    132. 						write_cnt <= 0 ;
    133. 					end
    134. 			end
    135. 	end	
    136. else if( read_sig == 1 )
    137. 	begin
    138. 		read_cnt <= read_cnt + 1 ;
    139. 		if(ack_result)
    140. 			begin
    141. 				cmd <= ack_check_state ;
    142. 				read_cnt <= 0 ;
    143. 			end
    144. 		else
    145. 			begin
    146. 				if(read_cnt == 1)
    147. 					cmd <= idel_state ;//进入空闲态
    148. 				else if ( read_cnt == 2 )
    149. 					begin
    150. 						cmd <= start_bit_state ;//产生起始位
    151. 					end
    152. 				else if ( read_cnt == 3 )
    153. 					begin
    154. 						cmd <= wr_data_state ;
    155. 						write_data <= IIC_id ;//发送IIC器件ID 和写指令
    156. 					end
    157. 				else if ( read_cnt == 11)
    158. 					begin
    159. 						cmd <= ack_check_state ;
    160. 					end
    161. 				else if ( read_cnt == 12 )
    162. 					begin
    163. 						cmd <= wr_data_state ;
    164. 						write_data <= rd_addr[15:8] ;//写存储器高位地址
    165. 					end
    166. 				else if ( read_cnt == 20 )
    167. 					begin
    168. 						cmd <= ack_check_state ;
    169. 					end
    170. 				else if ( read_cnt == 21 )
    171. 					begin
    172. 						cmd <= wr_data_state ;
    173. 						write_data <= rd_addr[7:0] ;//写存储器低位地址
    174. 					end
    175. 				else if ( read_cnt == 29 )
    176. 					begin
    177. 						cmd <= ack_check_state ;
    178. 					end
    179. 				else if ( read_cnt == 30 )
    180. 					begin
    181. 						cmd <= start_bit_state ;
    182. 					end	
    183. 				else if ( read_cnt == 31 )
    184. 					begin
    185. 						cmd <= wr_data_state ;
    186. 						write_data <= ( IIC_id | 6'b000001 ) ;//写IIC器件ID 和读指令
    187. 					end
    188. 				else if ( read_cnt == 39 )
    189. 					begin
    190. 						cmd <= ack_check_state ;
    191. 					end					
    192. 				else if ( read_cnt == 40 )
    193. 					begin
    194. 						cmd <= rd_data_state ;
    195. 					end
    196. 				else if ( read_cnt == 48 )
    197. 					begin
    198. 						cmd <= gen_noack_state ;
    199. 					end
    200. 				else if ( read_cnt == 49 )
    201. 					begin
    202. 						cmd <= stop_bit_state ;//产生停止位
    203. 						read_data <= rd_data ; //寄存读数据
    204. 					end
    205. 				else if ( read_cnt == 50 )
    206. 					begin
    207. 						cmd <= idel_state ;//进入空闲态
    208. 						write_cnt <= 0 ;
    209. 					end
    210. 			end
    211. 	end	
    212. else
    213. 	begin
    214. 		cmd <= idel_state ;
    215. 		write_cnt <= 0 ;
    216. 		read_cnt <= 0 ;
    217. 	end
    220. endmodule
    1. module IIC_underlying_logic(
    2. 	
    3. 	input sda_clk ,//
    4. 	input rst_n ,
    5. 	input [7:0]cmd ,
    6. 	input [7:0]wr_data ,
    7. 	
    8. 	output reg [7:0]rd_data ,
    9. 	output reg ack_result ,
    10. 	output reg trans_done ,
    11. 	inout  IIC_sda
    12.  
    13. );
    14.  
    15.  
    16. //********* IIC_sda设计 ************//
    17. reg sda_out ;
    18. reg sda_ctrl;
    19. assign IIC_sda = sda_ctrl ? ( sda_out ? 1'bz : 1'b0 ) : 1'bz ; //三态门，高阻态时，要么由总线上的上拉电阻拉至高电平，即输出/输出1；要么由从机拉至0，输入0；
    22. //定义状态机7个状态参数
    23. localparam idel_state 		= 8'b10000000 ;  //空闲态:释放sda控制权
    24. localparam start_bit_state = 8'b01000000 ; //产生起始位
    25. localparam wr_data_state   = 8'b00100000 ; // 写数据
    26. localparam rd_data_state   = 8'b00010000 ; // 读数据
    27. localparam ack_check_state = 8'b00001000 ; //检查响应
    28. localparam stop_bit_state  = 8'b00000100 ; //产生停止位
    29. localparam gen_ack_state   = 8'b00000010 ; //产生停止位
    30. localparam gen_noack_state = 8'b00000001 ; //产生停止位
    33. reg [7:0]rw_state ;//实时状态
    34. always@( posedge sda_clk or negedge rst_n )
    35. if(!rst_n)
    36. 	begin
    37. 		rw_state <= idel_state ;
    38. 	end
    39. else 
    40. 	begin
    41. 		if( cmd & idel_state )
    42. 			rw_state <= idel_state ;
    43. 		else if ( cmd & start_bit_state )
    44. 			rw_state <= start_bit_state ;
    45. 		else if ( cmd & wr_data_state )
    46. 			rw_state <= wr_data_state ;
    47. 		else if ( cmd & rd_data_state )
    48. 			rw_state <= rd_data_state ;
    49. 		else if ( cmd & ack_check_state )
    50. 			rw_state <= ack_check_state ;
    51. 		else if ( cmd & stop_bit_state )
    52. 			rw_state <= stop_bit_state ;
    53. 		else if ( cmd & gen_ack_state )
    54. 			rw_state <= gen_ack_state ;	
    55. 		else if ( cmd & gen_noack_state )
    56. 			rw_state <= gen_noack_state ;
    57. 	end
    58. 	
    59. reg [5:0]cnt ;
    60. always@( posedge sda_clk or negedge rst_n )
    61. if(!rst_n)
    62. 	begin
    63. 		sda_out <= 1'b1 ;
    64. 		sda_ctrl<= 1'b0 ;
    65. 		trans_done <= 0 ;
    66. 		ack_result <= 0 ;
    67. 		rd_data <= 0 ;
    68. 		cnt <= 1'b0 ;
    69. 	end
    70. else 
    71. 	begin
    72. 		case(rw_state)
    73. 			
    74. 			idel_state:
    75. 				begin
    76. 					cnt <= 1'b0 ;
    77. 					sda_ctrl<= 1'b0 ;//释放sda控制权
    78. 					sda_out <= 1'b1 ;
    79. 					trans_done <= 0 ;
    80. 					ack_result <= 0 ;
    81. 				end		
    82. 			start_bit_state:
    83. 				begin		
    84. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    85. 					if(cnt == 2 )
    86. 						begin
    87. 							sda_out <= 1'b0 ;
    88. 						end
    89. 					cnt <= cnt + 1 ;	
    90. 					if(cnt == 3 )
    91. 						cnt <= 0 ;
    92. 				end
    93. 			wr_data_state:
    94. 				begin
    95. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    96. 					if( cnt == 0 )
    97. 						sda_out <= wr_data[7] ;
    98. 					else if ( cnt == 4 )
    99. 						sda_out <= wr_data[6] ;
    100. 					else if ( cnt == 8 )
    101. 						sda_out <= wr_data[5] ;	
    102. 					else if ( cnt == 12 )
    103. 						sda_out <= wr_data[4] ;	
    104. 					else if ( cnt == 16 )
    105. 						sda_out <= wr_data[3] ;	
    106. 					else if ( cnt == 20 )
    107. 						sda_out <= wr_data[2] ;
    108. 					else if ( cnt == 24 )
    109. 						sda_out <= wr_data[1] ;	
    110. 					else if ( cnt == 28 )
    111. 						sda_out <= wr_data[0] ;
    112. 					cnt <= cnt +1 ;
    113. 					if( cnt == 31 )
    114. 						cnt <= 0 ;
    115. 				end				
    116. 			rd_data_state:
    117. 				begin
    118. 					sda_ctrl<= 1'b0 ;//释放sda控制权
    119. 					if( cnt == 2 )
    120. 						rd_data[7] <= IIC_sda ;
    121. 					else if ( cnt == 6 )
    122. 						rd_data[6] <= IIC_sda ;
    123. 					else if ( cnt == 10 )
    124. 						rd_data[5] <= IIC_sda ;	
    125. 					else if ( cnt == 14 )
    126. 						rd_data[4] <= IIC_sda ;
    127. 					else if ( cnt == 18 )
    128. 						rd_data[3] <= IIC_sda ;
    129. 					else if ( cnt == 22 )
    130. 						rd_data[2] <= IIC_sda ;
    131. 					else if ( cnt == 26 )
    132. 						rd_data[1] <= IIC_sda ;
    133. 					else if ( cnt == 30 )
    134. 						rd_data[0] <= IIC_sda ;
    135. 					cnt <= cnt +1 ;
    136. 					if( cnt == 31 )
    137. 						cnt <= 0 ;
    138. 				end
    139. 			ack_check_state:
    140. 				begin
    141. 					sda_ctrl<= 1'b0 ;//释放sda控制权
    142. 					if( cnt == 2 )
    143. 						ack_result <= IIC_sda ;
    144. 					cnt <= cnt + 1 ;
    145. 					if( cnt == 3 )
    146. 						cnt <= 0 ;
    147. 				end
    148. 			stop_bit_state:
    149. 				begin
    150. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    151. 					sda_out <= 1'b0 ;
    152. 					if( cnt == 2 )
    153. 						begin
    154. 							sda_ctrl<= 1'b0 ;//释放sda控制权
    155. 						end
    156. 					cnt <= cnt + 1 ;	
    157. 					if(cnt == 3 )
    158. 						begin
    159. 							cnt <= 0 ;
    160. 							trans_done <= 1 ;
    161. 						end
    162. 				end
    163. 			gen_ack_state:
    164. 				begin
    165. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    166. 					sda_out <= 1'b0 ;
    167. 					cnt <= cnt + 1 ;	
    168. 					if(cnt == 3 )
    169. 						cnt <= 0 ;
    170. 				end
    171. 			gen_noack_state:
    172. 				begin
    173. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    174. 					sda_out <= 1'b1 ;
    175. 					cnt <= cnt + 1 ;	
    176. 					if(cnt == 3 )
    177. 						cnt <= 0 ;
    178. 				end
    179. 			default: ;
    180. 		endcase		
    181. 	end
    182. 	
    183. 	
    185. endmodule
    1. `timescale 1ns/1ns 
    2.  
    3. module IIC_design_tb();
    4.  
    5. reg fpga_clk ;
    6. reg rst_n ;
    7. reg rate_sel ;
    8. reg read_pulse ;
    9. reg write_pulse ;
    10. reg [7:0]write_data ;
    11. reg [7:0]IIC_id ;
    12. reg [15:0]wr_addr ;
    13. reg [15:0]rd_addr ;
    14. wire trans_done ;
    15. wire [7:0]read_data ;
    16. wire IIC_scl ;
    17. wire IIC_sda ;
    18.  
    19. pullup(IIC_sda) ;
    20.  
    21. IIC_design IIC_design_inst(
    22. 	.fpga_clk(fpga_clk),//50MHz
    23. 	.rst_n(rst_n) ,
    24. 	.rate_sel(rate_sel) ,
    25. 	.read_pulse(read_pulse) ,
    26. 	.write_pulse(write_pulse) ,
    27. 	.write_data(write_data) ,
    28. 	.IIC_id(IIC_id) ,
    29. 	.wr_addr(wr_addr) ,
    30. 	.rd_addr(rd_addr) ,
    31.  
    32. 	.trans_done(trans_done) ,
    33. 	.read_data(read_data) ,
    34. 	.IIC_scl(IIC_scl) ,
    35. 	.IIC_sda(IIC_sda)
    36. );
    37.  
    38.  
    39. M24LC04B M24LC04B_inst(
    40. 	.A0(0), 
    41. 	.A1(0), 
    42. 	.A2(0), 
    43. 	.WP(0), 
    44. 	.SDA(IIC_sda), 
    45. 	.SCL(IIC_scl), 
    46. 	.RESET(~rst_n)
    47. );
    48.  
    49. initial fpga_clk = 1 ;
    50. always #10 fpga_clk = ! fpga_clk ;
    51.  
    52. initial begin
    53. 	rst_n = 0 ;
    54. 	rate_sel = 1 ;
    55. 	read_pulse = 0 ;
    56. 	write_pulse = 0 ;
    57. 	write_data = 0 ;
    58. 	IIC_id = 0 ;
    59. 	wr_addr = 0 ;
    60. 	rd_addr = 0 ;
    61. 	#200 ;
    62. 	rst_n = 1 ;
    63. 	#1000 ;
    64. 	IIC_id = 8'b10100110 ;
    65. 	wr_addr = 16'd1 ;
    66. 	write_data = 8'd20 ;
    67. 	write_pulse = 1 ;
    68. 	#100 ;
    69. 	write_pulse = 0 ;
    70. 	#125000 ;
    71. 	rd_addr = 16'd1 ;
    72. 	read_pulse = 1 ;
    73. 	#100 ;
    74. 	read_pulse = 0 ;
    75. 	#250000 ;
    76. end
    77.  
    78.  
    79.  
    80. endmodule

    4.板级验证

            为验证代码可行性，设计如下验证程序 : fpga通过IIC协议向内部EEPROM存储器的某个单元写入数据，并能读取出来。

            设置两个按键：key1 产生写信号write_sig ；key2 产生写信号read_sig ；

            通过 in-systerm probes and sources 功能验证：

            引脚分配要注意IIC_scl和IIC_sda的引脚要根据手册对应连接，且IIC_id也要对应（这里eeprom存储器M24LC04B对应的器件ID为A0）

    1. module IIC_eeprom(
    2. 	input clk ,
    3. 	input rst_n ,
    4. 	input [1:0]key ,
    5. 	output IIC_scl ,
    6. 	inout IIC_sda 
    7. );
    8.  
    9. 	wire [7:0]read_data ;
    10. 	wire [15:0]addr ;
    11. 	wire [7:0]write_data ;
    12. 	
    13. 	wire write_sig ;
    14. 	wire read_sig  ;
    15. //assign addr = 16'd1 ;
    16. //assign write_data = 8'd250 ;
    17. 	IIC_design IIC_design_inst(
    18. 	.fpga_clk(clk),//50MHz
    19. 	.rst_n(rst_n) ,
    20. 	.rate_sel(1) ,
    21. 	.read_pulse(~read_sig) ,
    22. 	.write_pulse(~write_sig) ,
    23. 	.write_data(write_data) ,
    24. 	.IIC_id(8'ha0) ,
    25. 	.wr_addr(addr) ,
    26. 	.rd_addr(addr) ,
    27.  
    28. 	.trans_done() ,
    29. 	.read_data(read_data) ,
    30. 	.IIC_scl(IIC_scl) ,
    31. 	.IIC_sda(IIC_sda)
    32. );
    33.  
    34. buttopn_debounde buttopn_debounde_inst1(
    35.     .clk(clk),
    36.     .tx(key[1]),
    37.     .reset(rst_n),
    38.     .bd_tx(write_sig)
    39.     );
    40. buttopn_debounde buttopn_debounde_inst2(
    41.     .clk(clk),
    42.     .tx(key[0]),
    43.     .reset(rst_n),
    44.     .bd_tx(read_sig)
    45.     );
    46. insys_wrdata insys_wrdata_inst(
    47. 		.probe(),  //  probes.probe
    48. 		.source(write_data)  // 向addr写入数据
    49. 	);
    50. insys_rddata insys_rddata_inst(
    51. 		.probe(read_data),  //  probes.probe
    52. 		.source(addr)  // 手动输入地址，读取addr的数据
    53. 	);	
    54. 	 
    55. endmodule

    初始状态：

    修改addr：

    向addr写入数据66：

    从addr读出数据：

    串口-fpga-eeprom芯片

    功能：

    上位机（PC）通过uart串口协议与FPGA通信，发送想要向eeprom芯片写入的地址和数据，以及想要读取某地址的数据。FPGA通过IIC协议与eeprom芯片M24LC04B通信，读写数据。

    EEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。是相对于紫外擦除的rom来讲的。但是今天已经存在多种EEPROM的变种，变成了一类存储器的统称。这种rom的特点是可以随机访问和修改任何一个字节，可以往每个bit中写入0或者1。这是最传统的一种EEPROM，掉电后数据不丢失，可以保存100年，可以擦写100w次。具有较高的可靠性，但是电路复杂/成本也高。因此目前的EEPROM都是几十千字节到几百千字节的，绝少有超过512K的。

    flash属于广义的EEPROM，因为它也是电擦除的rom。但是为了区别于一般的按字节为单位的擦写的EEPROM，我们都叫它flash。flash做的改进就是擦除时不再以字节为单位，而是以块为单位，一次简化了电路，数据密度更高，降低了成本。上M的rom一般都是flash。

    要求：

    ① 要有一定的抗干扰能力

    ②能舍弃传输错误的数据，又不丢失正确的数据

    方法：

    ① 定义一个传输帧（协议），有帧头帧尾（最好定义为5 或 A 这两个电平不断翻转的），这个帧包括地址、器件ID、读写数据等。

    ② 利用移位寄存器，每接受一个新的数据，就对移位寄存器内所有数据进行一次帧判别，这样就不会丢失。

    实现：

    定义帧格式如下：

    帧头 IIC_id haddr laddr option data 帧尾

    帧头定义为：AA AA 帧尾定义为：55

    option定义： 读（5A）；写（A5）

    整帧：

    AA AA ID haddr laddr r/w data 55

    设计：

    每次uart接受模块接受到一个新数据，就通过移位寄存器保存下来，并进行整帧检测，如果符合帧格式，就产生读/写脉冲，通过IIC模块对eeprom存储器进行读写操作，然后通过uart发送模块传输到上位机。

    代码：

    1. module uart_IIC_eeprom(
    2. 	input fpga_clk ,
    3. 	input rst_n ,
    4. 	
    5. 	input uart_rx ,
    6. 	output rx_done ,
    7. 	output uart_tx ,
    8. 	
    9. 	output IIC_scl ,
    10. 	inout IIC_sda 
    11. 	
    12. );
    13.  
    14.  
    15. //receive uart data
    16. //wire rx_done ;
    17. wire [7:0]rx_data ;
    18. uart_receive uart_rec_inst(
    19.     .clk(fpga_clk) ,
    20.     .reset(rst_n) ,
    21.     .baud_rate('d5) ,//115200
    22.     .uart_rx(uart_rx), 
    23.     .data(rx_data) ,
    24.     .rx_done(rx_done)   
    25.     );
    26.  
    27. //Shift register
    28. reg [7:0]rec_shift_reg[7:0] ;
    29. reg rw_flag ;
    30. wire iic_done ;
    31. always@(posedge fpga_clk or negedge rst_n)
    32. if(!rst_n)
    33. 	begin
    34. 		rec_shift_reg[0] <= 0 ;
    35. 		rec_shift_reg[1] <= 0 ;
    36. 		rec_shift_reg[2] <= 0 ;
    37. 		rec_shift_reg[3] <= 0 ;
    38. 		rec_shift_reg[4] <= 0 ;
    39. 		rec_shift_reg[5] <= 0 ;
    40. 		rec_shift_reg[6] <= 0 ;
    41. 		rec_shift_reg[7] <= 0 ;
    42. 		rw_flag <= 0 ;
    43. 	end
    44. else if(rx_done)
    45. 	begin
    46. 		rec_shift_reg[0] <= rec_shift_reg[1] ;
    47.  		rec_shift_reg[1] <= rec_shift_reg[2] ;
    48. 		rec_shift_reg[2] <= rec_shift_reg[3] ; 
    49. 		rec_shift_reg[3] <= rec_shift_reg[4] ; 
    50. 		rec_shift_reg[4] <= rec_shift_reg[5] ; 
    51. 		rec_shift_reg[5] <= rec_shift_reg[6] ; 
    52. 		rec_shift_reg[6] <= rec_shift_reg[7] ; 
    53. 		rec_shift_reg[7] <= rx_data ; 
    54. 		rw_flag <= 1 ;
    55. 	end
    56. else if(iic_done)
    57. 		rw_flag <= 0 ;
    58.  
    59. reg [7:0]IIC_id ;
    60. reg [15:0]write_addr ;
    61. reg [15:0]read_addr ;
    62. reg [7:0]write_data ;
    63. reg [7:0]read_data ;
    64. wire [7:0]rd_data ;
    65. reg write_pulse ;
    66. reg read_pulse ;
    67.  
    68. IIC_design IIC_rw(
    69. 	.fpga_clk(fpga_clk),//50MHz
    70. 	.rst_n(rst_n) ,
    71. 	.rate_sel(1) ,
    72. 	.read_pulse(read_pulse) ,
    73. 	.write_pulse(write_pulse) ,
    74. 	.write_data(write_data) ,
    75. 	.IIC_id(IIC_id) ,
    76. 	.wr_addr(write_addr) ,
    77. 	.rd_addr(read_addr) ,
    78. 	
    79. 	.trans_done(iic_done) ,
    80. 	.read_data(rd_data) ,
    81. 	.IIC_scl(IIC_scl) ,
    82. 	.IIC_sda(IIC_sda)
    83. );	
    84.  
    85. wire uart_send_done ;
    86. reg uart_send_en ;
    87. uart_send uart_send(  
    88.     .clk(fpga_clk),
    89.     .reset(rst_n),
    90.     .data(read_data),
    91.     .send_en(uart_send_en),
    92.     .baud_rate(5),//115200
    93.     .uart_tx(uart_tx),
    94.     .tx_done(uart_send_done)
    95. );
    96.  
    97. //Parsing frames
    98. localparam frames_header = 8'hAA ;
    99. localparam frames_tail   = 8'h55 ;
    100. localparam read_option   = 8'h5A ;
    101. localparam write_option  = 8'hA5 ;
    102. reg [15:0]wr_cnt ;
    103. reg [15:0]rd_cnt ;
    104. always@(posedge fpga_clk or negedge rst_n)
    105. if(!rst_n)
    106. 	begin
    107. 		IIC_id <= 0 ;
    108. 		write_addr <= 0 ;
    109. 		read_addr <= 0 ;
    110. 		write_data <= 0;
    111. 		read_data <= 0 ;
    112. 		write_pulse <= 0 ;
    113. 		read_pulse <= 0 ;
    114. 		//uart_send_en <= 0 ;
    115. 		wr_cnt <= 0 ;
    116. 		rd_cnt <= 0 ;
    117. 	end
    118. 	
    119. else if( rw_flag )
    120. 	begin
    121. 		if ( (rec_shift_reg[0] == frames_header) && (rec_shift_reg[1] == frames_header) && (rec_shift_reg[7] == frames_tail) )
    122. 			begin
    123. 				IIC_id <= rec_shift_reg[2] ;
    124. 				if(rec_shift_reg[5] == write_option )
    125. 					begin
    126. 						write_addr <= { rec_shift_reg[3] , rec_shift_reg[4] } ;
    127. 						write_data <= rec_shift_reg[6] ;
    128. 						wr_cnt <= wr_cnt + 1 ;
    129. 						//write signal
    130. 						if( wr_cnt < 3 )
    131. 							write_pulse <= 1 ;
    132. 						else if(iic_done)
    133. 							begin
    134. 								wr_cnt <= 0 ;
    135. 								
    136. 							end	
    137. 						else
    138. 							write_pulse <= 0 ;	
    139. 					end
    140. 				else if ( rec_shift_reg[5] == read_option )
    141. 					begin
    142. 						read_addr <= { rec_shift_reg[3] , rec_shift_reg[4] } ;
    143. 						//read signal
    144. 						rd_cnt <= rd_cnt + 1 ;
    145. 						if(iic_done)
    146. 							begin
    147. 								read_data <= rd_data ;
    148. 								read_pulse <= 0 ;
    149. 								//uart_send_en <= 1 ;
    150. 								rd_cnt <= 0 ;
    151. 								
    152. 							end
    153. 						//else if(uart_send_done)
    154. 						//	uart_send_en <= 0 ;
    155. 						else if(rd_cnt <3)
    156. 							read_pulse <= 1 ;
    157. 						else
    158. 							read_pulse <= 0 ;
    159. 					end
    160. 			end
    161. 	end
    162. else
    163. 	begin
    164. 		write_pulse <= 0 ;
    165. 		read_pulse <= 0 ;
    166. 		//uart_send_en <= 0 ;
    167. 		wr_cnt <= 0 ;
    168. 		rd_cnt <= 0 ;
    169. 	end
    170. 	
    171. always@(posedge fpga_clk or negedge rst_n)
    172. if(!rst_n)
    173. 	uart_send_en <= 0 ;
    174. else if(iic_done && (rec_shift_reg[5] == read_option) )
    175. 	uart_send_en <= 1 ;
    176. else if(uart_send_done)
    177. 	uart_send_en <= 0 ;
    178. 	
    179. endmodule

    板级验证成功。

    可是可是，这样用分频器设计出来的sda_clk和drive_clk 时钟质量都很差，因为该时钟是从寄存器发出的信号，不是利用fpga的全局时钟资源，所以到达其他不同的寄存器的延时会因为布线长度的不同而不一样。这里上板验证可以成功，因为本设计对时钟质量要求不高。

    重新设计时，应该用fpga_clk或者PLL出来的时钟来设计。

    优化设计

    思路

            为了提高时钟质量，这里改变设计思路，选择用PLL出来的10MHz时钟作为驱动时钟，如图，只要把状态的转移设置从时钟下降沿开始，就可以兼顾起始位状态需要在scl高电平改变数据，读写数据需要在scl低电平修改数据的问题了。

    1. module IIC_design(
    2. 	input fpga_clk ,
    3. 	input rst_n ,
    4. 	input read_pulse ,
    5. 	input write_pulse ,
    6. 	input [7:0]write_data ,
    7. 	input [7:0]IIC_id ,
    8. 	input [15:0]wr_addr ,
    9. 	input [15:0]rd_addr ,
    10. 	
    11. 	output trans_done ,
    12. 	output [7:0]read_data ,
    13. 	output IIC_scl ,
    14. 	inout IIC_sda
    15. );
    16.  
    17. wire [7:0]wr_data ;
    18. wire [7:0]rd_data ;
    19. wire [7:0]command ;
    20. IIC_drive IIC_drive_inst(
    21. 	.fpga_clk(fpga_clk) ,
    22. 	.rst_n(rst_n) ,
    23. 	
    24. 	.write_sig(write_pulse) ,
    25. 	.read_sig(read_pulse) ,
    26. 	.IIC_id(IIC_id) ,
    27. 	.wr_addr(wr_addr) ,
    28. 	.rd_addr(rd_addr) ,
    29. 	.wr_data(write_data) ,
    30. 	.rd_data(rd_data) ,
    31. 	.trans_done(trans_done) ,
    32. 	
    33. 	.read_data(read_data) ,
    34. 	.write_data(wr_data) ,
    35. 	.cmd(command)
    36. 	
    37. );
    38.  
    39. IIC_underlying_logic IIC_underlying_logic_inst(
    40. 	.fpga_clk(fpga_clk) ,
    41. 	.rst_n(rst_n) ,
    42. 	
    43. 	.write_data(wr_data) ,
    44. 	.cmd(command),
    45. 	
    46. 	.read_data(rd_data) ,
    47. 	.trans_done(trans_done) ,
    48. 	.ack_result() ,
    49. 	
    50. 	.IIC_scl(IIC_scl) ,
    51. 	.IIC_sda(IIC_sda) 
    52. );
    53.  
    54. endmodule

    1. module IIC_drive(
    2. 	input fpga_clk ,
    3. 	input rst_n ,
    4. 	
    5. 	input write_sig ,
    6. 	input read_sig ,
    7. 	input [7:0]IIC_id ,
    8. 	input [15:0]wr_addr ,
    9. 	input [15:0]rd_addr ,
    10. 	input [7:0]wr_data ,
    11. 	input [7:0]rd_data ,
    12. 	input trans_done ,
    13. 		
    14. 	output reg[7:0]read_data ,
    15. 	output reg[7:0]write_data ,
    16. 	output reg [7:0]cmd
    17. 	
    18. );
    19.  
    20. wire clk_10m ;
    21. //PLL
    22. pll pll_inst(
    23. 	.inclk0(fpga_clk),
    24. 	.c0(clk_10m)
    25. 	);
    26.  
    27.  
    28. // IIC rate :  400k  clk : 10Mhz
    29. localparam cnt400k_max = 10000000 / 400000 ;
    30.  
    31. reg [15:0]IIC_cnt ;
    32. always@(posedge clk_10m or negedge rst_n)
    33. if(!rst_n)
    34. 	IIC_cnt <= 0 ;
    35. else if( IIC_cnt >= 24 )
    36. 	IIC_cnt <= 0 ;
    37. else 
    38. 	IIC_cnt <= IIC_cnt + 1 ;
    39.  
    40.  
    41. //定义状态机8个状态参数
    42. localparam idel_state 		= 8'b10000000 ;  //空闲态:释放sda控制权
    43. localparam start_bit_state = 8'b01000000 ; //产生起始位
    44. localparam wr_data_state   = 8'b00100000 ; // 写数据
    45. localparam rd_data_state   = 8'b00010000 ; // 读数据
    46. localparam ack_check_state = 8'b00001000 ; //检查响应
    47. localparam stop_bit_state  = 8'b00000100 ; //产生停止位
    48. localparam gen_ack_state   = 8'b00000010 ; //产生响应位
    49. localparam gen_noack_state = 8'b00000001 ; //产生非响应位
    50. 	
    51. 	
    52. //移位寄存器。寄存读写信号
    53. reg rd_pulse_reg ;
    54. reg wr_pulse_reg ;
    55. always@(posedge fpga_clk)
    56. begin
    57. 	wr_pulse_reg <= write_sig ;
    58. 	rd_pulse_reg <= read_sig ;
    59. end
    60.  
    61. reg rd_sig ;
    62. reg wr_sig ;
    63. always@(posedge fpga_clk or negedge rst_n)
    64. if(!rst_n)
    65. 	rd_sig <= 0 ;
    66. else if( rd_pulse_reg == 0 && read_sig == 1 )
    67. 	rd_sig <= 1 ;
    68. else if( trans_done )
    69. 	rd_sig <= 0 ;
    70. 	
    71. always@(posedge fpga_clk or negedge rst_n)
    72. if(!rst_n)
    73. 	wr_sig <= 0 ;
    74. else if( wr_pulse_reg == 0 && write_sig == 1 )
    75. 	wr_sig <= 1 ;
    76. else if( trans_done )
    77. 	wr_sig <= 0 ;
    78. 	
    79. //读写逻辑	
    80. reg [5:0]write_cnt ;
    81. reg [5:0]read_cnt ;
    82. always@(posedge clk_10m or negedge rst_n)
    83. if(!rst_n)
    84. 	begin
    85. 		cmd <= idel_state ;
    86. 		write_data <= 0 ;
    87. 		read_data <= 0 ;
    88. 		write_cnt <= 0 ;
    89. 		read_cnt <= 0 ;
    90. 	end
    91. else if( wr_sig )
    92. 	begin
    93. 		if(write_cnt == 0)
    94. 			cmd <= idel_state ; //空闲态
    95. 		else if ( write_cnt == 1 )
    96. 			begin
    97. 				cmd <= start_bit_state ;//产生起始位
    98. 			end
    99. 		else if ( write_cnt == 2 )
    100. 			begin
    101. 				cmd <= wr_data_state ;
    102. 				write_data <= IIC_id ;//发送IIC器件ID
    103. 			end
    104. 		else if ( write_cnt == 10)
    105. 			begin
    106. 				cmd <= ack_check_state ;
    107. 			end
    108. 		else if ( write_cnt == 11 )
    109. 			begin
    110. 				cmd <= wr_data_state ;
    111. 				write_data <= wr_addr[15:8] ;//写存储器高位地址
    112. 			end
    113. 		else if ( write_cnt == 19 )
    114. 			begin
    115. 				cmd <= ack_check_state ;
    116. 			end
    117. 		else if ( write_cnt == 20 )
    118. 			begin
    119. 				cmd <= wr_data_state ;
    120. 				write_data <= wr_addr[7:0] ;//写存储器低位地址
    121. 			end
    122. 		else if ( write_cnt == 28 )
    123. 			begin
    124. 				cmd <= ack_check_state ;
    125. 			end
    126. 		else if ( write_cnt == 29 )
    127. 			begin
    128. 				cmd <= wr_data_state ;
    129. 				write_data <= wr_data ; //写数据
    130. 			end
    131. 		else if ( write_cnt == 37 )
    132. 			begin
    133. 				cmd <= ack_check_state ;
    134. 			end
    135. 		else if ( write_cnt == 38 )
    136. 			begin
    137. 				cmd <= stop_bit_state ;//产生停止位
    138. 			end		
    139. 	
    140. 		if(IIC_cnt == 23)
    141. 			write_cnt <= write_cnt + 1 ;	
    142. 		if(write_cnt >= 39)
    143. 			begin
    144. 				write_cnt <= 0 ;
    145. 				cmd <= idel_state ; //空闲态
    146. 			end
    147. 	end
    148. else if( rd_sig )
    149. begin
    150. 		if(read_cnt == 0)
    151. 			cmd <= idel_state ; //空闲态
    152. 		else if ( read_cnt == 1 )
    153. 			begin
    154. 				cmd <= start_bit_state ;//产生起始位
    155. 			end
    156. 		else if ( read_cnt == 2 )
    157. 			begin
    158. 				cmd <= wr_data_state ;
    159. 				write_data <= IIC_id ;//发送IIC器件ID
    160. 			end
    161. 		else if ( read_cnt == 10) 
    162. 			begin
    163. 				cmd <= ack_check_state ;
    164. 			end
    165. 		else if ( read_cnt == 11 )
    166. 			begin
    167. 				cmd <= wr_data_state ;
    168. 				write_data <= rd_addr[15:8] ;//写存储器高位地址
    169. 			end
    170. 		else if ( read_cnt == 19 )
    171. 			begin
    172. 				cmd <= ack_check_state ;
    173. 			end
    174. 		else if ( read_cnt == 20 )
    175. 			begin
    176. 				cmd <= wr_data_state ;
    177. 				write_data <= rd_addr[7:0] ;//写存储器低位地址
    178. 			end
    179. 		else if ( read_cnt == 28 )
    180. 			begin
    181. 				cmd <= ack_check_state ;
    182. 			end
    183. 		else if( read_cnt == 29 )
    184. 				cmd <= start_bit_state ;
    185. 		else if ( read_cnt == 30 )
    186. 			begin
    187. 				cmd <= wr_data_state ;
    188. 				write_data <= (IIC_id | 8'b00000001 ) ; //写IIC器件ID 和读指令
    189. 			end
    190. 		else if ( read_cnt == 38 )
    191. 			begin
    192. 				cmd <= ack_check_state ;
    193. 			end
    194. 		else if ( read_cnt == 39 )
    195. 			begin
    196. 				cmd <= rd_data_state ;//
    197. 			end		
    198. 		else if ( read_cnt == 47 )
    199. 			begin
    200. 				cmd <= gen_noack_state ;//
    201. 			end
    202. 		else if ( read_cnt == 48 )
    203. 			begin
    204. 				cmd <= stop_bit_state ;
    205. 				read_data <= rd_data ;
    206. 			end	
    207. 			
    208. 		if(IIC_cnt == 23)
    209. 			read_cnt <= read_cnt + 1 ;	
    210. 		if ( read_cnt == 49 )
    211. 			begin
    212. 				cmd <= idel_state ;
    213. 				read_cnt <= 0 ;
    214. 			end
    215. 	end	
    216. else
    217. 	begin
    218. 		cmd <= idel_state ;
    219. 		write_cnt <= 0 ;
    220. 		read_cnt <= 0 ;
    221. 	end
    222. 	
    223. endmodule
    1. module IIC_underlying_logic(
    2. 	input fpga_clk ,
    3. 	input rst_n ,
    4.  
    5. 	input [7:0]write_data ,
    6. 	input [7:0]cmd ,
    7. 	
    8. 	output reg [7:0]read_data ,
    9. 	output reg trans_done ,
    10. 	output reg ack_result ,
    11. 	
    12. 	output reg IIC_scl ,
    13. 	inout IIC_sda 
    14. );
    15.  
    16. wire clk_10m ;
    17. //PLL
    18. pll pll_inst(
    19. 	.inclk0(fpga_clk),
    20. 	.c0(clk_10m)
    21. 	);
    22.  
    23.  
    24. // IIC rate : 100k 400k  clk : 10Mhz
    25. localparam cnt400k_max = 10000000 / 400000 ;
    26. localparam cnt100k_max = 10000000 / 100000 ;
    27.  
    28. reg [15:0]IIC_cnt ;
    29. always@(posedge clk_10m or negedge rst_n)
    30. if(!rst_n)
    31. 	IIC_cnt <= 0 ;
    32. else if( IIC_cnt >= 24 )
    33. 	IIC_cnt <= 0 ;
    34. else 
    35. 	IIC_cnt <= IIC_cnt + 1 ;
    36.  
    37. //IIC SCLK
    38. always@(posedge clk_10m or negedge rst_n)
    39. if(!rst_n)
    40. 	IIC_scl <= 0 ;
    41. else if( IIC_cnt == 24 | IIC_cnt == 11 )
    42. 	IIC_scl <= !IIC_scl ;
    43.  
    44. //IIC SDATA
    45. reg sda_ctrl ;
    46. reg sda_out ;
    47. assign IIC_sda = sda_ctrl ? ( sda_out ? 1'bz : 1'b0 ) : 1'bz ; //三态门，高阻态时，要么由总线上的上拉电阻拉至高电平，即输出/输出1；要么由从机拉至0，输入0；
    50. //定义状态机8个状态参数
    51. localparam idel_state 		= 8'b10000000 ;  //空闲态:释放sda控制权
    52. localparam start_bit_state = 8'b01000000 ; //产生起始位
    53. localparam wr_data_state   = 8'b00100000 ; // 写数据
    54. localparam rd_data_state   = 8'b00010000 ; // 读数据
    55. localparam ack_check_state = 8'b00001000 ; //检查响应
    56. localparam stop_bit_state  = 8'b00000100 ; //产生停止位
    57. localparam gen_ack_state   = 8'b00000010 ; //产生响应位
    58. localparam gen_noack_state = 8'b00000001 ; //产生非响应位
    60. //状态机实时状态
    61. wire [7:0]rw_state;
    62. assign rw_state = cmd ;
    64. reg [8:0]state_cnt ;
    65. always@(posedge clk_10m or negedge rst_n)
    66. if(!rst_n)
    67. 	begin
    68. 		sda_ctrl <= 0 ;
    69. 		sda_out <= 1 ;
    70. 		trans_done <= 0 ;
    71. 		ack_result <= 0 ;
    72. 		read_data <= 0 ;
    73. 		state_cnt <= 0 ;
    74. 	end
    75. else 
    76. 	begin
    77. 		case(rw_state)
    78. 			idel_state :
    79. 				begin
    80. 					sda_ctrl <= 0 ;
    81. 					trans_done <= 0 ;
    82. 					ack_result <= 0 ;
    83. 					state_cnt <= 0 ;
    84. 				end
    85. 			start_bit_state :
    86. 				begin
    87. 					sda_ctrl <= 1 ;
    88. 					state_cnt <= state_cnt + 1 ;
    89. 					if( state_cnt >= 17  )
    90. 						sda_out <= 0 ;
    91. 					else 
    92. 						sda_out <= 1 ;	
    93. 				   if ( state_cnt >= 24 )
    94. 						state_cnt <= 0 ;	
    95. 				end
    96. 			wr_data_state :
    97. 				begin
    98. 					sda_ctrl <= 1 ;
    99. 					state_cnt <= state_cnt + 1 ;
    100. 					if( state_cnt == 5 )
    101. 						sda_out <= write_data[7] ;
    102. 					else if( state_cnt == 30 )
    103. 						sda_out <= write_data[6] ;
    104. 					else if( state_cnt == 55 )
    105. 						sda_out <= write_data[5] ;
    106. 					else if( state_cnt == 80 )
    107. 						sda_out <= write_data[4] ;
    108. 					else if( state_cnt == 105 )
    109. 						sda_out <= write_data[3] ;
    110. 					else if( state_cnt == 130 )
    111. 						sda_out <= write_data[2] ;
    112. 					else if( state_cnt == 155 )
    113. 						sda_out <= write_data[1] ;
    114. 					else if( state_cnt == 180 )
    115. 						sda_out <= write_data[0] ;		
    116. 					
    117. 					if( state_cnt >= 199 )
    118. 						state_cnt <= 0 ;	
    119. 				end
    120. 			rd_data_state :
    121. 				begin
    122. 					sda_ctrl <= 0 ;
    123. 					state_cnt <= state_cnt + 1 ;
    124. 					if( state_cnt == 15 )
    125. 						read_data[7] <= IIC_sda ;
    126. 					else if( state_cnt == 40 )
    127. 						read_data[6] <= IIC_sda ;
    128. 					else if( state_cnt == 65 )
    129. 						read_data[5] <= IIC_sda ;
    130. 					else if( state_cnt == 90 )
    131. 						read_data[4] <= IIC_sda ;
    132. 					else if( state_cnt == 115 )
    133. 						read_data[3] <= IIC_sda ;
    134. 					else if( state_cnt == 140 )
    135. 						read_data[2] <= IIC_sda ;
    136. 					else if( state_cnt == 165 )
    137. 						read_data[1] <= IIC_sda ;
    138. 					else if( state_cnt == 190 )
    139. 						read_data[0] <= IIC_sda ;	
    140. 					
    141. 					if( state_cnt >= 199 )
    142. 						state_cnt <= 0 ;	
    143. 				end
    144. 			ack_check_state :
    145. 				begin
    146. 					sda_ctrl <= 0 ;//释放sda控制权
    147. 					state_cnt <= state_cnt + 1 ;
    148. 					if( state_cnt == 1 )
    149. 						ack_result <= IIC_sda ; 
    150. 					if(state_cnt >= 24)
    151. 						state_cnt <= 0 ;
    152. 				end
    153. 			stop_bit_state :
    154. 				begin
    155. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    156. 					sda_out <= 1'b0 ;
    157. 					state_cnt <= state_cnt + 1 ;
    158. 					if( state_cnt >= 17  )
    159. 						sda_out <= 1 ;
    160. 					else 
    161. 						sda_out <= 0 ;
    162. 				   if ( state_cnt >=24 )
    163. 					  begin
    164. 						state_cnt <= 0 ;
    165. 						trans_done <= 1 ;
    166. 					  end		
    167. 				end
    168. 			gen_ack_state :
    169. 				begin
    170. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    171. 					state_cnt <= state_cnt + 1 ;	
    172. 					if( state_cnt >= 10  )
    173. 						sda_out <= 1'b0 ;
    174. 					if(state_cnt >= 24 )
    175. 						state_cnt <= 0 ;
    176. 				end
    177. 			gen_noack_state :
    178. 				begin
    179. 					sda_ctrl<= 1'b1 ;//获取sda控制权
    180. 					state_cnt <= state_cnt + 1 ;	
    181. 					if( state_cnt >= 10  )
    182. 						sda_out <= 1'b1 ;
    183. 					if(state_cnt >= 24 )
    184. 						state_cnt <= 0 ;
    185. 				end
    186. 			default: ;
    187. 		endcase
    188. 	end
    191. endmodule
    1. //***************** ******************//
    2. //        串口波特率：115200           //
    3. //            通信帧格式：             //
    4. //      AA AA ID HA LA RW DA 55      //
    5. //    其中，AA AA 为帧头；55为帧尾；   //
    6. //   ID为IIC器件ID,HA、LA为存储器地址  //
    7. //   RW为读写控制，读：5A ;写：A5      //
    8. //   DA为要写入的数据，读的时候可为任意值 //
    9. // ********************************* //
    10.  
    11.  
    12. module uart_IIC_eeprom(
    13. 	input fpga_clk ,
    14. 	input rst_n ,
    15. 	
    16. 	input uart_rx ,
    17. 	output rx_done ,
    18. 	output uart_tx ,
    19. 	
    20. 	output IIC_scl ,
    21. 	inout IIC_sda 
    22. 	
    23. );
    24.  
    25.  
    26. //receive uart data
    27. //wire rx_done ;
    28. wire [7:0]rx_data ;
    29. uart_receive uart_rec_inst(
    30.     .clk(fpga_clk) ,
    31.     .reset(rst_n) ,
    32.     .baud_rate('d5) ,//115200
    33.     .uart_rx(uart_rx), 
    34.     .data(rx_data) ,
    35.     .rx_done(rx_done)   
    36.     );
    38. //Shift register
    39. reg [7:0]rec_shift_reg[7:0] ;
    40. reg rw_flag ;
    41. wire iic_done ;
    42. always@(posedge fpga_clk or negedge rst_n)
    43. if(!rst_n)
    44. 	begin
    45. 		rec_shift_reg[0] <= 0 ;
    46. 		rec_shift_reg[1] <= 0 ;
    47. 		rec_shift_reg[2] <= 0 ;
    48. 		rec_shift_reg[3] <= 0 ;
    49. 		rec_shift_reg[4] <= 0 ;
    50. 		rec_shift_reg[5] <= 0 ;
    51. 		rec_shift_reg[6] <= 0 ;
    52. 		rec_shift_reg[7] <= 0 ;
    53. 		rw_flag <= 0 ;
    54. 	end
    55. else if(rx_done)
    56. 	begin
    57. 		rec_shift_reg[0] <= rec_shift_reg[1] ;
    58.  		rec_shift_reg[1] <= rec_shift_reg[2] ;
    59. 		rec_shift_reg[2] <= rec_shift_reg[3] ; 
    60. 		rec_shift_reg[3] <= rec_shift_reg[4] ; 
    61. 		rec_shift_reg[4] <= rec_shift_reg[5] ; 
    62. 		rec_shift_reg[5] <= rec_shift_reg[6] ; 
    63. 		rec_shift_reg[6] <= rec_shift_reg[7] ; 
    64. 		rec_shift_reg[7] <= rx_data ; 
    65. 		rw_flag <= 1 ;
    66. 	end
    67. else if(iic_done)
    68. 		rw_flag <= 0 ;
    70. reg [7:0]IIC_id ;
    71. reg [15:0]write_addr ;
    72. reg [15:0]read_addr ;
    73. reg [7:0]write_data ;
    74. reg [7:0]read_data ;
    75. wire [7:0]rd_data ;
    76. reg write_pulse ;
    77. reg read_pulse ;
    79. IIC_design IIC_rw(
    80. 	.fpga_clk(fpga_clk),//50MHz
    81. 	.rst_n(rst_n) ,
    82. 	.read_pulse(read_pulse) ,
    83. 	.write_pulse(write_pulse) ,
    84. 	.write_data(write_data) ,
    85. 	.IIC_id(IIC_id) ,
    86. 	.wr_addr(write_addr) ,
    87. 	.rd_addr(read_addr) ,
    88. 	
    89. 	.trans_done(iic_done) ,
    90. 	.read_data(rd_data) ,
    91. 	.IIC_scl(IIC_scl) ,
    92. 	.IIC_sda(IIC_sda)
    93. );	
    95. wire uart_send_done ;
    96. reg uart_send_en ;
    97. uart_send uart_send(  
    98.     .clk(fpga_clk),
    99.     .reset(rst_n),
    100.     .data(read_data),
    101.     .send_en(uart_send_en),
    102.     .baud_rate(5),//115200
    103.     .uart_tx(uart_tx),
    104.     .tx_done(uart_send_done)
    105. );
    107. //Parsing frames
    108. localparam frames_header = 8'hAA ;
    109. localparam frames_tail   = 8'h55 ;
    110. localparam read_option   = 8'h5A ;
    111. localparam write_option  = 8'hA5 ;
    112. reg [15:0]wr_cnt ;
    113. reg [15:0]rd_cnt ;
    114. always@(posedge fpga_clk or negedge rst_n)
    115. if(!rst_n)
    116. 	begin
    117. 		IIC_id <= 0 ;
    118. 		write_addr <= 0 ;
    119. 		read_addr <= 0 ;
    120. 		write_data <= 0;
    121. 		read_data <= 0 ;
    122. 		write_pulse <= 0 ;
    123. 		read_pulse <= 0 ;
    124. 		wr_cnt <= 0 ;
    125. 		rd_cnt <= 0 ;
    126. 	end
    127. 	
    128. else if( rw_flag )
    129. 	begin
    130. 		if ( (rec_shift_reg[0] == frames_header) && (rec_shift_reg[1] == frames_header) && (rec_shift_reg[7] == frames_tail) )
    131. 			begin
    132. 				IIC_id <= rec_shift_reg[2] ;
    133. 				if(rec_shift_reg[5] == write_option )
    134. 					begin
    135. 						write_addr <= { rec_shift_reg[3] , rec_shift_reg[4] } ;
    136. 						write_data <= rec_shift_reg[6] ;
    137. 						wr_cnt <= wr_cnt + 1 ;
    138. 						//write signal
    139. 						if( wr_cnt < 3 )
    140. 							write_pulse <= 1 ;
    141. 						else if(iic_done)
    142. 							begin
    143. 								wr_cnt <= 0 ;
    144. 								
    145. 							end	
    146. 						else
    147. 							write_pulse <= 0 ;	
    148. 					end
    149. 				else if ( rec_shift_reg[5] == read_option )
    150. 					begin
    151. 						read_addr <= { rec_shift_reg[3] , rec_shift_reg[4] } ;
    152. 						//read signal
    153. 						rd_cnt <= rd_cnt + 1 ;
    154. 						if(iic_done)
    155. 							begin
    156. 								read_data <= rd_data ;
    157. 								read_pulse <= 0 ;
    158. 								rd_cnt <= 0 ;
    159. 								
    160. 							end
    162. 						else if(rd_cnt <3)
    163. 							read_pulse <= 1 ;
    164. 						else
    165. 							read_pulse <= 0 ;
    166. 					end
    167. 			end
    168. 	end
    169. else
    170. 	begin
    171. 		write_pulse <= 0 ;
    172. 		read_pulse <= 0 ;
    173. 		wr_cnt <= 0 ;
    174. 		rd_cnt <= 0 ;
    175. 	end
    176. 	
    177. always@(posedge fpga_clk or negedge rst_n)
    178. if(!rst_n)
    179. 	uart_send_en <= 0 ;
    180. else if(iic_done && (rec_shift_reg[5] == read_option) )
    181. 	uart_send_en <= 1 ;
    182. else if(uart_send_done)
    183. 	uart_send_en <= 0 ;
    184. 	
    185. endmodule
    1. module uart_receive(
    2.     clk ,
    3.     reset ,
    4.     baud_rate ,
    5.     uart_rx, 
    6.     data ,
    7.     rx_done   
    8.     );
    9.     input  clk ;
    10.     input reset ;
    11.     input [2:0]baud_rate ;
    12.     input uart_rx ;
    13.     output reg [7:0]data ;
    14.     output reg rx_done ;
    15.     
    16.     reg [2:0]r_data[7:0] ;
    17.     reg [2:0]sta_bit ;
    18.     reg [2:0]sto_bit ;
    19.     
    20.     reg [17:0]bit_tim ;
    21.     always@(baud_rate) 
    22.         begin
    23.             case(baud_rate)         
    24.             3'd0 : bit_tim = 1000000000/300/20 ;   
    25.             3'd1 : bit_tim = 1000000000/1200/20 ;  
    26.             3'd2 : bit_tim = 1000000000/2400/20 ;  
    27.             3'd3 : bit_tim = 1000000000/9600/20 ;  
    28.             3'd4 : bit_tim = 1000000000/19200/20 ; 
    29.             3'd5 : bit_tim = 1000000000/115200/20 ;
    30.             default bit_tim = 1000000000/9600/20 ; 
    31.             endcase
    32.      end
    33.     
    34.     wire [17:0]bit_tim_16 ;
    35.     assign bit_tim_16 = bit_tim / 16;
    36.     
    37.     wire [8:0]bit16_mid ; 
    38.     assign bit16_mid = bit_tim_16 / 2 ;
    39.     
    40.     
    41.     reg [1:0]edge_detect ;
    42.     always @( posedge clk or negedge reset )
    43.     begin
    44.         if (!reset )
    45.             edge_detect <= 2'd0 ;
    46.         else 
    47.             begin
    48.             edge_detect[0] <= uart_rx ;
    49.             edge_detect[1] <= edge_detect[0] ;
    50.             end
    51.     end    
    53.     wire byte_sta_neg ;
    54.     assign byte_sta_neg = ( edge_detect == 2'b10 ) ? 1 : 0 ;
    55.          
    56.     reg receive_en ;
    57.     reg [17:0]div_cnt ;
    58.      reg [7:0]bit16_cnt ;
    59.     always @( posedge clk or negedge reset )
    60.     begin
    61.          if (!reset )
    62.             receive_en <= 1'd0 ;
    63.         else if ( byte_sta_neg )    
    64.             receive_en <= 1'd1 ;
    65.         else if ( (rx_done) || (sta_bit >= 3'd4 ))    
    66.             receive_en <= 1'd0 ;   
    67.         else if ( ( bit16_cnt == 8'd159 ) && (div_cnt == bit_tim_16 - 1'd1 ) )
    68.             receive_en <= 1'd0 ;
    69.     end
    70.              
    71.     
    72.     always@( posedge clk or negedge reset )
    73.     begin
    74.         if ( ! reset )
    75.             div_cnt <= 18'd0 ;
    76.         else if (receive_en)
    77.         begin
    78.             if ( div_cnt == bit_tim_16 - 1'd1 )
    79.                 div_cnt <= 18'd0 ;               
    80.             else
    81.                 div_cnt <= div_cnt + 1'b1 ; 
    82.         end
    83.         else 
    84.             div_cnt <= 18'd0 ;
    85.     end
    86.     
    87.     reg bit16_pulse ;
    88.     always@( posedge clk or negedge reset )
    89.     begin
    90.         if ( ! reset )
    91.             bit16_pulse <= 18'd0 ;
    92.         else if (receive_en)
    93.             if ( div_cnt == bit16_mid )
    94.                 bit16_pulse <= 1'd1 ;
    95.             else
    96.                 bit16_pulse <= 1'd0 ;
    97.         else
    98.                 bit16_pulse <= 1'd0 ;                
    99.     end       
    100.    
    101.     always@( posedge clk or negedge reset )
    102.     begin
    103.         if ( ! reset )
    104.             bit16_cnt <= 8'd0 ;
    105.         else if (receive_en)
    106.         begin    
    107.             if (( bit16_cnt == 8'd159 ) && (div_cnt == bit_tim_16 - 1'd1 ))
    108.                 bit16_cnt <= 8'd0 ;
    109.             else if ( div_cnt == bit_tim_16 - 1'd1 )
    110.                 bit16_cnt <= bit16_cnt + 1'b1 ;
    111.         end
    112.     end
    113.       
    114.     always@(posedge clk or negedge reset)
    115.     begin
    116.     if(!reset)
    117.     begin
    118.         sta_bit   <= 3'd0 ;
    119.         r_data[0] <= 3'd0 ;
    120.         r_data[1] <= 3'd0 ;
    121.         r_data[2] <= 3'd0 ;
    122.         r_data[3] <= 3'd0 ;
    123.         r_data[4] <= 3'd0 ;
    124.         r_data[5] <= 3'd0 ;
    125.         r_data[6] <= 3'd0 ;
    126.         r_data[7] <= 3'd0 ;
    127.         sto_bit   <= 3'd0 ;
    128.     end
    129.     else if (bit16_pulse)
    130.         case(bit16_cnt)
    131.             0: 
    132.             begin 
    133.             sta_bit   <= 3'd0 ;
    134.             r_data[0] <= 3'd0 ;
    135.             r_data[1] <= 3'd0 ;
    136.             r_data[2] <= 3'd0 ;
    137.             r_data[3] <= 3'd0 ;
    138.             r_data[4] <= 3'd0 ;
    139.             r_data[5] <= 3'd0 ;
    140.             r_data[6] <= 3'd0 ;
    141.             r_data[7] <= 3'd0 ;
    142.             sto_bit   <= 3'd0 ;
    143.             end
    144.             5,6,7,8,9,10,11 : sta_bit <= sta_bit + uart_rx ;
    145.             21,22,23,24,25,26,27 : r_data[0] <= r_data[0] + uart_rx ;
    146.             37,38,39,41,42,43,44 : r_data[1] <= r_data[1] + uart_rx ; 
    147.             53,54,55,56,57,58,59 : r_data[2] <= r_data[2] + uart_rx ;
    148.             69,70,71,72,73,74,75 : r_data[3] <= r_data[3] + uart_rx ;
    149.             85,86,87,88,89,90,91 : r_data[4] <= r_data[4] + uart_rx ;
    150.             101,102,103,104,105,106,107 : r_data[5] <= r_data[5] + uart_rx ;
    151.             117,118,119,120,121,122,123 : r_data[6] <= r_data[6] + uart_rx ;
    152.             133,134,135,136,137,138,139 : r_data[7] <= r_data[7] + uart_rx ;
    153.             149,150,151,152,153,154,155 : sto_bit <= sto_bit + uart_rx ;
    154.             default ;
    155.         endcase
    156.     end
    157.  
    158.     always@( posedge clk or negedge reset )
    159.     begin
    160.         if ( ! reset )
    161.             rx_done <= 8'd0 ;
    162.         else if ( ( bit16_cnt == 8'd159 ) && (div_cnt == bit_tim_16 - 1'd1 ) )
    163.             rx_done <= 8'd1 ;
    164.         else if (rx_done <= 8'd1 )
    165.             rx_done <= 8'd0 ;
    166.     end         
    167.     
    168.     always@( posedge clk or negedge reset )
    169.     begin
    170.         if ( ! reset )
    171.             data <= 8'd0 ;
    172.         //else if ( rx_done )
    173. 		  else if(( bit16_cnt == 8'd159 ) && (div_cnt == bit_tim_16 - 1'd1 ))
    174.         begin
    175.             data[0] = ( r_data[0] >3 ) ? 1 : 0 ;
    176.             data[1] = ( r_data[1] >3 ) ? 1 : 0 ;
    177.             data[2] = ( r_data[2] >3 ) ? 1 : 0 ;
    178.             data[3] = ( r_data[3] >3 ) ? 1 : 0 ;
    179.             data[4] = ( r_data[4] >3 ) ? 1 : 0 ;
    180.             data[5] = ( r_data[5] >3 ) ? 1 : 0 ;
    181.             data[6] = ( r_data[6] >3 ) ? 1 : 0 ;
    182.             data[7] = ( r_data[7] >3 ) ? 1 : 0 ;
    183.         end
    184.         //else if ( receive_en )
    185.             //data <= 8'd0 ;
    186.     end
    187.          
    188.     
    189. endmodule
    1. module uart_send(  
    2.     clk,
    3.     reset,
    4.     data,
    5.     send_en,
    6.     baud_rate,
    7.     uart_tx,
    8.     tx_done
    9. );
    10.     input clk;
    11.     input reset;
    12.     input [7:0]data;
    13.     input send_en;
    14.     input [2:0]baud_rate;
    15.     output reg uart_tx;
    16.     output reg tx_done;
    17.     
    18.      reg [17:0]bit_tim;
    19.     
    20.   
    21.     always@(baud_rate)  //
    22.         begin
    23.             case(baud_rate)         
    24.             3'd0 : bit_tim = 1000000000/300/20 ; 
    25.             3'd1 : bit_tim = 1000000000/1200/20 ;
    26.             3'd2 : bit_tim = 1000000000/2400/20 ;
    27.             3'd3 : bit_tim = 1000000000/9600/20 ;
    28.             3'd4 : bit_tim = 1000000000/19200/20 ; 
    29.             3'd5 : bit_tim = 1000000000/115200/20 ;
    30.             default bit_tim = 1000000000/9600/20 ; 
    31.             endcase
    32.         end
    33.     
    34.     reg [17:0]counter1 ;
    35.     always@(posedge clk or negedge reset)
    36.         begin
    37.             if(!reset)
    38.                 counter1 <=17'b0 ;
    39.             else if (send_en )
    40.                 begin
    41.                 if( counter1 == bit_tim - 1'b1 )
    42.                     counter1 <= 17'b0 ;
    43.                 else
    44.                     counter1 <= counter1 + 1'b1 ;
    45.                 end
    46.             else counter1 <= 17'b0 ;           
    47.         end 
    48.     
    49.     reg [3:0]counter2 ; 
    50.     always@(posedge clk or negedge reset)
    51.         begin
    52.             if(!reset)
    53.                 counter2 <= 4'b0 ;
    54.             else if ( send_en )
    55.                 begin
    56.                 if(counter2 == 0)
    57.                     counter2 <= counter2 +1'b1 ;
    58.                 else if( counter1 == bit_tim - 1'b1 )
    59.                     counter2 <= counter2 + 4'b1 ;   
    60.                 else
    61.                     counter2 <= counter2 ;
    62.                 end
    63.             else
    64.                 counter2 <= 4'b0 ;    
    65.         end                
    66.  
    67.     always@(posedge clk or negedge reset)
    68.         begin
    69.             if(!reset)
    70.                 begin
    71.                     uart_tx <= 4'b1 ; 
    72.                 end  
    73.             else if ( send_en )
    74.                     case(counter2)
    75.                         0:begin uart_tx <= 1'b1 ; end
    76.                         1:uart_tx <= 1'b0 ;
    77.                         2:uart_tx <= data[0] ;
    78.                         3:uart_tx <= data[1] ;
    79.                         4:uart_tx <= data[2] ;
    80.                         5:uart_tx <= data[3] ;
    81.                         6:uart_tx <= data[4] ;
    82.                         7:uart_tx <= data[5] ;
    83.                         8:uart_tx <= data[6] ;
    84.                         9:uart_tx <= data[7] ;
    85.                         10:uart_tx <= 1'b1 ;
    86.                         11:begin uart_tx <= 1'b1 ;  end
    87.                         default uart_tx <= 1'b1 ;
    88.                     endcase
    89.            else 
    90.                 uart_tx <= 1'b1 ;         
    91.         end 
    92.         
    93.         always@(posedge clk or negedge reset)
    94.         begin
    95.             if(!reset)
    96.                 tx_done <= 1'b0 ;
    97.             else if (send_en )
    98.                 begin
    99.                 if( counter2 == 0 )//
    100.                      tx_done <= 1'b0 ;
    101.                 else if ( counter2 == 11 )
    102.                      tx_done <= 1'b1 ;
    103.                 end
    104.             else if (tx_done == 1'b1)
    105.                 tx_done <= 1'b0 ;
    106.         end 
    107. endmodule

    完结！只要串口按照帧格式发送数据就可以遵循IIC协议对AC609板子的eeprom存储器进行读写数据了，其他的IIC器件则修改对应IIC_id即可。

  • 相关阅读:
    代码随想录-021-349.两个数组的交集
    删除数据库
    【0119】PostgreSQL FMS（Free Space Map）
    21.9 Python 使用Selenium库
    【计算机毕业设计】校园二手市场平台+vue源码
    Validform验证时可以为空，否则按照指定格式验证
    kafka 自定义Interceptor（通过拦截器对消息进行定制化处理）
    dreamweaver个人网页设计作业 学生个人网页猫眼电影 WEB静态网页作业模板 大学生个人主页博客网页代码 dw个人网页作业成品
    工业无线网关在实际生产中的应用效果和价值-天拓四方
    快速入门安装及使用&git与svn的区别&常用命令
  • 原文地址：https://blog.csdn.net/qq_44366923/article/details/133561521