IIC协议系列博文：
FPGA实现IIC协议（二）----IIC总线的FPGA实现（单次读写驱动）
上一篇文章已经对IIC总线做了详细的介绍，了解了IIC总线的读写方式。这篇文章我们编写一个基于FPGA的IIC驱动模块，并对这个模块进行仿真及上板验证。
首先来回顾一下IIC总线单次读写时序。
单次写时序如下：
单次读时序如下：
大致总结一下单次写时序的过程（假设从机均正确响应，若响应不正确或不响应则跳转到初始状态重新开始写操作）：
单次读时序的过程（假设从机均正确响应，若响应不正确或不响应则跳转到初始状态重新开始读操作）：
本文的目的是设计一个IIC的驱动模块，包含单次读、单次写，也兼容16位寄存器与8位寄存器。据次及上述时序图，可以绘制出IIC单次读写驱动的状态机如下：
上图状态机将单字节写操作和随机读操作相结合，可以实 现 I2C 设备单次写操作和单次随机读操作的状态跳转。需要说明的是状态ACK1、ACK2、ACK3、ACK4、ACK5还在主机没有正确接收到从机的响应信号时跳转回初始状态。
对各个状态、状态跳转条件、输出进行说明（假设主机为FPGA）：
Verilog编写的IIC驱动的整体框图、输入输出信号如下所示：
其中信号描述如下表：
| 属性 | 名称 | 位宽 | 说明 | |
| 系统接口 | 输入 | sys_clk | 1 | 输入系统时钟,50MHz |
| sys_rst_n | 1 | 输入复位信号,低电平有效 | ||
| I2C时序控制接口 | i2c_rw | 1 | 读写使能信号----1:读；0：写 | |
| i2c_start | 1 | i2c开始信号 | ||
| i2c_num | 1 | i2c字节地址字节数----1：16位；0：8位 | ||
| i2c_addr | 16 | i2c字节地址 | ||
| i2c_data_w | 8 | 写入i2c数据 | ||
| i2c_clk | 1 | i2c驱动时钟 | ||
| 输出 | i2c_end | 1 | i2c一次读/写操作完成 | |
| i2c_data_r | 8 | i2c读取数据 | ||
| I2C物理接口 | scl | 1 | 输出至i2c设备的串行时钟信号scl | |
| 双向 | sda | 1 | 输出至i2c设备的串行数据信号sda |
需要注意的是：i2c_clk是本驱动模块的工作时钟，由系统时钟 sys_clk 分频而来，它的时钟频率为串行时钟scl频率的 4 倍。为什么是4倍呢，不妨看一下下图的IIC基础时序：
在SCL为高电平器件，要求SDA上的数据保持稳定；在SCL为低电平器件，允许SDA上的数据变化。我们知道驱动模块对IIC总线上的数据进行读写肯定是需要一个驱动时钟的，根据上图就可以看到当驱动时钟是SCL的4倍频率时，操作起来是最方便的。如下图：
根据上述状态机描述、整体设计不难编写出驱动模块的Verilog代码（注释很详细）：
这里主要讲几点需要注意的和大概思路：
module i2c_drive
#(
parameter DEVICE_ADDR = 7'b1010_000 , //i2c从机地址
parameter SYS_CLK_FREQ = 26'd50_000_000 , //系统时钟频率
parameter I2C_FREQ = 18'd250_000 //i2c时钟频率，250k
)
(
//系统接口
input sys_clk , //输入系统时钟,50MHz
input sys_rst_n , //输入复位信号,低电平有效
//I2C时序控制接口
input i2c_rw , //读写使能信号----1:读；0：写
input i2c_start , //i2c开始信号
input i2c_num , //i2c字节地址字节数----1：16位；0：8位
input [15:0] i2c_addr , //i2c字节地址
input [7:0] i2c_data_w , //写入i2c数据
output reg i2c_clk , //i2c驱动时钟
output reg i2c_end , //i2c一次读/写操作完成
output reg [7:0] i2c_data_r , //i2c读取数据
//I2C物理接口
output reg scl , //输出至i2c设备的串行时钟信号scl
inout wire sda //输出至i2c设备的串行数据信号sda
);
//状态机定义
localparam IDLE = 4'd0, //初始化状态
START1 = 4'd1, //发送开始信号状态1
SEND_D_ADDR_W = 4'd2, //设备地址写入状态 + 控制写
ACK1 = 4'd3, //等待从机响应信号1
SEND_R_ADDR_H = 4'd4, //发送寄存器地址高8位
ACK2 = 4'd5, //等待从机响应信号2
SEND_R_ADDR_L = 4'd6, //发送寄存器地址低8位
ACK3 = 4'd7, //等待从机响应信号3
WR_DATA = 4'd08, //写数据状态
ACK4 = 4'd09, //应答状态4
START2 = 4'd10, //发送开始信号状态12
SEND_D_ADDR_R = 4'd11, //设备地址写入状态 + 控制读
ACK5 = 4'd12, //应答状态5
RD_DATA = 4'd13, //读数据状态
NACK = 4'd14, //非应答状态
STOP = 4'd15; //结束状态
//根据系统频率及IIC驱动频率计算分频系数
localparam CLK_DIVIDE = SYS_CLK_FREQ / I2C_FREQ >> 2'd3;
//scl4分频时钟=IIC驱动时钟i2c_clk，方便操作对采集数据及变化数据操作
always@(posedge sys_clk or negedge sys_rst_n)begin
if(~sys_rst_n)begin
i2c_clk <= 1'b0;
clk_cnt <= 10'd0;
end
else if(clk_cnt == CLK_DIVIDE - 1'b1)begin
i2c_clk <= ~i2c_clk;
clk_cnt <= 10'd0;
end
else begin
i2c_clk <= i2c_clk;
clk_cnt <= clk_cnt + 1'd1;
end
end
//i2c_clk计数器使能
always@(posedge i2c_clk or negedge sys_rst_n)begin
if(!sys_rst_n)
i2c_clk_cnt_en <= 1'b0;
//只有在发送完了结束信号或者没有接收到IIC开始传输信号的初始状态下才不停对i2c_clk计数器复位（使能为0）
else if ((cur_state == STOP && i2c_clk_cnt == 2'd3 && bit_cnt == 2'd3)||(cur_state == IDLE && !i2c_start ))
i2c_clk_cnt_en <= 1'b0;
else if(i2c_start)
i2c_clk_cnt_en <= 1'b1; //接收到开始信号，代表一次传输开始，计数器开始计数
else
i2c_clk_cnt_en <= i2c_clk_cnt_en; //其他时候保持不变
end
//i2c_clk_cnt计数器
always@(posedge i2c_clk or negedge sys_rst_n)begin
if(!sys_rst_n)
i2c_clk_cnt <= 2'd0;
else if(i2c_clk_cnt_en)
i2c_clk_cnt <= i2c_clk_cnt + 1'd1; //使能信号有效，计数器开始计数
else
i2c_clk_cnt <= 2'd0; //使能信号无效，计数器清零
end
//三段式状态机第一段
always@(posedge i2c_clk or negedge sys_rst_n)begin
if(~sys_rst_n)
cur_state <= IDLE;
else
cur_state <= next_state;
end
//三段式状态机第二段
always@(*)begin
next_state = IDLE;
case(cur_state)
IDLE:
if(i2c_start)
next_state = START1; //接收到开始信号，跳转到发送起始信号状态
else
next_state = IDLE;
START1:
if(i2c_clk_cnt == 2'd3) //i2c_clk 计数到最大值3，跳转到发送器件地址+写标志位状态
next_state = SEND_D_ADDR_W;
else
next_state = START1;
SEND_D_ADDR_W:
if(i2c_clk_cnt == 2'd3 && bit_cnt == 3'd7) //发送了8位地址后跳转到从机响应状态
next_state = ACK1;
else
next_state = SEND_D_ADDR_W;
ACK1:
if(ack_flag && i2c_clk_cnt == 2'd3)begin //响应标志有效
//根据地址状态位判断是16位地址还是8位地址，从而跳转到不同状态
if(i2c_num) //16位地址
next_state = SEND_R_ADDR_H; //跳转到寄存器高8位地址发送状态
else //8位地址
next_state = SEND_R_ADDR_L; //跳转到寄存器低8位地址发送状态
end
else if(i2c_clk_cnt == 2'd3) //响应无效或者响应不及时则跳转回初始状态
next_state = IDLE;
else
next_state = ACK1;
SEND_R_ADDR_H:
if(i2c_clk_cnt == 2'd3 && bit_cnt == 3'd7) //发送了寄存器高8位地址后跳转到从机响应状态
next_state = ACK2;
else
next_state = SEND_R_ADDR_H;
ACK2:
if(ack_flag && i2c_clk_cnt == 2'd3)
next_state = SEND_R_ADDR_L; //响应标志有效则跳转到寄存器低8位地址发送状态
else if(i2c_clk_cnt == 2'd3) //响应无效或者响应不及时则跳转回初始状态
next_state = IDLE;
else
next_state = ACK2;
SEND_R_ADDR_L:
if(i2c_clk_cnt == 2'd3 && bit_cnt == 3'd7) //发送了寄存器低8位地址后跳转到从机响应状态
next_state = ACK3;
else
next_state = SEND_R_ADDR_L;
ACK3:
if(ack_flag && i2c_clk_cnt == 2'd3)begin //响应标志有效
if(i2c_rw) //读状态
next_state = START2; //跳转到第二次发送起始信号
else //写状态
next_state = WR_DATA; //跳转到写数据状态
end
else if(i2c_clk_cnt == 2'd3)
next_state = IDLE; //响应无效或者响应不及时则跳转回初始状态
else
next_state = ACK3;
START2:
if(i2c_clk_cnt == 2'd3)
next_state = SEND_D_ADDR_R; //第二次发送起始信号后跳转到发送器件地址+读标志位状态
else
next_state = START2;
SEND_D_ADDR_R:
if(i2c_clk_cnt == 2'd3 && bit_cnt == 3'd7) //发送完了8位地址后跳转到从机响应状态
next_state = ACK5;
else
next_state = SEND_D_ADDR_R;
ACK5:
if(ack_flag && i2c_clk_cnt == 2'd3)
next_state = RD_DATA; //响应标志有效则跳转到读数据状态
else if(i2c_clk_cnt == 2'd3)
next_state = IDLE; //响应无效或者响应不及时则跳转回初始状态
else
next_state = ACK5;
RD_DATA:
if(i2c_clk_cnt == 2'd3 && bit_cnt == 3'd7) //接收完了8位数据后跳转到主机发送非响应状态
next_state = NACK;
else
next_state = RD_DATA;
NACK:
if(i2c_clk_cnt == 2'd3)
next_state = STOP; //发送完了非响应信号后跳转到发送结束信号状态
else
next_state = NACK;
WR_DATA:
if(bit_cnt == 3'd7 && i2c_clk_cnt == 2'd3)
next_state = ACK4; //写完了8位数据后跳转到从机响应状态
else
next_state = WR_DATA;
ACK4:
if(ack_flag && i2c_clk_cnt == 2'd3)
next_state = STOP; //响应标志有效则跳转到发送结束信号状态
else if(i2c_clk_cnt == 2'd3)
next_state = IDLE; //响应无效或者响应不及时则跳转回初始状态
else
next_state = ACK4;
STOP:
if(bit_cnt == 2'd3 && i2c_clk_cnt == 2'd3) //结束信号发送完毕（这里还预留了2个周期）跳转到初始状态，等待下一次传输开始信号
next_state = IDLE;
else
next_state = STOP;
default:next_state = IDLE;
endcase
end
//三段式状态机第三段
always@(posedge i2c_clk or negedge sys_rst_n)begin
if(~sys_rst_n)begin //初始状态
sda_en <= 1'b1;
sda_out <= 1'b1;
bit_cnt <= 3'd0;
i2c_end <= 1'b0;
i2c_data_r <= 8'd0;
i2c_data_r_temp <= 8'd0;
end
else begin
i2c_end <= 1'b0;
case(cur_state)
IDLE:begin
sda_en <= 1'b1; //控制总线
sda_out <= 1'b1; //拉高总线
end
START1:begin
if(i2c_clk_cnt == 2'd3)begin //发送完了开始信号
if(addr_w[7])begin //如果器件地址的最高位为1则提前拉高总线
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin //如果器件地址的最高位为0则提前拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
else begin //还没发送完开始信号则保持低电平
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
SEND_D_ADDR_W:begin
if(bit_cnt == 3'd7)begin
if(i2c_clk_cnt == 2'd3)begin //发送了8个数据（器件地址+写标志位）
bit_cnt <= 3'd0; //发送数据计数器清零
sda_en <= 1'b0; //释放总线
end
end
else if(i2c_clk_cnt == 2'd3)begin //发送完了一个数据
bit_cnt <= bit_cnt + 1'd1; //发送数据计数器清零
sda_en <= 1'b1; //控制总线
sda_out <= addr_w[6-bit_cnt]; //总线依次串行输出地址
end
end
ACK1:begin
if(i2c_clk_cnt == 2'd3)begin
if(i2c_num)begin //如果器件地址为16位
if(i2c_addr[15])begin //如果器件地址的16位为1则提前拉高总线
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin //如果器件地址的16位为0则提前拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
else begin //如果器件地址为8位
if(i2c_addr[7])begin //如果器件地址的8位为1则提前拉高总线
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin //如果器件地址的8位为0则提前拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
end
end
SEND_R_ADDR_H:begin
if(bit_cnt == 3'd7)begin //8个数据发送完了
if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= 3'd0; //发送数据计数器清零
sda_en <= 1'b0; //释放总线
end
end
else if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= bit_cnt + 1'd1; //发送数据计数器清零
sda_en <= 1'b1; //控制总线
sda_out <= i2c_addr[14-bit_cnt];//总线依次串行输出地址
end
end
ACK2:begin
if(i2c_clk_cnt == 2'd3)begin
if(i2c_addr[7])begin //下一个要发送数据的首个数据为高则提前拉高总线
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin //下一个要发送数据的首个数据为低则提前拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
end
SEND_R_ADDR_L:begin
if(bit_cnt == 3'd7)begin //8个数据发送完了
if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= 3'd0; //发送数据计数器清零
sda_en <= 1'b0; //释放总线
end
end
else if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= bit_cnt + 1'd1; //发送数据计数器清零
sda_en <= 1'b1; //控制总线
sda_out <= i2c_addr[6-bit_cnt]; //总线依次串行输出地址
end
end
ACK3:begin
if(!i2c_rw)begin //是写操作
if(i2c_clk_cnt == 2'd3)begin
if(i2c_data_w[7])begin //下一个要发送数据的首个数据为高则提前拉高总线
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin //下一个要发送数据的首个数据为低则提前拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
end
else begin //是读操作
if(i2c_clk_cnt == 2'd3)begin //提前拉高总线进入再次发送起始信号状态
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
end
START2:begin
if(i2c_clk_cnt == 2'd1)begin //拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
else if(i2c_clk_cnt == 2'd3)begin
if(addr_r[7])begin //下一个要发送数据的首个数据为高则提前拉高总线
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else begin //下一个要发送数据的首个数据为低则提前拉低总线
sda_en <= 1'b1;
sda_out <= 1'b0;
end
end
end
SEND_D_ADDR_R:begin
if(bit_cnt == 3'd7)begin //8个数据发送完了
if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= 3'd0; //发送数据计数器清零
sda_en <= 1'b0; //释放总线
end
end
else if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= bit_cnt + 1'd1; //发送数据计数器清零
sda_en <= 1'b1; //控制总线
sda_out <= addr_r[6-bit_cnt]; //总线依次串行输出地址
end
end
ACK5:
sda_en <= 1'b0; //下一个状态是接收数据，所以释放总线
RD_DATA:
if(i2c_clk_cnt == 2'd3)begin
if(bit_cnt == 3'd7)begin //接收了8个数据
bit_cnt <= 3'd0; //发送数据计数器清零
sda_en <= 1'b1; //控制总线
sda_out <= 1'b1; //拉高总线（为了下一步发送非响应信号）
i2c_data_r <= i2c_data_r_temp; //将读取的数据输出
end
else begin //数据还未接收完毕
bit_cnt <= bit_cnt + 3'd1;
end
end
else if(i2c_clk_cnt == 2'd1)begin //在SCL的中间采集数据
i2c_data_r_temp[7-bit_cnt] <=sda_in;//将总线上的数据依次串行采集
end
NACK:
if(i2c_clk_cnt == 2'd3)begin
sda_en <= 1'b1; //控制总线
sda_out <= 1'b0; //拉高总线
end
WR_DATA:
if(bit_cnt == 3'd7)begin //写完了8个数据
if(i2c_clk_cnt == 2'd3)begin
bit_cnt <= 3'd0; //发送数据计数器清零
sda_en <= 1'b0; //释放总线
end
end
else if(i2c_clk_cnt == 2'd3)begin //没有写完8个数据
bit_cnt <= bit_cnt + 1'd1; //发送数据计数器累加
sda_en <= 1'b1;
sda_out <= i2c_data_w[6-bit_cnt]; //依次输出数据
end
ACK4:
if(i2c_clk_cnt == 2'd3)begin
sda_en <= 1'b1; //控制总线
sda_out <= 1'b0; //拉低总线（为了下一步发送终止信号）
end
STOP:
if(i2c_clk_cnt == 2'd2 && bit_cnt == 2'd0)begin //拉高信号作为终止信号
sda_en <= 1'b1;
sda_out <= 1'b1;
end
else if( i2c_clk_cnt == 2'd3 )begin
if(bit_cnt == 2'd3)begin
bit_cnt <= 2'd0;
i2c_end <= 1'b1; //发送完了终止信号且延时一段时间发送IIC结束信号
end
else
bit_cnt <= bit_cnt + 1'd1;
end
default:;
endcase
end
end
//i2c时钟生成
always@(posedge i2c_clk or negedge sys_rst_n)begin
if(~sys_rst_n)
scl <= 1'b1;
else if(cur_state != STOP)begin
if(i2c_clk_cnt == 2'd2)
scl <= 1'b0;
else if(i2c_clk_cnt == 2'd0)
scl <= 1'b1;
end
else
scl <= 1'b1;
end
//从机响应信号标志
always@(posedge i2c_clk or negedge sys_rst_n)begin
if(~sys_rst_n)
ack_flag <= 1'b0;
else
case(cur_state)
ACK1,ACK2,ACK3,ACK4,ACK5:
if(i2c_clk_cnt == 2'd1 && !sda_in) //在从机响应状态正确接收到了从机发送的响应信号则拉高响应标志
ack_flag <= 1'b1;
else if(i2c_clk_cnt == 2'd3)
ack_flag <= 1'b0;
default:ack_flag <= 1'b0;
endcase
end
endmodule现在我们的驱动模块就写好了，接下来分别用一个简单的和稍复杂的Testbench来对其进行测试。需要注意的是这里的仿真还需要一个EEPROM_AT24C64的仿真模型，这个模型在夏宇闻老师的书里可以找到。
AT24C64是一种非易失性存储器（断掉数据仍保留），可以通俗的理解为一个大的二维数组。
AT24C64 的存储空间为 64 Kbit(8Kbyte)，一共有256页，每页32个数据。需要 13 位存储地址才可满足所有存储单元的寻址，存储地址为 2 字节，存储地址示意图如下：
最高支持400k通信速率，每次写入数据需间隔最少10ms.。
编写Testbench实现如下目标：
`timescale 1ns/1ns //时间单位/精度
//------------<模块及端口声明>----------------------------------------
module tb_i2c_drive();
reg sys_clk ;
reg sys_rst_n ;
reg i2c_rw ;
reg i2c_start ;
reg [15:0] i2c_addr ;
reg [7:0] i2c_data_w ;
wire [7:0] i2c_data_r ;
wire scl ;
wire sda ;
//------------<例化被测试模块>----------------------------------------
//例化IIC驱动模块
i2c_drive
#(
.DEVICE_ADDR (7'b1010_000 ), //i2c从机地址
.SYS_CLK_FREQ (26'd50_000_000 ), //系统时钟频率50M
.I2C_FREQ (18'd250_000 ) //i2c时钟频率，250k
)
i2c_drive_inst(
.sys_clk (sys_clk ), //输入系统时钟,50MHz
.sys_rst_n (sys_rst_n ), //输入复位信号,低电平有效
.i2c_rw (i2c_rw ), //读写使能信号----1:读；0：写
.i2c_start (i2c_start ), //i2c开始信号
.i2c_num (1'b1 ), //i2c字节地址字节数----1：16位；0：8位
.i2c_addr (i2c_addr ), //i2c字节地址
.i2c_data_w (i2c_data_w ), //写入i2c数据
.i2c_clk ( ), //i2c驱动时钟
.i2c_end ( ), //i2c一次读/写操作完成
.i2c_data_r (i2c_data_r ), //i2c读取数据
.scl (scl ), //输出至i2c设备的串行时钟信号scl
.sda (sda ) //输出至i2c设备的串行数据信号sda
);
//从机模块
EEPROM_AT24C64 u_EEPROM_AT24C64_inst(
.scl (scl),
.sda (sda)
);
//------------<设置初始测试条件>----------------------------------------
initial begin
sys_clk = 1'b0; //初始时钟为0
sys_rst_n <= 1'b0; //初始复位
i2c_rw <= 1'b0;
i2c_start <= 1'b0;
i2c_addr <= 16'd0;
i2c_data_w <= 8'd0;
#65 //65个时钟周期后
sys_rst_n <= 1'b1; //拉高复位，系统进入工作状态
#1_000_000 //1ms延时
i2c_rw <= 1'b0; //写状态控制
i2c_start <= 1'b1; //拉高开始信号
//i2c_addr <= ADDR;
i2c_addr <= ($random%65536);//生成一个0~65535的随机数，即16位的二进制随机数
i2c_data_w <= ($random%256);//生成一个0~255的随机数，即8位的二进制随机数
#1200 //这里保证i2c_start超过一个i2c_clk周期，保证能采集到该信号
i2c_start <= 1'b0;
#10_000_000
i2c_rw <= 1'b1; //写状态控制
i2c_start <= 1'b1; //拉高开始信号
#1200 //这里保证i2c_start超过一个i2c_clk周期，保证能采集到该信号
i2c_start <= 1'b0;
end
//------------<设置时钟>----------------------------------------------
always #10 sys_clk = ~sys_clk; //系统时钟周期20ns
endmodule使用modelsi'm软件进行仿真，仿真结果如下图：
截取写操作部分的详细仿真结果：
截取读操作部分的详细仿真结果：
在6.2节我们通过对AT24C64模型的某个地址写入随机数据然后读出对比验证的方式来对编写的IIC驱动代码做了验证，验证结果成功。可是上节的激励是来自编写的Testbench，而不是主机，也就是说无法模拟主机调用IIC总线，这样的测试难免不够周全。
在这一节，我们再编写两个Verilog文件--i2c_top、i2c_rw：
i2c_rw读写模块预期实现的功能：
i2c_rw读写模块代码：
module i2c_rw(
input i2c_clk , //i2c驱动时钟
input rst_n , //低电平有效的复位信号
input i2c_end , //i2c一次读/写操作完成
input [7:0] i2c_data_r , //i2c读取数据
output reg i2c_rw , //读写使能信号----1:读；0：写
output reg i2c_start , //i2c开始信号
output reg [15:0] i2c_addr , //i2c字节地址
output reg [7:0] i2c_data_w //写入i2c数据
);
parameter DATA_MAX = 16'd64; //最大256页地址（每页32个），最多8192个地址
parameter WR_CYCLE_MAX = 32'd10_000; //每次写入需要间隔的时间，默认10ms(1M时钟下)
reg [31:0] cnt_wr_cycle; //写入间隔计数器
//写入间隔计数
always@(posedge i2c_clk or negedge rst_n)begin
if(!rst_n)
cnt_wr_cycle <= 32'd0;
else if(cnt_wr_cycle == WR_CYCLE_MAX) //已计数到最大则清零（间隔时间结束）
cnt_wr_cycle <= 32'd0;
else
cnt_wr_cycle <= cnt_wr_cycle + 1'd1; //否则计数器累加
end
//读写状态控制
always@(posedge i2c_clk or negedge rst_n)begin
if(!rst_n)
i2c_rw <= 1'b0;
else if((i2c_addr == DATA_MAX - 1'd1) && (i2c_end)) //数据全部写入则将读写控制拉高（表示读）
i2c_rw <= 1'b1;
else
i2c_rw <= i2c_rw;
end
//AT24C64地址设置
always@(posedge i2c_clk or negedge rst_n)begin
if(!rst_n)
i2c_addr <= 16'd0;
else if(i2c_end)begin //一次读写操作结束
if(i2c_rw) begin //读操作
if(i2c_addr == DATA_MAX - 1'd1)
i2c_addr <= 16'd0; //已到达最大操作个数地址则清零
else
i2c_addr <= i2c_addr + 1'd1; //否则地址累加
end
else begin //写操作
if(i2c_addr == DATA_MAX - 1'd1)
i2c_addr <= 16'd0; //已到达最大操作个数地址则清零
else
i2c_addr <= i2c_addr + 1'd1; //否则地址累加
end
end
else
i2c_addr <= i2c_addr;
end
//读写AT24C64
always @(posedge i2c_clk or negedge rst_n) begin
if(!rst_n) begin
i2c_start <= 1'b0;
i2c_data_w <= 8'd0;
end
else begin
if(!i2c_rw) begin //从eeprom的第1页的第1个字节开始写入数据
if(cnt_wr_cycle == WR_CYCLE_MAX - 1'b1) begin //一次写间隔结束，可以开始新一轮写入
i2c_start <= 1'b1; //拉高IIC开始信号，准备写入数据
i2c_data_w <= i2c_addr[7:0]; //写入数据与写入地址相同
// i2c_data_w <= 0; //暴力清零
end
else begin //否则保持状态不变
i2c_start <= 1'b0;
i2c_data_w <= i2c_data_w;
end
end
else begin //从eeprom的第1页的第1个字节开始读取数据
if(cnt_wr_cycle == 0 && i2c_addr == 0) //第一次读取延时
i2c_start <= 1'b1; //拉高IIC开始信号，准备读数据
else if(i2c_end ) //一次读操作完成
i2c_start <= 1'b1; //拉高IIC开始信号，准备再次读数据
else
i2c_start <= 1'b0;
end
end
end
endmodulei2c_top顶层模块代码：
module i2c_top(
input sys_clk , //输入系统时钟,50MHz
input sys_rst_n , //输入复位信号,低电平有效
output scl , //输出至i2c设备的串行时钟信号scl
inout sda //输出至i2c设备的串行数据信号sda
);
wire i2c_rw ;
wire i2c_start ;
wire [15:0] i2c_addr ;
wire [7:0] i2c_data_w ;
wire i2c_clk ;
wire i2c_end ;
wire [7:0] i2c_data_r ;
i2c_rw i2c_rw_inst(
.i2c_clk (i2c_clk ), //i2c驱动时钟
.rst_n (sys_rst_n ), //低电平有效的复位信号
.i2c_end (i2c_end ), //i2c一次读/写操作完成
.i2c_data_r (i2c_data_r ), //i2c读取数据
.i2c_rw (i2c_rw ), //读写使能信号----1:读；0：写
.i2c_start (i2c_start ), //i2c开始信号
.i2c_addr (i2c_addr ), //i2c字节地址
.i2c_data_w (i2c_data_w ) //写入i2c数据
);
i2c_drive
#(
.DEVICE_ADDR (7'b1010_000 ), //i2c设备地址,7'b1010_000
.SYS_CLK_FREQ(26'd50_000_000 ), //输入系统时钟频率
.I2C_FREQ (18'd250_000 ) //i2c设备时钟频率
)
i2c_drive_inst(
.sys_clk (sys_clk ), //输入系统时钟,50MHz
.sys_rst_n (sys_rst_n ), //输入复位信号,低电平有效
.i2c_rw (i2c_rw ), //读写使能信号----1:读；0：写
.i2c_start (i2c_start ), //i2c开始信号
.i2c_num (1'b1 ), //i2c字节地址字节数----1：16位；0：8位
.i2c_addr (i2c_addr ), //i2c字节地址
.i2c_data_w (i2c_data_w ), //写入i2c数据
.i2c_clk (i2c_clk ), //i2c驱动时钟
.i2c_end (i2c_end ), //i2c一次读/写操作完成
.i2c_data_r (i2c_data_r ), //i2c读取数据
//I2C物理接口
.scl (scl ), //输出至i2c设备的串行时钟信号scl
.sda (sda ) //输出至i2c设备的串行数据信号sda
);
endmodule编写Testbench例化i2c_top顶层模块和AT24C64仿真模型，同时打印读写信息（读写状态；地址；数据）：
`timescale 1ns/1ns //时间单位/精度
//------------<模块及端口声明>----------------------------------------
module tb_i2c_top();
reg sys_clk ;
reg sys_rst_n ;
wire scl ;
wire sda ;
defparam i2c_top_inst.i2c_rw_inst.WR_CYCLE_MAX = 1000; //仿真时将写入间隔改为1ms（节省时间）
//defparam i2c_top_inst.i2c_rw_inst.DATA_MAX = 10; //可以重新修改写入个数
//------------<例化被测试模块>----------------------------------------
i2c_top i2c_top_inst(
.sys_clk (sys_clk ),
.sys_rst_n (sys_rst_n ),
.scl (scl ),
.sda (sda )
);
EEPROM_AT24C64 u_EEPROM_AT24C64_inst(
.scl (scl),
.sda (sda)
);
//------------<设置初始测试条件>----------------------------------------
initial begin
sys_clk = 1'b0; //初始时钟为0
sys_rst_n <= 1'b0; //初始复位;
#65 //65个时钟周期后
sys_rst_n <= 1'b1; //拉高复位，系统进入工作状态
end
//------------<命令窗口监控>----------------------------------------
always @(*) begin
if(i2c_top_inst.i2c_rw_inst.i2c_rw == 1'b0)begin //写操作
if (i2c_top_inst.i2c_rw_inst.i2c_end) //写操作结束
//打印：时间--地址--数据
$display("@time %t write: addr=%d data=%d",$time,i2c_top_inst.i2c_rw_inst.i2c_addr, i2c_top_inst.i2c_rw_inst.i2c_data_w);
end
else begin
if (i2c_top_inst.i2c_rw_inst.i2c_end) //读操作
//打印：时间--地址--数据 //读操作结束
$display("@time %t read: addr=%d data=%d",$time,i2c_top_inst.i2c_rw_inst.i2c_addr, i2c_top_inst.i2c_rw_inst.i2c_data_r);
end
end
//------------<设置时钟>----------------------------------------------
always #10 sys_clk = ~sys_clk; //系统时钟周期20ns
endmodule使用modelsi'm软件进行仿真，仿真结果如下图：
接下来局部截图进行讲解：
下图中：
i2c_rw为低电平，代表在进行写操作，分别往地址d55中写入d55·······地址d62中写入d62等，直到往地址d63中写入d63后，i2c_rw被拉高，开始进行读操作。重新从地址0开始到63进行读取操作。
下图中：
i2c_rw为高电平，代表在进行读操作，分别从地址d42中读取d42·······直到地址d63中写入d63等后，i2c_rw被拉高，重新从地址0开始到63进行读取操作。需要注意的是，下图与上图在IIC时序上，sda信号存在蓝色（不定态）和红色（x状态），产生的原因我们最后再讲，这里只需要知道它们对时序没有影响即可。
还记得之前我们在testbench加入了命令打印行吗？接下来就看一下命令打印窗口：
首先对地址0-63写入数据0-63，然后重复对地址0-63读取，读取的数据为0-63，与写入数据一致
至此已经顺利完成了IIC驱动的仿真验证，接下来使用一块Cyclone IV E的开发板上板验证，使用signaltap II抓一下波形。
因为每两次写入操作中间隔10ms，所以在FPGA芯片资源有限的情况下肯定没办法同时抓到两次写入的波形，只好随便抓几个个波形分析下IIC时序：
下图往地址d18写入数据d18：
下图往地址d50写入数据d50：
其他地址类推。
读操作的截图如下：
从地址48-63（实际上是0-63，截图问题）读取了数据48-63，然后进行新一轮的读取。读取的数据与写入的数据一致。
对地址50进行读操作的截图如下：
在使用仿真模型进行读写仿真时出现了高阻态与未知态，见下图（写操作）：
上图的蓝色高阻态均发生在sda_en为低电平期间，此时主机放弃了总线控制权，放弃总线的原因是为了等待从机发送响应信号（低电平），而高阻态的出现就是因为总线控制权的过渡需要时间。同时还可以发现高阻态发生在scl低电平（基本算是中间），此时是允许数据变化的，所以不会对写时序造成影响。
读操作出现的问题如下：
读操作的情况基本与写操作一致，不过还出现了x状态，但也不影响读写时序。
在上板验证时发现在从机应答时出现了高电平，分别如下两图：
画图说明：
从A部分可以看出，发送数据的时候，数据的改变都是在低电平的中间，所以发送给从机的单bit数据时间宽度==scl时钟的半个低电平+scl时钟的一个高电平+scl时钟的半个低电平；我一开始在C部分检测从机的应答信号的时候，先是在前一个低电平的中间释放了总线，然后等待总线被从机拉低后再拉高。根据A部分的数据发送经验我以为，从机的响应应该也会持续到下一个低电平的中间才会发生变化（也就是从机的响应会维持一个scl时钟周期），可实际上从机提前了1/4个scl时钟周期，在scl时钟的下降沿就发生了变化。
这个问题我一开始一直以为是响应不成功，加上状态机的状态跳转我又是设计的在低电平的中间检测从机是否响应，导致我的状态跳转一直是错的。后面仔细查了数据手册，发现了这个响应的时序如下（AT24C64）：
可以看到，时序图上的响应信号也确实是在scl的下降沿变化，而不是低电平的中间。
然后又搜了点资料，发现正点原子的开发板的教学资料上EEPROM章节，signaltap II 抓的时序如下：
图中黑圈都是从机响应后被上拉电阻拉高，而且从机都是在scl的下降沿将总线释放了，和我抓到的图是一致。
解决办法： 在响应信号的scl的上升沿中间进行采样，一旦在采样中检测到响应信号，就把标志信号拉高（ack_flag），这样状态的跳转就可以通过标志信号来判断了。
下图说明：
从上图可以看到，两次写操作的间隔时间只有100us，这就导致第二次写操作失败（回了非响应信号）。每个I2C从器件的写间隔时间不一样，具体以手册为准。
解决办法：查看AT24CC64的手册，发现写入时间间隔twr==10ms，所以把两次写入的间隔时间改成10ms就好了。
读操作在发送“器件地址+读”之前应该先进行一次哑写操作，这样就可以把地址指针指向想写入数据的寄存器地址。
我一开始调试的时候就是忘了这点，直接发送的读操作，然后就收到了从机的非响应信号，导致时序错误。
解决办法：先进行写操作就可以了。
如果需要完整的工程文件请点这里：工程文件下载
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visitthehelpcenter指导。关闭10年前。问题1)我想知道rubyonrails是否有功能类似于primefaces的gem。我问的原因是如果您使用primefaces(http://www.primefaces.org/showcase-labs/ui/home.jsf)，开发人员无需担心javascript或jquery的东西。据我所知，JSF是一个规范，基于规范的各种可用实现，prim
华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o
本教程将在Unity3D中混合Optitrack与数据手套的数据流，在人体运动的基础上，添加双手手指部分的运动。双手手背的角度仍由Optitrack提供，数据手套提供双手手指的角度。 01 客户端软件分别安装MotiveBody与MotionVenus并校准人体与数据手套。MotiveBodyMotionVenus数据手套使用、校准流程参照：https://gitee.com/foheart_1/foheart-h1-data-summary.git02 数据转发打开MotiveBody软件的Streaming，开始向Unity3D广播数据；MotionVenus中设置->选项选择Unit
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
最近在学习CAN，记录一下，也供大家参考交流。推荐几个我觉得很好的CAN学习，本文也是在看了他们的好文之后做的笔记首先是瑞萨的CAN入门，真的通透；秀！靠这篇我竟然2天理解了CAN协议！实战STM32F4CAN！原文链接：https://blog.csdn.net/XiaoXiaoPengBo/article/details/116206252CAN详解（小白教程）原文链接：https://blog.csdn.net/xwwwj/article/details/105372234一篇易懂的CAN通讯协议指南1一篇易懂的CAN通讯协议指南1-知乎(zhihu.com)视频推荐CAN总线个人知识总
MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO
遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg
通常，数组被实现为内存块，集合被实现为HashMap，有序集合被实现为跳跃列表。在Ruby中也是如此吗？我正在尝试从性能和内存占用方面评估Ruby中不同容器的使用情况 最佳答案 数组是Ruby核心库的一部分。每个Ruby实现都有自己的数组实现。Ruby语言规范只规定了Ruby数组的行为，并没有规定任何特定的实现策略。它甚至没有指定任何会强制或至少建议特定实现策略的性能约束。然而，大多数Rubyist对数组的性能特征有一些期望，这会迫使不符合它们的实现变得默默无闻，因为实际上没有人会使用它:插入、前置或追加以及删除元素的最坏情况步骤复
在ruby中，你可以这样做:classThingpublicdeff1puts"f1"endprivatedeff2puts"f2"endpublicdeff3puts"f3"endprivatedeff4puts"f4"endend现在f1和f3是公共(public)的，f2和f4是私有(private)的。内部发生了什么，允许您调用一个类方法，然后更改方法定义？我怎样才能实现相同的功能(表面上是创建我自己的java之类的注释)例如...classThingfundeff1puts"hey"endnotfundeff2puts"hey"endendfun和notfun将更改以下函数定