【代碼更新】IIC協議建模——讀寫EEPROM

　　案例采用明德揚設計思想完成。IIC協議是非常常用的接口協議，在電子類崗位招聘要求中經常出現它的身影。關於IIC協議這里只做簡要介紹，詳細信息請自行百度或查閱相關Datasheet，網上資料非常多。該篇博文主要講如何使用verilog來描述IIC協議，以讀寫EEPROM為例帶領大家了解下明德揚四段式狀態機規范和優勢，另外還有一些自己在設計過程中總結的經驗技巧。

　　IIC協議時序格式以Datasheet中時序圖的形式供大家參考。IIC協議有一條時鍾線SCL和一條雙線數據總線SDA。SDA在SCL高電平時保持穩定，否則視為開始或結束條件。

　　發送端發送1byte數據后，接收端在下一個SCL高電平期間拉低總線表示應答，即接收數據成功。

　　以下分別是器件地址為1字節的EEPROM的單字節寫和讀操作，需要注意的是DEVICE ADDRESS段中前四位固定是4'b1010，后三位根據EEPROM地址信號電平決定（本次實驗地址信號引腳均接地，因此后三位為000），最后一位是讀寫標志位，低電平寫。

　　好了，有了以上五張時序圖我們便知道要干什么了，就是實現這些時序嘛！對於這種串行時序，時間有先后且操作差異較大的要用狀態機實現。每種類型操作定義在一個狀態中，狀態內部需要多個操作則配合計數器實現。整體設計思路如下：先構造時鍾信號SCL，這里頻率定義為200KHz，而系統時鍾有頻率為200MHz差分晶振提供，顯然需要用到分頻計數器。由於SCL高電平期間數據要保持穩定，所以我們在分頻計數器計數到1/4處拉高SCL，3/4處拉低SCL，這樣做的好處是在結束計數時正好處於SCL低電平中間點，此處作為數據變化的時刻再合適不過。

　　有了時鍾信號，下一步就是通過不同的狀態實現SDA信號線滿足上述時序要求。我們先來划分狀態（實際上時序圖中都給我們標識好了），很明顯綜合考慮寫和讀兩種時序，狀態應定義為：初始狀態、開始、寫控制、響應1、寫地址、響應2、寫數據、響應3、重新開始、讀控制、響應4、讀數據、不響應、停止。這里寫控制和讀控制即是DEVICE ADDRESS階段，唯一的區別在於讀寫標志位不同。能看出以上狀態划分包括寫流程分支和讀流程分支，可以根據指令用一個標志位加以區分。

　　定義狀態參數並采用獨熱碼進行編碼：

　　IIC協議中每次SCL高電平期間視為一次操作，因此為了讓每個狀態都有整數個SCL周期（完整分頻計數周期），對每個狀態進行比特計數，寫控制、地址、寫數據、讀控制、讀數據階段計數周期是8，其他為1。另外為保證代碼的“健壯性”，也就是即使發送1byte數據后沒有響應也不至於掛死在等待響應階段，設定在每次等待響應階段若響應才進入下一操作，否則回到初始狀態。由此得到狀態轉移圖（只包括主要流程，轉移條件及未響應回到IDLE狀態未畫出）：

　　至此所有的設計工作都已經完成，接下來就是根據上述分析編寫代碼。在編寫代碼之前簡要介紹明德揚四段式狀態機的設計思想和代碼規范：四段式狀態機實質上是在三段式狀態機基礎上單獨提出狀態轉移條件定義的結構。目的是讓設計者一個時間段只專注於一件事情，也就是說當設計狀態機的時候先把狀態轉移流程確定，而條件用不同的信號名代替，等狀態轉移流程確定后再定義轉移條件。這樣做的另一個好處是作為條件的信號名可以很方便的在后續時序邏輯中使用。其中用於代替條件的信號名要遵循類似如下格式：<state_c>2<state_n>。<>處用狀態名代替。

整體代碼如下：

`timescale 1ns / 1ps

module i2c_interface#(parameter SCL_CYC = 1000)//200KHz
(
    input clk,
    input rst_n,
    
    //用戶側接口
    input write_en,//寫指令
    input read_en, //讀指令
    input [7:0]share_addr,    //讀寫復用地址
    input [7:0] wri_data,//代寫入數據
    input wri_data_vld,
    
    output reg busy,//總線忙信號
    output reg [7:0] rd_data,//讀回數據
    output reg rd_data_vld,
    
    //仿真用接口
    output reg [13:0] state_c,
    
    //eeprom側接口
    output reg scl, //時鍾
    input sda_in,
    output reg sda_en,
    output reg sda_reg
    
    );
    
    reg [11:0] div_cnt;
    reg high_middle,low_middle;
    reg [3:0] bit_cnt;
    reg [3:0] N;
    //(*keep = "true"*)reg [13:0] state_c;
    reg [13:0] state_n;
    reg [7:0] wri_byte;
    reg rd_flag;
    reg [7:0] rd_buf;
    reg [13:0] state_c_tmp;
    reg [7:0] device_addr_wr_shift;
    
    wire add_bit_cnt,end_bit_cnt;
    wire add_div_cnt,end_div_cnt;
    wire idle2start,start2wri_ctrl,wri_ctrl2ack1,ack12addr,addr2ack2,ack22wri_data;
    wire wri_data2ack3,ack32stop,ack22re_start,re_start2rd_ctrl,rd_ctrl2ack4;
    wire ack42rd_data,rd_data2nack,nack2stop,stop2idle,ack2idle;
    reg ack_valid,ack_invalid;
    wire [2:0] cs;
    wire wri_vld;
    wire [7:0] device_addr_rd,device_addr_wr;
    wire [7:0] word_addr;
    wire ack_state;
    
    //狀態編碼
    localparam IDLE     = 14'b00_0000_0000_0001,//1
               START    = 14'b00_0000_0000_0010,//2
               WRI_CTRL = 14'b00_0000_0000_0100,//4
               ACK1     = 14'b00_0000_0000_1000,//8
               ADDR     = 14'b00_0000_0001_0000,//10
               ACK2     = 14'b00_0000_0010_0000,//20
               WRI_DATA = 14'b00_0000_0100_0000,//40
               ACK3     = 14'b00_0000_1000_0000,//80
               RE_START = 14'b00_0001_0000_0000,//100
               RD_CTRL  = 14'b00_0010_0000_0000,//200
               ACK4     = 14'b00_0100_0000_0000,//400
               RD_DATA  = 14'b00_1000_0000_0000,//800
               NACK     = 14'b01_0000_0000_0000,//1000
               STOP     = 14'b10_0000_0000_0000;//2000
    
    //分頻計數器 在響應操作直到完成或退出到IDLE中間都計數
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            div_cnt <= 0;
        else if(add_div_cnt)begin
            if(end_div_cnt)
                div_cnt <= 0;
            else 
                div_cnt <= div_cnt + 1'b1;
        end
        else 
            div_cnt <= 0;
    end
    
    assign add_div_cnt = busy == 1;
    assign end_div_cnt = add_div_cnt && div_cnt == SCL_CYC - 1;
    
    //比特計數器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            bit_cnt <= 0;
        else if(add_bit_cnt)begin
            if(end_bit_cnt)
                bit_cnt <= 0;
            else 
                bit_cnt <= bit_cnt + 1'b1;
        end
    end
    
    assign add_bit_cnt = end_div_cnt;
    assign end_bit_cnt = add_bit_cnt && bit_cnt == N - 1;
    
    always@(*)begin
        case(state_c)
            WRI_CTRL:N = 8;
            ADDR:N = 8;
            WRI_DATA:N = 8;
            RD_CTRL:N = 8;
            RD_DATA:N = 8;
            default:N = 1;
        endcase
    end
    
    //---------------------iic時序四段式狀態機部分-------------------------
    
    //時序邏輯描述狀態轉移
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            state_c <= IDLE;
        else 
            state_c <= state_n;
    end
    
    //組合邏輯描述狀態轉移條件
    always@(*)begin
        case(state_c)
            IDLE:begin       //空閑狀態
                if(idle2start)
                    state_n = START;
                else 
                    state_n = state_c;
            end
            
            START:begin    //產生開始條件 即SCL高電平期間SDA拉低
                if(start2wri_ctrl)
                    state_n = WRI_CTRL;
                else 
                    state_n = state_c;
            end
            
            WRI_CTRL:begin  //寫器件地址和寫標志位
                if(wri_ctrl2ack1)
                    state_n = ACK1;
                else 
                    state_n = state_c;
            end
            
            ACK1:begin   //等待響應
                if(ack12addr)
                    state_n = ADDR;
                else if(ack2idle)
                    state_n = IDLE;
                else 
                    state_n = state_c;
            end
            
            ADDR:begin  //寫存儲單元地址
                if(addr2ack2)
                    state_n = ACK2;
                else 
                    state_n = state_c;
            end
            
            ACK2:begin   //等待響應2
                if(ack22wri_data)   //寫操作
                    state_n = WRI_DATA;
                else if(ack22re_start)//讀操作
                    state_n = RE_START;
                else if(ack2idle)
                    state_n = IDLE;
                else 
                    state_n = state_c;
            end
            
            WRI_DATA:begin   //寫數據 8bit
                if(wri_data2ack3)
                    state_n = ACK3;
                else 
                    state_n = state_c;
            end
            
            ACK3:begin   //等待響應3
                if(ack32stop)
                    state_n = STOP;
                else if(ack2idle)
                    state_n = IDLE;
                else 
                    state_n = state_c;
            end
            
            RE_START:begin  //若為讀操作在響應2后再次構造開始條件
                if(re_start2rd_ctrl)
                    state_n = RD_CTRL;
                else 
                    state_n = state_c;
            end
            
            RD_CTRL:begin   //寫入存儲單元地址和讀標志位
                if(rd_ctrl2ack4)
                    state_n = ACK4;
                else 
                    state_n = state_c;
            end
            
            ACK4:begin  //等待響應4
                if(ack42rd_data)
                    state_n = RD_DATA;
                else if(ack2idle)
                    state_n = IDLE;
                else 
                    state_n = state_c;
            end
            
            RD_DATA:begin  //讀數據 8bit
                if(rd_data2nack)
                    state_n = NACK;
                else 
                    state_n = state_c;
            end
            
            NACK:begin  //不響應 無操作即可
                if(nack2stop)
                    state_n = STOP;
                else 
                    state_n = state_c;
            end
            
            STOP:begin  //構造停止條件
                if(stop2idle)
                    state_n = IDLE;
                else 
                    state_n = state_c;
            end
            
            default:
                state_n = IDLE;
        endcase
    end
    
    //連續賦值語句定義狀態轉移條件
    assign idle2start       = state_c  == IDLE     && (write_en || read_en);
    assign start2wri_ctrl   = state_c  == START    && end_bit_cnt;  
    assign wri_ctrl2ack1    = state_c  == WRI_CTRL && end_bit_cnt;
    assign ack12addr        = state_c  == ACK1     && ack_valid && end_bit_cnt;
    assign addr2ack2        = state_c  == ADDR     && end_bit_cnt;
    assign ack22wri_data    = state_c  == ACK2     && ack_valid && !rd_flag && end_bit_cnt;
    assign wri_data2ack3    = state_c  == WRI_DATA && end_bit_cnt;
    assign ack32stop        = state_c  == ACK3     && ack_valid && end_bit_cnt;
    assign ack22re_start    = state_c  == ACK2     && ack_valid && rd_flag && end_bit_cnt;
    assign re_start2rd_ctrl = state_c  == RE_START && end_bit_cnt;
    assign rd_ctrl2ack4     = state_c  == RD_CTRL  && end_bit_cnt;
    assign ack42rd_data     = state_c  == ACK4     && ack_valid && end_bit_cnt;
    assign rd_data2nack     = state_c  == RD_DATA  && end_bit_cnt;
    assign nack2stop        = state_c  == NACK     && end_bit_cnt;
    assign stop2idle        = state_c  == STOP     && end_bit_cnt;
    assign ack2idle         = ack_state && ack_invalid;
    

    
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            ack_valid <= 0;
        else if(ack12addr || ack22wri_data || ack32stop || ack22re_start || ack42rd_data || ack2idle)
            ack_valid <= 0;
        else if(ack_state && high_middle && !sda_en && !sda_in)
            ack_valid <= 1;
    end
    
    assign ack_state = state_c == ACK1 || state_c == ACK2 || state_c == ACK3 || state_c == ACK4;
    
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            ack_invalid <= 0;
        else if(state_c == NACK && high_middle && !sda_en && sda_in)
            ack_invalid <= 1;
        else if(end_bit_cnt)
            ack_invalid <= 0;
    end
    
    //時序邏輯描述狀態輸出
    
    //scl時鍾信號
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            scl <= 0;
        else if(add_div_cnt && div_cnt == SCL_CYC/4 - 1)
            scl <= 1;
        else if(add_div_cnt && div_cnt == SCL_CYC/4 + SCL_CYC/2 - 1)
            scl <= 0;
    end
    
    //找到scl高低電平中間點
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            high_middle <= 0;
        else if(add_div_cnt && div_cnt == SCL_CYC/2 - 1)
            high_middle <= 1;
        else 
            high_middle <= 0;
    end
    
    //三態門輸出使能
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            sda_en <= 1;
        else if(idle2start || ack12addr || ack22wri_data || ack32stop || ack22re_start || nack2stop|| rd_data2nack)
            sda_en <= 1;
        else if(wri_ctrl2ack1 || addr2ack2 || wri_data2ack3 || rd_ctrl2ack4 || ack2idle || stop2idle)
            sda_en <= 0;
    end
    
    //數據總線輸出寄存器
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            sda_reg <= 1;
        else if(idle2start)
            sda_reg <= 1;
        else if((state_c == START || state_c == RE_START) && high_middle)
            sda_reg <= 0;
        else if(state_c == WRI_CTRL)
            sda_reg <= device_addr_wr[7-bit_cnt];
        else if(state_c == ADDR)
            sda_reg <= word_addr[7 - bit_cnt];
        else if(state_c == WRI_DATA)
            sda_reg <= wri_data[7 - bit_cnt];
        else if(state_c == STOP && high_middle)
            sda_reg <= 1;
        else if(ack22re_start)
            sda_reg <= 1;
        else if(state_c == RE_START && high_middle)
            sda_reg <= 0;
        else if(state_c == RD_CTRL)
            sda_reg <= device_addr_rd[7- bit_cnt];
        else if(ack_state)
            sda_reg <= 0;
        else if(rd_data2nack)
            sda_reg <= 1;
        else if(nack2stop)
            sda_reg <= 0;
    end
    
    assign device_addr_wr = {4'b1010,cs,1'b0};
    assign cs             = 3'b000;
    assign word_addr      = share_addr;
    assign device_addr_rd = {4'b1010,cs,1'b1};
    
    //讀取數據緩存
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            rd_buf <= 0;
        else if(state_c == RD_DATA && high_middle)
            rd_buf <= {rd_buf[6:0],sda_in};
    end
    
    //讀數據有效指示
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            rd_data_vld <= 0;
        else if(rd_data2nack)
            rd_data_vld <= 1;
        else 
            rd_data_vld <= 0;
    end
    
    //讀數據輸出
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            rd_data <= 0;
        else 
            rd_data <= rd_buf;
    end
    
    //讀標志位
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            rd_flag <= 0;
        else if(read_en)
            rd_flag <= 1;
        else if(rd_flag && (stop2idle || state_c == IDLE))
            rd_flag <= 0;
    end
    
    //總線忙信號
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            busy <= 0;
        else if(write_en || read_en)
            busy <= 1;
        else if(busy == 1 &&(stop2idle || state_c == IDLE))
            busy <= 0;
    end
    
endmodule

 　　可以看出狀態機部分依次分為：時序邏輯描述狀態轉移，組合邏輯描述狀態轉移條件，連續賦值定義狀態轉移條件以及時序邏輯描述狀態相關輸出。並且至始至終使用state_c和state_n兩個信號表示現態和次態，使邏輯更加清晰。接口部分為了方便仿真和調試，加入狀態信號state_c。這里涉及到一個雙向端口sda，用三個信號：輸出使能sda_en，輸出寄存器sda_reg和輸入緩存sda_in表示。在頂層模塊中使用這三個信號通過三態門的形式給出，關於三態門的使用細節和仿真方式稍后講述。

　　先設計其他模塊和頂層模塊，之后對頂層模塊進行仿真測試，這時觀察各個模塊中信號數值分析排查問題。有了時序接口模塊，在正確無誤情況下，已經可以實現對EEPROM的讀寫操作。現在明確設計目的，我們要實現EEPROM的一字節數據讀寫，因此可以通過按鍵發送指令向EEPROM中某地址中寫入任意一個數據，之后用另一個按鍵發送讀指令將剛寫入地址中數據讀出的方式驗證讀寫操作是否正常工作。編寫控制模塊（控制模塊僅實現IIC總線空閑時才響應操作，實際上用按鍵方式猶豫時間間隔較長，不會出現多個指令搶占總線的情況，這里設計控制模塊是為了適應其他場合或功能擴展用途）

`timescale 1ns / 1ps

module iic_ctrl(
    input clk,
    input rst_n,
    input local_rd,
    input local_wr,
    
    input iic_busy,
    output reg com_rd,
    output reg com_wr
    );
    
    wire ready;
    
    assign ready = !iic_busy;
    
    //寫命令
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            com_wr <= 0;
        else if(local_wr && ready)//iic總線空閑時才響應操作
            com_wr <= 1;
        else 
            com_wr <= 0;
    end
    
    //讀命令
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            com_rd <= 0;
        else if(local_rd && ready)
            com_rd <= 1;
        else 
            com_rd <= 0;
    end
    
    
endmodule

 　　剩下只需加入按鍵消抖模塊，並把按鍵消抖模塊，控制模塊還有時序接口模塊都例化在頂層文件中即可。按鍵消抖模塊在之前的博文中有講述，這里使用計數器配合狀態標志位的方式實現。需要說明的是多個按鍵使用一個按鍵消抖模塊的設計方式：只需將信號位寬定義為可變參數。

`timescale 1ns / 1ps

module key_filter
#(parameter DATA_W    = 24,
            KEY_W     = 2,
            TIME_20MS = 4_000_000)
(
   input clk    ,
   input rst_n  ,
   input [KEY_W-1 :0] key_in ,    //按鍵 按下為低電平
   output reg [KEY_W-1 :0] key_vld 
);

    reg [DATA_W-1:0] cnt;
    reg flag;
    reg [KEY_W-1 :0] key_in_ff1;
    reg [KEY_W-1 :0] key_in_ff0;

    wire add_cnt,end_cnt;
    
    //延時計數器
    always  @(posedge clk or negedge rst_n)begin
        if(rst_n==1'b0)
            cnt <= 0;
        else if(add_cnt)begin
            if(end_cnt)
                cnt <= 0;
            else
                cnt <= cnt + 1'b1;
        end
        else
            cnt <= 0;
    end
    //按下狀態才計數，松手清零
    assign add_cnt = flag == 1'b0 && (key_in_ff1 != 2'b11); 
    assign end_cnt = add_cnt && cnt == TIME_20MS - 1;
    
    //計數標志位，0有效 為了只計數一個周期
    always  @(posedge clk or negedge rst_n)begin 
        if(rst_n==1'b0)begin
            flag <= 1'b0;
        end
        else if(end_cnt)begin
            flag <= 1'b1;
        end
        else if(key_in_ff1 == 2'b11)begin//松手重新清零
            flag <= 1'b0;
        end
    end
    
    //同步處理
    always  @(posedge clk or negedge rst_n)begin 
        if(rst_n==1'b0)begin
            key_in_ff0 <= 0;
            key_in_ff1 <= 0;
        end
        else begin
            key_in_ff0 <= key_in    ;
            key_in_ff1 <= key_in_ff0;
        end
    end

    //輸出有效
    always  @(posedge clk or negedge rst_n)begin 
        if(rst_n==1'b0)begin
            key_vld <= 0;
        end
        else if(end_cnt)begin
            key_vld <= ~key_in_ff1;
        end
        else begin
            key_vld <= 0;
        end
    end
    
endmodule

 頂層模塊例化子模塊：

`timescale 1ns / 1ps

module eeprom_top(
    
    input sys_clk_p,
    input sys_clk_n,
    input rst_n,
    input [1:0] key,
    //仿真接口
    output sda_en,
    output [13:0] state_c,
    
    //EEPROM接口
    output scl,
    inout sda
    );
    
    wire sys_clk_ibufg;
    (*keep = "true"*)wire busy;
    (*keep = "true"*)wire read,write;
    wire [7:0] rd_data;
    wire rd_data_vld;
    (*keep = "true"*)wire sda_reg,sda_in;
    (*keep = "true"*)wire [1:0] key_vld;
    //(*keep = "true"*)wire sda_en;
    //(*keep = "true"*)wire [13:0] state_c;
    wire [39:0] probe0;
    
    IBUFGDS #
    (
    .DIFF_TERM ("FALSE"),
    .IBUF_LOW_PWR ("FALSE")
    )
    u_ibufg_sys_clk
    (
    .I (sys_clk_p),     //差分時鍾的正端輸入，需要和頂層模塊的端口直接連接
    .IB (sys_clk_n),    // 差分時鍾的負端輸入，需要和頂層模塊的端口直接連接
    .O (sys_clk_ibufg)  //時鍾緩沖輸出
    );
    
    
    key_filter
    #(.DATA_W(24),
      .KEY_W(2),
      .TIME_20MS(4_000_000))
    key_filter
    (
       .clk (sys_clk_ibufg)   ,
       .rst_n(rst_n)  ,
       .key_in (key),    //按鍵 按下為低電平
       .key_vld(key_vld) 
    );
    
    iic_ctrl iic_ctrl(
    .clk(sys_clk_ibufg),
    .rst_n(rst_n),
    .local_wr(key_vld[1]),
    .local_rd(key_vld[0]),
    
    .iic_busy(busy),
    .com_rd(read),
    .com_wr(write)
    );
    
    iic_interface
    #(.SCL_CYC(1000))
    iic_interface(
    .clk(sys_clk_ibufg),
    .rst_n(rst_n),
    
    //用戶側接口
    .write_en(write),  //寫指令
    .read_en(read),    //讀指令
    .share_addr(8'h15),//讀寫復用地址
    .wri_data(8'h32),  //待寫入數據
    .wri_data_vld(1'b1),
    .busy(busy),       //總線忙信號
    .rd_data(rd_data), //讀回數據
    .rd_data_vld(rd_data_vld),
    //仿真接口
    .state_c(state_c),
    //eeprom側接口
    .scl(scl), //時鍾
    .sda_in(sda_in),
    .sda_en(sda_en),
    .sda_reg(sda_reg)
    );
    
    //三態門
    assign sda    = sda_en ? sda_reg : 1'bz;
    assign sda_in = sda;
    
    ila_0 ila_0 (
    .clk(sys_clk_ibufg), // input wire clk
    .probe0(probe0) // input wire [39:0] probe0
);

    assign probe0[13:0] = state_c; //14bit
    assign probe0[14] = busy;
    assign probe0[15] = scl;
    assign probe0[16] = sda_en;
    assign probe0[17] = sda_reg;
    assign probe0[18] = sda_in;
    assign probe0[19] = write;
    assign probe0[20] = read;
    assign probe0[39:21] = 0;
    
endmodule

　　看一下軟件分析出的原理圖結構（ILA IP核是之后添加的）：

　　此處詳細說明下雙向端口使用：頂層模塊中建立三態門結構，在輸出使能有效時作為輸出端口，無效是呈現高阻態，此時作為輸入端口，由sda_in信號讀取數值。那雙向端口如何仿真呢？很簡單，在測試文件中也構造一個三態門結構，而輸出使能信號為設計中輸出使能信號的相反值，這樣在設計中該端口呈現高阻態時，正好在測試文件中相應端口作為輸出的階段。可以注意到我在頂層模塊中加入了兩個仿真接口：state_c和sda_en，方便在測試文件中找到給出響應的位置。測試文件如下：

`timescale 1ns / 1ps

module eeprom_top_tb;
    
    reg sys_clk_p,sys_clk_n;
    reg rst_n;
    reg [1:0] key;
    
    wire scl;
    wire sda;
    wire sda_en;//高電平時待測試文件為輸出
    
    reg [15:0] myrand;
    reg sda_tb_out;
    wire [13:0] state_c;
    
    eeprom_top eeprom_top(
    .sys_clk_p(sys_clk_p),
    .sys_clk_n(sys_clk_n),
    .rst_n(rst_n),
    .key(key),
    .sda_en(sda_en),
    .state_c(state_c),
    .scl(scl),
    .sda(sda)
    );
    
    assign sda = (!sda_en) ? sda_tb_out : 1'bz;
    
    parameter CYC = 5,
              RST_TIME = 2;
    
    defparam eeprom_top.key_filter.TIME_20MS = 200;
    
    initial begin
        sys_clk_p = 0;
        forever #(CYC/2) sys_clk_p = ~sys_clk_p;
    end
    
    initial begin
        sys_clk_n = 1;
        forever #(CYC/2) sys_clk_n = ~sys_clk_n;
    end
    
    localparam IDLE     = 14'b00_0000_0000_0001,
               START    = 14'b00_0000_0000_0010,
               WRI_CTRL = 14'b00_0000_0000_0100,
               ACK1     = 14'b00_0000_0000_1000,
               ADDR     = 14'b00_0000_0001_0000,
               ACK2     = 14'b00_0000_0010_0000,
               WRI_DATA = 14'b00_0000_0100_0000,
               ACK3     = 14'b00_0000_1000_0000,
               RE_START = 14'b00_0001_0000_0000,
               RD_CTRL  = 14'b00_0010_0000_0000,
               ACK4     = 14'b00_0100_0000_0000,
               RD_DATA  = 14'b00_1000_0000_0000,
               NACK     = 14'b01_0000_0000_0000,
               STOP     = 14'b10_0000_0000_0000;
    
    initial begin
        rst_n = 1;
        #1;
        rst_n = 0;
        #(CYC*RST_TIME);
        rst_n = 1;
    end
    
    initial begin
        #1;
        key = 2'b11;
        #(CYC*RST_TIME);
        #(CYC*10);
        
        press_key_wr;
        #120_000;
        press_key_rd;
        #80_000;
        $stop;
    end
    
    //構造響應條件
    always@(*)begin
        if(state_c == ACK1 || state_c == ACK2 || state_c == ACK3 || state_c == ACK4)
            sda_tb_out <= 0;
        else 
            sda_tb_out <= 1;
    end
    
    task press_key_wr;
    begin
        repeat(20)begin//模擬抖動過程
            myrand = {$random}%400;
            #myrand key[1] = ~key[1];
        end
        key[1] = 0;
        #3000;
        repeat(20)begin
            myrand = {$random}%400;
            #myrand key[1] = ~key[1];
        end
        key[1] = 1;
        #3000;
    end
    endtask
    
    task press_key_rd;
    begin
        repeat(20)begin//模擬抖動過程
            myrand = {$random}%400;
            #myrand key[0] = ~key[0];
        end
        key[0] = 0;
        #3000;
        repeat(20)begin
            myrand = {$random}%400;
            #myrand key[0] = ~key[0];
        end
        key[0] = 1;
        #3000;
    end
    endtask
    
endmodule

　　我的開發板使用差分晶振作為系統時鍾，在測試文件中也要以差分信號的形式給出時鍾。與單端時鍾唯一的區別在於給出兩個初始值不同周期相同的時鍾信號。其中為了找到響應位置，引入狀態編碼，並在需要給出響應的時刻拉低總線。運行行為仿真：

整體結構：

寫操作：

讀操作：

　　讀寫操作過程中狀態轉移、比特計數器、sda 、scl這些核心信號數據正常，仿真通過。實際上這是設計過程中遇到些小問題，修改代碼后的結果。下一步要在線調試了，這里是本篇博文最后一個重點要說明的內容。以往我會使用添加屬性的方式(*mark_debug = "true"*)標志要觀察的信號，再在綜合后使用debug設置向導引入調試IP核。經過實驗發現調試核的引入是通過添加約束的方式實現的，而且當要觀察別的信號時該約束部分必須改動否則報錯，所以這里使用IP核例化調試探測流程，直接在IP catalog中生成ILA IP核。這里有一個小技巧：生成IP核是只使用一個探針信號，並把位寬設置的較大，且使用OOC方式。在例化IP核后使用這個信號的不同位寬部分連接需要在線觀察的信號。這樣可以避免在反復綜合、布局布線的過程中重新編譯ILA IP核部分，節約時間。

　　打開硬件管理器，下載bit流后自動打開調試界面。設置觸發條件觀察波形，這里可以很方便的利用狀態信號的不同狀態設置觸發條件。

寫操作：

 讀操作：

　　寫入數據定義為8'h32,讀取bit依次是0011_0010，即為32，說明正確將寫入數據讀出。大家可以在本次實驗基礎上擴展，比如實現頁寫模式，或是使用串口來發送讀寫指令並讀回數據等。經過本次博文，掌握了IIC協議的四段式狀態機實現方式，雙向端口的三態門結構及仿真方法，並能夠靈活運用ILA IP核進行在線調試。希望大家和我一樣收獲很多。歡迎交流~