一、前置知识

1.1 EEPROM

EEPROM (Electrically Erasable Progammable Read Only Memory，E2PROM)即电可擦除可编程只读存储器，是一种常用的非易失性存储器，掉电数据不丢失。开发板上使用的是ATMEL生产的AT24C64芯片。AT24C64 存储容量为 64Kbit，内部分成 256 页，每页 32 字节， 共有 8192 个字节，且其读写操作都是以字节为基本单位。
AT24C64 采用两线串行接口的双向数据传输协议——I2C 协议实现读写操作。I2C 即 Inter-Integrated Circuit(集成电路总线），是由 Philips 半导体公司（现在的 NXP）在八十年代初设计出来的一种简单、双向、二线制总线标准。
对于 AT24C64 而言，其器件地址为 1010 加 3 位的可编程地址，3 位可编程地址由器件上的 3 个管脚A2、 A1、A0的硬件连接决定。当硬件电路上分别将这三个管脚连接到 GND 或 VCC 时，就可以设置不同的可编程地址。

1.2 IIC

1.2.1 IIC概述

I2C 总线由数据线 SDA 和时钟线 SCL 构成通信线路，既可用于发送数据，也可接收数据。在主控与被控 IC 之间可进行双向数据传送，数据的传输速率在标准模式下可达100kbit/s，在快速模式下可达 400kbit/s，在高速模式下可达 3.4Mbit/s，各种被控器件均并联在总线上，通过器件地址（SLAVE ADDR）识别。
下图是开发板上使用IIC总线设备的物理拓扑结构：
image.png
由于 I2C 器件一般采用开漏结构与总线相连，所以 I2C_SCL 和 I2C_SDA 均需接上拉电阻。

1.2.2 IIC时序

  1. 空闲状态：在IIC开始通信传输数据之前，时钟线SCL和数据线SDA由于上拉电阻，均处于拉高状态，此时I2C总线空闲。
  2. 起始信号：若主机想要传输数据，需要在SCL为高电平时，将SDA数据线拉低，产生一个起始信号。
  3. 数据传输：主机检测到起始信号后，开始传输数据。
  4. 停止信号：数据传输完成后，主机需要产生一个停止信号。停止信号是在SCL为高电平时，SDA由低电平跳变到高电平。

image.png
具体传输时序图：
image.png

  1. 主机产生起始信号后，在第1个周期开始传输数据。
  2. SCL为高电平时，SDA状态保持以便采样数据；SCL为低电平时允许SDA电平改变。
  3. 在第8个周期结束后，主机释放SDA以使从机产生应答信号。
  4. 在第9个周期，SCL高电平时，如果SDA被从机拉低，说明从机产生应答，本次通信有效；如果SDA没有被从机拉低，说明从机未产生应答，本次通信无效。
  5. 若从机产生有效应答信号，从机会在第9个周期末释放SDA，以使主机继续传输数据。
  6. 如果主机发送停止信号，则通信过程停止；若主机发送起始信号，则继续进行下一轮通信。
  7. 数据以8bit即1字节为单位进行传输，最先传输的为数据最高位。

    1.2.3 传输过程

    1. 器件地址
    在进行数据传输时，主机首先向总线上发出开始信号，对应开始位 S，然后按照从高到低的位序发送器件地址，一般为 7bit，第 8bit 位为读写控制位 R/W，该位为 0 时表示主机对从机进行写操作，当该位为 1 时表示主机对从机进行读操作，然后接收从机响应。
    image.png
    发送完第一个字节（7位器件地址和1位读写控制位）并收到从机正确的应答后就开始发送字地址（Word Address）。
    2. 字地址
    字地址就是IC内部寄存器的地址，由于IC存储容量的大小不同，字地址的长度也不同。比如AT24C02的存储容量是2Kbit即256Byte，寻址是以字节为单位的，所以256字节需要8位寻址的字地址就够了，即字地址为8位（1个字节）；但是AT24C64存储容量为64Kb即8KB，需要13位地址来做寻址，即字地址为13位（至少2个字节）。因此就有了单字节字地址和双字节字地址。
    单字节字地址：
    image.png
    双字节字地址：
    image.pngimage.png
    3. 写数据
    主机发送字地址，从机正确应答后，就可以根据器件地址的读写位R/W进行数据读写操作了。如果是写操作R/W=0，主机就发送写的数据。写数据分为单次写和连续写。
  • 单次写是指在主机写完1字节数据后，主机发送停止信号，结束输出传输。
  • 连续写是指在主机写完1字节数据后，主机继续发送下1个字节的数据，多次以1字节为单位发送，最后再发一个停止信号结束。

单次写数据：
image.png
连续写数据：
image.png

4. 读数据

主机发送字地址，从机正确应答后，就可以根据器件地址的读写位R/W进行数据读写操作了。如果是读操作R/W=1，从机就开始发送数据，主机读从机的数据。读数据分为当前地址读、随机读、连续读。

  • 当前地址读是指在一次读写操作后进行一次读操作。由于I2C在读写操作后其内部地址指针自动加一，所以当前地址读到的数据是下一个地址的数据，即若上次读写的地址是02，则当前读所读的地址是03地址。

image.png

  • 随机读是指首先主机在发送器件地址时，使用写操作，接着在发送完字地址之后再第二次发送起始信号，器件地址使用读操作，然后接着进行一次读数据。这样做是为了在第一次写操作之后，让I2C指针指向器件内部我们所需要的地址，然后在该地址进行数据读取。上面第一次的写操作成为需写操作（Dummy Write）。

无标题.png

  • 连续读是指连续读几个字节的数据。对于当前地址读和随机读，都是只读1字节数据，在读完1字节数据后，主机发送不应答信号1，主机从送停止信号结束通信。对于连续读，在每次读完1字节数据后，主机发送应答信号0，主机继续读，直到主机发送不应答的1，主机发送停止信号结束通信。

无标题.png

5. 起始和停止信号
  • 起始信号：SCL高电平时，SDA由高拉低

  • 停止信号：SCL高电平时，SDA由低拉高

    二、硬件设计

    开发板上使用的AT24C64引脚及功能描述如下：
    image.png

  • A0、A1、A2：器件地址选择位

  • GND、VCC：接地，电源
  • SDA、SCL：I2C数据线和地址线
  • WP：写保护，高电平有效。高电平时只能读数据不能写入，低电平时可写入数据。

AT24C64原理图如下：
image.png
开发板上只有一个AT24C64，其A0A1A2都接地，所以器件地址为：1010_000=0x50
管脚分配如下：
image.png
image.png

  1. inout  sda;
  2. assign sda = sda_dir ? sda_out : 1'bz;
  3. assign sda_in = sda;

三、代码编写

image.png
image.png

3.1 各模块接口

3.1.1 I2C驱动模块

image.png

  • clk：系统时钟
  • rst_n：系统复位
  • i2c_exec：I2C触发执行信号，高电平开始执行I2C读写操作。
  • bit_ctr：字地址位控制(16b/8b)，1为16bit字地址；0为8bit字地址
  • i2c_rh_wl：I2C读写控制信号，1读0写
  • i2c_addr：I2C器件内地址
  • i2c_data_w：I2C要写的数据
  • i2c_data_r：I2C读出的数据
  • i2c_done：I2C一次操作完成，高电平写入完成
  • i2c_ack：I2C应答标志 0:应答 1:未应答
  • scl：I2C的SCL时钟信号
  • sda：I2C的SDA信号

  • dri_clk：输出驱动I2C操作的驱动时钟

    3.1.2 读写测试模块

    image.png

  • clk：由I2C驱动模块产生的时钟信号

  • rst_n：系统复位信号
  • i2c_ack：I2C应答标志
  • i2c_done：I2C一次操作完成标志
  • i2c_exec：I2C触发执行信号
  • i2c_rh_wl：I2C读写控制信号
  • i2c_data_r[7:0]：I2C读出的数据
  • i2c_data_w[7:0]：I2C要写的数据
  • i2c_addr[15:0]：I2C器件内的地址
  • rw_done：E2PROM读写测试完成标志

  • rw_result：E2PROM读写测试结果

    3.1.3 LED灯模块

    image.png

  • clk：时钟信号（I2C驱动时钟）

  • rst_n：复位信号
  • rw_done：E2PROM读写测试完成
  • rw_result：E2PROM读写测试结果

  • led：控制LED状态

    3.2 模块代码编写

    3.2.1 读写测试模块

    I2C驱动代码较复杂，假设I2C驱动代码已经编写完成，先来编写I2C读写测试模块。示例代码使用了四状态的状态机来实现功能。状态0和1用来向E2PROM写入数据；状态2和3用来读取E2PROM的数据并验证数据正确性。

  • 状态0：写数据和判断所有写数据完成

  • 状态1：等待本次写数据完成，改变下一轮写数据和写地址
  • 状态2：执行读数据并条状到状态3

  • 状态3：等待本次读数据完成，验证数据正确性，向用户接口输出验证结果 ```verilog module eeprom_rw( input clk , // I2C驱动提供的时钟信号 input rst_n , // 系统复位

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

    output reg rw_done , // E2PROM读写测试完成标志 output reg rw_result // E2PROM读写测试结果 );

parameter MAX_ADDR = 9’d256; // 测试地址0~255 parameter WRITE_WAIT_TIME = 13’d5000; // I2C模块输出频率4us，

reg [ 1:0] flow_cnt; // 状态流切换控制 reg [12:0] wait_cnt; // 写等待倒计时

always @(posedge clk or negedge rst_n) begin if(!rst_n) begin i2c_exec <= 1’b0; i2c_rh_wl <= 1’b0; i2c_data_w <= 8’d0; i2c_addr <= 16’d0; rw_done <= 1’b0; rw_result <= 1’b0; flow_cnt <= 2’d0; wait_cnt <= 13’d0; end else begin i2c_exec <= 1’b0; case(flow_cnt) 2’d0: begin // 写数据 wait_cnt <= wait_cnt + 1’b1; if(wait_cnt == WRITE_WAIT_TIME) begin wait_cnt <= 1’b0; if(i2c_addr == MAX_ADDR) begin flow_cnt <= 2’d2; // 跳转到读状态 i2c_addr <= 16’d0; i2c_rh_wl <= 1’b1; end else begin // 准备写入数据 i2c_exec <= 1’b1; flow_cnt <= 2’d1; end end end 2’d1: begin // 等待一轮写入数据完成,准备下一轮写入的数据 if(i2c_done) begin flow_cnt <= 2’d0; i2c_data_w <= i2c_data_w + 1’b1; i2c_addr <= i2c_addr + 1’b1; end end 2’d2: begin // 读数据 i2c_exec <= 1’b1; flow_cnt <= 2’d3; end 2’d3: begin // 等待读数据完成，验证数据正确性 if(i2c_done) begin if((i2c_data_r != i2c_addr[7:0]) || (i2c_ack == 1)) begin rw_done <= 1’b1; // 验证出错 rw_result <= 1’b0; end else if(i2c_addr == MAX_ADDR-1) begin // 全部验证完成 rw_done <= 1’b1; rw_result <= 1’b1; end else begin // 下一轮数据读取和验证 i2c_addr <= i2c_addr + 1’b1; flow_cnt <= 2’d2; end end end default :; endcase end end

endmodule

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/25873077/1651824690105-a5b433bf-39ec-45ae-80eb-70431d065869.png#clientId=ud4d9d2c3-1449-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=600&id=u2486bafe&margin=%5Bobject%20Object%5D&name=image.png&originHeight=600&originWidth=771&originalType=binary&ratio=1&rotation=0&showTitle=false&size=35572&status=done&style=none&taskId=u95e81df1-f5b5-4947-b8f7-d7bbfdcf385&title=&width=771)
  2. <a name="iKUSJ"></a>
  3. #### 3.2.2 LED灯控制模块
  4. 上述编写的读写测试模块，当全部0~255地址中的数据全部读取并验证无误后，读写测试结束，读写测试模块在状态3不断循环，由于i2c_done是脉冲信号，而rx_done被清零，所以rx_done会输出脉冲1，rx_result一直输出1。如果存在数据验证出错，则同样在状态3循环，rx_done会输出脉冲信号1而rx_result则一直输出0。
  5. ```verilog
  6. module led_alarm(
  7.     input           clk,
  8.     input           rst_n,
  10.     input           rx_done,
  11.     input           rx_result,
  13.     output  reg     led
  14. );
  16. parameter   BILNK_TIME = 25_000_000;
  18. reg         rx_done_flag;
  19. reg [24:0]  bilnk_cnt;
  21. always @(posedge clk or negedge rst_n) begin
  22.     if(!rst_n)
  23.         rx_done_flag <= 1'b0;
  24.     else if(rx_done)
  25.         rx_done_flag <= 1'b1;
  26. end
  28. always @(posedge clk or negedge rst_n) begin
  29.     if(!rst_n) begin
  30.         led <= 1'b0;
  31.         bilnk_cnt <= 25'd0;
  32.     end
  33.     else begin
  34.         if(rx_done_flag) begin
  35.             if(rx_result == 1'b0) begin // 验证失败
  36.                 bilnk_cnt <= bilnk_cnt + 1'b1;
  37.                 if(bilnk_cnt == BILNK_TIME - 1) begin
  38.                     led <= ~led;
  39.                     bilnk_cnt <= 25'd0;
  40.                 end
  41.             end
  42.             else
  43.                 led <= 1'b1;    // 验证成功
  44.         end
  45.         else    // 还未验证完成
  46.             led <= 1'b0;
  47.     end
  48. end
  50. endmodule

3.2.3 I2C驱动模块

正点原子教程使用8状态的状态机实现了I2C驱动模块，暂时先使用正点原子提供的模板，以后再自己写。。

  1. //****************************************Copyright (c)***********************************//
  2. //原子哥在线教学平台：www.yuanzige.com
  3. //技术支持：www.openedv.com
  4. //淘宝店铺：http://openedv.taobao.com
  5. //关注微信公众平台微信号："正点原子"，免费获取ZYNQ & FPGA & STM32 & LINUX资料。
  6. //版权所有，盗版必究。
  7. //Copyright(C) 正点原子 2018-2028
  8. //All rights reserved
  9. //----------------------------------------------------------------------------------------
  10. // File name:           i2c_dri
  11. // Last modified Date:  2019/05/04 9:19:08
  12. // Last Version:        V1.0
  13. // Descriptions:        IIC驱动
  14. //                      
  15. //----------------------------------------------------------------------------------------
  16. // Created by:          正点原子
  17. // Created date:        2019/05/04 9:19:08
  18. // Version:             V1.0
  19. // Descriptions:        The original version
  20. //
  21. //----------------------------------------------------------------------------------------
  22. //****************************************************************************************//
  24. module i2c_dri
  25.     #(
  26.       parameter   SLAVE_ADDR = 7'b1010000   ,  //EEPROM从机地址
  27.       parameter   CLK_FREQ   = 26'd50_000_000, //模块输入的时钟频率
  28.       parameter   I2C_FREQ   = 18'd250_000     //IIC_SCL的时钟频率
  29.     )
  30.    (                                                            
  31.     input                clk        ,    
  32.     input                rst_n      ,   
  34.     //i2c interface                      
  35.     input                i2c_exec   ,  //I2C触发执行信号
  36.     input                bit_ctrl   ,  //字地址位控制(16b/8b)
  37.     input                i2c_rh_wl  ,  //I2C读写控制信号
  38.     input        [15:0]  i2c_addr   ,  //I2C器件内地址
  39.     input        [ 7:0]  i2c_data_w ,  //I2C要写的数据
  40.     output  reg  [ 7:0]  i2c_data_r ,  //I2C读出的数据
  41.     output  reg          i2c_done   ,  //I2C一次操作完成
  42.     output  reg          i2c_ack    ,  //I2C应答标志 0:应答 1:未应答
  43.     output  reg          scl        ,  //I2C的SCL时钟信号
  44.     inout                sda        ,  //I2C的SDA信号
  46.     //user interface                   
  47.     output  reg          dri_clk       //驱动I2C操作的驱动时钟
  48.      );
  50. //localparam define
  51. localparam  st_idle     = 8'b0000_0001; //空闲状态
  52. localparam  st_sladdr   = 8'b0000_0010; //发送器件地址(slave address)
  53. localparam  st_addr16   = 8'b0000_0100; //发送16位字地址
  54. localparam  st_addr8    = 8'b0000_1000; //发送8位字地址
  55. localparam  st_data_wr  = 8'b0001_0000; //写数据(8 bit)
  56. localparam  st_addr_rd  = 8'b0010_0000; //发送器件地址读
  57. localparam  st_data_rd  = 8'b0100_0000; //读数据(8 bit)
  58. localparam  st_stop     = 8'b1000_0000; //结束I2C操作
  60. //reg define
  61. reg            sda_dir   ; //I2C数据(SDA)方向控制
  62. reg            sda_out   ; //SDA输出信号
  63. reg            st_done   ; //状态结束
  64. reg            wr_flag   ; //写标志
  65. reg    [ 6:0]  cnt       ; //计数
  66. reg    [ 7:0]  cur_state ; //状态机当前状态
  67. reg    [ 7:0]  next_state; //状态机下一状态
  68. reg    [15:0]  addr_t    ; //地址
  69. reg    [ 7:0]  data_r    ; //读取的数据
  70. reg    [ 7:0]  data_wr_t ; //I2C需写的数据的临时寄存
  71. reg    [ 9:0]  clk_cnt   ; //分频时钟计数
  73. //wire define
  74. wire          sda_in     ; //SDA输入信号
  75. wire   [8:0]  clk_divide ; //模块驱动时钟的分频系数
  77. //*****************************************************
  78. //**                    main code
  79. //*****************************************************
  81. //SDA控制
  82. assign  sda     = sda_dir ?  sda_out : 1'bz;     //SDA数据输出或高阻
  83. assign  sda_in  = sda ;                          //SDA数据输入
  84. assign  clk_divide = (CLK_FREQ/I2C_FREQ) >> 2'd2;//模块驱动时钟的分频系数
  86. //生成I2C的SCL的四倍频率的驱动时钟用于驱动i2c的操作
  87. always @(posedge clk or negedge rst_n) begin
  88.     if(!rst_n) begin
  89.         dri_clk <=  1'b0;
  90.         clk_cnt <= 10'd0;
  91.     end
  92.     else if(clk_cnt == clk_divide[8:1] - 1'd1) begin
  93.         clk_cnt <= 10'd0;
  94.         dri_clk <= ~dri_clk;
  95.     end
  96.     else
  97.         clk_cnt <= clk_cnt + 1'b1;
  98. end
  100. //(三段式状态机)同步时序描述状态转移
  101. always @(posedge dri_clk or negedge rst_n) begin
  102.     if(!rst_n)
  103.         cur_state <= st_idle;
  104.     else
  105.         cur_state <= next_state;
  106. end
  108. //组合逻辑判断状态转移条件
  109. always @(*) begin
  110.     next_state = st_idle;
  111.     case(cur_state)
  112.         st_idle: begin                          //空闲状态
  113.            if(i2c_exec) begin
  114.                next_state = st_sladdr;
  115.            end
  116.            else
  117.                next_state = st_idle;
  118.         end
  119.         st_sladdr: begin
  120.             if(st_done) begin
  121.                 if(bit_ctrl)                    //判断是16位还是8位字地址
  122.                    next_state = st_addr16;
  123.                 else
  124.                    next_state = st_addr8 ;
  125.             end
  126.             else
  127.                 next_state = st_sladdr;
  128.         end
  129.         st_addr16: begin                        //写16位字地址
  130.             if(st_done) begin
  131.                 next_state = st_addr8;
  132.             end
  133.             else begin
  134.                 next_state = st_addr16;
  135.             end
  136.         end
  137.         st_addr8: begin                         //8位字地址
  138.             if(st_done) begin
  139.                 if(wr_flag==1'b0)               //读写判断
  140.                     next_state = st_data_wr;
  141.                 else
  142.                     next_state = st_addr_rd;
  143.             end
  144.             else begin
  145.                 next_state = st_addr8;
  146.             end
  147.         end
  148.         st_data_wr: begin                       //写数据(8 bit)
  149.             if(st_done)
  150.                 next_state = st_stop;
  151.             else
  152.                 next_state = st_data_wr;
  153.         end
  154.         st_addr_rd: begin                       //写地址以进行读数据
  155.             if(st_done) begin
  156.                 next_state = st_data_rd;
  157.             end
  158.             else begin
  159.                 next_state = st_addr_rd;
  160.             end
  161.         end
  162.         st_data_rd: begin                       //读取数据(8 bit)
  163.             if(st_done)
  164.                 next_state = st_stop;
  165.             else
  166.                 next_state = st_data_rd;
  167.         end
  168.         st_stop: begin                          //结束I2C操作
  169.             if(st_done)
  170.                 next_state = st_idle;
  171.             else
  172.                 next_state = st_stop ;
  173.         end
  174.         default: next_state= st_idle;
  175.     endcase
  176. end
  178. //时序电路描述状态输出
  179. always @(posedge dri_clk or negedge rst_n) begin
  180.     //复位初始化
  181.     if(!rst_n) begin
  182.         scl       <= 1'b1;
  183.         sda_out   <= 1'b1;
  184.         sda_dir   <= 1'b1;                          
  185.         i2c_done  <= 1'b0;                          
  186.         i2c_ack   <= 1'b0;                          
  187.         cnt       <= 1'b0;                          
  188.         st_done   <= 1'b0;                          
  189.         data_r    <= 1'b0;                          
  190.         i2c_data_r<= 1'b0;                          
  191.         wr_flag   <= 1'b0;                          
  192.         addr_t    <= 1'b0;                          
  193.         data_wr_t <= 1'b0;                          
  194.     end                                              
  195.     else begin                                       
  196.         st_done <= 1'b0 ;                            
  197.         cnt     <= cnt +1'b1 ;                       
  198.         case(cur_state)                              
  199.              st_idle: begin                          //空闲状态
  200.                 scl     <= 1'b1;                     
  201.                 sda_out <= 1'b1;                     
  202.                 sda_dir <= 1'b1;                     
  203.                 i2c_done<= 1'b0;                     
  204.                 cnt     <= 7'b0;               
  205.                 if(i2c_exec) begin                   
  206.                     wr_flag   <= i2c_rh_wl ;         
  207.                     addr_t    <= i2c_addr  ;         
  208.                     data_wr_t <= i2c_data_w;  
  209.                     i2c_ack <= 1'b0;                      
  210.                 end                                  
  211.             end                                      
  212.             st_sladdr: begin                         //写地址(器件地址和字地址)
  213.                 case(cnt)                            
  214.                     7'd1 : sda_out <= 1'b0;          //开始I2C
  215.                     7'd3 : scl <= 1'b0;              
  216.                     7'd4 : sda_out <= SLAVE_ADDR[6]; //传送器件地址
  217.                     7'd5 : scl <= 1'b1;              
  218.                     7'd7 : scl <= 1'b0;              
  219.                     7'd8 : sda_out <= SLAVE_ADDR[5]; 
  220.                     7'd9 : scl <= 1'b1;              
  221.                     7'd11: scl <= 1'b0;              
  222.                     7'd12: sda_out <= SLAVE_ADDR[4]; 
  223.                     7'd13: scl <= 1'b1;              
  224.                     7'd15: scl <= 1'b0;              
  225.                     7'd16: sda_out <= SLAVE_ADDR[3]; 
  226.                     7'd17: scl <= 1'b1;              
  227.                     7'd19: scl <= 1'b0;              
  228.                     7'd20: sda_out <= SLAVE_ADDR[2]; 
  229.                     7'd21: scl <= 1'b1;              
  230.                     7'd23: scl <= 1'b0;              
  231.                     7'd24: sda_out <= SLAVE_ADDR[1]; 
  232.                     7'd25: scl <= 1'b1;              
  233.                     7'd27: scl <= 1'b0;              
  234.                     7'd28: sda_out <= SLAVE_ADDR[0]; 
  235.                     7'd29: scl <= 1'b1;              
  236.                     7'd31: scl <= 1'b0;              
  237.                     7'd32: sda_out <= 1'b0;          //0:写
  238.                     7'd33: scl <= 1'b1;              
  239.                     7'd35: scl <= 1'b0;              
  240.                     7'd36: begin                     
  241.                         sda_dir <= 1'b0;             
  242.                         sda_out <= 1'b1;                         
  243.                     end                              
  244.                     7'd37: scl     <= 1'b1;            
  245.                     7'd38: begin                     //从机应答 
  246.                         st_done <= 1'b1;
  247.                         if(sda_in == 1'b1)           //高电平表示未应答
  248.                             i2c_ack <= 1'b1;         //拉高应答标志位     
  249.                     end                                          
  250.                     7'd39: begin                     
  251.                         scl <= 1'b0;                 
  252.                         cnt <= 1'b0;                 
  253.                     end                              
  254.                     default :  ;                     
  255.                 endcase                              
  256.             end                                      
  257.             st_addr16: begin                         
  258.                 case(cnt)                            
  259.                     7'd0 : begin                     
  260.                         sda_dir <= 1'b1 ;            
  261.                         sda_out <= addr_t[15];       //传送字地址
  262.                     end                              
  263.                     7'd1 : scl <= 1'b1;              
  264.                     7'd3 : scl <= 1'b0;              
  265.                     7'd4 : sda_out <= addr_t[14];    
  266.                     7'd5 : scl <= 1'b1;              
  267.                     7'd7 : scl <= 1'b0;              
  268.                     7'd8 : sda_out <= addr_t[13];    
  269.                     7'd9 : scl <= 1'b1;              
  270.                     7'd11: scl <= 1'b0;              
  271.                     7'd12: sda_out <= addr_t[12];    
  272.                     7'd13: scl <= 1'b1;              
  273.                     7'd15: scl <= 1'b0;              
  274.                     7'd16: sda_out <= addr_t[11];    
  275.                     7'd17: scl <= 1'b1;              
  276.                     7'd19: scl <= 1'b0;              
  277.                     7'd20: sda_out <= addr_t[10];    
  278.                     7'd21: scl <= 1'b1;              
  279.                     7'd23: scl <= 1'b0;              
  280.                     7'd24: sda_out <= addr_t[9];     
  281.                     7'd25: scl <= 1'b1;              
  282.                     7'd27: scl <= 1'b0;              
  283.                     7'd28: sda_out <= addr_t[8];     
  284.                     7'd29: scl <= 1'b1;              
  285.                     7'd31: scl <= 1'b0;              
  286.                     7'd32: begin                     
  287.                         sda_dir <= 1'b0;             
  288.                         sda_out <= 1'b1;   
  289.                     end                              
  290.                     7'd33: scl  <= 1'b1;             
  291.                     7'd34: begin                     //从机应答
  292.                         st_done <= 1'b1;     
  293.                         if(sda_in == 1'b1)           //高电平表示未应答
  294.                             i2c_ack <= 1'b1;         //拉高应答标志位    
  295.                     end        
  296.                     7'd35: begin                     
  297.                         scl <= 1'b0;                 
  298.                         cnt <= 1'b0;                 
  299.                     end                              
  300.                     default :  ;                     
  301.                 endcase                              
  302.             end                                      
  303.             st_addr8: begin                          
  304.                 case(cnt)                            
  305.                     7'd0: begin                      
  306.                        sda_dir <= 1'b1 ;             
  307.                        sda_out <= addr_t[7];         //字地址
  308.                     end                              
  309.                     7'd1 : scl <= 1'b1;              
  310.                     7'd3 : scl <= 1'b0;              
  311.                     7'd4 : sda_out <= addr_t[6];     
  312.                     7'd5 : scl <= 1'b1;              
  313.                     7'd7 : scl <= 1'b0;              
  314.                     7'd8 : sda_out <= addr_t[5];     
  315.                     7'd9 : scl <= 1'b1;              
  316.                     7'd11: scl <= 1'b0;              
  317.                     7'd12: sda_out <= addr_t[4];     
  318.                     7'd13: scl <= 1'b1;              
  319.                     7'd15: scl <= 1'b0;              
  320.                     7'd16: sda_out <= addr_t[3];     
  321.                     7'd17: scl <= 1'b1;              
  322.                     7'd19: scl <= 1'b0;              
  323.                     7'd20: sda_out <= addr_t[2];     
  324.                     7'd21: scl <= 1'b1;              
  325.                     7'd23: scl <= 1'b0;              
  326.                     7'd24: sda_out <= addr_t[1];     
  327.                     7'd25: scl <= 1'b1;              
  328.                     7'd27: scl <= 1'b0;              
  329.                     7'd28: sda_out <= addr_t[0];     
  330.                     7'd29: scl <= 1'b1;              
  331.                     7'd31: scl <= 1'b0;              
  332.                     7'd32: begin                     
  333.                         sda_dir <= 1'b0;         
  334.                         sda_out <= 1'b1;                    
  335.                     end                              
  336.                     7'd33: scl     <= 1'b1;          
  337.                     7'd34: begin                     //从机应答
  338.                         st_done <= 1'b1;     
  339.                         if(sda_in == 1'b1)           //高电平表示未应答
  340.                             i2c_ack <= 1'b1;         //拉高应答标志位    
  341.                     end   
  342.                     7'd35: begin                     
  343.                         scl <= 1'b0;                 
  344.                         cnt <= 1'b0;                 
  345.                     end                              
  346.                     default :  ;                     
  347.                 endcase                              
  348.             end                                      
  349.             st_data_wr: begin                        //写数据(8 bit)
  350.                 case(cnt)                            
  351.                     7'd0: begin                      
  352.                         sda_out <= data_wr_t[7];     //I2C写8位数据
  353.                         sda_dir <= 1'b1;             
  354.                     end                              
  355.                     7'd1 : scl <= 1'b1;              
  356.                     7'd3 : scl <= 1'b0;              
  357.                     7'd4 : sda_out <= data_wr_t[6];  
  358.                     7'd5 : scl <= 1'b1;              
  359.                     7'd7 : scl <= 1'b0;              
  360.                     7'd8 : sda_out <= data_wr_t[5];  
  361.                     7'd9 : scl <= 1'b1;              
  362.                     7'd11: scl <= 1'b0;              
  363.                     7'd12: sda_out <= data_wr_t[4];  
  364.                     7'd13: scl <= 1'b1;              
  365.                     7'd15: scl <= 1'b0;              
  366.                     7'd16: sda_out <= data_wr_t[3];  
  367.                     7'd17: scl <= 1'b1;              
  368.                     7'd19: scl <= 1'b0;              
  369.                     7'd20: sda_out <= data_wr_t[2];  
  370.                     7'd21: scl <= 1'b1;              
  371.                     7'd23: scl <= 1'b0;              
  372.                     7'd24: sda_out <= data_wr_t[1];  
  373.                     7'd25: scl <= 1'b1;              
  374.                     7'd27: scl <= 1'b0;              
  375.                     7'd28: sda_out <= data_wr_t[0];  
  376.                     7'd29: scl <= 1'b1;              
  377.                     7'd31: scl <= 1'b0;              
  378.                     7'd32: begin                     
  379.                         sda_dir <= 1'b0;           
  380.                         sda_out <= 1'b1;                              
  381.                     end                              
  382.                     7'd33: scl <= 1'b1;              
  383.                     7'd34: begin                     //从机应答
  384.                         st_done <= 1'b1;     
  385.                         if(sda_in == 1'b1)           //高电平表示未应答
  386.                             i2c_ack <= 1'b1;         //拉高应答标志位    
  387.                     end          
  388.                     7'd35: begin                     
  389.                         scl  <= 1'b0;                
  390.                         cnt  <= 1'b0;                
  391.                     end                              
  392.                     default  :  ;                    
  393.                 endcase                              
  394.             end                                      
  395.             st_addr_rd: begin                        //写地址以进行读数据
  396.                 case(cnt)                            
  397.                     7'd0 : begin                     
  398.                         sda_dir <= 1'b1;             
  399.                         sda_out <= 1'b1;             
  400.                     end                              
  401.                     7'd1 : scl <= 1'b1;              
  402.                     7'd2 : sda_out <= 1'b0;          //重新开始
  403.                     7'd3 : scl <= 1'b0;              
  404.                     7'd4 : sda_out <= SLAVE_ADDR[6]; //传送器件地址
  405.                     7'd5 : scl <= 1'b1;              
  406.                     7'd7 : scl <= 1'b0;              
  407.                     7'd8 : sda_out <= SLAVE_ADDR[5]; 
  408.                     7'd9 : scl <= 1'b1;              
  409.                     7'd11: scl <= 1'b0;              
  410.                     7'd12: sda_out <= SLAVE_ADDR[4]; 
  411.                     7'd13: scl <= 1'b1;              
  412.                     7'd15: scl <= 1'b0;              
  413.                     7'd16: sda_out <= SLAVE_ADDR[3]; 
  414.                     7'd17: scl <= 1'b1;              
  415.                     7'd19: scl <= 1'b0;              
  416.                     7'd20: sda_out <= SLAVE_ADDR[2]; 
  417.                     7'd21: scl <= 1'b1;              
  418.                     7'd23: scl <= 1'b0;              
  419.                     7'd24: sda_out <= SLAVE_ADDR[1]; 
  420.                     7'd25: scl <= 1'b1;              
  421.                     7'd27: scl <= 1'b0;              
  422.                     7'd28: sda_out <= SLAVE_ADDR[0]; 
  423.                     7'd29: scl <= 1'b1;              
  424.                     7'd31: scl <= 1'b0;              
  425.                     7'd32: sda_out <= 1'b1;          //1:读
  426.                     7'd33: scl <= 1'b1;              
  427.                     7'd35: scl <= 1'b0;              
  428.                     7'd36: begin                     
  429.                         sda_dir <= 1'b0;            
  430.                         sda_out <= 1'b1;                    
  431.                     end
  432.                     7'd37: scl     <= 1'b1;
  433.                     7'd38: begin                     //从机应答
  434.                         st_done <= 1'b1;     
  435.                         if(sda_in == 1'b1)           //高电平表示未应答
  436.                             i2c_ack <= 1'b1;         //拉高应答标志位    
  437.                     end   
  438.                     7'd39: begin
  439.                         scl <= 1'b0;
  440.                         cnt <= 1'b0;
  441.                     end
  442.                     default : ;
  443.                 endcase
  444.             end
  445.             st_data_rd: begin                        //读取数据(8 bit)
  446.                 case(cnt)
  447.                     7'd0: sda_dir <= 1'b0;
  448.                     7'd1: begin
  449.                         data_r[7] <= sda_in;
  450.                         scl       <= 1'b1;
  451.                     end
  452.                     7'd3: scl  <= 1'b0;
  453.                     7'd5: begin
  454.                         data_r[6] <= sda_in ;
  455.                         scl       <= 1'b1   ;
  456.                     end
  457.                     7'd7: scl  <= 1'b0;
  458.                     7'd9: begin
  459.                         data_r[5] <= sda_in;
  460.                         scl       <= 1'b1  ;
  461.                     end
  462.                     7'd11: scl  <= 1'b0;
  463.                     7'd13: begin
  464.                         data_r[4] <= sda_in;
  465.                         scl       <= 1'b1  ;
  466.                     end
  467.                     7'd15: scl  <= 1'b0;
  468.                     7'd17: begin
  469.                         data_r[3] <= sda_in;
  470.                         scl       <= 1'b1  ;
  471.                     end
  472.                     7'd19: scl  <= 1'b0;
  473.                     7'd21: begin
  474.                         data_r[2] <= sda_in;
  475.                         scl       <= 1'b1  ;
  476.                     end
  477.                     7'd23: scl  <= 1'b0;
  478.                     7'd25: begin
  479.                         data_r[1] <= sda_in;
  480.                         scl       <= 1'b1  ;
  481.                     end
  482.                     7'd27: scl  <= 1'b0;
  483.                     7'd29: begin
  484.                         data_r[0] <= sda_in;
  485.                         scl       <= 1'b1  ;
  486.                     end
  487.                     7'd31: scl  <= 1'b0;
  488.                     7'd32: begin
  489.                         sda_dir <= 1'b1;             
  490.                         sda_out <= 1'b1;
  491.                     end
  492.                     7'd33: scl     <= 1'b1;
  493.                     7'd34: st_done <= 1'b1;          //非应答
  494.                     7'd35: begin
  495.                         scl <= 1'b0;
  496.                         cnt <= 1'b0;
  497.                         i2c_data_r <= data_r;
  498.                     end
  499.                     default  :  ;
  500.                 endcase
  501.             end
  502.             st_stop: begin                           //结束I2C操作
  503.                 case(cnt)
  504.                     7'd0: begin
  505.                         sda_dir <= 1'b1;             //结束I2C
  506.                         sda_out <= 1'b0;
  507.                     end
  508.                     7'd1 : scl     <= 1'b1;
  509.                     7'd3 : sda_out <= 1'b1;
  510.                     7'd15: st_done <= 1'b1;
  511.                     7'd16: begin
  512.                         cnt      <= 1'b0;
  513.                         i2c_done <= 1'b1;            //向上层模块传递I2C结束信号
  514.                     end
  515.                     default  : ;
  516.                 endcase
  517.             end
  518.         endcase
  519.     end
  520. end
  522. endmodule

3.2.4 顶层模块

顶层模块将读写测试模块、I2C驱动模块和LED控制模块连接起来即可。

  1. module iic_eeprom(
  2.     input           sys_clk,
  3.     input           sys_rst_n,
  4.     // IIC interface
  5.     output          iic_scl,
  6.     output          iic_sda,
  7.     // User interface
  8.     output          led
  9. );
  11. parameter   BIT_CTRL    = 1'b1;             // 字地址位控制参数
  12. parameter   SLAVE_ADDR  = 7'b1010000;       // EEPROM从机地址
  13. parameter   CLK_FREQ    = 26'd50_000_000;   // 模块输入的时钟频率
  14. parameter   I2C_FREQ    = 18'd250_000;      // IIC_SCL的时钟频率
  15. parameter   BILNK_TIME  = 17'd125_000;      // LED闪烁时间参数
  17. wire        i2c_exec   ;
  18. wire        i2c_rh_wl  ;
  19. wire [15:0] i2c_addr   ;
  20. wire [ 7:0] i2c_data_w ;
  21. wire [ 7:0] i2c_data_r ;
  22. wire        i2c_done   ;
  23. wire        i2c_ack    ;
  24. wire        dri_clk    ;
  25. wire        rw_done    ;
  26. wire        rw_result  ;
  28. i2c_dri #(
  29.     .SLAVE_ADDR     (SLAVE_ADDR),
  30.     .CLK_FREQ       (CLK_FREQ  ),
  31.     .I2C_FREQ       (I2C_FREQ  )
  32. ) u_i2c_dri(
  33.     .clk            (sys_clk   ),
  34.     .rst_n          (sys_rst_n ),
  35.     .i2c_exec       (i2c_exec  ),
  36.     .bit_ctrl       (BIT_CTRL  ),
  37.     .i2c_rh_wl      (i2c_rh_wl ),
  38.     .i2c_addr       (i2c_addr  ),
  39.     .i2c_data_w     (i2c_data_w),
  40.     .i2c_data_r     (i2c_data_r),
  41.     .i2c_done       (i2c_done  ),
  42.     .i2c_ack        (i2c_ack   ),
  43.     .scl            (iic_scl   ),
  44.     .sda            (iic_sda   ),
  45.     .dri_clk        (dri_clk   )
  46. );
  48. eeprom_rw u_eeprom_rw(
  49.     .clk            (dri_clk   ),
  50.     .rst_n          (sys_rst_n ),
  51.     .i2c_ack        (i2c_ack   ),
  52.     .i2c_done       (i2c_done  ),
  53.     .i2c_exec       (i2c_exec  ),
  54.     .i2c_rh_wl      (i2c_rh_wl ),
  55.     .i2c_data_r     (i2c_data_r),
  56.     .i2c_data_w     (i2c_data_w),
  57.     .i2c_addr       (i2c_addr  ),
  58.     .rw_done        (rw_done   ),
  59.     .rw_result      (rw_result )
  60. );
  62. led_alarm #(
  63.     .BILNK_TIME     (BILNK_TIME)
  64. )u_led_alarm(
  65.     .clk            (dri_clk   ),
  66.     .rst_n          (sys_rst_n ),
  67.     .rx_done        (rw_done   ),
  68.     .rx_result      (rw_result ),
  69.     .led            (led       )
  70. );
  72. endmodule

3.2.5 TCL脚本

只需定义顶层模块中CLK、RST_N、SCL、SDA和LED的引脚即可。

  2. package require ::quartus::project
  4. #system clock:50Mhz
  5. set_location_assignment PIN_M2 -to sys_clk
  7. #system reset
  8. set_location_assignment PIN_M1 -to sys_rst_n
  10. #led
  11. set_location_assignment PIN_D11 -to led
  13. #I2C(EEPROM/ALS&PS/RTC/AUDIO)
  14. set_location_assignment PIN_D8 -to iic_scl
  15. set_location_assignment PIN_C8 -to iic_sda

程序烧录

12_iic_eeprom_error.mp4 (5.93MB)结果出现错误，数据验证出错，LED闪烁。
另外由于其余三个LED没有约束，一直为亮的状态。在Assignments→Device→Device and Pin Options→unused pin页面，把未使用的引脚设置为As input tri-stated。重新编译之后再烧录就好了。
image.png
数据验证失败的问题还在调试中。。。