【verilog】FPGA 一主多从模式下的IIC驱动(一段状态机法)

已于 2022-08-30 23:23:50 修改
阅读量1.9k 收藏 21
点赞数 3
分类专栏： Verilog 文章标签： fpga verilog 状态机
于 2020-05-05 13:27:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helloworld573/article/details/105931141
版权

MAIN CODE

IIC时序见：链接
有关细节部分，代码中已经给出了详细的注释！

/*
    iic freq = 250khz
    fpga freq = 50Mhz
    
    -------------------------------------

    1、起始位+7位从机地址+1位写标志+从机应答 
    2、高8位从机内部寄存器地址+从机应答
    3、低8位从机内部寄存器地址+从机应答
    4、8位发送数据+从机应答
    5、停止位
    6、起始位+7位从机地址+1位读标志+从机应答 
    7、读8位数据+主机发送非应答

   向内部寄存器地址位数为8的从机写数据:1->3->4->5            need:type16_type8=0,read1_write0=0.
   向内部寄存器地址位数为16的从机写数据:1->2->3->4->5        need:type16_type8=1,read1_write0=0.
   从内部寄存器地址位数为8的从机读出数据:1->3->6->7->5       need:type16_type8=0,read1_write0=1.
   从内部寄存器地址位数为16的从机读出数据:1->2->3->6->7->5   need:type16_type8=1,read1_write0=1.


*/
module iic
     (
     
          //fpga
          input                clk        ,      // 输入时钟(clk_freq)
          input                rst_n      ,      // 复位信号
          
          //addr and data
          input [6:0] slave_address,               //从机地址
          input        [15:0]  iic_inner_reg_addr, //从机内部寄存器地址，若为8bit形式，直接用低八位
          input        [ 7:0]  i2c_data_w ,        //写数据端口
          output  reg  [ 7:0]  i2c_data_r ,        //读数据端口
          
          //select mode
          input                type16_type8,        //从机内部寄存器地址是否属于16bit形式(16-1/8-0)
          input                read1_write0,       //读模式或写模式
          
          //i2c interface
          input                i2c_exec   ,      // IIC使能【1】
          output  reg          i2c_done   ,      // 一次操作完成的标志信号
          output  reg          scl        ,      // SCL输出
          inout                sda        ,      // SDA输出

          //user interface
          output  reg          dri_clk           // 低频时钟输出
     );
     
          reg [25:0] clk_freq = 26'd50_000_000;  //输入时钟(clk_freq)的频率：26'd50_000_000
          reg [17:0] i2c_freq = 18'd250_000;     //选用iic的频率：18'd250_000 
          
          
          
        //#############################  三态门sda  ##################################
        reg            sda_dir     ;                     // (SDA)方向控制读出还是写入
        reg            sda_out     ;                     // SDA输出信号
        wire           sda_in       ;                     // SDA输入信号

        assign  sda     = sda_dir ?  sda_out : 1'bz;     // 如果是输出，引脚sda输出数据就跟随sda_out寄存器的数据，如果是输入就拉为高阻
        assign  sda_in  = sda ;                          // 输入线，数据跟随sda
        //#########################################################################

        
        
        
        /*####################  低频时钟 dri_clk 的产生   ###################################
                                                                            
                        dri_clk的时钟频率，最好四倍于SCL的频率。                                     
                        因为SCL的一次低电平为SCL的半个时钟周期                   
                        SDA在SCL为低电平时候变化。四倍于SCL的时钟频率             
                        可以让我们准确的找到SCL为低电平的中间点，方便我们           
                        发送数据。   
                        系统时钟频率除以SCL频率=分频值，再/2=翻转值，再/4=dri_clk的翻转值
        */

        wire   [8:0]  clk_divide   ;                     // 模块驱动时钟的分频系数
        reg    [ 9:0]  clk_cnt     ;                     // 分频时钟计数

        assign  clk_divide = (clk_freq/i2c_freq) >> 2'd3;// 模块驱动时钟的分频系数

        always @(posedge clk or negedge rst_n) begin
            if(rst_n == 1'b0) begin
                dri_clk <=  1'b1;
                clk_cnt <= 10'd0;
            end
            else if(clk_cnt == clk_divide - 1'd1) begin
                clk_cnt <= 10'd0;
                dri_clk <= ~dri_clk;
            end
            else
                clk_cnt <= clk_cnt + 1'b1;
        end
        //####################################################################################
        
        
        
        //######################################### MAIN #######################################
        reg [6:0]  main_cnt;
        reg [6:0]  minor_cnt;
        reg [6:0]  slave_addr;   
        reg [15:0] inner_reg_addr; 
        reg [ 7:0] data_w;
        reg [ 7:0] data_r;
        
        always @(posedge dri_clk or negedge rst_n) begin//(0)
        if(rst_n == 1'b0) begin
            scl        <= 1'b1;
            sda_dir    <= 1'b1;
            sda_out    <= 1'b1;    //根据协议，IIC空闲状态两条线均为高
            
            
            main_cnt   <= 1'b0;
            minor_cnt  <= 1'b0;
            
            data_r     <= 1'b0;
            i2c_data_r <= 1'b0;
            data_w <= 1'b0;    
            inner_reg_addr <= 1'b0;
            slave_addr <= 1'b0;
            
            
            i2c_done   <= 1'b0;
        end
        else begin//（1）
            
                    if(i2c_exec == 1'd1 && main_cnt == 7'd0) begin
                        inner_reg_addr    <= iic_inner_reg_addr;  //将IIC【内部寄存器地址】寄存
                        data_w <= i2c_data_w;                  //将需要发送的【数据】寄存
                        slave_addr <= slave_address;              //将【从机地址】寄存
                        main_cnt <= 7'd1;              //主计数器+1，进入下一状态！
                        sda_dir <= 1'b1;                          //设置三态门状态为输出
                        i2c_done <= 1'b0;            //iic一次完成操作标志清0
                    end
                    
                    //1、【发送起始位+7bit从机地址+1bit写标志(0)+1bitack】
                    else if(main_cnt == 7'd1)begin//（a2）          
                                                                   //【注】SDA在SCL高稳定低变化，起始位：在SCL为1时，SDA出现下降沿
                       minor_cnt <= minor_cnt + 1'b1;
                       
                       case(minor_cnt)     //一个计数值代表SCL的半个周期(可以这样理解) 
                        7'd1 : sda_out <= 1'b0; //sda下降沿(此时SCL为1，此为起始位)
                        7'd2 :;                 //SCL高电平维持半个周期                                  
                        7'd3 : scl <= 1'b0;     //SCL拉低
                        7'd4 : sda_out <= slave_addr[6];//SCL低电平维持半个周期（同时给SDA线发送提供数据）
                        7'd5 : scl <= 1'b1;      //同理...
                        7'd6 :;
                        7'd7 : scl <= 1'b0;
                        7'd8 : sda_out <= slave_addr[5];
                        7'd9 : scl <= 1'b1;
                        7'd10:;
                        7'd11: scl <= 1'b0;
                        7'd12: sda_out <= slave_addr[4];
                        7'd13: scl <= 1'b1;
                        7'd14:;
                        7'd15: scl <= 1'b0;
                        7'd16: sda_out <= slave_addr[3];
                        7'd17: scl <= 1'b1;
                        7'd18:;
                        7'd19: scl <= 1'b0;
                        7'd20: sda_out <= slave_addr[2];
                        7'd21: scl <= 1'b1;
                        7'd22:;
                        7'd23: scl <= 1'b0;
                        7'd24: sda_out <= slave_addr[1];
                        7'd25: scl <= 1'b1;
                        7'd26:;
                        7'd27: scl <= 1'b0;
                        7'd28: sda_out <= slave_addr[0];
                        7'd29: scl <= 1'b1;
                        7'd30:;
                        7'd31: scl <= 1'b0;
                        7'd32: sda_out <= 1'b0;      //写标志
                        7'd33: scl <= 1'b1;
                        7'd34:;
                        7'd35: scl <= 1'b0;
                        7'd36: begin
                            sda_dir <= 1'b0;         // sda线路设为高阻态准备接收从机应答
                            sda_out <= 1'b1;         //此时sda_out已经控制不了SDA线
                        end
                        7'd37: scl     <= 1'b1;
                        7'd38: ;
                        7'd39: begin//最后把scl拉低,minor_cnt计数器清0，main_cnt计数器+1或+2进入下一状态。
                            scl <= 1'b0;             
                            minor_cnt <= 1'b0;
                            //-------------------------------
                            if(type16_type8 == 1'b1)
                                main_cnt <= 7'd2; 
                            else
                                main_cnt <= 7'd3; 
                            //-------------------------------
                        end
                        default :  ;
                    endcase
                    end//（a2）
                    
                    //2、【发送从机内部寄存器地址的高8bit +1bitack】
                    else if(main_cnt == 7'd2)begin//（a3）
                    
                       minor_cnt <= minor_cnt + 1'b1;
                        
                       case(minor_cnt)
                        7'd0 : begin
                            sda_dir <= 1'b1 ;               
                            sda_out <= inner_reg_addr[15];           
                        end
                        7'd1 : scl <= 1'b1;
                        7'd2 :;
                        7'd3 : scl <= 1'b0;
                        7'd4 : sda_out <= inner_reg_addr[14];
                        7'd5 : scl <= 1'b1;
                        7'd6 :;
                        7'd7 : scl <= 1'b0;
                        7'd8 : sda_out <= inner_reg_addr[13];
                        7'd9 : scl <= 1'b1;
                        7'd10:;
                        7'd11: scl <= 1'b0;
                        7'd12: sda_out <= inner_reg_addr[12];
                        7'd13: scl <= 1'b1;
                        7'd14:;
                        7'd15: scl <= 1'b0;
                        7'd16: sda_out <= inner_reg_addr[11];
                        7'd17: scl <= 1'b1;
                        7'd18:;
                        7'd19: scl <= 1'b0;
                        7'd20: sda_out <= inner_reg_addr[10];
                        7'd21: scl <= 1'b1;
                        7'd22:;
                        7'd23: scl <= 1'b0;
                        7'd24: sda_out <= inner_reg_addr[9];
                        7'd25: scl <= 1'b1;
                        7'd26:;
                        7'd27: scl <= 1'b0;
                        7'd28: sda_out <= inner_reg_addr[8];
                        7'd29: scl <= 1'b1;
                        7'd30:;
                        7'd31: scl <= 1'b0;
                        7'd32: begin
                            sda_dir <= 1'b0;               
                            sda_out <= 1'b1;
                        end
                        7'd33: scl     <= 1'b1;
                        7'd34: ;
                        7'd35: begin
                            scl <= 1'b0;
                            minor_cnt <= 1'b0;
                            //-------------------------------
                            main_cnt <= 7'd3;
                            //-------------------------------
                        end
                        default :;
                    endcase
                    end//(a3)
                    
                    //3、【发送从机内部寄存器地址的低8bit +1bitack】
                    else if(main_cnt == 7'd3)begin//（a4）
                    
                       minor_cnt <= minor_cnt + 1'b1;
                   
                       case(minor_cnt)
                        7'd0: begin
                           sda_dir <= 1'b1 ;                
                           sda_out <= inner_reg_addr[7];            
                        end
                        7'd1 : scl <= 1'b1;
                        7'd2 :;
                        7'd3 : scl <= 1'b0;
                        7'd4 : sda_out <= inner_reg_addr[6];
                        7'd5 : scl <= 1'b1;
                        7'd6 :;
                        7'd7 : scl <= 1'b0;
                        7'd8 : sda_out <= inner_reg_addr[5];
                        7'd9 : scl <= 1'b1;
                        7'd10:;
                        7'd11: scl <= 1'b0;
                        7'd12: sda_out <= inner_reg_addr[4];
                        7'd13: scl <= 1'b1;
                        7'd14:;
                        7'd15: scl <= 1'b0;
                        7'd16: sda_out <= inner_reg_addr[3];
                        7'd17: scl <= 1'b1;
                        7'd18:;
                        7'd19: scl <= 1'b0;
                        7'd20: sda_out <= inner_reg_addr[2];
                        7'd21: scl <= 1'b1;
                        7'd22:;
                        7'd23: scl <= 1'b0;
                        7'd24: sda_out <= inner_reg_addr[1];
                        7'd25: scl <= 1'b1;
                        7'd26:;
                        7'd27: scl <= 1'b0;
                        7'd28: sda_out <= inner_reg_addr[0];
                        7'd29: scl <= 1'b1;
                        7'd30:;
                        7'd31: scl <= 1'b0;
                        7'd32: begin
                            sda_dir <= 1'b0;               
                            sda_out <= 1'b1;
                        end
                        7'd33: scl <= 1'b1;
                        7'd34:;              
                        7'd35: begin
                            scl <= 1'b0;                    
                            minor_cnt <= 1'b0;
                            //-------------------------------
                            if(read1_write0 == 1'b1)
                                main_cnt <= 7'd6;
                            else
                                main_cnt <= 7'd4;
                            //-------------------------------
                        end
                        default :;
                    endcase
                    end//(a4)
                    
                    
                    //4、【发送8bit数据 +1bitack】
                    else if(main_cnt == 7'd4)begin//（a5）
                    
                        minor_cnt <= minor_cnt + 1'b1;
                        
                        case(minor_cnt)
                        7'd0: begin
                            sda_dir <= 1'b1;                
                            sda_out <= data_w[7];        
                        end
                        7'd1 : scl <= 1'b1;
                        7'd2 :;
                        7'd3 : scl <= 1'b0;
                        7'd4 : sda_out <= data_w[6];
                        7'd5 : scl <= 1'b1;
                        7'd6 :;
                        7'd7 : scl <= 1'b0;
                        7'd8 : sda_out <= data_w[5];
                        7'd9 : scl <= 1'b1;
                        7'd10:;
                        7'd11: scl <= 1'b0;
                        7'd12: sda_out <= data_w[4];
                        7'd13: scl <= 1'b1;
                        7'd14:;
                        7'd15: scl <= 1'b0;
                        7'd16: sda_out <= data_w[3];
                        7'd17: scl <= 1'b1;
                        7'd18:;
                        7'd19: scl <= 1'b0;
                        7'd20: sda_out <= data_w[2];
                        7'd21: scl <= 1'b1;
                        7'd22:;
                        7'd23: scl <= 1'b0;
                        7'd24: sda_out <= data_w[1];
                        7'd25: scl <= 1'b1;
                        7'd26:;
                        7'd27: scl <= 1'b0;
                        7'd28: sda_out <= data_w[0];
                        7'd29: scl <= 1'b1;
                        7'd30:;
                        7'd31: scl <= 1'b0;
                        7'd32: begin
                            sda_dir <= 1'b0;               
                            sda_out <= 1'b1;
                        end
                        7'd33: scl <= 1'b1;
                        7'd34: ;
                        7'd35: begin
                            scl  <= 1'b0;
                            minor_cnt  <= 1'b0;
                            //-------------------------------
                            main_cnt <= 7'd5;
                            //-------------------------------
                        end
                        default  :;
                    endcase
                    end//(a5)
                    
                    //5、【发送停止位(1次iic操作结束)】
                    else if(main_cnt == 7'd5)begin//（a6）                        
                                                           //【注】停止位：在SCL为1时，SDA出现上升沿
                        minor_cnt <= minor_cnt + 1'b1;
                        
                        case(minor_cnt)
                        7'd0: begin
                            sda_dir <= 1'b1;              
                            sda_out <= 1'b0;              
                        end
                        7'd1 : scl     <= 1'b1;           //把scl抬高
                        7'd2 :;
                        7'd3 : sda_out <= 1'b1;           //在scl为高电平的状态的时候，把sda抬高，从而产生上升沿作为停止位。

                        7'd16: begin
                            minor_cnt <= 1'b0;
                            i2c_done <= 1'b1;             //向上层模块传递I2C操作结束
                            //-------------------------------
                            main_cnt <= 7'd0;
                            //-------------------------------
                        end
                        default  : ;
                    endcase
                    end//（a6）
                  
                    //6、【发送起始位+7bit从机地址+1bit读标志(1)+1bitack】
                    else if(main_cnt == 7'd6)begin//（a7）   
                        
                        minor_cnt <= minor_cnt + 1'b1;
                        
                        case(minor_cnt)
                        7'd0 : begin
                            sda_dir <= 1'b1;                
                            sda_out <= 1'b1;
                        end
                        7'd1 : scl <= 1'b1;
                        7'd2 : sda_out <= 1'b0; //起始位              
                        
                        7'd3 : scl <= 1'b0;
                        7'd4 : sda_out <= slave_addr[6];    
                        7'd5 : scl <= 1'b1;
                        7'd6 :;
                        7'd7 : scl <= 1'b0;
                        7'd8 : sda_out <= slave_addr[5];
                        7'd9 : scl <= 1'b1;
                        7'd10:;
                        7'd11: scl <= 1'b0;
                        7'd12: sda_out <= slave_addr[4];
                        7'd13: scl <= 1'b1;
                        7'd14:;
                        7'd15: scl <= 1'b0;
                        7'd16: sda_out <= slave_addr[3];
                        7'd17: scl <= 1'b1;
                        7'd18:;
                        7'd19: scl <= 1'b0;
                        7'd20: sda_out <= slave_addr[2];
                        7'd21: scl <= 1'b1;
                        7'd22:;
                        7'd23: scl <= 1'b0;
                        7'd24: sda_out <= slave_addr[1];
                        7'd25: scl <= 1'b1;
                        7'd26:;
                        7'd27: scl <= 1'b0;
                        7'd28: sda_out <= slave_addr[0];
                        7'd29: scl <= 1'b1;
                        7'd30:;
                        7'd31: scl <= 1'b0;
                        7'd32: sda_out <= 1'b1;             // 1:读
                        7'd33: scl <= 1'b1;
                        7'd34:;
                        

                        7'd35: scl <= 1'b0;
                        7'd36: begin
                            sda_dir <= 1'b0;                
                            sda_out <= 1'b1;
                        end
                        7'd37: scl     <= 1'b1;
                        7'd38:;
                        7'd39: begin
                            scl <= 1'b0;                    
                            minor_cnt <= 1'b0;
                            //-------------------------------
                            main_cnt <= 7'd7;
                            //-------------------------------
                        end
                        default : ;
                    endcase
                    end//(a7)
                    
                    //7、【读8bit数据+主机发送+1bitNOack】
                    else if(main_cnt == 7'd7)begin//（a8）
                    
                        minor_cnt <= minor_cnt + 1'b1;               
                        
                        case(minor_cnt)
                        7'd0: sda_dir <= 1'b0;             //sda线路设为向内读入状态
                        7'd1: begin
                            data_r[7] <= sda_in;
                            scl       <= 1'b1;
                        end
                        7'd3: scl  <= 1'b0;
                        7'd5: begin
                            data_r[6] <= sda_in ;
                            scl       <= 1'b1   ;
                        end
                        7'd7: scl  <= 1'b0;
                        7'd9: begin
                            data_r[5] <= sda_in;
                            scl       <= 1'b1  ;
                        end
                        7'd11: scl  <= 1'b0;
                        7'd13: begin
                            data_r[4] <= sda_in;
                            scl       <= 1'b1  ;
                        end
                        7'd15: scl  <= 1'b0;
                        7'd17: begin
                            data_r[3] <= sda_in;
                            scl       <= 1'b1  ;
                        end
                        7'd19: scl  <= 1'b0;
                        7'd21: begin
                            data_r[2] <= sda_in;
                            scl       <= 1'b1  ;
                        end
                        7'd23: scl  <= 1'b0;
                        7'd25: begin
                            data_r[1] <= sda_in;
                            scl       <= 1'b1  ;
                        end
                        7'd27: scl  <= 1'b0;
                        7'd29: begin
                            data_r[0] <= sda_in;
                            scl       <= 1'b1  ;
                        end
                        7'd31: scl  <= 1'b0;
                        7'd32: begin
                            sda_dir <= 1'b1;              //sda线路设为输出 准备让主机发送非应答
                            sda_out <= 1'b1;
                        end
                        7'd33: scl     <= 1'b1;
                        7'd35: begin
                            scl <= 1'b0;                  
                            minor_cnt <= 1'b0;
                            i2c_data_r <= data_r;         //把读完放到寄存器data_r中的数据，传出来。
                            //-------------------------------
                            main_cnt <= 7'd5;
                            //-------------------------------
                        end
                        default  :  ;
                    endcase
                    end//（a8）
                    
             end//（1）
    end//(0)
    //###################################################################################

endmodule

写测试

`timescale 1ns/1ns
module iic_tb;

          reg                clk    ;       
          reg                rst_n  ;       

                 
          wire          i2c_done    ;
          wire                scl   ;      
          wire                sda   ;


iic f1
     (
     
          //fpga
          .clk(clk)        ,      // 输入时钟(clk_freq)
          .rst_n(rst_n)      ,      // 复位信号
          
          //addr and data
          .slave_address(7'b1010000),               //从机地址
          .iic_inner_reg_addr(16'haa), //从机内部寄存器地址，若为8bit形式，直接用低八位
          .i2c_data_w(8'hbb) ,        //写数据端口
          .i2c_data_r() ,        //读数据端口
          
          //select mode
          .type16_type8(1'b0),        //从机内部寄存器地址是否属于16bit形式(16-1/8-0)
          .read1_write0(1'b0),       //读模式或写模式
          
          //i2c interface
          .i2c_exec(1'b1)   ,      // IIC使能【1】
          .i2c_done(i2c_done)   ,      // 一次操作完成的标志信号
          .scl(scl)        ,      // SCL输出
          .sda(sda)        ,      // SDA输出

          //user interface
          .dri_clk()           // 低频时钟输出
     );
     
     
    initial clk = 1'b1;
    always#10 clk = ~clk;
    initial begin
    rst_n = 1'b0; //未运行状态
    #400;
    rst_n = 1'b1;
    @(posedge i2c_done)
    
    $stop;
    
    end
    endmodule

在这里插入图片描述

搞IC的那些年
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
FPGA-Verilog语言-IIC接口驱动代码
04-11
2. **状态机**：IIC通信通常由一个状态机来控制，确保遵循协议规范的顺序。状态机可能包括IDLE（空闲）、START（启动）、ADDRESS（发送/接收地址）、DATA_TRAN（数据传输）、ACK_CHECK（检查应答）、RESTART（重启动...
FPGA中 通过IIC读写EEPROM驱动代码示例
08-20
综上所述，实现FPGA中的IIC驱动涉及对IIC协议的深入理解，使用Verilog HDL编写状态机和控制逻辑，以及进行仿真验证。通过这个过程，你可以实现与EEPROM的有效通信，从而在FPGA项目中发挥重要作用。
基于FPGA的I2C接口控制器（包含单字节和多字节读写）
weixin_50810761的博客
02-14 2152
本文档详细阐述了基于FPGA实现的I2C接口控制器设计，支持可变长度的寄存器地址和数据读写。通过分析EEPROM的单字节和页读写时序，提出了一个通用模块，使用状态机和计数器实现I2C通信。设计考虑了I2C的时序要求，如应答机制和数据线状态变化。文档提供了详细的端口信号列表、状态机设计和参考代码，以及对模块的仿真和资源消耗分析。
用verilog写IIC驱动
weixin_35748962的博客
01-11 260
IIC (Inter-Integrated Circuit) 通常称为 I2C，是一种串行通信协议，可以在线性、主从模式中传输数据。 用 Verilog 写 I2C 驱动程序，需要先了解 I2C 协议的工作原理。可以参考 I2C 官方文档或其他可靠资料了解 I2C 的基本操作。 下面是一个简单的 I2C 驱动程序的示例，它实现了 I2C 总线上的读操作： module i2c_master_rea...
【IIC的中断与DMA以及状态机编程】
最新发布
Xjb200512的博客
04-26 307
【代码】【IIC的中断与DMA以及状态机编程】
verilog实现I2C控制器 （小梅哥思路）----详细解析
weixin_45614076的博客
08-26 7354
verilog实现I2C控制器 （小梅哥思路）----详细解析
I2C基本概念讲解（时序，架构，速率）
HCD9701的博客
06-07 4220
I2C是一种同步串口总线的协议，由NXP公司设计。使用一主多从的设计框架，本文从基础出发，主要讲解I2C基本概念讲解（时序，架构，速率），分析IIC的时序图，以及拆分讲解IIC时序的各个部分内容
FPGA实现IIC通信（读写EEPROM）
xs_sd的博客
03-08 5872
FPGA实现iic通信（读写EEPROM） 实验平台：正点原子ALIENTEK开拓者FPGA开发板 1. IIC协议简介 1.1 什么是IIC协议 IIC即为Inter-Inegrated Circuit（集成电路总线），在上世纪八十年代左右由Philips公司（即现做的NXP半导体公司）设计出来的一种简单、双向、二进制总线标准。其只需要两根线（SDA数据线和SCL时钟线）即可实现总线连接的器件间的通信。SDA和SCL都是双向I/O线，所以主要适用于数据量小，距离短的主从通信，数据的传输速率在标准模式下可达
FPGA模块——IIC协议（FPGA做主机操作24C64）
Treasureljc的博客
11-15 783
重点是：SCL在低电平期间SDA可以进行数据变化，而SCL在高电平期间，SDA的数据要保持稳定。当SCL和SDA为高，SDA突然拉低的时候，是起始信号（下降沿）。掉电不丢失，采用固定的读写协议。数据的稳定性和可重复擦写性突出。当SCL为高时，SDA突然拉高，是结束信号（上升沿）。有16位，24C64实际用到13位寄存器地址。要先向器件进行虚写命令，再进行读命令。电路设计，可以配置24C64的地址。不读了主机FPGA进行非应答。
i2c.rar_IIC FPGA_fpga调试iic_iic verilog_iic调试_verilog iic
09-24
标题中的“i2c.rar_IIC_FPGA_fpga调试iic_iic_verilog_iic调试_verilog_iic”表明这是一个关于IIC（Inter-Integrated Circuit）通信协议在FPGA（Field-Programmable Gate Array）上实现的项目，其中包含了Verilog...
IIC_TOP(Verilog).rar
03-22
- **状态机设计**：IIC协议的流程可以通过状态机模型清晰地表示，使得设计易于理解和维护。 - **可配置性**：设计应允许配置参数，如IIC的速度等级、从机地址等，以适应不同的应用场景。 学习并理解这些Verilog模块...
用Verilog实现IIC协议
10-05
用Verilog实现I2C协议，有主机从机的代码，以及顶层模块和测试模块
IIC状态机的硬件描述语言
06-04
IIC状态机的硬件描述语言。 您上传的资源如果因版权、使用、内容完整度 等原因被举报并通过官方审核，将扣除通过该资源获得的全部积分
I2C从设备接收数据verilog代码实现
07-12
本资源是利用verilog语言实现的从设备接收存储数据，严格按照I2C总线时序来开发设计的，对于初学者有很大的帮助。
基于FPGA的iic主从机驱动实现 Verilog实现iic slave和iic master 顶层模块实现master对sla
07-09
项目中的"基于FPGA的iic主从机驱动实现 Verilog实现iic slave和iic master"可能包含以下步骤： 1. 设计I2C主设备和从设备的Verilog模块，分别实现基本的信号处理逻辑。 2. 设计顶层模块，将主从机模块集成在一起，并...
基于FPGA的MCP4725驱动程序
explode_boom的博客
11-08 3402
基于FPGA的MCP4725驱动程序 芯片资料       MCP4725是低功耗、高精度、单通道的12位缓冲电压输出数模转换器（Digital-to-Analog Convertor，DAC)，具有非易失性存储器（EEPROM)。用户可以使用I2C接口命令将DAC输入和配置数据烧写到非易失性存储器（EEPROM)。非易失性存储器功能使得DAC器件在断电期间仍能保持DAC输入代码，且DAC输出在上电后立即可用。   &nb
FPGA_IIC代码-正点原子 野火 小梅哥 特权同学对比写法（3）
weixin_41226265的博客
11-20 1072
首先介绍 IIC 驱动模块的设计，I2C 驱动模块的主要功能是按照 I2C 协议对 E2PROM 存储芯片执行数据读写操作。I2C 驱动模块框图和输入输出端口简介由图表可知，I2C 驱动模块包括 13 路输入输出信号，其中 7 路输入信号、5 路输出信号，还有一路 sda既可以做输出，也可以做输入。●clk、rst_n 是从顶层例化到 I2C 驱动模块的系统时钟和复位信号；● i2c_exec 是 I2C 触发执行信号，由 e2Prom 读写模块生成并传入，高电平有效；
IIC通信协议
STATEABC的博客
07-23 1362
IIC即Inter-Integrated Circuit(集成电路总线)，是一种双向、半双工、二线制串行通信总线。多用于主机和从机在数据量不大且传输距离短的场合下的主从通信。主机启动总线，并产生时钟用于传送数据，此时任何接收数据的器件均被认为是从机。
AXI interconnect IP核的说明及用法
热门推荐
QUACK_G的博客
07-21 1万+
AXI interconnect可以对AXI总线进行管理，支持多个主机采用AXI总线访问从机，或者一个主机访问多个从机。真正实现了总线通信，N Master模块与M Slave模块的通信，减少了相互间通信的复杂度，内部实现时钟域转换，不需要外部的过度干预，内部可实现FIFO等，免去了很多场景下需要FIFO，Register，位宽转换，协议转换的需求。.........
fpga驱动iic Verilog
05-26
以下是一个基本的FPGA I2C驱动程序的Verilog代码，它可以通过I2C总线与其他设备进行通信。 ```verilog module i2c_master( input clk, input rst, output scl, inout sda ); // I2C状态机定义 parameter IDLE ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

搞IC的那些年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值