Chapter007-FPGA学习之IIC总线EEPROM读取

2023-05-16

IIC总线是嵌入式领域较为重要的器件间通信总线,同样,FPGA也能通过模块的形式实现IIC的功能,其原理和STM32的模拟IIC总线一致,就是控制每个时间点的SCL、SDA总线电平。
IIC总线需要对应的从机机通信器件进行通信,故目前使用AT24C64【IIC总线的EEPROM】作为从机,通过实现对EEPROM的读、写,来学习IIC协议在FPGA的实现。

硬件原理

由于IIC本质就是2线通信方式,以从机地址作为鉴别依据,在IIC总线上进行点对点通信,故不再对细节的硬件进行描述,使用拓扑图即可说明问题,再IIC总线上,EEPROM的从机地址为7‘h50,也就是二进制的0b1010000。
在这里插入图片描述
IIC总线的通信波形图我就不过多赘述,大致电文思路就是:
开始–>器件地址输出–>读写功能输出–>等待反馈–>数据地址(读/写)–>等待反馈–>数据与内容(读/写)–>等待反馈–>结束

相关线路的引脚如下:
在这里插入图片描述
时序分为写时序、读时序,具体内容如下:
写时序:
在这里插入图片描述
连续写就是将8bit的数据与往后继续发送;

读时序:
在这里插入图片描述
若要实现连续读,将最后一个主机非应答变为主机应答即可,需要读几个就应答几次。

设计目标

设计目标为将EEPROM中,地址从0开始到255顺序写入0 ~ 255的数值,写入完成后,将地址0 ~ 255的数据读取出来,并检查是否地址与数据相对应,若数据与地址完全一致,则使红色PL_LED闪烁、否则PL_LED常亮。

使用到的资源为:
1、IIC的SCL线和SDA线
2、用于指示的LED灯
3、复位和系统时钟

模块分析
由于需要使用到EEPROM外设,而外设使用IIC总线进行通信,故首先需要实现IIC总线驱动模块
输入:
位控制信号【数据地址可能位0 ~ 255(8bit)或0 ~ 65535(16bit)】
系统时钟
IIC的数据地址
IIC需要写入的数据【8bit】
IIC使能信号
IIC读写控制信号
模块复位信号

输出:
上层模块的控制时钟【用于让上层模块使用匹配的频率向该模块发送数据】
IIC是否收到应答的标志
IIC读取到的数据【8bit】
IIC当前操作完成标志
IIC总线的SCL信号
IIC总线的SDA信号

当有了IIC的驱动模块后,上层的功能只需要将对应的地址、数据按一定的节拍发送给IIC驱动模块,即可实现IIC的通信,故需要实现EEPROM的读写给,需要有一个读写流程的逻辑模块实现这一功能;
输入:
IIC操作时钟
IIC是否收到应答的标志
IIC读取到的数据【8bit】
IIC当前操作完成标记
复位

输出:
需要操作的IIC地址
IIC写入的数据
IIC驱动模块的使能信号
IIC的读写标记
读写完成标记【用于驱动LED模块】
读写结果【用于驱动LED模块】

最后就是之前提到的用于描述实验是否成功的LED模块,若写入和读取内容一致,则LED闪烁,若不一致则LED长亮;
输入:
运行时钟
复位
读写完成标记
读写结果

输出:
LED灯控制信号

之后使用上层模块将上述子模块例化,即可得到整体设计;
输入:
系统时钟
复位
输出:
IIC_CLK
IIC_SDA
LED

模块原理图如下所示:
在这里插入图片描述

代码编辑

Verilog语言的代码包括以下几个部分:
一个用于例化子模块的顶层模块;

  1. IIC驱动模块【i2c_driver.v】
  2. EEPROM读写控制模块【eeprom_rw.v】
  3. led报警模块【led_alarm.v】

顶层模块相关代码

顶层模块代码(eeprom_top.v):

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2022/07/21 21:29:06
// Design Name: 
// Module Name: eeprom_top
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module eeprom_top(
    input               sys_clk    ,      //系统时钟
    input               sys_rst_n  ,      //系统复位
    //eeprom interface
    output              iic_scl    ,      //eeprom的时钟线scl
    inout               iic_sda    ,      //eeprom的数据线sda
    //user interface
    output              led               //led显示
    );
 
//parameter define
parameter    SLAVE_ADDR = 7'b1010000     ; //器件地址(SLAVE_ADDR)
parameter    BIT_CTRL   = 1'b1           ; //字地址位控制参数(16b/8b)
parameter    CLK_FREQ   = 26'd50_000_000 ; //i2c_dri模块的驱动时钟频率(CLK_FREQ)
parameter    I2C_FREQ   = 18'd250_000    ; //I2C的SCL时钟频率
parameter    L_TIME     = 17'd125_000    ; //led闪烁时间参数

//wire define
wire           dri_clk   ; //I2C操作时钟
wire           i2c_exec  ; //I2C触发控制
wire   [15:0]  i2c_addr  ; //I2C操作地址
wire   [ 7:0]  i2c_data_w; //I2C写入的数据
wire           i2c_done  ; //I2C操作结束标志
wire           i2c_ack   ; //I2C应答标志 0:应答 1:未应答
wire           i2c_rh_wl ; //I2C读写控制
wire   [ 7:0]  i2c_data_r; //I2C读出的数据
wire           rw_done   ; //E2PROM读写测试完成
wire           rw_result ; //E2PROM读写测试结果 0:失败 1:成功 

//*****************************************************
//**                    main code
//*****************************************************   
//e2prom读写测试模块
eeprom_rw u_eeprom_rw(
    .clk         (dri_clk   ),  //时钟信号
    .rst_n       (sys_rst_n ),  //复位信号
    //i2c interface
    .i2c_exec    (i2c_exec  ),  //I2C触发执行信号
    .i2c_rh_wl   (i2c_rh_wl ),  //I2C读写控制信号
    .i2c_addr    (i2c_addr  ),  //I2C器件内地址
    .i2c_data_w  (i2c_data_w),  //I2C要写的数据
    .i2c_data_r  (i2c_data_r),  //I2C读出的数据
    .i2c_done    (i2c_done  ),  //I2C一次操作完成
    .i2c_ack     (i2c_ack   ),  //I2C应答标志 
    //user interface
    .rw_done     (rw_done   ),  //E2PROM读写测试完成
    .rw_result   (rw_result )   //E2PROM读写测试结果 0:失败 1:成功
);

//i2c驱动模块
i2c_driver #(
    .SLAVE_ADDR  (SLAVE_ADDR),  //EEPROM从机地址
    .CLK_FREQ    (CLK_FREQ  ),  //模块输入的时钟频率
    .I2C_FREQ    (I2C_FREQ  )   //IIC_SCL的时钟频率
) u_i2c_driver(
    .clk         (sys_clk   ),  
    .rst_n       (sys_rst_n ),  
    //i2c interface
    .i2c_exec    (i2c_exec  ),  //I2C触发执行信号
    .bit_ctrl    (BIT_CTRL  ),  //器件地址位控制(16b/8b)
    .i2c_rh_wl   (i2c_rh_wl ),  //I2C读写控制信号
    .i2c_addr    (i2c_addr  ),  //I2C器件内地址
    .i2c_data_w  (i2c_data_w),  //I2C要写的数据
    .i2c_data_r  (i2c_data_r),  //I2C读出的数据
    .i2c_done    (i2c_done  ),  //I2C一次操作完成
    .i2c_ack     (i2c_ack   ),  //I2C应答标志
    .scl         (iic_scl   ),  //I2C的SCL时钟信号
    .sda         (iic_sda   ),  //I2C的SDA信号
    //user interface
    .dri_clk     (dri_clk   )   //I2C操作时钟
);

//led指示模块
led_alarm #(.L_TIME(L_TIME  )   //控制led闪烁时间
) u_led_alarm(
    .clk         (dri_clk   ),  
    .rst_n       (sys_rst_n ), 
    
    .rw_done     (rw_done   ),  
    .rw_result   (rw_result ),
    .led         (led       )    
);    
    
endmodule

顶层约束文件(eeprom_top.xdc):

set_property -dict {PACKAGE_PIN U18 IOSTANDARD LVCMOS33} [get_ports sys_clk]
set_property -dict {PACKAGE_PIN N16 IOSTANDARD LVCMOS33} [get_ports sys_rst_n]
set_property -dict {PACKAGE_PIN E18 IOSTANDARD LVCMOS33} [get_ports iic_scl]
set_property -dict {PACKAGE_PIN F17 IOSTANDARD LVCMOS33} [get_ports iic_sda]
set_property -dict {PACKAGE_PIN H15 IOSTANDARD LVCMOS33} [get_ports led]

下层功能模块代码

IIC驱动模块,负责将数据与地址操作变为IIC上的电平信号【i2c_driver.v】
该模块将IIC总线输出信号使用复杂的三段式状态机表述【同步时序表述状态转移、组合逻辑判断状态转移、各状态下正常功能执行】,具体含义可见代码注释表述;

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2022/07/21 21:36:55
// Design Name: 
// Module Name: i2c_driver
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module i2c_driver
    #(
      parameter   SLAVE_ADDR = 7'b1010000   ,  //EEPROM从机地址
      parameter   CLK_FREQ   = 26'd50_000_000, //模块输入的时钟频率
      parameter   I2C_FREQ   = 18'd250_000     //IIC_SCL的时钟频率
    )
    (
    input                clk        ,    
    input                rst_n      ,   
                                         
    //i2c interface                      
    input                i2c_exec   ,  //I2C触发执行信号
    input                bit_ctrl   ,  //字地址位控制(16b/8b)
    input                i2c_rh_wl  ,  //I2C读写控制信号
    input        [15:0]  i2c_addr   ,  //I2C器件内地址
    input        [ 7:0]  i2c_data_w ,  //I2C要写的数据
    output  reg  [ 7:0]  i2c_data_r ,  //I2C读出的数据
    output  reg          i2c_done   ,  //I2C一次操作完成
    output  reg          i2c_ack    ,  //I2C应答标志 0:应答 1:未应答
    output  reg          scl        ,  //I2C的SCL时钟信号
    inout                sda        ,  //I2C的SDA信号
                                       
    //user interface                   
    output  reg          dri_clk       //驱动I2C操作的驱动时钟
    );
    
//localparam define
localparam  st_idle     = 8'b0000_0001; //空闲状态
localparam  st_sladdr   = 8'b0000_0010; //发送器件地址(slave address)
localparam  st_addr16   = 8'b0000_0100; //发送16位字地址
localparam  st_addr8    = 8'b0000_1000; //发送8位字地址
localparam  st_data_wr  = 8'b0001_0000; //写数据(8 bit)
localparam  st_addr_rd  = 8'b0010_0000; //发送器件地址读
localparam  st_data_rd  = 8'b0100_0000; //读数据(8 bit)
localparam  st_stop     = 8'b1000_0000; //结束I2C操作

//reg define
reg            sda_dir   ; //I2C数据(SDA)方向控制
reg            sda_out   ; //SDA输出信号
reg            st_done   ; //状态结束
reg            wr_flag   ; //写标志
reg    [ 6:0]  cnt       ; //计数
reg    [ 7:0]  cur_state ; //状态机当前状态
reg    [ 7:0]  next_state; //状态机下一状态
reg    [15:0]  addr_t    ; //地址
reg    [ 7:0]  data_r    ; //读取的数据
reg    [ 7:0]  data_wr_t ; //I2C需写的数据的临时寄存
reg    [ 9:0]  clk_cnt   ; //分频时钟计数

//wire define
wire          sda_in     ; //SDA输入信号
wire   [8:0]  clk_divide ; //模块驱动时钟的分频系数

//*****************************************************
//**                    main code
//*****************************************************

//SDA控制
assign  sda        = sda_dir ?  sda_out : 1'bz   ;  //SDA数据输出或高阻
assign  sda_in     = sda                         ;  //SDA数据输入
assign  clk_divide = (CLK_FREQ/I2C_FREQ) >> 2'd2 ;  //模块驱动时钟的分频系数

//生成I2C的SCL的四倍频率的驱动时钟用于驱动i2c的操作
always @(posedge clk or negedge rst_n) begin
    if(!rst_n) begin
        dri_clk <=  1'b0;
        clk_cnt <= 10'd0;
    end
    else if(clk_cnt == clk_divide[8:1] - 1'd1) begin
        clk_cnt <= 10'd0;
        dri_clk <= ~dri_clk;
    end
    else
        clk_cnt <= clk_cnt + 1'b1;
end

//(三段式状态机)同步时序描述状态转移
always @(posedge dri_clk or negedge rst_n) begin
    if(!rst_n)
        cur_state <= st_idle;
    else
        cur_state <= next_state;
end

//组合逻辑判断状态转移条件
always @(*) begin
    next_state = st_idle;
    case(cur_state)
        st_idle: begin                          //空闲状态
           if(i2c_exec) begin
               next_state = st_sladdr;
           end
           else
               next_state = st_idle;
        end
        st_sladdr: begin
            if(st_done) begin
                if(bit_ctrl)                    //判断是16位还是8位字地址
                   next_state = st_addr16;
                else
                   next_state = st_addr8 ;
            end
            else
                next_state = st_sladdr;
        end
        st_addr16: begin                        //写16位字地址
            if(st_done) begin
                next_state = st_addr8;
            end
            else begin
                next_state = st_addr16;
            end
        end
        st_addr8: begin                         //8位字地址
            if(st_done) begin
                if(wr_flag==1'b0)               //读写判断
                    next_state = st_data_wr;
                else
                    next_state = st_addr_rd;
            end
            else begin
                next_state = st_addr8;
            end
        end
        st_data_wr: begin                       //写数据(8 bit)
            if(st_done)
                next_state = st_stop;
            else
                next_state = st_data_wr;
        end
        st_addr_rd: begin                       //写地址以进行读数据
            if(st_done) begin
                next_state = st_data_rd;
            end
            else begin
                next_state = st_addr_rd;
            end
        end
        st_data_rd: begin                       //读取数据(8 bit)
            if(st_done)
                next_state = st_stop;
            else
                next_state = st_data_rd;
        end
        st_stop: begin                          //结束I2C操作
            if(st_done)
                next_state = st_idle;
            else
                next_state = st_stop ;
        end
        default: next_state= st_idle;
    endcase
end

//时序电路描述状态输出
always @(posedge dri_clk or negedge rst_n) begin
    //复位初始化
    if(!rst_n) begin
        scl       <= 1'b1;
        sda_out   <= 1'b1;
        sda_dir   <= 1'b1;                          
        i2c_done  <= 1'b0;                          
        i2c_ack   <= 1'b0;                          
        cnt       <= 1'b0;                          
        st_done   <= 1'b0;                          
        data_r    <= 1'b0;                          
        i2c_data_r<= 1'b0;                          
        wr_flag   <= 1'b0;                          
        addr_t    <= 1'b0;                          
        data_wr_t <= 1'b0;                          
    end                                              
    else begin                                       
        st_done <= 1'b0 ;                            
        cnt     <= cnt +1'b1 ;                       
        case(cur_state)                              
             st_idle: begin                          //空闲状态
                scl     <= 1'b1;                     
                sda_out <= 1'b1;                     
                sda_dir <= 1'b1;                     
                i2c_done<= 1'b0;                     
                cnt     <= 7'b0;               
                if(i2c_exec) begin                   
                    wr_flag   <= i2c_rh_wl ;         
                    addr_t    <= i2c_addr  ;         
                    data_wr_t <= i2c_data_w;  
                    i2c_ack   <= 1'b0;                      
                end                                  
            end                                      
            st_sladdr: begin                         //写地址(器件地址和字地址)
                case(cnt)                            
                    7'd1 : sda_out <= 1'b0;          //开始I2C
                    7'd3 : scl <= 1'b0;              
                    7'd4 : sda_out <= SLAVE_ADDR[6]; //传送器件地址
                    7'd5 : scl <= 1'b1;              
                    7'd7 : scl <= 1'b0;              
                    7'd8 : sda_out <= SLAVE_ADDR[5]; 
                    7'd9 : scl <= 1'b1;              
                    7'd11: scl <= 1'b0;              
                    7'd12: sda_out <= SLAVE_ADDR[4]; 
                    7'd13: scl <= 1'b1;              
                    7'd15: scl <= 1'b0;              
                    7'd16: sda_out <= SLAVE_ADDR[3]; 
                    7'd17: scl <= 1'b1;              
                    7'd19: scl <= 1'b0;              
                    7'd20: sda_out <= SLAVE_ADDR[2]; 
                    7'd21: scl <= 1'b1;              
                    7'd23: scl <= 1'b0;              
                    7'd24: sda_out <= SLAVE_ADDR[1]; 
                    7'd25: scl <= 1'b1;              
                    7'd27: scl <= 1'b0;              
                    7'd28: sda_out <= SLAVE_ADDR[0]; 
                    7'd29: scl <= 1'b1;              
                    7'd31: scl <= 1'b0;              
                    7'd32: sda_out <= 1'b0;          //0:写
                    7'd33: scl <= 1'b1;              
                    7'd35: scl <= 1'b0;              
                    7'd36: begin                     
                        sda_dir <= 1'b0;             
                        sda_out <= 1'b1;                         
                    end                              
                    7'd37: scl     <= 1'b1;            
                    7'd38: begin                     //从机应答 
                        st_done <= 1'b1;
                        if(sda_in == 1'b1)           //高电平表示未应答
                            i2c_ack <= 1'b1;         //拉高应答标志位     
                    end                                          
                    7'd39: begin                     
                        scl <= 1'b0;                 
                        cnt <= 1'b0;                 
                    end                              
                    default :  ;                     
                endcase                              
            end                                      
            st_addr16: begin                         
                case(cnt)                            
                    7'd0 : begin                     
                        sda_dir <= 1'b1 ;            
                        sda_out <= addr_t[15];       //传送字地址
                    end                              
                    7'd1 : scl <= 1'b1;              
                    7'd3 : scl <= 1'b0;              
                    7'd4 : sda_out <= addr_t[14];    
                    7'd5 : scl <= 1'b1;              
                    7'd7 : scl <= 1'b0;              
                    7'd8 : sda_out <= addr_t[13];    
                    7'd9 : scl <= 1'b1;              
                    7'd11: scl <= 1'b0;              
                    7'd12: sda_out <= addr_t[12];    
                    7'd13: scl <= 1'b1;              
                    7'd15: scl <= 1'b0;              
                    7'd16: sda_out <= addr_t[11];    
                    7'd17: scl <= 1'b1;              
                    7'd19: scl <= 1'b0;              
                    7'd20: sda_out <= addr_t[10];    
                    7'd21: scl <= 1'b1;              
                    7'd23: scl <= 1'b0;              
                    7'd24: sda_out <= addr_t[9];     
                    7'd25: scl <= 1'b1;              
                    7'd27: scl <= 1'b0;              
                    7'd28: sda_out <= addr_t[8];     
                    7'd29: scl <= 1'b1;              
                    7'd31: scl <= 1'b0;              
                    7'd32: begin                     
                        sda_dir <= 1'b0;             
                        sda_out <= 1'b1;   
                    end                              
                    7'd33: scl  <= 1'b1;             
                    7'd34: begin                     //从机应答
                        st_done <= 1'b1;     
                        if(sda_in == 1'b1)           //高电平表示未应答
                            i2c_ack <= 1'b1;         //拉高应答标志位    
                    end        
                    7'd35: begin                     
                        scl <= 1'b0;                 
                        cnt <= 1'b0;                 
                    end                              
                    default :  ;                     
                endcase                              
            end                                      
            st_addr8: begin                          
                case(cnt)                            
                    7'd0: begin                      
                       sda_dir <= 1'b1 ;             
                       sda_out <= addr_t[7];         //字地址
                    end                              
                    7'd1 : scl <= 1'b1;              
                    7'd3 : scl <= 1'b0;              
                    7'd4 : sda_out <= addr_t[6];     
                    7'd5 : scl <= 1'b1;              
                    7'd7 : scl <= 1'b0;              
                    7'd8 : sda_out <= addr_t[5];     
                    7'd9 : scl <= 1'b1;              
                    7'd11: scl <= 1'b0;              
                    7'd12: sda_out <= addr_t[4];     
                    7'd13: scl <= 1'b1;              
                    7'd15: scl <= 1'b0;              
                    7'd16: sda_out <= addr_t[3];     
                    7'd17: scl <= 1'b1;              
                    7'd19: scl <= 1'b0;              
                    7'd20: sda_out <= addr_t[2];     
                    7'd21: scl <= 1'b1;              
                    7'd23: scl <= 1'b0;              
                    7'd24: sda_out <= addr_t[1];     
                    7'd25: scl <= 1'b1;              
                    7'd27: scl <= 1'b0;              
                    7'd28: sda_out <= addr_t[0];     
                    7'd29: scl <= 1'b1;              
                    7'd31: scl <= 1'b0;              
                    7'd32: begin                     
                        sda_dir <= 1'b0;         
                        sda_out <= 1'b1;                    
                    end                              
                    7'd33: scl     <= 1'b1;          
                    7'd34: begin                     //从机应答
                        st_done <= 1'b1;     
                        if(sda_in == 1'b1)           //高电平表示未应答
                            i2c_ack <= 1'b1;         //拉高应答标志位    
                    end   
                    7'd35: begin                     
                        scl <= 1'b0;                 
                        cnt <= 1'b0;                 
                    end                              
                    default :  ;                     
                endcase                              
            end                                      
            st_data_wr: begin                        //写数据(8 bit)
                case(cnt)                            
                    7'd0: begin                      
                        sda_out <= data_wr_t[7];     //I2C写8位数据
                        sda_dir <= 1'b1;             
                    end                              
                    7'd1 : scl <= 1'b1;              
                    7'd3 : scl <= 1'b0;              
                    7'd4 : sda_out <= data_wr_t[6];  
                    7'd5 : scl <= 1'b1;              
                    7'd7 : scl <= 1'b0;              
                    7'd8 : sda_out <= data_wr_t[5];  
                    7'd9 : scl <= 1'b1;              
                    7'd11: scl <= 1'b0;              
                    7'd12: sda_out <= data_wr_t[4];  
                    7'd13: scl <= 1'b1;              
                    7'd15: scl <= 1'b0;              
                    7'd16: sda_out <= data_wr_t[3];  
                    7'd17: scl <= 1'b1;              
                    7'd19: scl <= 1'b0;              
                    7'd20: sda_out <= data_wr_t[2];  
                    7'd21: scl <= 1'b1;              
                    7'd23: scl <= 1'b0;              
                    7'd24: sda_out <= data_wr_t[1];  
                    7'd25: scl <= 1'b1;              
                    7'd27: scl <= 1'b0;              
                    7'd28: sda_out <= data_wr_t[0];  
                    7'd29: scl <= 1'b1;              
                    7'd31: scl <= 1'b0;              
                    7'd32: begin                     
                        sda_dir <= 1'b0;           
                        sda_out <= 1'b1;                              
                    end                              
                    7'd33: scl <= 1'b1;              
                    7'd34: begin                     //从机应答
                        st_done <= 1'b1;     
                        if(sda_in == 1'b1)           //高电平表示未应答
                            i2c_ack <= 1'b1;         //拉高应答标志位    
                    end          
                    7'd35: begin                     
                        scl  <= 1'b0;                
                        cnt  <= 1'b0;                
                    end                              
                    default  :  ;                    
                endcase                              
            end                                      
            st_addr_rd: begin                        //写地址以进行读数据
                case(cnt)                            
                    7'd0 : begin                     
                        sda_dir <= 1'b1;             
                        sda_out <= 1'b1;             
                    end                              
                    7'd1 : scl <= 1'b1;              
                    7'd2 : sda_out <= 1'b0;          //重新开始
                    7'd3 : scl <= 1'b0;              
                    7'd4 : sda_out <= SLAVE_ADDR[6]; //传送器件地址
                    7'd5 : scl <= 1'b1;              
                    7'd7 : scl <= 1'b0;              
                    7'd8 : sda_out <= SLAVE_ADDR[5]; 
                    7'd9 : scl <= 1'b1;              
                    7'd11: scl <= 1'b0;              
                    7'd12: sda_out <= SLAVE_ADDR[4]; 
                    7'd13: scl <= 1'b1;              
                    7'd15: scl <= 1'b0;              
                    7'd16: sda_out <= SLAVE_ADDR[3]; 
                    7'd17: scl <= 1'b1;              
                    7'd19: scl <= 1'b0;              
                    7'd20: sda_out <= SLAVE_ADDR[2]; 
                    7'd21: scl <= 1'b1;              
                    7'd23: scl <= 1'b0;              
                    7'd24: sda_out <= SLAVE_ADDR[1]; 
                    7'd25: scl <= 1'b1;              
                    7'd27: scl <= 1'b0;              
                    7'd28: sda_out <= SLAVE_ADDR[0]; 
                    7'd29: scl <= 1'b1;              
                    7'd31: scl <= 1'b0;              
                    7'd32: sda_out <= 1'b1;          //1:读
                    7'd33: scl <= 1'b1;              
                    7'd35: scl <= 1'b0;              
                    7'd36: begin                     
                        sda_dir <= 1'b0;            
                        sda_out <= 1'b1;                    
                    end
                    7'd37: scl     <= 1'b1;
                    7'd38: begin                     //从机应答
                        st_done <= 1'b1;     
                        if(sda_in == 1'b1)           //高电平表示未应答
                            i2c_ack <= 1'b1;         //拉高应答标志位    
                    end   
                    7'd39: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                    end
                    default : ;
                endcase
            end
            st_data_rd: begin                        //读取数据(8 bit)
                case(cnt)
                    7'd0: sda_dir <= 1'b0;
                    7'd1: begin
                        data_r[7] <= sda_in;
                        scl       <= 1'b1;
                    end
                    7'd3: scl  <= 1'b0;
                    7'd5: begin
                        data_r[6] <= sda_in ;
                        scl       <= 1'b1   ;
                    end
                    7'd7: scl  <= 1'b0;
                    7'd9: begin
                        data_r[5] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd11: scl  <= 1'b0;
                    7'd13: begin
                        data_r[4] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd15: scl  <= 1'b0;
                    7'd17: begin
                        data_r[3] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd19: scl  <= 1'b0;
                    7'd21: begin
                        data_r[2] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd23: scl  <= 1'b0;
                    7'd25: begin
                        data_r[1] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd27: scl  <= 1'b0;
                    7'd29: begin
                        data_r[0] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd31: scl  <= 1'b0;
                    7'd32: begin
                        sda_dir <= 1'b1;             
                        sda_out <= 1'b1;
                    end
                    7'd33: scl     <= 1'b1;
                    7'd34: st_done <= 1'b1;          //非应答
                    7'd35: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                        i2c_data_r <= data_r;
                    end
                    default  :  ;
                endcase
            end
            st_stop: begin                           //结束I2C操作
                case(cnt)
                    7'd0: begin
                        sda_dir <= 1'b1;             //结束I2C
                        sda_out <= 1'b0;
                    end
                    7'd1 : scl     <= 1'b1;
                    7'd3 : sda_out <= 1'b1;
                    7'd15: st_done <= 1'b1;
                    7'd16: begin
                        cnt      <= 1'b0;
                        i2c_done <= 1'b1;            //向上层模块传递I2C结束信号
                    end
                    default  : ;
                endcase
            end
        endcase
    end
end    
    
endmodule

LED的报警模块【led_alarm.v】

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2022/07/21 22:03:45
// Design Name: 
// Module Name: led_alarm
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module led_alarm #(parameter L_TIME = 25'd25_000_000)
    (
    input        clk       ,  //时钟信号
    input        rst_n     ,  //复位信号
                 
    input        rw_done   ,  //错误标志
    input        rw_result ,  //E2PROM读写测试完成
    output  reg  led          //E2PROM读写测试结果 0:失败 1:成功
    );
    
//reg define
reg          rw_done_flag;    //读写测试完成标志
reg  [24:0]  led_cnt     ;    //led计数

//*****************************************************
//**                    main code
//*****************************************************    

always @(posedge clk or negedge rst_n)begin
    if(!rst_n)
        rw_done_flag <= 1'b0;
    else if(rw_done)
        rw_done_flag <= 1'b1;
end    

//错误标志为1时PL_LED0闪烁,否则PL_LED0常亮
always @(posedge clk or negedge rst_n) begin
    if(!rst_n)begin
        led_cnt <= 25'd0;
        led <= 1'b0;
    end
    else begin
        if(rw_done_flag)begin
            if(rw_result)
                led <= 1'b1;
            else begin
                led_cnt <= led_cnt + 25'd1;
                if(led_cnt == L_TIME - 1'b1)begin
                    led_cnt <= 25'd0;
                    led <= ~led;
                end
            end
        end
        else
            led <= 1'b0;
    end
end
    
endmodule

EEPROM的读写判断模块【eeprom_rw.v】
该部分逻辑较为简单,使用单段式状态机实现(状态跳转及状态动作在单段代码实现)。

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2022/07/21 21:34:30
// Design Name: 
// Module Name: eeprom_rw
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module eeprom_rw(
    input                 clk        , //时钟信号
    input                 rst_n      , //复位信号

    //i2c interface
    output   reg          i2c_rh_wl  , //I2C读写控制信号
    output   reg          i2c_exec   , //I2C触发执行信号
    output   reg  [15:0]  i2c_addr   , //I2C器件内地址
    output   reg  [ 7:0]  i2c_data_w , //I2C要写的数据
    input         [ 7:0]  i2c_data_r , //I2C读出的数据
    input                 i2c_done   , //I2C一次操作完成
    input                 i2c_ack    , //I2C应答标志

    //user interface
    output   reg          rw_done    , //E2PROM读写测试完成
    output   reg          rw_result    //E2PROM读写测试结果 0:失败 1:成功
    );

//parameter define
//EEPROM写数据需要添加间隔时间,读数据则不需要
parameter      WR_WAIT_TIME = 14'd5000; //写入间隔时间
parameter      MAX_BYTE     = 16'd256 ; //读写测试的字节个数

//reg define
reg   [1:0]    flow_cnt  ; //状态流控制
reg   [13:0]   wait_cnt  ; //延时计数器

//*****************************************************
//**                    main code
//*****************************************************
//EEPROM读写测试,先写后读,并比较读出的值与写入的值是否一致
always @(posedge clk or negedge rst_n) begin
    if(!rst_n) begin
        flow_cnt   <= 2'b0;
        i2c_rh_wl  <= 1'b0;
        i2c_exec   <= 1'b0;
        i2c_addr   <= 16'b0;
        i2c_data_w <= 8'b0;
        wait_cnt   <= 14'b0;
        rw_done    <= 1'b0;
        rw_result  <= 1'b0;        
    end
    else begin
        i2c_exec <= 1'b0;
        rw_done  <= 1'b0;
        case(flow_cnt)
            2'd0 : begin                                  
                wait_cnt <= wait_cnt + 1'b1;               //延时计数
                if(wait_cnt == WR_WAIT_TIME - 1'b1) begin  //EEPROM写操作延时完成
                    wait_cnt <= 1'b0;
                    if(i2c_addr == MAX_BYTE) begin         //256个字节写入完成
                        i2c_addr  <= 1'b0;
                        i2c_rh_wl <= 1'b1;
                        flow_cnt  <= 2'd2;
                    end
                    else begin
                        flow_cnt <= flow_cnt + 1'b1;
                        i2c_exec <= 1'b1;
                    end
                end
            end
            2'd1 : begin
                if(i2c_done == 1'b1) begin                  //EEPROM单次写入完成
                    flow_cnt   <= 2'd0;
                    i2c_addr   <= i2c_addr + 1'b1;           //地址0~255分别写入
                    i2c_data_w <= i2c_data_w + 1'b1;         //数据0~255
                end    
            end
            2'd2 : begin                                   
                flow_cnt <= flow_cnt + 1'b1;
                i2c_exec <= 1'b1;
            end    
            2'd3 : begin
                if(i2c_done == 1'b1) begin                 //EEPROM单次读出完成
                    //读出的值错误或者I2C未应答,读写测试失败
                    if((i2c_addr[7:0] != i2c_data_r) || (i2c_ack == 1'b1)) begin
                        rw_done <= 1'b1;
                        rw_result <= 1'b1;
                    end
                    else if(i2c_addr == MAX_BYTE - 1'b1) begin //读写测试成功
                        rw_done   <= 1'b1;
                        rw_result <= 1'b0;
                    end    
                    else begin
                        flow_cnt <= 2'd2;
                        i2c_addr <= i2c_addr + 1'b1;
                    end
                end                 
            end
            default : ;
        endcase    
    end
end        
    
    
endmodule

完成代码编辑后,将代码编译为二进制流,并下载到FPGA上。

实验结果

按下复位后,经过一小段时间,EEPROM读写模块校正成功,LED开始闪烁
请添加图片描述
至此,实验成功,IIC功能模块能够移植使用。

本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

Chapter007-FPGA学习之IIC总线EEPROM读取 的相关文章

  • VMware+Centos+Oracle

    一 安装VMware 百度网盘 内含注册码 https pan baidu com s 1LyG 7KndmmGwwlg9IbWdpA 提取码 rls7 二 安装Centos7 官方镜像网站 http isoredirect centos
  • mybatis自动生成代码

    参考 xff1a https blog csdn net shusheng0516 article details 82317139
  • Android studio在真机上调试程序的步骤

    1 手机连接到电脑 笔者使用的小米5s手机进行调试 xff0c 首先用USB线将手机连接到电脑 xff0c 在小米官网上下载手机驱动 xff0c 在电脑的设备管理器中选中手机 xff0c 右键 gt 更新驱动程序软件 gt 浏览计算机以查找
  • ROS报错处理(持续更新)

    1 运行节点时报错 xff1a rospack Error package 39 test 39 not found 没有找到ros功能包 xff0c 原因是没有为功能包配置系统环境 xff0c 可以利用source运行工作空间中devel
  • win10创建Ubuntu16.04子系统,安装常用软件以及图形界面(包括win10远程桌面连接Ubuntu)

    目录 一 开启win10子系统 Windows Subsystem for Linux xff08 WSL xff09 二 基本配置 三 安装常用的软件 安装配置zsh 使用 bash 客户端软件 cmder xff08 其实是window
  • ros入门 工程目录结构、节点通信方式、基本操作命令

    目录 ROS Robot Operating System ros的特点 ros的系统实现 ROS Robot Operating System ros的基本框架是斯坦福大学人工智能实验室在STAIR项目与机器人技术公司Willow Gar
  • SSH简介及两种远程登录的方法

    目录 SSH的安全机制 SSH的安装 启动服务器的SSH服务 SSH两种级别的远程登录 SSH的高级应用 S ecure Sh ell SSH 是由 IETF The Internet Engineering Task Force 制定的建
  • 基于STM32CubeMX移植freeModbusRTU(从站)

    困惑了将近一年多的ModbusRTU在我昨天穷极无聊给自己定目标的情况下搞出来了 xff0c 以前移植不出来主要原因就是基本功不扎实 xff0c 没有进一步理解串口和定时器配置的原理 xff0c 一通操作 xff0c 移植完之后就Timeo
  • tensorflow简介以及与Keras的关系、常用机器学习框架一览

    tensorflow是Google开源的基于数据流图的机器学习框架 xff0c 支持python和c 43 43 程序开发语言 轰动一时的AlphaGo就是使用tensorflow进行训练的 xff0c 其命名基于工作原理 xff0c te
  • 配置NAO的python开发环境(Windows10)

    目录 1 用电脑连接nao机器人 2 安装 choregraphe 编程软件 3 安装python 4 安装NAOqi SDK 5 nao操控实践 1 用电脑连接nao机器人 nao支持有线和无线上网 可以利用同一网络上的任意一台电脑来控制
  • 合并(归并)排序原理及代码实现(c/c++)

    合并排序是采用分治法 xff0c 先将无序序列划分为有序子序列 xff0c 再将有序子序列合并成一个有序序列的有效的排序算法 原理 xff1a 先将无序序列利用二分法划分为子序列 xff0c 直至每个子序列只有一个元素 单元素序列必有序 x
  • Docker 的安装使用

    官方说明文档网址 xff1a Install Docker Engine on Ubuntu Docker Documentation 安装Docker 准备工作 要在 Ubuntu 上开始使用 Docker Engine xff0c 请确
  • μC/OS任务就绪和优先级查找过程理解

    任务创建时 xff0c 任务加入就绪表的过程 xff1a 1 C OS任务共64个优先级 xff0c 本文中一个优先级只对应一个任务 xff0c 最低优先级用二进制表示为00111111 只需占用6位 xff0c 如图1所示 图1 2 创建
  • 信号量、消息队列和全局变量的区别

    在操作系统任务编程中 xff0c 解决任务间通信问题 xff0c 可以使用全局变量 信号量或者消息队列来完成 那么它们有什么区别 xff0c 在遇到任务间通讯时 xff0c 该怎样选择用哪一种方式呢 xff1f 一 任务间通讯内涵 任务间通
  • 解决在项目里引入Spring Security后iframe或者frame所引用的页无法显示的问题

    出现这个问题的原因是因为Spring Security默认将header response里的X Frame Options属性设置为DENY 如果页面里有需要通过iframe frame引用的页面 xff0c 需要配置Spring Sec
  • 参考 opencv aruco 实现对二维码(QR码)的检测与定位

    参考 opencv aruco 实现对单个QR码的检测与定位 aruco是opencv contrib的一个模块 实现了对AR码的检测 姿态估计 使用aruco需要安装opencv contrib 本文将aruco中姿态估计用到的函数提取出
  • jetson nano 供电模式及其切换或自定义

    写在前面 jetson nano 开发板在预设的10W MAXN 模式下需要用5v4A的DC供电 用5v2A的DC或者micro usb供电建议使用5W模式 供电不足会导致掉电关机 以下是学习jetson nano时 xff0c 对供电模式
  • STM32CubeMX在FreeRTOS下使用串口进行数据收发(不定长度)

    STM32CubeMX gt FreeRTOS 43 USART接收不定长数据 由于本人做的一个项目功能相对复杂 xff0c 要求使用操作系统 xff0c 且项目工程中有很多需要串口操作的外设 xff0c 所以需要对串口设计不定长的收发功能
  • jetson nano 散热风扇控制

    由于jetson nano开发板完全依靠自带的静态散热在运行程序时通过jtop查看GPU CPU等组件温度均超过70 xff0c 所以添加一个5v散热风扇 xff08 tegrastats也可以用来查看系统状态 xff09 tegrasta
  • win10环境安装numpy,tensorflow,keras及版本对应关系

    python未安装的 xff0c 可以阅读我的文章如下图标题 xff0c 虚拟环境不是必要的 xff0c 但是为了规范和后续工作的方便管理 xff0c 建立虚拟环境也是非常重要的 建议安装python3 6版本的 xff0c 这个版本相对来

随机推荐

  • 解决方案No module named ‘sklearn.utils.linear_assignment_‘

    错误原因 xff1a linear assignment被弃用 xff0c 官方将scipy optimize linear sum assignment代替了sklearn utils linear assignment 方法一 xff1
  • pip使用豆瓣镜像源

    一 镜像源 清华镜像源 https pypi tuna tsinghua edu cn simple 豆瓣镜像源 http pypi douban com simple 阿里镜像源 http mirrors aliyun com pypi
  • 信息熵(ID3)、信息增益(C4.5)、基尼值和基尼指数

    1 信息熵 熵 Entropy 是 混乱 程度的量度 系统越有序 xff0c 熵值越低 xff1b 系统越混乱或者分散 xff0c 熵值越高 信息理论 xff1a 1 从信息的完整性上进行的描述 当系统的有序状态一致时 xff0c 数据越集
  • nvidia-smi 系列命令,查看gpu ,显存信息

    显卡包含gpu xff0c 显存 xff0c gpu不等于显存 nvidia smi 的定义 xff1a 基于 NVIDIA Management Library xff08 NVIDIA 管理库 xff09 xff0c 实现 NVIDIA
  • chown和chmod区别

    一 文件权限结构 ll查看某一个目录会得到一个7字段的列表 第一个字段是文件属性字段 xff08 eg drwxr xr x xff09 xff0c 文件属性字段总共10个字母 xff1a 第一个字符代表文件类型 xff1a xff1a 普
  • git常用命令大全

    目录 1 设置用户签名 2 初始化本地库 3 添加到暂存区 4 删除暂存区文件 xff0c 但是工作区仍存在 5 提交本地库 6 查看日志信息 7 修改文件 8 版本穿梭 参考文献 尚硅谷Git入门到精通全套教程 xff08 涵盖GitHu
  • 安装kalibr踩坑1:Could NOT find GTest (missing: GTEST_LIBRARY GTEST_MAIN_LIBRARY)

    Could NOT find GTest missing GTEST LIBRARY GTEST MAIN LIBRARY 因为GTest虽然安装过 xff0c 但是好像找不到头文件 sudo apt get install libgtes
  • 安装kalibr踩坑2:fatal error: ceres/rotation.h: No such file or directory #include “ceres/rotation.h“

    fatal error ceres rotation h No such file or directory include 34 ceres rotation h 34 ceres没有装好 xff0c 需要重装 xff0c 安装方法如下
  • 嵌入式数据结构以及算法(数据结构篇)

    数据结构可以说是嵌入式开发学习中比较重要的一个部分了 xff0c 而沉迷于基础硬件控制的我到现在才意识到这个东西的重要性可以说是比较迟钝了 xff0c 但是迟钝总比知道也不学来的好 xff08 自我安慰请忽略 xff09 下面总结一下经过几
  • ubuntu18.04安装kalibr疯狂踩坑记录

    1 安装ubuntu18 04对应的ros 我用的是镜像Docker Hub xff0c 该镜像包含vnc和ros docker pull tiryoh ros desktop vnc melodic 2 安装kalibr 1 安装依赖环境
  • CMakeList.txt写法

    ROS 创建并运行一个c 43 43 的demo xyzxyz576的博客 CSDN博客 目录 样例 解释如下 1 确定cmake最低版本需求 2 确定工程名 3 添加需要的库 4 添加需要的头文件 5 确定编译语言 6 设定变量 7 添加
  • 解决WSL2中Vmmem内存占用过大问题

    Vmmem介绍 Vmmem 进程是系统合成的一个虚拟进程 xff0c 用于表示虚拟机消耗的内存和 CPU 资源 换句话说 xff0c 如果您看到 Vmmem 消耗大量内存和 CPU 资源 xff0c 那么这意味着您的虚拟机正在消耗大量内存和
  • gnss、gps、imu、rtk、ins区分及含义

    gnss和gps区别 1 GPS xff08 全球卫星定位系统 xff09 是由美国国防部研制建立的一种具有全方位 全天候 全时段 高精度的卫星导航系统 xff1b 能为全球用户提供低成本 高精度的三维位置 速度和精确定时等导航信息 2 G
  • Windows下启动Docker容器遇到Error invoking remote method ‘docker-start-container‘: Error解决办法

    报错 xff1a Error invoking remote method 39 docker start container 39 Error HTTP code 500 server error Ports are not availa
  • java变量的定义

    JAVA数据类型 对于整型数据 xff0c 通常情况下使用int类型 但是如果表示极大的数据 xff0c 就需要long类型了 xff0c byte和short类型主要用于特定的应用场合 xff0c 例如 xff1a 底层的文件处理或者需要
  • java数据类型转换(强制转换)

    数据类型的转换 xff0c 分为自动转换和强制转换 自动转换是程序在执行过程中 无声 进行的转换 xff0c 不需要提前声明 xff0c 一般是从位数低的类型向位数高的类型转换 xff1b 强制转换则必须在代码中声明 xff0c 转换顺序不
  • 斗鱼直播与熊猫直播竞品分析

    引言 xff1a 目前国内直播平台虽然十分火爆 xff0c 但是直播的市场尚未成熟 xff0c 斗鱼等其他直播平台在利用自己用户的基础一直处在直播平台的主流市场 xff0c 而新晋直播平台开始大肆的宣传和吸引用户 xff0c 最终直播这块市
  • 知乎产品分析|知识社区何去何从

    一 引言 2017 年 2 月 xff0c 知乎月独立用户设备数再次回升 xff0c 相比 1 月上涨了 11 2 xff0c 达到了 1109 万台 1 1 目的 通过对知乎这款产品的分析 xff0c 锻炼自己的思维能力 xff0c 深化
  • 以CSDN为例解释尼尔森十大交互原则

    一 状态可见原则 用户在网页上的任何操作 xff0c 不论是单击 滚动还是按下键盘 xff0c 页面应即时给出反馈 即时 是指 xff0c 页面响应时间小于用户能忍受的等待时间 举例 xff1a CSDN上文章底部都会有一个 喜欢 按钮 x
  • Chapter007-FPGA学习之IIC总线EEPROM读取

    IIC总线是嵌入式领域较为重要的器件间通信总线 xff0c 同样 xff0c FPGA也能通过模块的形式实现IIC的功能 xff0c 其原理和STM32的模拟IIC总线一致 xff0c 就是控制每个时间点的SCL SDA总线电平 IIC总线