协议-IIC

于 2024-08-31 15:55:49 发布
阅读量1.2k 收藏 28
点赞数 25
分类专栏： FPGA：协议 文章标签： 嵌入式硬件 fpga
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47973334/article/details/141752297
版权

        I²C即Inter-Integrated Circuit（集成电路总线），它是一种串行通信总线，使用多主从结构，由飞利浦公司在1980年代设计出来的一种简单、双向、二线制总线标准。多用于主机和从机在数据量不大且传输距离短的场合下的主从通信。主机启动总线，并产生时钟用于传送数据，此时任何接收数据的器件均被认为是从机。I²C总线由数据线SDA和时钟线SCL构成通信线路，既可用于发送数据，也可接收数据。在主控与被控IC之间可进行双向数据传送，数据的传输速率在标准模式下可达100kbits/s，在快速模式下可达400kbit/s，在高速模式下可达3.4Mbit/s，各种被控器件均并联在总线上，通过器件地址（SLAVE ADDR，具体可查器件手册）识别。I²C总线物理拓扑结构图如下所示：

IIC


        图中的IIC_SCL是串行时钟线，IIC_SDA是串行数据线，由于I2C器件一般采用开漏结构与总线相连，所以IIC-SCL和IIC-SDA均需接上拉电阻，也正因此，当总线空闲时，这两条线路都处于高电平状态，当连到总线上的任一器件输出低电平，都将使总线拉低，即各器件的SDA及SCL都是“线与”关系。IIC总线支持多主和主从两种工作模式，通常工作在主从工作方式。在主从工作方式中，系统中只有一个主机，其它器件都是具有I2C总线的外围从机。在主从工作方式中，主机启动数据的发送（发出启动信号）并产生时钟信号，数据发送完成后，发出停止信号。I2C总线结构虽然简单，使用两线传输，然而要实现器件间的通信，需要通过控制SCL和SDA的时序，使其满足I2C的总线传输协议，方可实现器件间的数据传输。

一、起始和结束

        在IIC器件开始通信（传输数据）之前，串行时钟线SCL和串行数据线由于上拉的原因处于高电平状态，此时I2C总线处于空闲状态。
        如果主机（此处指FPGA）想开始传输数据，只需在SCL为高电平时将SDA线拉低，产生一个起始信号，从机检测到起始信号后，准备接收数据，当数据传输完成，主机只需产生一个停止信号，告诉从机数据传输结束，停止信号的产生是在SCL为高电平时，SDA从低电平跳变到高电平，从机检测到停止信号后，停止接收数据。起始信号之前为空闲状态，起始信号之后到停止信号之前的这一段为数据传输状态，主机可以向从机写数据，也可以读取从机输出的数据，数据的传输由双向数据线（SDA）完成。停止信号产生后，总线再此处于空闲状态。

IIC


起始：SCL为高时，SDA由高拉低。
停止：SCL为高时，SDA由低拉高。

二、数据传输和应答期

　　先看看数据是怎么通过两根线传过来的，除了起始和结束比较特殊，中间的数据传输所遵循的规律如下所示：

　　

1.数据传输　　

　　SCL为低时，SDA运行变化。

　　SCL为高时，SDA数据锁存。

2.应答期，SDA总线是三态门

　　①在第8个时钟周期末，主机释放SDA以使从机应答

　　②在第9个时钟周期，从机将SDA拉低以应答

　　③若第9个时钟周期，SCL为高电平时，SDA未被检测到为低电平，视为非应答，表明此次数据传输失败。

　　④在第9个时钟周期末，从机释放SDA以使主机继续传输数据，如果主机发送停止信号，此次传输结束。

三、器件地址

　　每个I2C器件都有一个器件地址，有些I2C器件的器件地址是固定的，而有些I2C器件的器件地址由一个固定部分和一个可编程的部分构成，这是因为很可能在一个系统中有几个同样的器件，器件地址的可编程部分能最大数量的使这些器件连接到I2C总线上，例如为了增加系统的EEPROM容量，可能需要多个EEPROM。器件可编程地址位的数量由它可使用的管脚决定，比如EEPROM器件一般会留下3个管脚用于可编程地址位，当硬件电路上分别将这3个管脚连接到GND或VCC时，就可以设置不同的可编程地址。但有些I2C器件在出厂时器件地址就设置好了，用户不可以更改（如实时时钟PCF8563的器件地址为固定的7’h51）。所以当主机想给某个器件发送数据时，只需向总线上发送接收器件的器件地址即可。

　　进行数据传输时，主机首先向总线上发出开始信号，对应开始位S，然后按照从高到低的位序发送器件地址，一般为7bit，第8bit位为读写控制位R/W，该位为0时表示主机对从机进行写操作，当该位为1时表示主机对从机进行读操作，然后接收从机响应。对于AT24C64来说，其传输器件地址格式如下图所示。

四、存储器地址（字地址）

　　一般而言，每个兼容I2C协议的器件，内部总会有可供读写的寄存器或存储器，对于我们本次实验用到的EEPROM存储器，内部就是一系列顺序编址的存储单元。所以，当我们对一个器件中的存储单元（包括寄存器）进行读写时，首先要指定存储单元的地址即字地址，然后再向该地址写入内容。该地址为一个或两个字节长度，具体长度由器件内部的存储单元的数量决定，当存储单元数量不超过一个字节所能表示的最大数量（2^8=256）时，用一个字节表示，超过一个字节所能表示的最大数量时，就需要用两个字节来表示。

1.单字节的字地址

2.双字节的字地址

五、IIC写

　　主机发送完字地址，从机正确应答后就把内部的存储单元地址指针指向该单元。如果读写控制位R/W位为“0”即写命令，从机就处于接收数据的状态，此时，主机就开始写数据了。写数据分为单字节写（对于EEPROM而言，称为字节写）和连续写（对于EEPROM而言，称为页写）。

　　不管单字节写和连续写，都可概括为：start + 器件地址 + 写命令（0） + 字地址 + 数据 + stop

1.单字节写

　　单字节写：发送完一字节数据后发送结束信号。

2.连续写

　　连续写：发送完一字节数据后继续发送下一字节数据，最后发送的是结束信号。

六、IIC读

　　主机发送完字地址，从机正确应答后就把内部的存储单元地址指针指向该单元。如果读写控制位R/W位为“1”即读命令，主机就处于接收数据的状态，从机从该地址单元输出数据。读数据分为当前地址读、单字节读和连续读。

　　不管是单字节读还是连续读，都可以概括为：start + 器件地址 + 写命令（0） + 字地址 + start + 器件地址 + 读命令（1） + 接收从机的数据 + 主机非应答（1） + stop

1.单字节读

　　发送完器件地址和字地址后又发送起始信号和器件地址，而且第一次发送器件地址时后面的读写控制位为“0”，也就是写命令，第二次发送器件地址时后面的读写控制位为“1”，也就是读。为什么会有这样奇怪的操作呢？这是因为我们需要使从机内的存储单元地址指针指向我们想要读取的存储单元地址处，所以首先发送了一次Dummy Write也就是虚写操作，只所以称为虚写，是因为我们并不是真的要写数据，而是通过这种虚写操作使地址指针指向虚写操作中字地址的位置，等从机应答后，就可以按当前地址读的方式读数据了。因此也可以理解为：没有发送数据的单次写操作 + 当前地址的读操作

　   单字节读：读取完一字节数据后，主机发送非应答信号。

2.连续读

　　连续读：读取完一字节数据后，主机发送应答信号，读取完最后一个字节数据后，主机发送非应答信号。

 

七、IIC控制器Verilog代码设计

//**************************************************************************
// *** 名称 : iic.v
// *** 作者 : 木子
// *** 日期 : 2024-07-30
// *** 描述 : IIC控制器
//**************************************************************************

module iic
//========================< 参数 >==========================================
#(
parameter DEVICE_ID         = 7'b1010000            ,  //器件ID
parameter CLK               = 26'd50_000_000        ,  //本模块的时钟频率
parameter SCL               = 18'd250_000              //输出的SCL时钟频率
)
//========================< 端口 >==========================================
(
input                       clk                     , //时钟
input                       rst_n                   , //复位，低电平有效
//IIC control ---------------------------------------
input                       iic_en                  , //IIC触发信号
input                       addr16_en               , //16位地址使能
input                       addr8_en                , //8位地址使能
input                       write_en                , //IIC写使能
input                       read_en                 , //IIC读使能
input        [15:0]         iic_addr                , //IIC器件内地址
input        [ 7:0]         iic_data_wr             , //IIC要写的数据
//IIC output ----------------------------------------
output  reg  [ 7:0]         iic_data_rd             , //IIC读出的数据
output  reg                 iic_done                , //IIC一次操作完成
output  reg                 iic_scl                 , //IIC的SCL时钟信号
inout                       iic_sda                 , //IIC的SDA数据信号
//dri_clk -------------------------------------------
output  reg                 iic_dri_clk               //驱动IIC操作的驱动时钟，1Mhz
 );
//========================< 参数 >==========================================
localparam  IDLE            = 8'b0000_0001          ; //空闲状态
localparam  DEVICE          = 8'b0000_0010          ; //写器件地址
localparam  ADDR_16         = 8'b0000_0100          ; //写字地址高8位
localparam  ADDR_8          = 8'b0000_1000          ; //写字地址低8位
localparam  DATA_WR         = 8'b0001_0000          ; //写数据
localparam  DEVICE_RD       = 8'b0010_0000          ; //虚写器件地址
localparam  DATA_RD         = 8'b0100_0000          ; //读数据
localparam  STOP            = 8'b1000_0000          ; //结束
//========================< 信号 >==========================================
reg                         sda_dir                 ; //IIC数据(SDA)方向控制
reg                         sda_out                 ; //SDA输出信号
wire                        sda_in                  ; //SDA输入信号
reg                         state_done              ; //状态结束
reg    [ 6:0]               cnt                     ; //计数
reg    [ 7:0]               state_c                 ; //状态机当前状态
reg    [ 7:0]               state_n                 ; //状态机下一状态
reg    [15:0]               iic_addr_t              ; //地址
reg    [ 7:0]               iic_data_rd_t           ; //读取的数据
reg    [ 7:0]               iic_data_wr_t           ; //IIC需写的数据的临时寄存
reg    [ 9:0]               clk_cnt                 ; //分频时钟计数
wire   [ 8:0]               clk_divide              ; //模块驱动时钟的分频系数

//==========================================================================
//==    sda控制
//==========================================================================
assign iic_sda = sda_dir ? sda_out : 1'bz;            //SDA数据输出或高阻;做输入时inout端口时高阻态
assign sda_in  = iic_sda ;                            //SDA数据输入

//==========================================================================
//==     生成SCL的4倍时钟来驱动后面IIC的操作，生成1Mhz的iic_dri_clk
//==========================================================================
assign clk_divide = (CLK/SCL) >> 3;                   // >>3即除以8

always @(posedge clk or negedge rst_n) begin
    if(!rst_n) begin
        iic_dri_clk <=  1'b1;
        clk_cnt <= 10'd0;
    end
    else if(clk_cnt == clk_divide - 1'd1) begin
        clk_cnt <= 10'd0;
        iic_dri_clk <= ~iic_dri_clk;
    end
    else
        clk_cnt <= clk_cnt + 1'b1;
end

//==========================================================================
//==    状态机
//==========================================================================
always @(posedge iic_dri_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(iic_en) begin
               state_n = DEVICE;
           end
           else
               state_n = IDLE;
        end
        DEVICE: begin                           //写器件ID
            if(state_done) begin
                if(addr16_en)
                   state_n = ADDR_16;
                else if(addr8_en)
                   state_n = ADDR_8 ;
            end
            else
                state_n = DEVICE;
        end
        ADDR_16: begin                          //写地址高8位
            if(state_done)
                state_n = ADDR_8;
            else
                state_n = ADDR_16;
        end
        ADDR_8: begin                           //写地址低8位
            if(state_done) begin
                if(write_en)
                    state_n = DATA_WR;
                else if(read_en)
                    state_n = DEVICE_RD;
            end
            else
                state_n = ADDR_8;
        end
        DATA_WR: begin                          //写数据
            if(state_done)
                state_n = STOP;
            else
                state_n = DATA_WR;
        end
        DEVICE_RD: begin                        //虚写器件ID
            if(state_done)
                state_n = DATA_RD;
            else
                state_n = DEVICE_RD;
        end
        DATA_RD: begin                          //读数据
            if(state_done)
                state_n = STOP;
            else
                state_n = DATA_RD;
        end
        STOP: begin                             //结束
            if(state_done)
                state_n = IDLE;
            else
                state_n = STOP ;
        end
        default:state_n= IDLE;
    endcase
end

//==========================================================================
//==    设计各路信号
//==========================================================================
always @(posedge iic_dri_clk or negedge rst_n) begin
    if(!rst_n) begin
        iic_scl        <= 1'b1;
        sda_out        <= 1'b1;
        sda_dir        <= 1'b1;
        iic_done       <= 1'b0;
        cnt            <= 1'b0;
        state_done     <= 1'b0;
        iic_addr_t     <= 1'b0;
        iic_data_rd    <= 1'b0;
        iic_data_rd_t  <= 1'b0;
        iic_data_wr_t  <= 1'b0;
    end
    else begin
        state_done <= 1'b0 ;
        cnt        <= cnt +1'b1 ;
        case(state_c)
            //--------------------------------------------------- 空闲状态
            IDLE: begin
                    iic_scl  <= 1'b1;
                    sda_out  <= 1'b1;
                    sda_dir  <= 1'b1;
                    iic_done <= 1'b0;
                    cnt      <= 7'b0;
                    if(iic_en) begin
                        iic_addr_t    <= iic_addr;
                        iic_data_wr_t <= iic_data_wr;
                    end
            end
            //--------------------------------------------------- 写器件ID
            DEVICE: begin
                case(cnt)
                    7'd1 : sda_out <= 1'b0;
                    7'd3 : iic_scl <= 1'b0;
                    7'd4 : sda_out <= DEVICE_ID[6];
                    7'd5 : iic_scl <= 1'b1;
                    7'd7 : iic_scl <= 1'b0;
                    7'd8 : sda_out <= DEVICE_ID[5];
                    7'd9 : iic_scl <= 1'b1;
                    7'd11: iic_scl <= 1'b0;
                    7'd12: sda_out <= DEVICE_ID[4];
                    7'd13: iic_scl <= 1'b1;
                    7'd15: iic_scl <= 1'b0;
                    7'd16: sda_out <= DEVICE_ID[3];
                    7'd17: iic_scl <= 1'b1;
                    7'd19: iic_scl <= 1'b0;
                    7'd20: sda_out <= DEVICE_ID[2];
                    7'd21: iic_scl <= 1'b1;
                    7'd23: iic_scl <= 1'b0;
                    7'd24: sda_out <= DEVICE_ID[1];
                    7'd25: iic_scl <= 1'b1;
                    7'd27: iic_scl <= 1'b0;
                    7'd28: sda_out <= DEVICE_ID[0];
                    7'd29: iic_scl <= 1'b1;
                    7'd31: iic_scl <= 1'b0;
                    7'd32: sda_out <= 1'b0;             //0:写
                    7'd33: iic_scl <= 1'b1;
                    7'd35: iic_scl <= 1'b0;
                    7'd36: begin
                           sda_dir <= 1'b0;             //从机应答
                           sda_out <= 1'b1;
                    end
                    7'd37: iic_scl <= 1'b1;
                    7'd38: state_done <= 1'b1;          //状态结束
                    7'd39: begin
                           iic_scl <= 1'b0;
                           cnt <= 1'b0;
                    end
                    default :  ;
                endcase
            end
            //--------------------------------------------------- 写字地址高8位
            ADDR_16: begin
                case(cnt)
                    7'd0 : begin
                           sda_dir <= 1'b1 ;
                           sda_out <= iic_addr_t[15];
                    end
                    7'd1 : iic_scl <= 1'b1;
                    7'd3 : iic_scl <= 1'b0;
                    7'd4 : sda_out <= iic_addr_t[14];
                    7'd5 : iic_scl <= 1'b1;
                    7'd7 : iic_scl <= 1'b0;
                    7'd8 : sda_out <= iic_addr_t[13];
                    7'd9 : iic_scl <= 1'b1;
                    7'd11: iic_scl <= 1'b0;
                    7'd12: sda_out <= iic_addr_t[12];
                    7'd13: iic_scl <= 1'b1;
                    7'd15: iic_scl <= 1'b0;
                    7'd16: sda_out <= iic_addr_t[11];
                    7'd17: iic_scl <= 1'b1;
                    7'd19: iic_scl <= 1'b0;
                    7'd20: sda_out <= iic_addr_t[10];
                    7'd21: iic_scl <= 1'b1;
                    7'd23: iic_scl <= 1'b0;
                    7'd24: sda_out <= iic_addr_t[9];
                    7'd25: iic_scl <= 1'b1;
                    7'd27: iic_scl <= 1'b0;
                    7'd28: sda_out <= iic_addr_t[8];
                    7'd29: iic_scl <= 1'b1;
                    7'd31: iic_scl <= 1'b0;
                    7'd32: begin
                           sda_dir <= 1'b0;             //从机应答
                           sda_out <= 1'b1;
                    end
                    7'd33: iic_scl <= 1'b1;
                    7'd34: state_done <= 1'b1;          //状态结束
                    7'd35: begin
                           iic_scl <= 1'b0;
                           cnt <= 1'b0;
                    end
                    default :  ;
                endcase
            end
            //--------------------------------------------------- 写字地址低8位
            ADDR_8: begin
                case(cnt)
                    7'd0: begin
                           sda_dir <= 1'b1 ;
                           sda_out <= iic_addr_t[7];
                    end
                    7'd1 : iic_scl <= 1'b1;
                    7'd3 : iic_scl <= 1'b0;
                    7'd4 : sda_out <= iic_addr_t[6];
                    7'd5 : iic_scl <= 1'b1;
                    7'd7 : iic_scl <= 1'b0;
                    7'd8 : sda_out <= iic_addr_t[5];
                    7'd9 : iic_scl <= 1'b1;
                    7'd11: iic_scl <= 1'b0;
                    7'd12: sda_out <= iic_addr_t[4];
                    7'd13: iic_scl <= 1'b1;
                    7'd15: iic_scl <= 1'b0;
                    7'd16: sda_out <= iic_addr_t[3];
                    7'd17: iic_scl <= 1'b1;
                    7'd19: iic_scl <= 1'b0;
                    7'd20: sda_out <= iic_addr_t[2];
                    7'd21: iic_scl <= 1'b1;
                    7'd23: iic_scl <= 1'b0;
                    7'd24: sda_out <= iic_addr_t[1];
                    7'd25: iic_scl <= 1'b1;
                    7'd27: iic_scl <= 1'b0;
                    7'd28: sda_out <= iic_addr_t[0];
                    7'd29: iic_scl <= 1'b1;
                    7'd31: iic_scl <= 1'b0;
                    7'd32: begin
                           sda_dir <= 1'b0;             //从机应答
                           sda_out <= 1'b1;
                    end
                    7'd33: iic_scl <= 1'b1;
                    7'd34: state_done <= 1'b1;          //状态结束
                    7'd35: begin
                           iic_scl <= 1'b0;
                           cnt <= 1'b0;
                    end
                    default :  ;
                endcase
            end
            //--------------------------------------------------- 写数据
            DATA_WR: begin
                case(cnt)
                    7'd0: begin
                           sda_out <= iic_data_wr_t[7];
                           sda_dir <= 1'b1;
                    end
                    7'd1 : iic_scl <= 1'b1;
                    7'd3 : iic_scl <= 1'b0;
                    7'd4 : sda_out <= iic_data_wr_t[6];
                    7'd5 : iic_scl <= 1'b1;
                    7'd7 : iic_scl <= 1'b0;
                    7'd8 : sda_out <= iic_data_wr_t[5];
                    7'd9 : iic_scl <= 1'b1;
                    7'd11: iic_scl <= 1'b0;
                    7'd12: sda_out <= iic_data_wr_t[4];
                    7'd13: iic_scl <= 1'b1;
                    7'd15: iic_scl <= 1'b0;
                    7'd16: sda_out <= iic_data_wr_t[3];
                    7'd17: iic_scl <= 1'b1;
                    7'd19: iic_scl <= 1'b0;
                    7'd20: sda_out <= iic_data_wr_t[2];
                    7'd21: iic_scl <= 1'b1;
                    7'd23: iic_scl <= 1'b0;
                    7'd24: sda_out <= iic_data_wr_t[1];
                    7'd25: iic_scl <= 1'b1;
                    7'd27: iic_scl <= 1'b0;
                    7'd28: sda_out <= iic_data_wr_t[0];
                    7'd29: iic_scl <= 1'b1;
                    7'd31: iic_scl <= 1'b0;
                    7'd32: begin
                           sda_dir <= 1'b0;             //从机应答
                           sda_out <= 1'b1;
                    end
                    7'd33: iic_scl <= 1'b1;
                    7'd34: state_done <= 1'b1;          //状态结束
                    7'd35: begin
                        iic_scl  <= 1'b0;
                        cnt  <= 1'b0;
                    end
                    default  :  ;
                endcase
            end
            //--------------------------------------------------- 虚写器件ID
            DEVICE_RD: begin
                case(cnt)
                    7'd0 : begin
                           sda_dir <= 1'b1;
                           sda_out <= 1'b1;
                    end
                    7'd1 : iic_scl <= 1'b1;
                    7'd2 : sda_out <= 1'b0;             //重新开始
                    7'd3 : iic_scl <= 1'b0;
                    7'd4 : sda_out <= DEVICE_ID[6];
                    7'd5 : iic_scl <= 1'b1;
                    7'd7 : iic_scl <= 1'b0;
                    7'd8 : sda_out <= DEVICE_ID[5];
                    7'd9 : iic_scl <= 1'b1;
                    7'd11: iic_scl <= 1'b0;
                    7'd12: sda_out <= DEVICE_ID[4];
                    7'd13: iic_scl <= 1'b1;
                    7'd15: iic_scl <= 1'b0;
                    7'd16: sda_out <= DEVICE_ID[3];
                    7'd17: iic_scl <= 1'b1;
                    7'd19: iic_scl <= 1'b0;
                    7'd20: sda_out <= DEVICE_ID[2];
                    7'd21: iic_scl <= 1'b1;
                    7'd23: iic_scl <= 1'b0;
                    7'd24: sda_out <= DEVICE_ID[1];
                    7'd25: iic_scl <= 1'b1;
                    7'd27: iic_scl <= 1'b0;
                    7'd28: sda_out <= DEVICE_ID[0];
                    7'd29: iic_scl <= 1'b1;
                    7'd31: iic_scl <= 1'b0;
                    7'd32: sda_out <= 1'b1;             //1:读
                    7'd33: iic_scl <= 1'b1;
                    7'd35: iic_scl <= 1'b0;
                    7'd36: begin
                           sda_dir <= 1'b0;             //从机应答
                           sda_out <= 1'b1;
                    end
                    7'd37: iic_scl     <= 1'b1;
                    7'd38: state_done <= 1'b1;          //状态结束
                    7'd39: begin
                           iic_scl <= 1'b0;
                           cnt <= 1'b0;
                    end
                    default : ;
                endcase
            end
            //--------------------------------------------------- 读数据
            DATA_RD: begin
                case(cnt)
                    7'd0 : sda_dir <= 1'b0;
                    7'd1 : begin
                           iic_data_rd_t[7] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd3 : iic_scl <= 1'b0;
                    7'd5 : begin
                           iic_data_rd_t[6] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd7 : iic_scl <= 1'b0;
                    7'd9 : begin
                           iic_data_rd_t[5] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd11: iic_scl <= 1'b0;
                    7'd13: begin
                           iic_data_rd_t[4] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd15: iic_scl <= 1'b0;
                    7'd17: begin
                           iic_data_rd_t[3] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd19: iic_scl <= 1'b0;
                    7'd21: begin
                           iic_data_rd_t[2] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd23: iic_scl <= 1'b0;
                    7'd25: begin
                           iic_data_rd_t[1] <= sda_in;
                           iic_scl <= 1'b1;
                    end
                    7'd27: iic_scl <= 1'b0;
                    7'd29: begin
                           iic_data_rd_t[0] <= sda_in;
                           iic_scl <= 1'b1  ;
                    end
                    7'd31: iic_scl <= 1'b0;
                    7'd32: begin
                           sda_dir <= 1'b1;             //非应答
                           sda_out <= 1'b1;
                    end
                    7'd33: iic_scl <= 1'b1;
                    7'd34: state_done <= 1'b1;          //状态结束
                    7'd35: begin
                           iic_scl <= 1'b0;
                           cnt <= 1'b0;
                           iic_data_rd <= iic_data_rd_t;
                    end
                    default  :  ;
                endcase
            end
            //--------------------------------------------------- 结束
            STOP: begin
                case(cnt)
                    7'd0 : begin
                           sda_dir <= 1'b1;
                           sda_out <= 1'b0;
                    end
                    7'd1 : iic_scl <= 1'b1;
                    7'd3 : sda_out <= 1'b1;
                    7'd15: state_done <= 1'b1;          //状态结束
                    7'd16: begin
                           cnt <= 1'b0;
                           iic_done <= 1'b1;            //IIC配置完成
                    end
                    default  : ;
                endcase
            end
        endcase
    end
end




endmodule

 

游泳冒菜
关注
专栏目录
IIC协议理解
chinaclock的专栏
07-05 5283
先摘一摘网上的理解：一. 技术性能:工作速率有100K和400K两种；支持多机通讯；支持多主控模块，但同一时刻只允许有一个主控；      由数据线SDA和时钟SCL构成的串行总线；每个电路和模块都有唯一的地址；                    每个器件可以使用独立电源二. 基本工作原理:以启动信号START来掌管总线，以停止信号STOP来释放总线；每次通讯以START开始，以STOP结束；启动信号START后紧接着发送一个地址字节，其中7位为被控器件的地址码，一位为读/写控制位R/W，R/W位为0表
iic的介绍(二)
m0_67033140的博客
02-17 451
iic的协议层有起始信号和停止信号，数据有效性，响应，仲裁，时钟同步还有地址广播 地址广播意思就是一个人说很多人在听 主机写数据给从机(主机为单片机从机为外围设备) 主机发送数据给我们一个外设的时候， 画虚线部分是主机发送的信号 白色部分是外围设备发送的信号 第一个s的意思是数据发送至从机(起始信号) 第二个slave address是从机的地址 RW中的R是read，读，W是write，写，传输方向选择位:如果为0，则传输方向为主机传输至从机，为1时，从机接受传输方向位后，主机或从机.
协议——IIC
djue7752的博客
03-07 349
　　I²C即Inter-Integrated Circuit（集成电路总线），它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代设计出来的一种简单、双向、二线制总线标准。多用于主机和从机在数据量不大且传输距离短的场合下的主从通信。主机启动总线，并产生时钟用于传送数据，此时任何接收数据的器件均被认为是从机。I²C总线由数据线SDA和时钟线SCL构成通信线路，既可用于发送数据，...
IIC协议原理分析
热门推荐
weizhangyjs的博客
04-16 1万+
一、基本概念。 I2C总线（I2C bus，Inter-IC bus）是一个双向的两线连接总线，提供集成电路之间的通信线路。I2C属于一种串行扩展技术，广泛应用于电视、录像机、音频设备。I2C的意思是“完成集成电路或者功能单元之间信息交换的规范或协议”，采用一条数据线（SDA）和一条时钟线（SCL）来完成数据的传输以及外围器件的扩展。 通信的原理是控制SCL和SDA的时序，时期满足总线协议从而进...
I2C学习笔记——I2C协议学习
weixin_46403587的博客
06-03 875
通过I2C总线接口的可编程时钟来实现传输速率的调整，同时也跟所接的上拉电阻的阻值有关。SCL 的低电平 SDA 变化， SCL 的高电平 SDA 保持，每个时钟周期发送一位数据。当总线上的主机都不驱动总线，总线进入空闲状态， SCL 和 SDA 都为高电平。，第一帧 发送头序列(11110XX0，XX 表示 10 位地址的高两位)，第二帧发送低八位从机地址。串口，用的线很少，需要8个SCL周期才能将地址和RW位发送；（一个字节），用于指定主机通信的对象地址，在发送停止条件之前，指定的从机一直有效；
嵌入式硬件通信接口协议-IIC（一）：协议基础
01-19
本节继续讲嵌入式硬件通信接口协议中的又一个串行通信接口-IIC。相比于UART串口协议和SPI串行外设接口协议，这个IIC又有其独特之处。 　简介 　IIC(Inter-Integrated Circuit)，集成电路总线。 ...
pg090-axi-iic.pdf
03-23
IIC接口IP核能够实现I2C通信协议，可以用于多种场景，如系统配置、传感器数据采集、设备控制等。接下来，介绍了该IP核的授权和订购信息，说明了如何获取和使用该IP核。 在产品规格部分，提供了该IP核的技术标准、...
STM32F030C8-IIC-Slave-master.zip_STM32F030 寄存器_i2c slave_stm32f0
07-14
在这个项目中，我们主要关注的是STM32F030C8在I2C通信协议中的应用，具体为实现I2C从机模式。 I2C（Inter-Integrated Circuit）是一种多主机、双向二线制总线，由飞利浦（现NXP Semiconductors）开发，用于连接微...
EEPROM-IIC.zip_51eeprom使用_51iic.代码_EEPROM-IIC_eeprom使用iic
09-20
总结一下，51单片机通过IIC接口与EEPROM进行通信，涉及的关键点包括IIC协议的理解、51单片机I/O口的配置、模拟IIC时序的代码实现，以及针对具体EEPROM型号的读写操作。在给定的压缩包`EEPROM-IIC.zip`中，可能包含了...
MY-IIC.zip_IIC 通用_iic协议代码_myiic
09-20
【标题】"MY-IIC.zip_IIC 通用_iic协议代码_myiic"是一个包含通用IIC协议代码的压缩包，主要用于实现多种IIC通信场景。IIC（Inter-Integrated Circuit）是一种由飞利浦（现为NXP）开发的两线式串行接口，用于连接微...
一文让你看懂IIC、SPI、UART协议
小秦同学的博客
07-12 1380
一文让你看懂IIC\SPI\UART协议
Verilog(3)I2C通信协议
m0_55542784的博客
02-26 923
I2C
FPGA低速接口SPI_I2C_UART的使用
最新发布
Njustxiaobai的博客
11-22 309
fpga低速接口总述
8.23 正点原子领航者V1开发板学习之EEPROM
liufulim的博客
09-04 882
记录学习
9.5 正点原子领航者V1开发板学习之RTC时钟
liufulim的博客
09-06 787
本次实验就是利用FPGA与PCF8563进行IIC通信写入初始数据，然后读取时间信息，传递给LCD模块输出在显示屏上。重点是PCF8563控制模块的设计和显示模块。其中控制模块是将iic_dri模块读取的数据提取成我们需要的时间信息，同时也负责初始值的写入，即将要写的数据和对应的地址提供给dri模块，由它来完成和芯片的通信。
FPGA自学9——IIC总线操作EEPROM
#include
10-22 1523
1、IIC总线简介 IIC是集成电路总线，是一种两线式的串行总线，由SDA数据线、SCL时钟线构成的半双工通信方式。 标准模式：100kbit / s 快速模式：400kbit / s 高速模式：3.4Mbit / s 1.1 IIC 总线的时序 IIC设备：闲置---->开始信号---->发送地址/应答---->发送数据/应答---->停止信号 当数据线SDA 和时钟线SCL 都...
门控时钟与时钟使能
qq_40483920的博客
10-31 2653
在FPGA设计中，我们经常会使用分频的方法来得到一个我们需要的时钟频率，而在很多开发板厂家配套的教程里，他们常常会使用计数器分频得到的高低电平时钟来当做驱动时钟，这种方法简单易懂，但是，在工程设计中，这种方法是不被允许的。 门控时钟 门控时钟就是使用计数器和逻辑门翻转来产生的时钟，下面是典型的门控时钟 //生成I2C的SCL的四倍频率的驱动时钟用于驱动i2c的操作 always @(posedge sys_clk or negedge rst_n) begin if(rst_n == 1'b0) b
FPGA----常用协议2（iic）
王飞的博客
06-28 264
范例代码： module i2c_dri #( parameter SLAVE_ADDR = 7'b1010000 , //EEPROM从机地址 parameter CLK_FREQ = 26'd50_000_000, //模块输入的时钟频率 parameter I2C_FREQ = 18'd250_000 //IIC_SCL的时钟频率 ) ( ...
【FPGA——Cyclone Ⅳ学习笔记】七.IIC驱动EEPROM（EP4CE6F17C8）
默默无闻小菜鸡的博客
03-30 2987
一.原理图 此开发板的24LC04芯片与之前所用的AT24C02芯片有所不同，此芯片的A2，A1，A0管脚为无效管脚，不能用于器件地址的选择！ 二.IIC驱动及代码介绍 IIC的驱动程序主要是根据时序 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值