• FPGA project ： IIC_wr_eeprom

    简介：

    简单双向二线制，同步串行总线。

    scl：串行时钟线，用于同步通讯数据。

    sda：双向串行数据线。

    物理层：

    1，支持挂载多设备。

    2，二线制。

    3，每个设备有其单独的地址。

    4，空闲时，sda会被上拉电阻拉高。

    5，存在多个主机时，通过仲裁逻辑决定那个主机控制总线。

    6，三个速度模式：标准模式（100kb/s）;快速模式（400kb/s）；高速模式（3.4Mb/s）

    地址：

    器件地址。7bit，最后1bit为读写控制位。

    存储地址：分为单字节和双字节，与存储设备容量有关。就是有多少byte的容量，用几位二进制地址表示。

    读写地址。

    时序总结：

    在scl为高时，若sda变化，则为起始或终止信号。

    在scl为低时，（已启动读时隙），sda在scl低电平变化，高电平对sda采样。

    读时序：分为随机读（单字节读）和顺序读（页读）。

    写时序：单字节写和页写。

    框图：

    时序图也画了，很多很大，就不放了。

     代码：

    iic时序驱动模块+指令控制模块+按键消抖+顶层；

    1. /************************************************************
    2. ****************    iic 模块说明    ************************
    3. ****************    驱动接口模块    ************************
    4. *输入端口：
    5. *sys_clk    :   1Mhz时钟信号。
    6. *iic_start  :   开始进行读写通信标志信号。
    7. *en_w       :   写使能信号，与iic_start同时拉高，iic模块启动写时序。
    8. *addr       :   地址信号，读写公用一个地址信号。
    9. *data_w     :   要通过iic协议写入从机的8bit数据。
    10. *en_r       :   读使能信号，与iic_start同时拉高，iic模块启动读时序。
    11. *addr_num   :   由于地址有单byte和双byte情况，addr_num == 0表示单。
    12. *输出端口:
    13. *scl        :   iic协议的同步时钟信号。串行时钟线，用于同步通讯数据。时钟频率为250kHz
    14. *sda        :   双向端口，双向串行数据线。
    15. *data_out   :   读取到的1byte数据。
    16. *iic_end    :   完成ibyte数据的读写标志信号。
    17. */
    18. module iic (
    19.     input       wire            sys_clk     , // 虽然写的是sys_clk但是例化时要接iic_clk
    20.     input       wire            sys_rst_n   ,
    21.     input       wire            iic_start   ,
    22.     input       wire            en_w        ,
    23.     input       wire            en_r        ,
    24.     input       wire    [15:0]  byte_addr   ,
    25.     input       wire    [7:0]   data_w      ,
    26.     input       wire            addr_num    ,
    27.  
    28.     inout       wire            sda         ,
    29.  
    30.     output      reg             scl         ,
    31.     output      reg     [7:0]   data_out    ,
    32.     output      reg             iic_end     
    33. );
    34.     // parameter
    35.     parameter   DEVICE_ADDR = 7'b1010_011 ; // 器件地址，最后一位要根据读写，来决定。[6:0]
    36.     wire        [7:0]   FIRST_ADDR        ; // AT24C64
    37.     wire        [7:0]   SECOND_ADDR       ; // 可在此设置读写地址。
    38.     assign      FIRST_ADDR  = byte_addr[15:8] ;
    39.     assign      SECOND_ADDR = byte_addr[ 7:0] ;
    40.     // localparam 
    41.     localparam  IDLE                    =4'b0000 ,
    42.                 START1                  =4'b0001 ,
    43.                 SEND_DEVICE_ADDR        =4'b0011 ,
    44.                 ACK1                    =4'b0010 ,
    46.                 SEND_FIRST_ADDR         =4'b0110 ,
    47.                 ACK2                    =4'b0111 ,
    48.                 SEND_SECOND_ADDR        =4'b0101 ,
    49.                 ACK3                    =4'b0100 ,
    51.                 WR_DATA                 =4'b1100 ,
    52.                 ACK4                    =4'b1101 ,
    53.                 STOP                    =4'b1111 ,
    54.                 START2                  =4'b1110 ,
    56.                 SEND_READ_DEVICE_ADDR   =4'b1010 ,
    57.                 ACK5                    =4'b1011 ,
    58.                 READ_DATA               =4'b1001 ,
    59.                 NO_ACK                  =4'b1000 ; 
    60.     // wire signal define
    61.     wire    sda_en ;
    62.     wire    IDLEtoSTART1                ;             
    63.     wire    START1toSEND_DEVICE_ADDR    ; 
    64.     wire    SEND_DEVICE_ADDRtoACK1      ;   
    65.     wire    ACK1toSEND_FIRST_ADDR       ;
    66.     wire    ACK1toSEND_SECOND_ADDR      ;   
    67.     wire    SEND_FIRST_ADDRtoACK2       ;    
    68.     wire    ACK2toSEND_SECOND_ADDR      ;   
    69.     wire    SEND_SECOND_ADDRtoACK3      ;   
    70.     wire    ACK3toWR_DATA               ;            
    71.     wire    ACK3toSTART2                ;             
    72.     wire    WR_DATAtoACK4               ;            
    73.     wire    ACK4toSTOP                  ;               
    74.     wire    STOPtoIDLE                  ;     
    75.     wire    START2toSEND_READ_DEVICE_ADDR;
    76.     wire    SEND_READ_DEVICE_ADDRtoACK5 ; 
    77.     wire    ACK5toREAD_DATA             ;          
    78.     wire    READ_DATAtoNO_ACK           ;        
    79.     wire    NO_ACKtoSTOP                ;             
    81.     // reg signal define
    82.     reg     [3:0]   state_c ;
    83.     reg     [3:0]   state_n ;
    84.     reg     [1:0]   cnt_iic ; // 关键计数器。很多信号赋值都与他有关。
    85.     reg     [2:0]   cnt_bit ; // bit计数器，计数值0-7
    86.     reg             sda_out ;
    87. /***********************************************************************/
    88.     // 状态机描述
    89.     // reg     [3:0]   state_c ;
    90.     always @(posedge sys_clk or negedge sys_rst_n) begin
    91.         if(~sys_rst_n) 
    92.             state_c <= IDLE ;
    93.         else
    94.             state_c <= state_n ;
    95.     end
    96.     // reg     [3:0]   state_n ;
    97.     always @(*) begin
    98.         case(state_c)
    99.                 IDLE                 :  if(IDLEtoSTART1) 
    100.                                             state_n = START1 ;
    101.                                         else 
    102.                                             state_n = IDLE ;
    103.                 START1               :  if(START1toSEND_DEVICE_ADDR)
    104.                                             state_n = SEND_DEVICE_ADDR ;
    105.                                         else 
    106.                                             state_n = START1 ;
    107.                 SEND_DEVICE_ADDR     :  if(SEND_DEVICE_ADDRtoACK1) 
    108.                                             state_n = ACK1 ;
    109.                                         else 
    110.                                             state_n = SEND_DEVICE_ADDR ;
    111.                 ACK1                 :  if(ACK1toSEND_FIRST_ADDR) 
    112.                                             state_n = SEND_FIRST_ADDR ;
    113.                                         else if(ACK1toSEND_SECOND_ADDR)
    114.                                             state_n = SEND_SECOND_ADDR ;
    115.                                         else 
    116.                                             state_n = ACK1 ;
    117.                 SEND_FIRST_ADDR      :  if(SEND_FIRST_ADDRtoACK2) 
    118.                                             state_n = ACK2 ;
    119.                                         else 
    120.                                             state_n = SEND_FIRST_ADDR ;
    121.                 ACK2                 :  if(ACK2toSEND_SECOND_ADDR) 
    122.                                             state_n = SEND_SECOND_ADDR ;
    123.                                         else 
    124.                                             state_n = ACK2 ;
    125.                 SEND_SECOND_ADDR     :  if(SEND_SECOND_ADDRtoACK3) 
    126.                                             state_n = ACK3 ;
    127.                                         else 
    128.                                             state_n = SEND_SECOND_ADDR ;
    129.                 ACK3                 :  if(ACK3toWR_DATA) 
    130.                                             state_n = WR_DATA ;
    131.                                         else if(ACK3toSTART2)
    132.                                             state_n = START2 ;
    133.                                         else 
    134.                                             state_n = ACK3 ;
    135.                 WR_DATA              :  if(WR_DATAtoACK4) 
    136.                                             state_n = ACK4 ;
    137.                                         else 
    138.                                             state_n = WR_DATA ;
    139.                 ACK4                 :  if(ACK4toSTOP) 
    140.                                             state_n = STOP ;
    141.                                         else 
    142.                                             state_n = ACK4 ;
    143.                 STOP                 :  if(STOPtoIDLE) 
    144.                                             state_n = IDLE ;
    145.                                         else 
    146.                                             state_n = STOP ;
    147.                 START2               :  if(START2toSEND_READ_DEVICE_ADDR) 
    148.                                             state_n = SEND_READ_DEVICE_ADDR ;
    149.                                         else 
    150.                                             state_n = START2 ;
    151.                 SEND_READ_DEVICE_ADDR:  if(SEND_READ_DEVICE_ADDRtoACK5) 
    152.                                             state_n = ACK5 ;
    153.                                         else 
    154.                                             state_n = SEND_READ_DEVICE_ADDR ;
    155.                 ACK5                 :  if(ACK5toREAD_DATA) 
    156.                                             state_n = READ_DATA ;
    157.                                         else 
    158.                                             state_n = ACK5 ;
    159.                 READ_DATA            :  if(READ_DATAtoNO_ACK) 
    160.                                             state_n = NO_ACK ;
    161.                                         else 
    162.                                             state_n = READ_DATA ;
    163.                 NO_ACK               :  if(NO_ACKtoSTOP) 
    164.                                             state_n = STOP ;
    165.                                         else 
    166.                                             state_n = NO_ACK ;
    167.                 default              :      state_n = IDLE ;
    168.         endcase
    169.     end
    170.     // 状态转移条件赋值：
    171.     assign  IDLEtoSTART1             = (state_c == IDLE  ) && (iic_start == 1'b1) ;
    172.     assign  START1toSEND_DEVICE_ADDR = (state_c == START1) && (cnt_iic == 3)      ;
    173.     assign  SEND_DEVICE_ADDRtoACK1   = (state_c == SEND_DEVICE_ADDR) && (cnt_iic == 3 && cnt_bit == 7) ;
    174.     assign  ACK1toSEND_FIRST_ADDR    = (state_c == ACK1  ) && (cnt_iic == 3 && sda == 1'b0 && addr_num == 1) ; //&& sda == 1'b0 由于仿真模型没有相应ack功能，所以要自己模拟。
    175.     assign  ACK1toSEND_SECOND_ADDR   = (state_c == ACK2  ) && (cnt_iic == 3 && sda == 1'b0 && addr_num == 0) ; //&& sda == 1'b0
    176.     assign  SEND_FIRST_ADDRtoACK2    = (state_c == SEND_FIRST_ADDR) && (cnt_iic == 3 && cnt_bit == 7) ;
    177.     assign  ACK2toSEND_SECOND_ADDR   = (state_c == ACK2  ) && (cnt_iic == 3 && sda == 0) ; //&& sda == 0
    178.     assign  SEND_SECOND_ADDRtoACK3   = (state_c == SEND_SECOND_ADDR) && (cnt_iic == 3 && cnt_bit == 7) ;
    179.     assign  ACK3toWR_DATA            = (state_c == ACK3  ) && (cnt_iic == 3 && en_w && sda == 0) ; // && sda == 0 
    180.     assign  ACK3toSTART2             = (state_c == ACK3  ) && (cnt_iic == 3 && en_r && sda == 0) ; // && sda == 0 
    181.     assign  WR_DATAtoACK4            = (state_c == WR_DATA ) && (cnt_iic == 3 && cnt_bit == 7) ;
    182.     assign  ACK4toSTOP               = (state_c == ACK4  ) && (cnt_iic == 3 && sda == 0) ; // && sda == 0
    183.     assign  STOPtoIDLE               = (state_c == STOP  ) && (cnt_iic == 3 && cnt_bit == 3) ;
    184.     assign  START2toSEND_READ_DEVICE_ADDR = (state_c == START2) && (cnt_iic == 3)      ;
    185.     assign  SEND_READ_DEVICE_ADDRtoACK5 = (state_c == SEND_READ_DEVICE_ADDR) && (cnt_iic == 3 && cnt_bit == 7) ;
    186.     assign  ACK5toREAD_DATA          = (state_c == ACK5  ) && (cnt_iic == 3 && sda == 0) ; //&& sda == 0
    187.     assign  READ_DATAtoNO_ACK        = (state_c == READ_DATA) && (cnt_iic == 3 && cnt_bit == 7) ;
    188.     assign  NO_ACKtoSTOP             = (state_c ==  NO_ACK) && (cnt_iic == 3 && sda == 1) ;
    189.     // reg     [1:0]   cnt_iic ; // 关键计数器。很多信号赋值都与他有关。
    190.     always @(posedge sys_clk or negedge sys_rst_n) begin
    191.         if(~sys_rst_n) 
    192.             cnt_iic <= 2'd0 ;
    193.         else if(state_c != IDLE)
    194.             cnt_iic <= cnt_iic + 1'b1 ;
    195.         else 
    196.             cnt_iic <= 1'b0 ;
    197.     end
    198.     // reg     [2:0]   cnt_bit ; // bit计数器，计数值0-7
    199.     always @(posedge sys_clk or negedge sys_rst_n) begin
    200.         if(~sys_rst_n) 
    201.             cnt_bit <= 3'd0 ;
    202.         else if(state_c != IDLE && state_c != START1 && state_c != START2 && state_c != NO_ACK && state_c != ACK1 && state_c != ACK2 && state_c != ACK3 && state_c != ACK4 && state_c != ACK5 && cnt_iic == 3)
    203.             cnt_bit <= cnt_bit + 1'b1 ;
    204.         else if(state_c != IDLE && state_c != START1 && state_c != START2 && state_c != NO_ACK && state_c != ACK1 && state_c != ACK2 && state_c != ACK3 && state_c != ACK4 && state_c != ACK5)
    205.             cnt_bit <= cnt_bit ;
    206.         else 
    207.             cnt_bit <= 3'd0 ;
    208.     end
    209.     // reg             sda_out ;
    210.     always @(posedge sys_clk or negedge sys_rst_n) begin
    211.         if(~sys_rst_n)
    212.             sda_out <= 1'b1 ; 
    213.         else
    214.         case (state_c)
    215.             IDLE                 :  sda_out <= 1'b1 ;
    216.             START1               :  if(cnt_iic == 0) 
    217.                                         sda_out <= 1'b0 ;
    218.                                     else 
    219.                                         sda_out <= sda_out ;
    220.             SEND_DEVICE_ADDR     :  if(cnt_iic == 0 && cnt_bit != 7) 
    221.                                         sda_out <= DEVICE_ADDR[6 - cnt_bit] ;
    222.                                     else if(cnt_iic == 0 && cnt_bit == 7) 
    223.                                         sda_out <= 1'b0 ; // 写控制位。
    224.             ACK1                 :  sda_out <= 1'b0 ;
    225.             SEND_FIRST_ADDR      :  if(cnt_iic == 0)
    226.                                         sda_out <= FIRST_ADDR[7 - cnt_bit] ;
    227.                                     else 
    228.                                         sda_out <= sda_out ;
    229.             ACK2                 :  sda_out <= 1'b0 ;
    230.             SEND_SECOND_ADDR     :  if(cnt_iic == 0)
    231.                                         sda_out <= SECOND_ADDR[7 - cnt_bit] ;
    232.                                     else 
    233.                                         sda_out <= sda_out ;
    234.             ACK3                 :  sda_out <= 1'b0 ;
    235.             WR_DATA              :  if(cnt_iic == 0)
    236.                                         sda_out <= data_w[7 - cnt_bit] ;
    237.                                     else 
    238.                                         sda_out <= sda_out ;
    239.             ACK4                 :  sda_out <= 1'b0 ;
    240.             STOP                 :  if(cnt_iic == 0 && cnt_bit == 0)
    241.                                         sda_out <= 1'b0 ;
    242.                                     else if(cnt_iic == 2 && cnt_bit == 0)
    243.                                         sda_out <= 1'b1 ;
    244.                                     else    
    245.                                         sda_out <= sda_out ;
    246.             START2               :  if(cnt_iic == 0)
    247.                                         sda_out <= 1'b1 ;
    248.                                     else if(cnt_iic == 2)
    249.                                         sda_out <= 1'b0 ;
    250.                                     else 
    251.                                         sda_out <= sda_out ;
    252.             SEND_READ_DEVICE_ADDR:  if(cnt_iic == 0 && cnt_bit != 7) 
    253.                                         sda_out <= DEVICE_ADDR[6 - cnt_bit] ;
    254.                                     else if(cnt_iic == 0 && cnt_bit == 7) 
    255.                                         sda_out <= 1'b1 ; // 读控制位。
    256.             ACK5                 :  sda_out <= 1'b0 ;
    257.             READ_DATA            :  sda_out <= 1'b0 ;
    258.             NO_ACK               :  sda_out <= 1'b1 ;
    259.             default              :  sda_out <= 1'b1 ;
    260.         endcase
    261.     end
    262.     // wire     sda_en 
    263.     assign sda_en = ((state_c == ACK1) || (state_c == ACK2) || (state_c == ACK3) || (state_c == ACK4) || (state_c == ACK5) || (state_c == READ_DATA)) ? 1'b0 : 1'b1 ;
    264. /***************************************************************************/
    265.     // wire            sda         ,
    266.     assign sda = (sda_en == 1) ? sda_out : 1'bz ;
    267.     // reg             scl         ,
    268.     always @(posedge sys_clk or negedge sys_rst_n) begin
    269.         if(~sys_rst_n) 
    270.             scl <= 1'b1 ;
    271.         else 
    272.         if(state_c != IDLE && state_c != STOP && state_c != START1) begin
    273.             if(cnt_iic == 1 || cnt_iic == 3)
    274.                 scl <= ~scl ;
    275.             else 
    276.                 scl <=  scl ;
    277.         end 
    278.         else if(state_c == IDLE)
    279.                 scl <= 1'b1 ;
    280.         else if(state_c == STOP && (cnt_bit == 0 && cnt_iic == 1))
    281.                 scl <= 1'b1 ;
    282.         else if(state_c == STOP)
    283.                 scl <= scl ;
    284.         else if(state_c == START1 && cnt_iic == 3)
    285.                 scl <= ~scl ;
    286.         else if(state_c == START1)
    287.                 scl <= scl ;
    288.         else 
    289.             scl <= 1'b1 ;
    290.     end
    291.     // reg     sda_data ;
    292.     // always @(posedge sys_clk or negedge sys_rst_n) begin
    293.     //     if(~sys_rst_n)
    294.     //         sda_data <= 1'b0 ;
    295.     //     else if(state_c == READ_DATA && cnt_iic == 0)
    296.     //         sda_data <= ~sda_data ;
    297.     //     else    
    298.     //         sda_data <=  sda_data ;
    299.     // end
    300.     // reg [7:0]    data_out
    301.     always @(posedge sys_clk or negedge sys_rst_n) begin
    302.         if(~sys_rst_n) 
    303.             data_out <= 8'd0 ;
    304.         else if(state_c == READ_DATA && cnt_iic == 2 && scl == 1)
    305.             data_out <= {data_out[6:0],sda} ; // 这里也需要自己模拟 sda_data
    306.         else 
    307.             data_out <= data_out ;
    308.     end
    309.     // wire            iic_end     
    310.     always @(posedge sys_clk or negedge sys_rst_n) begin
    311.         if(~sys_rst_n) 
    312.             iic_end <= 1'b0 ;
    313.         else if(state_c == STOP && cnt_iic == 3 && cnt_bit == 3)
    314.             iic_end <= 1'b1 ;
    315.         else    
    316.             iic_end <= 1'b0 ;
    317.     end
    318. endmodule
    1. /************************************************************
    2. ****************    iic_instruct 模块说明    ************************
    3. ****************    产生接口时序模块的控制信号，并存储读到的数据，并把数据传给数码管显示模块。
    4. */
    5. module iic_instruct (
    6.     input       wire            sys_clk   , // 20ns
    7.     input       wire            sys_rst_n ,
    8.     input       wire            iic_clk   , // 1000ns
    9.     input       wire            flag_w    ,
    10.     input       wire            flag_r    ,
    11.     input       wire            iic_end   ,
    12.     input       wire    [7:0]   data_r    , // iic 模块读到的1byte数据。
    13.  
    14.     output      reg             iic_start ,
    15.     output      reg             en_w      , // 写使能，往eeprom中写数据的使能信号。
    16.     output      reg             en_r      , // 读使能，从eeprom中读数据的使能信号。
    17.     output      reg     [15:0]  byte_addr , // 读写操作的数据地址。
    18.     output      reg     [7:0]   data_w    , // 往eeprom中写入的数据。
    19.     output      wire            addr_num  , // eeprom的存储地址是几个byte。
    20.     output      wire    [7:0]   data_out    // 传给数码管显示的数据。
    21. );
    22.     parameter   ADDR_START          = 16'h00_00 ,
    23.                 DATA_WRITE          = 8'd00     , // 写入的起始数据。
    24.                 CNT_MAX_START       = 49999     , // 5ms
    25.                 CNT_MAX_1S          = 1_000_000 ,
    26.                 CNT_MAX_WRITE_BYTE  = 10        , 
    27.                 CNT_MAX_READ_BYTE   = 10        ; 
    28. /******************************************************/
    29.     // 第一步：处理输入信号，实现快速时钟域标志信号同步到慢速时钟域。  
    30.     // 也就是保证慢速时钟域可以检测到标志信号。
    31.     reg             valid_write ;
    32.     reg     [7:0]   cnt_write   ;
    33.     reg             valid_read  ;
    34.     reg     [7:0]   cnt_read    ;
    35.     reg     [15:0]  cnt_read_byte   ;
    36.     reg     [15:0]  cnt_start       ;
    37.     reg     [15:0]  cnt_write_byte  ; // 写入eeprom字节计数器
    38. 	wire	        empty   ;
    39. 	wire	        full    ;
    40. 	wire	[9:0]   usedw   ;
    41.     always @(posedge sys_clk or negedge sys_rst_n) begin
    42.         if(~sys_rst_n) 
    43.             valid_write <= 1'b0 ;
    44.         else if(flag_w)
    45.             valid_write <= 1'b1 ;
    46.         else if(cnt_write == 199)
    47.             valid_write <= 1'b0 ;
    48.         else 
    49.             valid_write <=  valid_write ;
    50.     end
    51.     always @(posedge sys_clk or negedge sys_rst_n) begin
    52.         if(~sys_rst_n) 
    53.             cnt_write <= 8'd0 ;
    54.         else if(valid_write && cnt_write == 199)
    55.             cnt_write <= 8'd0 ;
    56.         else if(valid_write)
    57.             cnt_write <= cnt_write + 1'b1 ;
    58.         else 
    59.             cnt_write <= 8'd0 ;
    60.     end
    61.     always @(posedge sys_clk or negedge sys_rst_n) begin
    62.         if(~sys_rst_n) 
    63.             valid_read <= 1'b0 ;
    64.         else if(flag_r)
    65.             valid_read <= 1'b1 ;
    66.         else if(cnt_read == 199)
    67.             valid_read <= 1'b0 ;
    68.         else 
    69.             valid_read <=  valid_read ;
    70.     end
    71.     always @(posedge sys_clk or negedge sys_rst_n) begin
    72.         if(~sys_rst_n) 
    73.             cnt_read <= 8'd0 ;
    74.         else if(valid_read && cnt_read == 199)
    75.             cnt_read <= 8'd0 ;
    76.         else if(valid_read)
    77.             cnt_read <= cnt_read + 1'b1 ;
    78.         else 
    79.             cnt_read <= 8'd0 ;
    80.     end
    81.     assign addr_num = 1'b1 ;
    82. /**********************************************************************************/
    83.     // 第二步：产生写数据相关信号的产生。在iic_clk时钟域下。
    84.     
    85.     // en_w
    86.     always @(posedge iic_clk or negedge sys_rst_n) begin
    87.         if(~sys_rst_n) 
    88.             en_w <= 1'b0 ;
    89.         else if(iic_end && (cnt_write_byte == CNT_MAX_WRITE_BYTE - 1))
    90.             en_w <= 1'b0 ;
    91.         else if(valid_write)
    92.             en_w <= 1'b1 ;
    93.         else 
    94.             en_w <= en_w ;
    95.     end
    96.     //reg    iic_start
    97.     always @(posedge iic_clk or negedge sys_rst_n) begin
    98.         if(~sys_rst_n)
    99.             iic_start <= 1'b0 ;
    100.         else if(en_w == 0 && valid_write == 1 || cnt_start == CNT_MAX_START - 1)
    101.             iic_start <= 1'b1 ;
    102.         else 
    103.             iic_start <= 1'b0 ;
    104.     end
    105.     // reg   [15:0]  cnt_start ;
    106.     always @(posedge iic_clk or negedge sys_rst_n) begin
    107.         if(~sys_rst_n) 
    108.             cnt_start <= 16'd0 ;
    109.         else if(((en_w == 1) && ((cnt_start == CNT_MAX_START - 1)
    110.                 || (iic_end == 1 && cnt_write_byte == CNT_MAX_WRITE_BYTE - 1))) 
    111.                 || ((en_r == 1) && ((cnt_start == CNT_MAX_START - 1)
    112.                 || (iic_end == 1 && cnt_read_byte == CNT_MAX_READ_BYTE - 1))))
    113.             cnt_start <= 16'd0 ;
    114.         else if(en_w == 1 || en_r)
    115.             cnt_start <= cnt_start + 1'b1 ;
    116.         else 
    117.             cnt_start <= 16'd0 ;
    118.     end
    119.     // [15:0] byte_addr // 目前只完成了写地址，
    120.     always @(posedge iic_clk or negedge sys_rst_n) begin
    121.         if(~sys_rst_n) 
    122.             byte_addr <= ADDR_START ;
    123.         else if((iic_end == 1 && cnt_write_byte == CNT_MAX_WRITE_BYTE - 1) 
    124.                 || (iic_end == 1 && cnt_read_byte == CNT_MAX_READ_BYTE - 1))
    125.             byte_addr <= ADDR_START ;
    126.         else if(iic_end == 1)
    127.             byte_addr <= byte_addr + 1'b1 ;
    128.         else 
    129.             byte_addr <= byte_addr ;
    130.     end
    131.     // [7:0]    data_w
    132.     always @(posedge iic_clk or negedge sys_rst_n) begin
    133.         if(~sys_rst_n) 
    134.             data_w <= DATA_WRITE ;
    135.         else if(iic_end == 1 && cnt_write_byte == CNT_MAX_WRITE_BYTE - 1)
    136.             data_w <= DATA_WRITE ;
    137.         else if(en_w && iic_end == 1)
    138.             data_w <= data_w + 1'b1 ;
    139.         else 
    140.             data_w <= data_w ;
    141.     end
    142.     // [15:0]   cnt_write_byte
    143.     always @(posedge iic_clk or negedge sys_rst_n) begin
    144.         if(~sys_rst_n) 
    145.             cnt_write_byte <= 16'd0 ;
    146.         else if(en_w && iic_end == 1 && cnt_write_byte == CNT_MAX_WRITE_BYTE - 1)
    147.             cnt_write_byte <= 16'd0 ;
    148.         else  if(en_w && iic_end == 1)
    149.             cnt_write_byte <= cnt_write_byte + 1'b1 ;
    150.         else 
    151.             cnt_write_byte <= cnt_write_byte ;
    152.     end
    153. /*****************************************************************************/
    154.     // 读相关控制信号产生
    155.     // en_r
    156.     always @(posedge iic_clk or negedge sys_rst_n) begin
    157.         if(~sys_rst_n)
    158.             en_r <= 1'b0 ;
    159.         else if(iic_end == 1 && cnt_read_byte == CNT_MAX_READ_BYTE - 1)
    160.             en_r <= 1'b0 ;
    161.         else if(valid_read)
    162.             en_r <= 1'b1 ;
    163.         else 
    164.             en_r <= en_r ;
    165.     end
    166.     // [15:0]  cnt_read_byte 
    167.     always @(posedge iic_clk or negedge sys_rst_n) begin
    168.         if(~sys_rst_n) 
    169.             cnt_read_byte <= 16'd0 ;
    170.         else if(en_r && iic_end == 1 && cnt_read_byte == CNT_MAX_READ_BYTE - 1)
    171.             cnt_read_byte <= 16'd0 ;
    172.         else  if(en_r && iic_end == 1)
    173.             cnt_read_byte <= cnt_read_byte + 1'b1 ;
    174.         else 
    175.             cnt_read_byte <= cnt_read_byte ;
    176.     end
    177. /*******************************************************************************/
    178.     reg             valid_fifo_read ;
    179.     reg     [19:0]  cnt_1s          ;
    180.     reg             fifo_rd_en      ;
    181.     // valid_fifo_read
    182.     always @(posedge iic_clk or negedge sys_rst_n) begin
    183.         if(~sys_rst_n)
    184.             valid_fifo_read <= 1'b0 ;
    185.         else if(valid_fifo_read == 1 && usedw == 0)
    186.             valid_fifo_read <= 1'b0 ;
    187.         else if(usedw > (CNT_MAX_READ_BYTE - 1))
    188.             valid_fifo_read <= 1'b1 ;
    189.         else 
    190.             valid_fifo_read <= valid_fifo_read ;
    191.     end
    192.     // [19:0]  cnt_1s    
    193.     always @(posedge iic_clk or negedge sys_rst_n) begin
    194.         if(~sys_rst_n)
    195.             cnt_1s <= 20'd0 ;
    196.         else if(valid_fifo_read == 1 && cnt_1s == CNT_MAX_1S - 1)
    197.             cnt_1s <= 20'd0 ;
    198.         else if(valid_fifo_read == 1)
    199.             cnt_1s <= cnt_1s + 1'b1 ;
    200.         else 
    201.             cnt_1s <= 20'd0 ;
    202.     end
    203.     // fifo_rd_en
    204.     always @(posedge iic_clk or negedge sys_rst_n) begin
    205.         if(~sys_rst_n)
    206.             fifo_rd_en <= 1'b0 ;
    207.         else if(valid_fifo_read == 1 && cnt_1s == CNT_MAX_1S - 1)
    208.             fifo_rd_en <= 1'b1 ;
    209.         else 
    210.             fifo_rd_en <= 1'b0 ;
    211.     end
    212.  
    213. fifo_8x1024 fifo_8x1024_inst(
    214. 	.clock       ( iic_clk          ) ,
    215. 	.data        ( data_r           ) ,
    216. 	.rdreq       ( fifo_rd_en       ) ,
    217. 	.wrreq       ( en_r && iic_end  ) ,
    218. 	.empty       ( empty            ) ,
    219. 	.full        ( full             ) ,
    220. 	.q           ( data_out         ) ,
    221. 	.usedw       ( usedw            )  
    222. );
    223. endmodule

     

    1. module top (
    2.     input       wire        sys_clk     ,
    3.     input       wire        sys_rst_n   ,
    4.     input       wire        key_write   ,
    5.     input       wire        key_read    ,
    6.  
    7.     inout       wire        sda         ,
    8.     output      wire        scl         ,
    9.     output      wire        ds          ,
    10.     output      wire        oe          ,
    11.     output      wire        shcp        ,
    12.     output      wire        stcp        
    13. );
    14.     // 例化间连线
    15.     wire            clk_50mHz   ;
    16.     wire            clk_1mHz    ; 
    17.     wire            locked      ;  
    18.     wire            rst_n       ;
    19.     wire            flag_write  ;
    20.     wire            flag_read   ;
    21.     wire    [05:00] point       ;
    22.     wire            sign        ;
    23.     assign          point  = 5'd0 ;
    24.     assign          sign   = 1'b0 ;
    25.     assign          rst_n = sys_rst_n && locked ;
    26.  
    27. pll pll_isnt(
    28. 	.areset                 ( ~sys_rst_n ) ,
    29. 	.inclk0                 ( sys_clk    ) ,
    30. 	.c0                     ( clk_50mHz  ) ,
    31. 	.c1                     ( clk_1mHz   ) ,
    32. 	.locked                 ( locked     ) 
    33. );
    34.  
    35. key_filter key_filter_inst_w(
    36.     .sys_clk                ( clk_50mHz ) ,
    37.     .sys_rst_n              ( rst_n     ) ,
    38.     .key_in                 ( key_write ) ,
    39.  
    40.     .key_out                ( flag_write)         
    41. );   
    42. key_filter key_filter_inst_r(
    43.     .sys_clk                ( clk_50mHz ) ,
    44.     .sys_rst_n              ( rst_n     ) ,
    45.     .key_in                 ( key_read  ) ,
    46.  
    47.     .key_out                ( flag_read )         
    48. ); 
    49.  
    50.     wire            iic_start ;
    51.     wire            en_w      ;
    52.     wire            en_r      ;
    53.     wire    [15:0]  byte_addr ;
    54.     wire    [7:0]   data_w    ;
    55.     wire            addr_num  ;
    56.     wire    [7:0]   data_out  ;
    57.     wire            iic_end   ;
    58.     wire    [7:0]   data_r    ;
    59. iic_instruct iic_instruct_inst(
    60.     .sys_clk                ( clk_50mHz  ) , // 20ns
    61.     .sys_rst_n              ( rst_n      ) ,
    62.     .iic_clk                ( clk_1mHz   ) , // 1000ns
    63.     .flag_w                 ( flag_write ) ,
    64.     .flag_r                 ( flag_read  ) ,
    65.     .iic_end                ( iic_end    ) ,
    66.     .data_r                 ( data_r     ) , // iic 模块读到的1byte数据。
    67.  
    68.     .iic_start              ( iic_start  ) ,
    69.     .en_w                   ( en_w       ) , // 写使能，往eeprom中写数据的使能信号。
    70.     .en_r                   ( en_r       ) , // 读使能，从eeprom中读数据的使能信号。
    71.     .byte_addr              ( byte_addr  ) , // 读写操作的数据地址。
    72.     .data_w                 ( data_w     ) , // 往eeprom中写入的数据。
    73.     .addr_num               ( addr_num   ) , // eeprom的存储地址是几个byte。
    74.     .data_out               ( data_out   )   // 传给数码管显示的数据。
    75. );
    76.  
    77. iic iic_inst(
    78.     .sys_clk                ( clk_1mHz   ) , // 虽然写的是sys_clk但是例化时要接iic_clk
    79.     .sys_rst_n              ( rst_n      ) ,
    80.     .iic_start              ( iic_start  ) ,
    81.     .en_w                   ( en_w       ) ,
    82.     .en_r                   ( en_r       ) ,
    83.     .byte_addr              ( byte_addr  ) ,
    84.     .data_w                 ( data_w     ) ,
    85.     .addr_num               ( addr_num   ) ,
    86.  
    87.     .sda                    ( sda        ) ,
    88.  
    89.     .scl                    ( scl        ) ,
    90.     .data_out               ( data_r     ) ,
    91.     .iic_end                ( iic_end    )     
    92. );
    93.  
    94. seg_595_dynamic seg_595_dynamic_isnt(
    95.     .sys_clk                ( clk_50mHz ) ,
    96.     .sys_rst_n              ( rst_n     ) ,
    97.     .data                   ( {12'd0,data_out} ) , 
    98.     .point                  ( point     ) ,
    99.     .sign                   ( sign      ) ,
    100.     .seg_en                 ( rst_n     ) ,
    102.     .ds                     ( ds        ) ,      
    103.     .oe                     ( oe        ) ,      
    104.     .shcp                   ( shcp      ) ,      
    105.     .stcp                   ( stcp      )           
    106. );
    108. endmodule

    仿真测试，要用到 M24C64仿真模型。

    仿真验证通过，上板验证通过。

  • 相关阅读:
    【网络知识必知必会】再谈Cookie和Session
    java毕业设计点播影院运营系统mybatis+源码+调试部署+系统+数据库+lw
    Spring 最常用的几个注解
    在T3开发板上实现SylixOS最小系统（五）——实现T3串口驱动开发
    RocketMQ简介与安装
    概念解析 | 揭秘视觉与语言交叉模型：CLIP和BLIP的介绍
    vulnhub靶机Os-hackNos-1
    【华为OD机试真题 python】贪吃蛇【2022 Q4 | 200分】
    【Unity3D】GUI控件
    最新AI智能聊天对话问答系统源码（详细图文搭建部署教程）+AI绘画系统，DALL-E3文生图， Whisper & TTS 语音识别，文档分析
  • 原文地址：https://blog.csdn.net/Meng_long2022/article/details/133933491