1、概括
前文设计基于FPGA的IIC接口模块,本文将使用eeprom来验证该模块的设计。为了便于查看读写波形,采用两个按键来控制对eeprom数据的读写,当按键0按下后,FPGA向eeprom的前64个存储地址写入地址对应的数据,当按键1按下后,FPGA从eeprom的前64个存储地址读取数据。
该eeprom的原理图如下所示,其中A2、A1、A0表示该eeprom器件地址的低3位,器件地址的高4位固定为4’b1010。wp是写保护引脚,该引脚为低电平才能向eeprom中写入数据。24c02只能存储256字节数据,所以存储地址只有一个字节的数据。
该eeprom的单字节读写时序如下图所示:
该eeprom的页读写时序如下所示:
就是标准的IIC时序,只需要调用前文实现的IIC接口模块即可。
顶层模块的对应的RTL图如下所示,包含两个按键消抖模块对两路按键输入信号消抖,at24c02模块对IIC接口模块的读写进行控制,iic_drive模块驱动IIC时序。
顶层模块对应的参考代码如下所示:
module top #(
parameter TIME_20MS = 20_000_000 ,//按键消抖时间,默认20MS;
parameter TIME_CLK = 10 ,//系统时钟周期,默认10ns;
parameter FCLK = 100_000_000 ,//系统时钟频率,默认100MHz。
parameter FSCL = 250_000 ,//IIC时钟频率,默认400KHz。
parameter REG_ADDR_BYTE_NUM = 1 ,//寄存器地址字节数,最小值为1;
parameter DATA_BYTE_NUM = 1 ,//读写数据字节数,最小值为1.
parameter DELAY_TIME = 10_000_000 //延迟时间,10ms.
)(
input clk ,//系统时钟信号;
input rst_n ,//系统复位信号,低电平有效;
input [1 : 0] key ,//按键输入信号;
output led ,
output scl ,
inout sda
);
wire [1 : 0] key_out ;
wire start ;
wire rw_flag ;
wire [REG_ADDR_BYTE_NUM*8-1 : 0] reg_addr ;
wire [DATA_BYTE_NUM*8-1 : 0] wdata ;
wire [DATA_BYTE_NUM*8-1 : 0] rdata ;
wire rdata_vld ;
wire rdy ;
wire ack_flag ;
genvar i ;
//例化两个按键消抖模块,对输入的两路按键信号进行消抖;
generate
for(i=0 ; i<2 ; i=i+1)begin : KEY_C
key #(
.TIME_20MS ( TIME_20MS ),
.TIME_CLK ( TIME_CLK )
)
u_key (
.clk ( clk ),//系统时钟,100MHz。
.rst_n ( rst_n ),//系统复位,低电平有效。
.key_in ( key[i] ),//待输入的按键输入信号,默认低电平有效;
.key_out ( key_out[i]) //按键消抖后输出信号,当按键按下一次时,输出一个时钟宽度的高电平;
);
end
endgenerate
//例化eeprom的读写控制模块;
at2402 #(
.TCLK ( TIME_CLK ),//系统时钟周期,10ns.
.DELAY_TIME ( DELAY_TIME),//延迟时间,10ms.
.REG_ADDR_BYTE_NUM ( REG_ADDR_BYTE_NUM ),//寄存器地址字节数;
.DATA_BYTE_NUM ( DATA_BYTE_NUM ) //读写数据字节数。
)
u_at2402 (
.clk ( clk ),//系统时钟信号;
.rst_n ( rst_n ),//系统复位信号,低电平有效;
.key ( key_out ),//按键输入,分别控制写入和读取eeprom。
.rdy ( rdy ),//iic控制器忙闲指示信号,高电平表示空闲。
.rdata ( rdata ),//从IIC读出的数据;
.rdata_vld ( rdata_vld ),//IIC读出数据指示信号;
.start ( start ),//开始进行读写操作信号;
.rw_flag ( rw_flag ),//读写指示信号,高电平表示进行读操作;
.reg_addr ( reg_addr ),//寄存器地址;
.wdata ( wdata ),//需要写入寄存器的数据;
.led ( led ) //错误指示灯。
);
//例化IIC接口驱动模块;
iic_drive #(
.FCLK ( FCLK ),//系统时钟频率,默认100MHz。
.FSCL ( FSCL ),//IIC时钟频率,默认400KHz。
.REG_ADDR_BYTE_NUM ( REG_ADDR_BYTE_NUM ),//寄存器地址字节数;
.DATA_BYTE_NUM ( DATA_BYTE_NUM ) //读写数据字节数。
)
u_iic_drive (
.clk ( clk ),//系统时钟信号;
.rst_n ( rst_n ),//系统复位信号,低电平有效;
.start ( start ),//开始进行读写操作;
.rw_flag ( rw_flag ),//读写标志信号,高电平表示读操作,低电平表示写操作;
.reg_addr ( reg_addr ),//寄存器地址,读写操作时共用的地址信号;
.wdata ( wdata ),//写数据;
.rdata ( rdata ),//读数据信号;
.rdata_vld ( rdata_vld ),//读数据输出使能信号,高电平有效;
.rdy ( rdy ),//模块忙闲指示信号,位高电平时可以接收上游模块的读写使能信号;
.scl ( scl ),//IIC的时钟信号;
.ack_flag ( ack_flag ),//高电平表示应答失败;
.sda ( sda ) //IIC的双向数据信号;
);
//例化ILA调试模块
//ila_0 u_ila_0 (
// .clk ( clk ),//input wire clk
// .probe0 ( scl ),//input wire [0:0] probe0
// .probe1 ( u_iic_drive.sda_in ),//input wire [0:0] probe1
// .probe2 ( u_iic_drive.state_c ),//input wire [6:0] probe2
// .probe3 ( u_iic_drive.ack_flag ),//input wire [0:0] probe3
// .probe4 ( u_iic_drive.l2h_flag ),//input wire [0:0] probe4
// .probe5 ( u_iic_drive.h2l_flag ),//input wire [0:0] probe5
// .probe6 ( u_iic_drive.wr_flag ),//input wire [0:0] probe6
// .probe7 ( u_iic_drive.rd_flag ),//input wire [0:0] probe7
// .probe8 ( u_iic_drive.end_div_cnt ),//input wire [0:0] probe8
// .probe9 ( u_iic_drive.rw_flag ),//input wire [0:0] probe9
// .probe10 ( u_iic_drive.sda_out ),//input wire [0:0] probe10
// .probe11 ( u_iic_drive.state_n ),//input wire [6:0] probe11
// .probe12 ( u_iic_drive.reg_addr ),//input wire [7:0] probe12
// .probe13 ( u_iic_drive.bit_cnt ),//input wire [3:0] probe13
// .probe14 ( u_iic_drive.bit_cnt_num ),//input wire [3:0] probe14
// .probe15 ( u_iic_drive.div_cnt ),//input wire [8:0] probe15
// .probe16 ( u_iic_drive.start ),//input wire [0:0] probe16
// .probe17 ( u_iic_drive.rdata ),//input wire [7:0] probe17
// .probe18 ( u_iic_drive.rdata_vld ),//input wire [0:0] probe18
// .probe19 ( u_iic_drive.sda_out_en ),//input wire [0:0] probe19
// .probe20 ( u_iic_drive.rdy ) //input wire [0:0] probe20
//);
endmodule
当写入寄存器地址长度和读写数据长度为1字节,对应的TestBench文件如下所示:
`timescale 1 ns/1 ns
module test();
localparam CYCLE = 10 ;//系统时钟周期,单位ns,默认10ns;
localparam RST_TIME = 10 ;//系统复位持续时间,默认10个系统时钟周期;
localparam FCLK = 100_000_000 ;//系统时钟频率,默认100MHz。
localparam FSCL = 400_000 ;//IIC时钟频率,默认400KHz。
localparam TIME_20MS = 2000*CYCLE ;
localparam DELAY_TIME = 80000 ;
reg clk ;//系统时钟,默认100MHz;
reg rst_n ;//系统复位,默认低电平有效;
reg [1 : 0] key ;
wire led ;
wire scl ;
wire sda ;
top #(
.TIME_20MS ( TIME_20MS ),
.TIME_CLK ( CYCLE ),
.DELAY_TIME ( DELAY_TIME),
.FCLK ( FCLK ),
.FSCL ( FSCL )
)
u_top (
.clk ( clk ),
.rst_n ( rst_n ),
.key ( key ),
.led ( led ),
.scl ( scl ),
.sda ( sda )
);
eeprom u_eeprom0 (
.scl ( scl ),
.sda ( sda )
);
//生成周期为CYCLE数值的系统时钟;
initial begin
clk = 0;
forever #(CYCLE/2) clk = ~clk;
end
//生成复位信号;
initial begin
#1; rst_n <= 1'b1; key <= 2'b11;
#2; rst_n <= 0;//开始时复位10个时钟;
repeat(RST_TIME)@(posedge clk);
rst_n <= 1'b1;
repeat(3)@(posedge clk);
key_task(0);
repeat(1300000)@(posedge clk);
key_task(1);
repeat(1300000)@(posedge clk);
repeat(100)@(posedge clk);
$stop;//停止仿真;
end
task key_task(
input [1 : 0] value
);
begin
key[value] <= 1'b1;
@(posedge clk);
key[value] <= 1'b0;
repeat(7)begin
repeat({$random} % (TIME_20MS/2))@(posedge clk);
key[value] <= ~key[value];
end
key[value] <= 1'b0;
repeat(TIME_20MS*2)@(posedge clk);
repeat(7)begin
key[value] <= ~key[value];
repeat({$random} % (TIME_20MS/2))@(posedge clk);
end
key[value] <= 1'b1;
end
endtask
endmodule
其中使用的eeprom仿真模型是在网上找到的,这个文件只支持读写数据长度为1字节,需要的同学可以研究下。
`timescale 1ns / 1ps
`define timeslice 100
module eeprom (
input scl ,
inout sda
);
reg out_flag ;
reg [7 : 0] memory [2047 : 0] ;
reg [10 : 0] address ;
reg [7 : 0] memory_buf ;
reg [7 : 0] sda_buf ;
reg [7 : 0] shift ;
reg [7 : 0] addr_byte ;
reg [7 : 0] ctrl_byte ;
reg [1 : 0] State ;
integer i ;
// -------------------------------------
parameter r7 = 8'b10101111 ;
parameter r6 = 8'b10101101 ;
parameter r5 = 8'b10101011 ;
parameter r4 = 8'b10101001 ;
parameter r3 = 8'b10100111 ;
parameter r2 = 8'b10100101 ;
parameter r1 = 8'b10100011 ;
parameter r0 = 8'b10100001 ;
parameter w7 = 8'b10101110 ;
parameter w6 = 8'b10101100 ;
parameter w5 = 8'b10101010 ;
parameter w4 = 8'b10101000 ;
parameter w3 = 8'b10100110 ;
parameter w2 = 8'b10100100 ;
parameter w1 = 8'b10100010 ;
parameter w0 = 8'b10100000 ;
//--------------------------------------
assign sda= (out_flag == 1) ? sda_buf[7] : 1'bz;
//--------------寄存器和存储器初始化--------------
initial begin
addr_byte = 0;
ctrl_byte = 0;
out_flag = 0;
sda_buf = 0;
State = 2'b00;
memory_buf = 0;
address = 0;
shift = 0;
for(i = 0 ; i <= 2047 ; i = i + 1)
memory[i] = 0;
end
//--------------启动信号检测--------------
always @(negedge sda)
if(scl == 1)begin
State = State + 1;
if(State == 2'b11)
disable write_to_eeprm;
end
//--------------主状态机--------------
always @(posedge sda)
if(scl == 1)
stop_W_R;
else begin
casex(State)
2'b01 : begin
read_in;
if(ctrl_byte == w7||ctrl_byte == w6|| ctrl_byte == w5 || ctrl_byte == w4 || ctrl_byte == w3 || ctrl_byte == w2 ||ctrl_byte == w1 ||ctrl_byte == w0)begin
State = 2'b10;
write_to_eeprm;
end
else
State = 2'b00;
end
2'b11 :
read_from_eeprm;
default : State = 2'b00;
endcase
end
//--------------操作停止--------------
task stop_W_R;
begin
State = 2'b00;
addr_byte = 0;
ctrl_byte = 0;
out_flag = 0;
sda_buf = 0;
end
endtask
//--------------读进控制字和存储单元地址--------------
task read_in;
begin
shift_in(ctrl_byte);
shift_in(addr_byte);
end
endtask
//--------------EEPROM--------------
task write_to_eeprm;
begin
shift_in(memory_buf);
address = {ctrl_byte[3:1],addr_byte};
memory[address] = memory_buf;
$display("eeprm---memory[%0h]=%0h",address,memory[address]);
State = 2'b00;
end
endtask
//--------------EEPROM读操作--------------
task read_from_eeprm;
begin
shift_in(ctrl_byte);
if(ctrl_byte == r7 || ctrl_byte == r6 || ctrl_byte == r5 || ctrl_byte == r4 || ctrl_byte == r3 || ctrl_byte == r2 || ctrl_byte == r1 || ctrl_byte == r0)begin
address = {ctrl_byte[3:1],addr_byte};
sda_buf = memory [address];
shift_out;
State = 2'b00;
end
end
endtask
//--------------SDA 数据线上的数据存入寄存器 ,数据在SCL的高电平有效--------------
task shift_in;
output[7:0] shift;
begin
@(posedge scl) shift[7] = sda;
@(posedge scl) shift[6] = sda;
@(posedge scl) shift[5] = sda;
@(posedge scl) shift[4] = sda;
@(posedge scl) shift[3] = sda;
@(posedge scl) shift[2] = sda;
@(posedge scl) shift[1] = sda;
@(posedge scl) shift[0] = sda;
@(negedge scl)begin
#`timeslice;
out_flag = 1;
sda_buf = 0;
end
@(negedge scl)
#`timeslice out_flag = 0;
end
endtask
//--------------EEPROM存储器中的数据通过SDA数据线输出,数据在SCL低电平时变化--------------
task shift_out;
begin
out_flag = 1;
for(i = 6 ; i >= 0 ; i = i - 1)begin
@(negedge scl);
# `timeslice;
sda_buf = sda_buf << 1;
end
@(negedge scl) # `timeslice sda_buf[7] = 1;
@(negedge scl) # `timeslice out_flag = 0;
end
endtask
endmodule
2、eeprom控制模块
该模块就是检测按键按下,然后产生eeprom的读写开始信号,驱动iic模块生成对应读写时序。当按键0按下时,将写eeprom标志信号wr_flag拉高,由于两次写操作需要间隔一段时间,使用一个计数器来计数这段时间,当时间到达后把iic驱动模块的读写开始信号拉高,并且把寄存器地址和需要写入的数据输出给该模块。还需要一个计数器来记录写入多少个数据了,当数据全部写入eeprom之后,把wr_flag拉低。
按键1按下后,将读eeprom的标志信号rd_flag拉高,这里为了后续比较号使用ila抓取信号,两次读操作也加了写操作一样的延时。就是把写操作的寄存器全部都读一遍。
将读出的数据与写入数据进行对比,如果不一致则led输出低电平,否则输出高电平。这个其实没有必要,因为这里采用ila抓取信号可以更加直观。
该模块的代码比较简单,就不再详细讲解,主要的参考代码如下所示:
//产生读指示信号,初始值为低电平,按键1按下后拉高,读出指定地址数据后拉低;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin//初始值为0;
rd_flag <= 1'b0;
end
else if(end_cnt)begin//数据全部读出后拉低;
rd_flag <= 1'b0;
end
else if(key[1])begin//按键1按下时拉高;
rd_flag <= 1'b1;
end
end
//产生写指示信号,初始值为低电平,按下按键0后拉高,写入指定数据后拉高;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin//初始值为0;
wr_flag <= 1'b0;
end
else if(end_cnt)begin//写入规定数据后拉低;
wr_flag <= 1'b0;
end
else if(key[0])begin//按键0按下后拉高;
wr_flag <= 1'b1;
end
end
//延时计数器,每次写操作结束后,都需要延时一段时间,确保写入的数据被稳定存入eeprom内部;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin//
cnt_r <= 0;
end
else if(add_cnt_r)begin
if(end_cnt_r)
cnt_r <= 0;
else
cnt_r <= cnt_r + 1;
end
end
assign add_cnt_r = (wr_flag || rd_flag) && rdy;//当一次写操作结束时,开始对系统时钟计数;
assign end_cnt_r = add_cnt_r && cnt_r == DELAY_CNT - 1;
//计数器cnt用来记录每次按下按键后需要读写的数据个数;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin//
cnt <= 0;
end
else if(add_cnt)begin
if(end_cnt)
cnt <= 0;
else
cnt <= cnt + DATA_BYTE_NUM;
end
end
assign add_cnt = end_cnt_r;
assign end_cnt = add_cnt && cnt >= 64-1;
//如果读标志有效,则该信号拉高,表示进行读操作,否则默认进行写操作;
always@(posedge clk)begin
rw_flag <= rd_flag;
end
//生成读写的开始信号,还有读写操作的寄存器地址和需要写入的数据信号;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin//初始值为0;
reg_addr <= 0;
start <= 1'b0;
end
else if(add_cnt)begin
reg_addr <= cnt;
start <= 1'b1;
end
else begin
start <= 1'b0;
end
end
//一次写入EEPROM内部的数据;
generate
if(DATA_BYTE_NUM == 1)begin//每次发送1字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b0;
wdata <= 0;
end
else if(add_cnt)
wdata <= cnt;
else
led <= (cnt == rdata) && rdata_vld;
end
end
else if(DATA_BYTE_NUM == 2)begin//每次发送2字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1)} == rdata) && rdata_vld;
end
end
else if(DATA_BYTE_NUM == 3)begin//每次发送3字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2)} == rdata) && rdata_vld;
end
end
else if(DATA_BYTE_NUM == 4)begin//每次发送4字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3)} == rdata) && rdata_vld;
end
end
else if(DATA_BYTE_NUM == 5)begin//每次发送5字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4)} == rdata) && rdata_vld;
end
end
else if(DATA_BYTE_NUM == 6)begin//每次发送6字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4),(cnt[7:0]+8'd5)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4),(cnt[7:0]+8'd5)} == rdata) && rdata_vld;
end
end
else if(DATA_BYTE_NUM == 7)begin//每次发送7字节数据;
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4),(cnt[7:0]+8'd5),(cnt[7:0]+8'd6)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4),(cnt[7:0]+8'd5),(cnt[7:0]+8'd6)} == rdata) && rdata_vld;
end
end
else begin//每次发送8字节数据,此处最多写了一次写入或者读出8字节数据的程序,如果想要一次从EEPROM中写入更多数据,则需要将这个数据拼接更多位进行测试。
always@(posedge clk or negedge rst_n)begin
if(rst_n==1'b0)begin
led <= 1'b1;
wdata <= 0;
end
else if(add_cnt)
wdata <= {cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4),(cnt[7:0]+8'd5),(cnt[7:0]+8'd6),(cnt[7:0]+8'd7)};
else
led <= ({cnt[7:0],(cnt[7:0]+8'd1),(cnt[7:0]+8'd2),(cnt[7:0]+8'd3),(cnt[7:0]+8'd4),(cnt[7:0]+8'd5),(cnt[7:0]+8'd6),(cnt[7:0]+8'd7)} == rdata) && rdata_vld;
end
end
endgenerate
3、模块仿真
前文的按键消抖模块、IIC驱动模块都是使用前文详细讲解且开源的模块,此处不再赘述。直接对本工程进行仿真。
首先将顶层模块的写寄存器地址字节数、读写数据字节数均设置为1。使用vivado的仿真如下图所示:
把上图中写数据的一段时序放大后如下图所示,首先发送起始位,然后写入器件地址和写指示位,之后应答位。然后发送写寄存器地址26,之后写入数据26,最后发送停止位。完成向地址26中写入26的时序。
下图是读出地址为20的时序,首先发送起始位、器件地址、写寄存器地址,之后发送重复起始位,然后器件地址,之后就读取数据,最后发送停止位。图中蓝色信号就是三态门使能信号,该信号为低电平时关闭三态门,主机释放数据总线,从机驱动数据总线。
从地址20中读出的数据是20,由此验证写入和读出数据均没有问题。
接下来对页写和页读时序进行仿真,由于这个at2402的仿真模型只支持单字节的读写时序,所以多字节超出的部分从机不会应答,此处只是借助仿真查看下读写时序是否与预期一致即可,具体验证可以在后文的ILA抓取信号处验证。
将顶层模块的读写数据字节数的参数DATA_BYTE_NUM设置为3,就是每次读写3个地址的数据,然后运行仿真,结果如下所示。相比图7的读写时间将大幅度减小。
将上图中写入寄存器数据的一段仿真时序放大,如下图所示,向寄存器地址为30开始的三个寄存器中分别写入数据30、31、32。仿真时序没有问题,从机没有应答是因为仿真模型不支持这种模式,没有关系。
将上述读数据时序放大,如下图所示,从连续读出45、46、47地址处的数据。前面的时序都没有问题,主要关注在读数据阶段主机应答信号产生是否正确,主机在接收前两字节数据后都将数据线拉低应答,接收最后一字节数据后将数据线拉高,不应答从机然后发送停止位,由此仿真时序没有问题。
然后就是验证一下寄存器地址多字节的IIC读、写时序,将顶层模块的寄存器地址长度REG_ADDR_BYTE_NUM参数设置为3,读、写数据的长度DATA_BYTE_NUM设置为1,然后运行仿真,总体仿真结果如下图所示。
将上图中写数据的部分时序放大,如下图所示,向寄存器地址24’d12中写入12。连续输入三字节地址数据后,输入需要写入的数据,注意先写高字节数据的高位。
将图13中读时序放大,结果如下所示,寄存器地址包含3字节数据,读取24’d35中的数据,3字节寄存器地址发送完毕后,发送重复起始位,之后依次发送器件地址,之后读数据,最后发送停止位。
多字节数据的读写时序与前文的eeprom页读写时序是一样的,因此就不再单独仿真了。仿真到此结束,由于仿真模型的问题,后续几个仿真只能查看读写的时序是否符合要求,不能通过读写的数据得到仿真结果,如果有兴趣可以试着修改仿真模型,达到要求。
4、上板测试
上面已经对仿真做了仿真,本文采用的eeprom的寄存器地址只有一个字节,所以不能对多字节的地址读写进行验证,但是通过前文仿真结果也应该不会有问题了。
首先抓取单个存储地址数据的读写时序,把顶层模块的写寄存器地址长度参数(REG_ADDR_BYTE_NUM)设置为1字节,读写数据长度的参数(DATA_BYTE_NUM)也设置为1字节。然后对工程综合、实现,查看该工程的资源消耗如下图所示,消耗89个LUT资源和65个触发器资源。
将bit文件下载到开发板中,ILA将start高电平作为触发条件。按下按键0抓取的信号如下图所示:
将上图中的一帧数据放大,如下图所示,向地址5中写入5,对应的时序与前文仿真的时序基本一致,这里的sda_in就是iic数据总线的状态。
按下按键1,FPGA读取eeprom前64个地址的数据,ILA抓取的时序如下所示。
将上图中的一帧数据放大,如下图所示,从地址5中读出数据,最后读出的数据为5,证明前面写入和本次读出的数据均正常。
然后对页读写时序进行测试,把顶层模块的读写数据长度的参数(DATA_BYTE_NUM)设置为5字节,然后对工程进行综合、实现,查看该工程消耗的资源。当读写数据为5字节时IIC驱动模块消耗135个LUT、160个触发器资源。
然后按下按键0,抓取的信号如下图所示:
将上述的写时序放大,结果如下图所示,向寄存器地址5、6、7、8、9中分别写入5、6、7、8、9。ILA抓取的时序与前文仿真结果基本一致,首先写入第一字节数据5之后,继续发送下一字节数据6,直到写入5字节数据后,才发送停止位结束写入时序。
按下按键1,ILA抓取读时序如下图所示:
将上述的读时序放大,结果如下图所示,向寄存器地址10开始连续读取5字节的数据。由于ILA抓取信号的位宽就设置成了8位,所以下图ILA输出的信号就只显示了最后输出的那一字节数据,实际上是包含5字节数据的,只是ILA显示不出来,需要修改IP位宽。
上图中紫色信号是IIC数据总线,天蓝色信号是IIC时钟信号,黄色信号是主机的数据输出使能,低电平表示主机释放数据总线。读取的第一字节就是10,然后依次是11、12、13、14。由此连续读出了地址10、11、12、13、14的数据。
证明多字节的IIC读写时序正常,没有问题,也就验证了IIC接口模块设计无误。
至此,IIC接口模块的设计和验证就将清楚了,如果不理解的可以留言,接口时序电路的设计首先都要查看官方技术手册,然后再去查找具体芯片对该接口时序的要求。要特别注意该接口的时钟频率、读写间隔时间、建立时间、保持时间,像这种数据再时钟中部赋值的低速串行接口时序,建立时间和保持时间一般是不会存在问题的。文章来源:https://www.toymoban.com/news/detail-833760.html
最后如果要获取本设计的工程文件,在后台回复“基于FPGA的eeprom读写工程”(不包括引号)即可,工程中ILA默认是被注释掉的。IIC接口模块已经全部做了参数化处理,使用时直接例化修改parameter参数即可,不需要额外修改其余任何代码。文章来源地址https://www.toymoban.com/news/detail-833760.html
到了这里,关于通过eeprom验证FPGA实现的单字节/页读写IIC接口时序的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!