• 基于 I2C 协议的 AD实验(附代码)

    前言：因篇幅过长本实验涉及的知识点在文章中。

    实验目标：使用板载 AD/DA 芯片 PCF8591 测量来自电位器输入的模拟电压信号并在PC端显示。

    最终实验效果如下：Serial Port Utility 软件截图

    1. 硬件资源

     PCF8591 实物图

    PCF8591 原理图

    2. 程序设计

    2.1 模块框图设计

     以上模块重点学习掌握I2C协议。 

    2.2 工程整体框图

    2.2.1 I2C控制模块

    1. 模块框图

         功能按照 I2C 协议对PCF8591芯片执行数据读写操作。

    输入输出信号功能简介： 

          由表和下面的状态机可知输入由8路，首先读/写使能信号且I2C开始信号有效时,该模块开始工作，其他时刻SDA和SCL均为休闲状态。然后生成PCF8591芯片的工作时钟，方便对其进行读写操作。先进行控制命令的写入当最高位为0时，实现主机对从设备的写数据操作。当从设备接收到完该数据后回传一个应答信号。然后进行主机对从机存储命令的写入，依据存储地址字节标志信号对从设备进行单/双字节存储地址的写入(高位在前)，当从设备接收到完该地址后回传一个应答信号。最后单/多字节数据写入，完成后主机接收到从机的应答信号后，向从机发送停止信号，数据
    写入完成。
         当执行读数据操作时，与写数据不同的是没有存储地址的写入操作以及最后的不响应信号。若想要实现数据的连续读/写，可持续拉高读/写使能 rd_en/wr_en，并输入有效的单字节数据读/写开始信号 i2c_start 即可。

    状态机示意图： 

    2. 波形图分析

    写数据：

     第一部分：从机设备时钟

       为了满足PCF8591芯片的模数转换速率，iic工作时钟使用250Khz。已知板载时钟是50Mhz，为什么不直接设计一个模200的计数器得到250Khz时钟？为了生成1byte数据(存储地址、控制命令、读写数据)更方便。

     读数据：

     3. RTL代码设计
    1. `timescale  1ns/1ns
    2.  
    3. module  i2c_ctrl
    4. #(
    5.     parameter   DEVICE_ADDR     =   7'b1010_000     ,   //i2c设备地址
    6.     parameter   SYS_CLK_FREQ    =   26'd50_000_000  ,   //输入系统时钟频率     50MHZ
    7.     parameter   SCL_FREQ        =   18'd250_000         //i2c设备scl时钟频率   250khz
    8. )
    9. (
    10.     input   wire            sys_clk     ,   //输入系统时钟,50MHz
    11.     input   wire            sys_rst_n   ,   //输入复位信号,低电平有效
    12.     input   wire            wr_en       ,   //输入写使能信号
    13.     input   wire            rd_en       ,   //输入读使能信号
    14.     input   wire            i2c_start   ,   //输入i2c触发信号
    15.     input   wire            addr_num    ,   //输入i2c字节地址字节数
    16.     input   wire    [15:0]  byte_addr   ,   //输入i2c字节地址
    17.     input   wire    [7:0]   wr_data     ,   //输入i2c设备数据
    18.  
    19.     output  reg             i2c_clk     ,   //i2c驱动时钟
    20.     output  reg             i2c_end     ,   //i2c一次读/写操作完成
    21.     output  reg     [7:0]   rd_data     ,   //输出i2c设备读取数据
    22.     output  reg             i2c_scl     ,   //输出至i2c设备的串行时钟信号scl
    23.     inout   wire            i2c_sda         //输出至i2c设备的串行数据信号sda
    24. );
    25.  
    26. // parameter define
    27. localparam  CNT_CLK_MAX     =   (SYS_CLK_FREQ/SCL_FREQ) >> 2'd3   ;   //cnt_clk计数器计数最大值  (SYS_CLK_FREQ/SCL_FREQ) = 200,  25 = 200/(2^3)
    28.  
    29. localparam  CNT_START_MAX   =   8'd100; //cnt_start计数器计数最大值
    30.  
    31. localparam  IDLE            =   4'd00,  //初始状态
    32.             START_1         =   4'd01,  //开始状态1
    33.             SEND_D_ADDR     =   4'd02,  //设备地址写入状态 + 控制写
    34.             ACK_1           =   4'd03,  //应答状态1
    35.             SEND_B_ADDR_H   =   4'd04,  //字节地址高八位写入状态
    36.             ACK_2           =   4'd05,  //应答状态2
    37.             SEND_B_ADDR_L   =   4'd06,  //字节地址低八位写入状态
    38.             ACK_3           =   4'd07,  //应答状态3
    39.             WR_DATA         =   4'd08,  //写数据状态
    40.             ACK_4           =   4'd09,  //应答状态4
    41.             START_2         =   4'd10,  //开始状态2
    42.             SEND_RD_ADDR    =   4'd11,  //设备地址写入状态 + 控制读
    43.             ACK_5           =   4'd12,  //应答状态5
    44.             RD_DATA         =   4'd13,  //读数据状态
    45.             N_ACK           =   4'd14,  //非应答状态
    46.             STOP            =   4'd15;  //结束状态
    47.  
    48. // wire  define
    49. wire            sda_in          ;   //sda输入数据寄存
    50. wire            sda_en          ;   //sda数据写入使能信号
    51.  
    52. // reg   define
    53. reg     [7:0]   cnt_clk         ;   //系统时钟计数器,控制生成clk_i2c时钟信号
    54. reg     [3:0]   state           ;   //状态机状态
    55. reg             cnt_i2c_clk_en  ;   //cnt_i2c_clk计数器使能信号
    56. reg     [1:0]   cnt_i2c_clk     ;   //clk_i2c时钟计数器,控制生成cnt_bit信号
    57. reg     [2:0]   cnt_bit         ;   //sda比特计数器
    58. reg             ack             ;   //应答信号
    59. reg             i2c_sda_reg     ;   //sda数据缓存
    60. reg     [7:0]   rd_data_reg     ;   //自i2c设备读出数据
    61.  
    62.  
    63. // cnt_clk:系统时钟计数器,控制生成clk_i2c时钟信号
    64. always@(posedge sys_clk or negedge sys_rst_n)
    65.     if(sys_rst_n == 1'b0)
    66.         cnt_clk <=  8'd0;
    67.     else    if(cnt_clk == CNT_CLK_MAX - 1'b1)  //0-24
    68.         cnt_clk <=  8'd0;
    69.     else
    70.         cnt_clk <=  cnt_clk + 1'b1;
    71. // i2c_clk:i2c驱动时钟
    72. always@(posedge sys_clk or negedge sys_rst_n)
    73.     if(sys_rst_n == 1'b0)
    74.         i2c_clk <=  1'b1;
    75.     else    if(cnt_clk == CNT_CLK_MAX - 1'b1)
    76.         i2c_clk <=  ~i2c_clk;
    77.  
    78. // cnt_i2c_clk_en:cnt_i2c_clk计数器使能信号
    79. always@(posedge i2c_clk or negedge sys_rst_n)
    80.     if(sys_rst_n == 1'b0)
    81.         cnt_i2c_clk_en  <=  1'b0;
    82.     else    if((state == STOP) && (cnt_bit == 3'd3) &&(cnt_i2c_clk == 3))
    83.         cnt_i2c_clk_en  <=  1'b0;
    84.     else    if(i2c_start == 1'b1)
    85.         cnt_i2c_clk_en  <=  1'b1;
    86.  
    87. // cnt_i2c_clk:i2c_clk时钟计数器,控制生成cnt_bit信号
    88. always@(posedge i2c_clk or negedge sys_rst_n)
    89.     if(sys_rst_n == 1'b0)
    90.         cnt_i2c_clk <=  2'd0;
    91. 	else  if(cnt_i2c_clk <= 2'd3 || cnt_i2c_clk_en == 1'b0 )
    92.         cnt_i2c_clk <=  2'd0;	
    93.     else    if(cnt_i2c_clk_en == 1'b1)
    94.         cnt_i2c_clk <=  cnt_i2c_clk + 1'b1;
    95. 	
    96.  
    97. // cnt_bit:sda比特计数器
    98. always@(posedge i2c_clk or negedge sys_rst_n)
    99.     if(sys_rst_n == 1'b0)
    100.         cnt_bit <=  3'd0;
    101.     else    if((state == IDLE) || (state == START_1) || (state == START_2)
    102.                 || (state == ACK_1) || (state == ACK_2) || (state == ACK_3)
    103.                 || (state == ACK_4) || (state == ACK_5) || (state == N_ACK))
    104.         cnt_bit <=  3'd0;
    105.     else    if((cnt_bit == 3'd7) && (cnt_i2c_clk == 2'd3))
    106.         cnt_bit <=  3'd0;
    107.     else    if((cnt_i2c_clk == 2'd3) && (state != IDLE))
    108.         cnt_bit <=  cnt_bit + 1'b1;
    109.  
    110. // state:状态机状态跳转
    111. always@(posedge i2c_clk or negedge sys_rst_n)
    112.     if(sys_rst_n == 1'b0)
    113.         state   <=  IDLE;
    114.     else    case(state)
    115.         IDLE:
    116.             if(i2c_start == 1'b1)
    117.                 state   <=  START_1;
    118.             else
    119.                 state   <=  state;
    120.         START_1:
    121.             if(cnt_i2c_clk == 3)
    122.                 state   <=  SEND_D_ADDR;
    123.             else
    124.                 state   <=  state;
    125.         SEND_D_ADDR:
    126.             if((cnt_bit == 3'd7) &&(cnt_i2c_clk == 3))
    127.                 state   <=  ACK_1;
    128.             else
    129.                 state   <=  state;
    130.         ACK_1:
    131.             if((cnt_i2c_clk == 3) && (ack == 1'b0))
    132.                 begin
    133.                     if(addr_num == 1'b1)
    134.                         state   <=  SEND_B_ADDR_H;
    135.                     else
    136.                         state   <=  SEND_B_ADDR_L;
    137.                 end
    138.              else
    139.                 state   <=  state;
    140.         SEND_B_ADDR_H:
    141.             if((cnt_bit == 3'd7) &&(cnt_i2c_clk == 3))
    142.                 state   <=  ACK_2;
    143.             else
    144.                 state   <=  state;
    145.         ACK_2:
    146.             if((cnt_i2c_clk == 3) && (ack == 1'b0))
    147.                 state   <=  SEND_B_ADDR_L;
    148.             else
    149.                 state   <=  state;
    150.         SEND_B_ADDR_L:
    151.             if((cnt_bit == 3'd7) && (cnt_i2c_clk == 3))
    152.                 state   <=  ACK_3;
    153.             else
    154.                 state   <=  state;
    155.         ACK_3:
    156.             if((cnt_i2c_clk == 3) && (ack == 1'b0))
    157.                 begin
    158.                     if(wr_en == 1'b1)
    159.                         state   <=  WR_DATA;
    160.                     else    if(rd_en == 1'b1)
    161.                         state   <=  START_2;
    162.                     else
    163.                         state   <=  state;
    164.                 end
    165.              else
    166.                 state   <=  state;
    167.         WR_DATA:
    168.             if((cnt_bit == 3'd7) &&(cnt_i2c_clk == 3))
    169.                 state   <=  ACK_4;
    170.             else
    171.                 state   <=  state;
    172.         ACK_4:
    173.             if((cnt_i2c_clk == 3) && (ack == 1'b0))
    174.                 state   <=  STOP;
    175.             else
    176.                 state   <=  state;
    177.         START_2:
    178.             if(cnt_i2c_clk == 3)
    179.                 state   <=  SEND_RD_ADDR;
    180.             else
    181.                 state   <=  state;
    182.         SEND_RD_ADDR:
    183.             if((cnt_bit == 3'd7) &&(cnt_i2c_clk == 3))
    184.                 state   <=  ACK_5;
    185.             else
    186.                 state   <=  state;
    187.         ACK_5:
    188.             if((cnt_i2c_clk == 3) && (ack == 1'b0))
    189.                 state   <=  RD_DATA;
    190.             else
    191.                 state   <=  state;
    192.         RD_DATA:
    193.             if((cnt_bit == 3'd7) &&(cnt_i2c_clk == 3))
    194.                 state   <=  N_ACK;
    195.             else
    196.                 state   <=  state;
    197.         N_ACK:
    198.             if(cnt_i2c_clk == 3)
    199.                 state   <=  STOP;
    200.             else
    201.                 state   <=  state;
    202.         STOP:
    203.             if((cnt_bit == 3'd3) &&(cnt_i2c_clk == 3))
    204.                 state   <=  IDLE;
    205.             else
    206.                 state   <=  state;
    207.         default:    state   <=  IDLE;
    208.     endcase
    209.  
    210. // ack:应答信号
    211. always@(*)
    212.     case    (state)
    213.         IDLE,START_1,SEND_D_ADDR,SEND_B_ADDR_H,SEND_B_ADDR_L,
    214.         WR_DATA,START_2,SEND_RD_ADDR,RD_DATA,N_ACK:
    215.             ack <=  1'b1;
    216.         ACK_1,ACK_2,ACK_3,ACK_4,ACK_5:
    217.             if(cnt_i2c_clk == 2'd0)
    218.                 ack <=  sda_in;
    219.             else
    220.                 ack <=  ack;
    221.         default:    ack <=  1'b1;
    222.     endcase
    223.  
    224. // i2c_scl:输出至i2c设备的串行时钟信号scl
    225. always@(*)
    226.     case    (state)
    227.         IDLE:
    228.             i2c_scl <=  1'b1;
    229.         START_1:
    230.             if(cnt_i2c_clk == 2'd3)
    231.                 i2c_scl <=  1'b0;
    232.             else
    233.                 i2c_scl <=  1'b1;
    234.         SEND_D_ADDR,ACK_1,SEND_B_ADDR_H,ACK_2,SEND_B_ADDR_L,
    235.         ACK_3,WR_DATA,ACK_4,START_2,SEND_RD_ADDR,ACK_5,RD_DATA,N_ACK:
    236.             if((cnt_i2c_clk == 2'd1) || (cnt_i2c_clk == 2'd2))
    237.                 i2c_scl <=  1'b1;
    238.             else
    239.                 i2c_scl <=  1'b0;
    240.         STOP:
    241.             if((cnt_bit == 3'd0) &&(cnt_i2c_clk == 2'd0))
    242.                 i2c_scl <=  1'b0;
    243.             else
    244.                 i2c_scl <=  1'b1;
    245.         default:    i2c_scl <=  1'b1;
    246.     endcase
    247.  
    248. // i2c_sda_reg:sda数据缓存
    249. always@(*)
    250.     case (state)
    251.         IDLE:
    252.             begin
    253.                 i2c_sda_reg <=  1'b1;
    254.                 rd_data_reg <=  8'd0;
    255.             end
    256.         START_1:
    257.             if(cnt_i2c_clk <= 2'd0)
    258.                 i2c_sda_reg <=  1'b;
    259.             else
    260.                 i2c_sda_reg <=  1'b0;
    261.         SEND_D_ADDR:
    262.             if(cnt_bit <= 3'd6)
    263.                 i2c_sda_reg <=  DEVICE_ADDR[6 - cnt_bit];
    264.             else
    265.                 i2c_sda_reg <=  1'b0;
    266.         ACK_1:
    267.             i2c_sda_reg <=  1'b1;
    268.         SEND_B_ADDR_H:
    269.             i2c_sda_reg <=  byte_addr[15 - cnt_bit];
    270.         ACK_2:
    271.             i2c_sda_reg <=  1'b1;
    272.         SEND_B_ADDR_L:
    273.             i2c_sda_reg <=  byte_addr[7 - cnt_bit];
    274.         ACK_3:
    275.             i2c_sda_reg <=  1'b1;
    276.         WR_DATA:
    277.             i2c_sda_reg <=  wr_data[7 - cnt_bit];
    278.         ACK_4:
    279.             i2c_sda_reg <=  1'b1;
    280.         START_2:
    281.             if(cnt_i2c_clk <= 2'd1)
    282.                 i2c_sda_reg <=  1'b1;
    283.             else
    284.                 i2c_sda_reg <=  1'b0;
    285.         SEND_RD_ADDR:
    286.             if(cnt_bit <= 3'd6)
    287.                 i2c_sda_reg <=  DEVICE_ADDR[6 - cnt_bit];
    288.             else
    289.                 i2c_sda_reg <=  1'b1;
    290.         ACK_5:
    291.             i2c_sda_reg <=  1'b1;
    292.         RD_DATA:
    293.             if(cnt_i2c_clk  == 2'd)
    294.                 rd_data_reg[7 - cnt_bit]    <=  sda_in;
    295.             else
    296.                 rd_data_reg <=  rd_data_reg;
    297.         N_ACK:
    298.             i2c_sda_reg <=  1'b1;
    299.         STOP:
    300.             if((cnt_bit == 3'd0) && (cnt_i2c_clk < 2'd3))
    301.                 i2c_sda_reg <=  1'b0;
    302.             else
    303.                 i2c_sda_reg <=  1'b1;
    304.         default:
    305.             begin
    306.                 i2c_sda_reg <=  1'b1;
    307.                 rd_data_reg <=  rd_data_reg;
    308.             end
    309.     endcase
    310.  
    311. // rd_data:自i2c设备读出数据
    312. always@(posedge i2c_clk or negedge sys_rst_n)
    313.     if(sys_rst_n == 1'b0)
    314.         rd_data <=  8'd0;
    315.     else    if((state == RD_DATA) && (cnt_bit == 3'd7) && (cnt_i2c_clk == 2'd3))
    316.         rd_data <=  rd_data_reg;
    317.  
    318. // i2c_end:一次读/写结束信号
    319. always@(posedge i2c_clk or negedge sys_rst_n)
    320.     if(sys_rst_n == 1'b0)
    321.         i2c_end <=  1'b0;
    322.     else    if((state == STOP) && (cnt_bit == 3'd3) &&(cnt_i2c_clk == 3))
    323.         i2c_end <=  1'b1;
    324.     else
    325.         i2c_end <=  1'b0;
    326.  
    327. // sda_in:sda输入数据寄存
    328. assign  sda_in = i2c_sda;
    329. // sda_en:sda数据写入使能信号
    330. assign  sda_en = ((state == RD_DATA) || (state == ACK_1) || (state == ACK_2)
    331.                     || (state == ACK_3) || (state == ACK_4) || (state == ACK_5))
    332.                     ? 1'b0 : 1'b1;
    333. // i2c_sda:输出至i2c设备的串行数据信号sda
    334. assign  i2c_sda = (sda_en == 1'b1) ? i2c_sda_reg : 1'bz;
    335.  
    336.  
    337. endmodule

    2.2.2 数据生成模块

    1. 模块框图

    2. 波形图分析 

    3. RTL代码编写
    1. `timescale  1ns/1ns
    2.  
    3. module  pcf8591_ad
    4. (
    5.     input   wire            sys_clk     ,  
    6.     input   wire            sys_rst_n   ,  
    7.     input   wire            i2c_end     ,   //i2c设备一次读/写操作完成
    8.     input   wire    [7:0]   rd_data     ,   //输出i2c设备读取数据
    10.     output  reg             rd_en       ,   //输入i2c设备读使能信号
    11.     output  reg             i2c_start   ,   //输入i2c设备触发信号
    12.     output  reg     [15:0]  byte_addr   ,   //输入i2c设备字节地址
    13.     output  wire    [7:0]   po_data     ,        
    14.     output  wire             po_flag         
    15. );
    16.  
    17. parameter   CTRL_DATA   =   8'b0100_0000;   //AD/DA控制字
    18. parameter   CNT_WAIT_MAX=   18'd6_9999  ;   //采样间隔计数最大值
    19. parameter   IDLE        =   3'b001,
    20.             AD_START    =   3'b010,
    21.             AD_CMD      =   3'b100;
    22.  
    23. //wire  define
    24. //wire    [31:0]  data_reg/* synthesis keep */;   //数码管待显示数据缓存
    25.  
    26. //reg   define
    27. reg     [17:0]  cnt_wait;   //采样间隔计数器
    28. reg     [4:0]   state   ;   //状态机状态变量
    29. reg     [7:0]   ad_data ;   //AD数据
    30.  
    31.  
    32. assign  po_flag = i2c_end ;
    33.  
    34. //cnt_wait:采样间隔计数器
    35. always@(posedge sys_clk or negedge sys_rst_n)
    36.     if(sys_rst_n == 1'b0)
    37.         cnt_wait    <=  18'd0;
    38.     else    if(state == IDLE)
    39.         if(cnt_wait == CNT_WAIT_MAX)
    40.             cnt_wait    <=  18'd0;
    41.         else
    42.             cnt_wait    <=  cnt_wait + 18'd1;
    43.     else
    44.         cnt_wait    <=  18'd0;
    45.  
    46. //state:状态机状态变量
    47. always@(posedge sys_clk or negedge sys_rst_n)
    48.     if(sys_rst_n == 1'b0)
    49.         state   <=  IDLE;
    50.     else
    51.         case(state)
    52.             IDLE:
    53.                 if(cnt_wait == CNT_WAIT_MAX)
    54.                     state   <=  AD_START;
    55.                 else
    56.                     state   <=  IDLE;
    57.             AD_START:
    58.                 state   <=  AD_CMD;
    59.             AD_CMD:
    60.                 if(i2c_end == 1'b1)
    61.                     state   <=  IDLE;
    62.                 else
    63.                     state   <=  AD_CMD;
    64.             default:state   <=  IDLE;
    65.         endcase
    66.  
    67. //i2c_start:输入i2c设备触发信号
    68. always@(posedge sys_clk or negedge sys_rst_n)
    69.     if(sys_rst_n == 1'b0)
    70.         i2c_start   <=  1'b0;
    71.     else    if(state == AD_START)
    72.         i2c_start   <=  1'b1;
    73.     else
    74.         i2c_start   <=  1'b0;
    75.  
    76. //rd_en:输入i2c设备读使能信号
    77. always@(posedge sys_clk or negedge sys_rst_n)
    78.     if(sys_rst_n == 1'b0)
    79.         rd_en   <=  1'b0;
    80.     else    if(state == AD_CMD)
    81.         rd_en   <=  1'b1;
    82.     else
    83.         rd_en   <=  1'b0;
    84.  
    85. //byte_addr:输入i2c设备字节地址
    86. always@(posedge sys_clk or negedge sys_rst_n)
    87.     if(sys_rst_n == 1'b0)
    88.         byte_addr   <=  16'b0;
    89.     else
    90.         byte_addr   <=  CTRL_DATA;
    91.  
    92. //ad_data:AD数据
    93. always@(posedge sys_clk or negedge sys_rst_n)
    94.     if(sys_rst_n == 1'b0)
    95.         ad_data <=  8'b0;
    96.     else    if(i2c_end == 1'b1) //(state == AD_CMD) && (i2c_end == 1'b1))
    97.         ad_data <=  rd_data;
    98.  
    99. //data_reg:数码管待显示数据缓存
    100. //assign  data_reg = ((ad_data * 3300) >> 4'd8);
    101.  
    102. //po_data:数码管待显示数据
    103. assign  po_data = ad_data[7:0];
    104.  
    105. endmodule
    106.

    2.3.4 串口接收模块

    前面文章详细讲解过，这里不在复述。

    总结： (1) 根据I2C时序将读写过程，使用状态机进行描述。

  • 相关阅读:
    原型——重构数组方法chunk，新写css方法， 函数柯里化——全网最优原型继承继承
    Linux——进程间通信——管道（文件）通信
    DAY38：内网信息搜集
    JAVA 0基础 基本数据类型之间的互相转换
    【论文阅读】DeepLab:语义图像分割与深度卷积网络，自然卷积，和完全连接的crf
    亚商投资顾问 早餐FM/1130物流需求延续逐步恢复态势
    flask celery定时任务
    Pr怎么消除人声？三个方法解决！
    QT系列教程(11) TextEdit实现Qt 文本高亮
    腾讯云重新注册算不算新用户？算！
  • 原文地址：https://blog.csdn.net/m0_72885897/article/details/132394262