基于FPGA的IIC通讯-MASTER接收篇

已于 2025-05-16 22:56:00 修改
阅读量518 收藏 4
点赞数 15
CC 4.0 BY-SA版权
分类专栏： 基于FPGA的OV5640图像传输 文章标签： fpga开发
于 2025-04-11 16:39:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/junpingc/article/details/147147862

（三）、主机读

        上一篇文章完成了IIC写程序代码，这篇文章主要是要实现IIC读程，有了IIC写程序的经验，对于IIC读来说就不会有一开始的迷茫，话不多说，先看下IIC读所需要的过程如何，如下图示:

        如图所示，上述包含了单字节读和多字节连续读的时序过程，分别为开始信号+从机地址+写信号+应答+寄存器地址+应答+再次的开始信号+从机地址+读信号+应答+data0+...+datan+PEC+应答+停止信号。

        对于PEC，他是IIC得一种校验码，这里先不用管它，因为大多数场景不需要使用，但是这个d代码也可以接收，此外，相对于IIC写代码来说，读代码会比写代码要复杂一点，另外还需注意中间得起始信号时序。

        话不多说，直接上代码，请各位注意版权问题，其次，代码在仿真和项目中已经初步实现读取功能，但是是否可应用于大多数场景还是未知得，若出现bug还需再次优化。

// ********************************************************
// Copyright: 优快云 account juningc
// The email address is: junpingc@noreply.gitcode.com
// Unauthorized copying is prohibited. If you need to use it, please contact the author
// All interpretation rights belong to the copyright author
// 2025年04月11日
// ********************************************************
module iic_read_master #
(
   parameter               DWID       = 8       ,
   parameter               UCNT       = 25      ,
   parameter               BUILD_TIME = 5       ,  //us
   parameter               HOLD_TIME  = 4          //us
)
(
   input                   clk_sys              ,
   input                   rst_sys              ,
   //
   input                   write_dena           ,
   input      [6:0]        slave_addr           ,
   input      [7:0]        regis_addr           ,

   input      [2:0]        read_mode            ,
   output reg              read_valid           ,
   output reg [7:0]        read_tdata           ,
   //
   input                   i2c_scl_m_i          ,
   output                  i2c_scl_m_o          ,
   output                  i2c_scl_m_t          ,
   input                   i2c_sda_m_i          ,
   output                  i2c_sda_m_o          ,
   output                  i2c_sda_m_t
);
// ********************************************************
// localparam
// ********************************************************
localparam                 IDLE    = 4'd0       ;
localparam                 START   = 4'd1       ;
localparam                 SADDR   = 4'd2       ;
localparam                 RADDR   = 4'd3       ;
localparam                 AGAIN   = 4'd4       ;
localparam                 DADDR   = 4'd5       ;
localparam                 RDATA   = 4'd6       ;
localparam                 RACK    = 4'd7       ;
localparam                 STOP    = 4'd8       ;


// ********************************************************
// signal
// ********************************************************
reg   [3:0]                cstate = IDLE        ;
reg   [3:0]                nstate = IDLE        ;

wire                       write_start          ;
reg                        write_sack           ;
wire                       pedge_sack           ;

reg   [15:0]               cnt_us = 0           ;
reg   [7:0]                cnt_div = 0          ;
reg   [3:0]                cnt_stop = 0         ;
reg   [3:0]                cnt_tags = 0         ;

reg   [2:0]                shift_wcnt = 0       ;
reg   [3:0]                shift_rcnt = 0       ;
reg   [7:0]                shift_dat = 0        ;

reg                        reg_str = 0          ;
reg                        reg_scl              ;
reg                        reg_sda              ;

wire                       scl_pedge            ;
wire                       scl_nedge            ;
wire                       sda_pedge            ;
wire                       sda_nedge            ;
// ********************************************************
// process
// ********************************************************

always @ ( posedge clk_sys )
begin
   if( rst_sys || &cnt_stop )
      reg_str <= 0 ;
   else if( write_start )
      reg_str <= 1 ;
   else ;
end

always @ ( posedge clk_sys ) // 1s == 25M    1us == 25次
begin
   if( rst_sys || &cnt_stop )
      cnt_div <= 0 ;
   else if( cnt_div == UCNT - 1 )
      cnt_div <= 0 ;
   else if( reg_str )
      cnt_div <= cnt_div + 1 ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == STOP )
      cnt_us <= 0 ;
   else if( reg_str == 1 && cnt_div == UCNT - 1 )
      cnt_us <= cnt_us + 1 ;
   else ;
end

// ========================================================
//
// ========================================================

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      cstate = IDLE ;
   else
      cstate = nstate ;
end

always @ ( * )
begin
   case( cstate )
      IDLE : begin
         if( write_start )
            nstate = START ;
         else
            nstate = IDLE ;
      end
      START : begin
         if( cnt_us == BUILD_TIME + HOLD_TIME )
            nstate = SADDR ;
         else
            nstate = START ;
      end
      SADDR : begin
         if( pedge_sack )
            nstate = RADDR ;
         else
            nstate = SADDR ;
      end
      RADDR : begin
         if( pedge_sack )
            nstate = AGAIN ;
         else
            nstate = RADDR ;
      end
      AGAIN : begin
         if( cnt_us == 16'h2f + 16'h5 + 16'h4 )
            nstate = DADDR ;
         else
            nstate = AGAIN ;
      end
      DADDR : begin
         if( pedge_sack )
            nstate = RDATA ;
         else
            nstate = DADDR ;
      end
      RDATA : begin
         if( shift_rcnt == 0 && scl_nedge && read_mode[2] == 0 )
            nstate = RACK ;
         else if( shift_rcnt == 0 && scl_nedge && read_mode[2] == 1 && cnt_tags == read_mode[1:0] + 1 )
            nstate = RACK ;
         else
            nstate = RDATA ;
      end
      RACK : begin
         if( scl_pedge )
            nstate = STOP ;
         else
            nstate = RACK ;
      end
      STOP : begin
         if( &cnt_stop )
            nstate = IDLE ;
         else
            nstate = STOP ;
      end
      default:nstate = IDLE ;
   endcase
end
// ========================================================
//
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == STOP )
      reg_scl <= 1 ;
   else if( cnt_us <= BUILD_TIME + HOLD_TIME )
      reg_scl <= 1 ;
   else if( cstate == AGAIN && cnt_us >= 16'h2f && cnt_us < 16'h38 )
      reg_scl <= 1 ;
   else if( cstate == AGAIN && ( cnt_us == 16'h2f + 16'h5 + 16'h4 ) )
      reg_scl <= 0 ;
   else if( cstate == RACK && scl_pedge )
      reg_scl <= 1 ;
   else if( cnt_us % 2 == 0 )
      reg_scl <= 0 ;
   else if( cnt_us % 2 == 1 )
      reg_scl <= 1 ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys || pedge_sack )
      shift_wcnt <= 0 ;
   else if( i2c_sda_m_t == 1'b0 && i2c_sda_m_i == 1'b0 )
      shift_wcnt <= shift_wcnt ;
   else if(( cstate == SADDR || cstate == RADDR || cstate == DADDR ) && scl_nedge )
      shift_wcnt <= shift_wcnt + ~&shift_wcnt ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      reg_sda <= 1 ;
   else if(( cstate == IDLE || cstate == START || cstate == SADDR || cstate == RADDR || cstate == AGAIN || cstate == DADDR ) && ( i2c_sda_m_i == 0 ))
      reg_sda <= 1'bz ;
   else if( reg_str == 1 && cnt_us == BUILD_TIME )
      reg_sda <= 0 ;
   else if( cstate == AGAIN && cnt_us == 16'h2e )
      reg_sda <= 1 ;
   else if( cstate == AGAIN && cnt_us == 16'h33 )
      reg_sda <= 0 ;
   else if( cstate == SADDR && scl_nedge )
   begin
      case ( shift_wcnt )
         0 : reg_sda <= slave_addr[6];
         1 : reg_sda <= slave_addr[5];
         2 : reg_sda <= slave_addr[4];
         3 : reg_sda <= slave_addr[3];
         4 : reg_sda <= slave_addr[2];
         5 : reg_sda <= slave_addr[1];
         6 : reg_sda <= slave_addr[0];
         7 : reg_sda <= 0 ; // WRITER
         default : reg_sda <= 0 ;
      endcase
   end
   else if( cstate == RADDR )
   begin
      case ( shift_wcnt )
         0 : reg_sda <= regis_addr[7];
         1 : reg_sda <= regis_addr[6];
         2 : reg_sda <= regis_addr[5];
         3 : reg_sda <= regis_addr[4];
         4 : reg_sda <= regis_addr[3];
         5 : reg_sda <= regis_addr[2];
         6 : reg_sda <= regis_addr[1];
         7 : reg_sda <= regis_addr[0] ;
         default : reg_sda <= 0 ;
      endcase
   end
   else if( cstate == DADDR && scl_nedge )
      case ( shift_wcnt )
         0 : reg_sda <= slave_addr[6];
         1 : reg_sda <= slave_addr[5];
         2 : reg_sda <= slave_addr[4];
         3 : reg_sda <= slave_addr[3];
         4 : reg_sda <= slave_addr[2];
         5 : reg_sda <= slave_addr[1];
         6 : reg_sda <= slave_addr[0];
         7 : reg_sda <= 1 ; // READ
         default : reg_sda <= 0 ;
      endcase
   else if( cstate == RDATA && shift_rcnt == 9 && scl_nedge && read_mode[2] == 0)
      reg_sda <= 1 ;
   else if( cstate == RDATA && shift_rcnt == 0 && scl_nedge && read_mode[2] == 1)
      reg_sda <= 1'hz ;
   else if( cstate == RDATA && shift_rcnt == 9 && scl_nedge && read_mode[2] == 1 && cnt_tags != read_mode + 1 )
      reg_sda <= 0 ;
   else if( cstate == RACK && scl_nedge )
      reg_sda <= 0 ;
   else if( cstate == STOP && cnt_stop == 4 )
      reg_sda <= 1 ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      write_sack <= 0 ;
   else if(( cstate != IDLE )&& ( i2c_sda_m_t == 0 && i2c_sda_m_i == 0 ))
      write_sack <= 1 ;
   else
      write_sack <= 0 ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == IDLE )
      cnt_tags <= 0 ;
   else if( cstate == RDATA && shift_rcnt == 9 && scl_pedge && read_mode[2] == 1 )
      cnt_tags <= cnt_tags + ~&cnt_tags ;
   else ;
end

// ========================================================
// READ
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys )
      shift_rcnt <= 0 ;
   else if(shift_rcnt == 9 && scl_pedge )
      shift_rcnt <= 0 ;
   else if( cstate == RDATA && scl_pedge && ( cnt_tags == 0 || read_mode[2] == 0 ))
      shift_rcnt <= shift_rcnt + 1 ;
   else if( cstate == RDATA && (cnt_tags > 0 && scl_nedge && read_mode[2] == 1 ))
      shift_rcnt <= shift_rcnt + 1 ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      shift_dat <= 0 ;
   else if( cstate == RDATA && scl_pedge )
      shift_dat <= {shift_dat[6:0],i2c_sda_m_i};
   else ;
end

// always @ ( posedge clk_sys )
// begin
   // if( rst_sys || ( cstate == RDATA && shift_edge == 2 && scl_pedge ))
      // shift_edge <= 0 ;
   // else if( cstate == RDATA && shift_rcnt == 9 && scl_pedge )
      // shift_edge <= shift_edge + 1 ;
   // else if( cstate == RDATA && shift_rcnt == 0 && scl_pedge && shift_edge == 1 )
      // shift_edge <= shift_edge + ~&shift_edge ;
   // else ;
// end

always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == IDLE )
      cnt_stop <= 0 ;
   else if( cstate == STOP && reg_scl && cnt_div == UCNT - 1 )
      cnt_stop <= cnt_stop + ~&cnt_stop ;
   else ;
end

assign i2c_scl_m_o = reg_scl ;
assign i2c_sda_m_o = reg_sda ;
assign i2c_sda_m_t = i2c_sda_m_i ;
// ========================================================
//
// ========================================================

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      read_valid <= 0 ;
   else if( cstate == RDATA && shift_rcnt == 9 )
      read_valid <= 1 ;
   else
      read_valid <= 0 ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      read_tdata <= 0 ;
   else if( cstate == RDATA && shift_rcnt == 9 )
      read_tdata <= shift_dat ;
   else ;
end



// ========================================================
//
// ========================================================
edge_detect u0_edge_detect
(
   //input
   .clk                          ( clk_sys               ),
   .sig_in                       ( write_dena            ),
   //output
   .p_edge                       ( write_start           ),
   .n_edge                       (                       )
);

edge_detect u2_edge_detect
(
   //input
   .clk                          ( clk_sys               ),
   .sig_in                       ( write_sack            ),
   //output
   .p_edge                       ( pedge_sack            ),
   .n_edge                       (                       )
);

edge_detect u1_edge_detect
(
   //input
   .clk                          ( clk_sys               ),
   .sig_in                       ( reg_scl               ),
   //output
   .p_edge                       ( scl_pedge             ),
   .n_edge                       ( scl_nedge             )
);

edge_detect u3_edge_detect
(
   //input
   .clk                          ( clk_sys               ),
   .sig_in                       ( cstate == RDATA       ),
   //output
   .p_edge                       ( sda_pedge             ),
   .n_edge                       ( sda_nedge             )
);




endmodule

        具体得仿真等到IIC-Slave读取代码书写完成后会发布上传

I2C连续读写实现
小王在努力...的博客
08-15 3484
上文的 i2c_bit_shift 模块说完了，我们发现实现一个字节的写操作还是可以实现的，实际的应用中我们不可能只写一个字节的数据，那么此时这个 i2c_bit_shift 模块用来连续写就有些不方便了，从上面的仿真代码就能看出来，这时就需要一个上层模块来控制这个i2c_bit_shift 模块去连续写，这样就方便一些。
基于FPGA的IIC通讯-SLAVE接收篇
junpingc的博客
04-17 356
上一篇我们讲解了IIC的MASTER控制读写过程，今天我们讲一下IIC的SLAVE接收和回读的篇章，今天先开始介绍IIC的从机接收写指令的过程。由图可看知，下发的IIC与解析出的IIC一致。
基于FPGA的IIC通讯-MASTER发送篇
junpingc的博客
04-07 459
本章节进入到IIC通讯篇章，本篇章开始就得开始付费啦，请关注的各位理解，因为代码每个人的想法不同书写的个人版权，请大家注意版权问题，IIC通讯主要分为两大部分，一个是主机读和主机写，另一个是从机接收，IIC具体的原理这里就不细讲，主要是依据IIC时序进行代码编写，本节主要是介绍IIC主机写程序，依据的是SMBUS2.0协议，它与IIC的不同在于存在IIC_SCL时钟的约束，即SMBUS是IIC的一个子集。好的，现在话不多说，我的IIC-MASTER-WRITE的代码支持什么功能呢？
FPGA常用接口协议--IIC
不会武功的火柴的博客
05-03 5864
  IIC接口协议是一种比较简单、常用的一种接口协议，使用它的场景很广泛（最常见的如EEPROM读写、一些寄存器的配置等），是我们学习FPGA过程中常用的接口协议，本篇使用EEPROM（AT24C512B）器件作为目标器件进行IIC接口实现，其他器件读写方式略有差别，IIC协议不变。  IIC （Inter-Integrated Circuit（集成电路总线）），百度百科解释如下：IIC-百度百科。  这里简单概括一下协议内容:IIC（IIC，inter-Integrated circuit）,两线式串行总
基于FPGA的IIC控制EEPROM读写（1）
Turing_kun的博客
07-16 1051
本文简单介绍了IIC协议的基础概念，以及用Verilog如何去实现，仿真效果和上版效果如何，主要为个人学习过程的记录。
基于FPGA的ICG-20330陀螺仪设计
FDL_AQ的博客
01-20 4694
设计要求 本次设计使用CMOD-S7和ICG-20330搭建一个基于FPGA的陀螺仪驱动系统，最终的设计要求有如下几点： 理解陀螺仪芯片工作原理； 正确使用FPGA驱动ICG-20330陀螺仪芯片，能够正常获取陀螺仪芯片的数据； FPGA正常采集陀螺仪芯片数据，完成陀螺仪芯片的数据整合工作； 通过串口将数据发送至上位机； 根据陀螺仪芯片的工作原理，将上位机数据正确转换成对应的X,Y,Z轴的角度等信息。 设计方案 3.1 设计平台介绍 3.1.1 FPGA介绍 本次设计使用CM...
FPGA—IIC 设计
Rayone_的博客
09-12 1782
主要介绍了IIC通信协议的特点以及RTL代码的设计
FPGA——基于IIC协议的EEPROM功能实现
zhu1289的博客
08-14 3219
关于EEPROM学习的小结。其中相关代码来自正点原子、相关资料来自米联客。
基于FPGA的IIC控制EEPROM读写（2）
Turing_kun的博客
07-17 1040
主要介绍了EEPROM的基本信息，以及如何对他进行读写的操作。本文包括了本人学习过程中个人理解写出的读写操作代码，以及一个复用性与可读性较高的写法。
基于FPGA的iic主从机驱动实现 Verilog实现iic slave和iic master 顶层模块实现master对sla
07-09
项目中的"基于FPGA的iic主从机驱动实现 Verilog实现iic slave和iic master"可能包含以下步骤： 1. 设计I2C主设备和从设备的Verilog模块，分别实现基本的信号处理逻辑。 2. 设计顶层模块，将主从机模块集成在一起，并...
基于FPGA的iic主从机驱动实现 Verilog实现iic slave和iic master 顶层模块实现master对slave自定义的寄存器读取 带仿真模块
01-09
本文档聚焦于在FPGA平台上利用Verilog语言实现I2C（Inter-Integrated Circuit）总线协议的主从机（Master-Slave）驱动。I2C总线是一种多主机串行总线，广泛用于各种集成电路之间的短距离通信。通过实现I2C主从机驱动...
基于FPGA的I2C主从机驱动实现及自定义寄存器读取的Verilog设计与仿真,基于FPGA的iic主从机驱动实现 Verilog实现iic slave和iic master 顶层模块实现master
01-21
接下来，我们需要在FPGA上实现顶层模块，该模块将作为I2C通信的主节点（master），负责发起通信请求、发送起始和停止条件、处理时钟伸展和等待状态，以及管理数据的发送和接收。此外，顶层模块还需要能够识别和操作...
基于FPGA的I2C实验Verilog源代码_代码分析_Master/Slave_fpga_verilog_i2cverific
10-04
这个实验项目名为“基于FPGA的I2C实验”，通过Verilog硬件描述语言实现了I2C协议的主（Master）和从（Slave）模式，同时提供了详细的代码分析和验证过程。 1. Verilog HDL（硬件描述语言）：Verilog是用于描述数字...
应用代码解释
weixin_46151178的博客
07-25 19
本文介绍了基于Aurora协议的光纤通信系统数据流处理流程，主要包含发送和接收两个方向。发送路径从UART输入开始，经aurora_top模块进行8B/10B编码后通过光纤传输；接收路径则反向处理光纤数据并输出至UART。关键处理环节包括时钟域同步、FIFO缓冲控制（含写入计数和状态机读取）、AXI Stream封装等，涉及uart_fiber_top.v、aurora_top.v和aurora_ctrl_mod.v三个主要模块的协同工作。文中详细标注了各功能在源代码中的具体行号位置（如FIFO写入控制位于
再谈fpga开发（状态机的应用）
嵌入式-老费，一个分享专业嵌入式知识的blog
07-25 663
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】         前面说过，fpga上面最基础的部分是寄存器，而所有寄存器存在每一个clock下，都有被翻转的可能性。至于这些寄存器是不是真的翻转，或者说是保持不变，取决于当时的状态。所以在clock运行的区间内，我们习惯于把任务切分成若干个状态，不同状态下的register是不一样的，当然只有一部分register参与工作，大部分保持不变。等到条件成熟的时候，再切换到下一个状态。这就是fpga下状态
嵌入式开发
qq_26074053的博客
07-22 866
逻辑开发与软件开发，皆为高度专业化的技术领域，能在两者之间自由穿梭、解决复杂问题的工程师，凤毛麟角。然而，“精通”本身并无边界。在实际工程中，无论是算法实现、高速接口，还是雷达系统、电机控制，每一个方向都深邃如海，足以让人终身钻研。真正重要的，从来不是“掌握一切”，而是在中，构建起，持续迭代，稳步积累。“精通”或许遥远，但问题所需的知识是清晰、有限、可攻克的。一旦识别了问题域，路径便不再模糊；只要开始积累，掌控力终将悄然生长。
verilator如何实现RTL的仿真(腾讯混元)
baidu_38316985的博客
07-22 544
Verilator 通过将 Verilog RTL 转换为高效的 C++ 模型，实现了高性能的仿真。使用内部解析器生成 AST；对 AST 进行优化与转换；将 RTL 结构映射为 C++ 类与函数；通过 C++ 编译生成可执行文件；在主程序中控制仿真流程。这种静态编译的方式使 Verilator 在大规模设计验证中具有显著优势，但也牺牲了一些传统仿真器的灵活性和功能完整性。
[NLP]UPF+RTL联合仿真的VCS命令及UPF-aware 波形工具的使用
元直的博客
07-25 340
摘要：本文介绍了UPF+RTL联合仿真的VCS命令实现方法及UPF-aware波形工具的使用技巧。重点包括：1) Testbench中低功耗控制信号(pwr_sw_ctrl/iso_ctrl/ret_ctrl)的驱动方法，模拟"上电-断电-唤醒"场景；2) UPF-aware波形工具(Verdi)的特殊功能：显示电源域状态、高亮隔离/保持行为、电源控制信号专用面板；3) 典型VCS仿真命令示例，包含UPF文件加载、波形生成等关键参数。通过联合仿真和波形分析，可直观验证芯片低功耗设计的正确
[NLP]多电源域设计的仿真验证方法
最新发布
元直的博客
07-25 330
本文介绍了多电源域设计的仿真验证方法。首先给出了包含两个电源域PD1和PD2的Testbench示例，包含5种典型低功耗场景：单域掉电/唤醒、全芯片掉电/恢复等。其次详细说明了在Verdi中正确显示电源域状态的操作步骤，包括加载UPF文件、使用PowerAware模式等。最后解释了VCS参数-debug_access+all的作用，该参数可确保生成包含所有低功耗相关调试信息的波形文件，是进行低功耗验证的必要条件。这些方法共同构成了完整的低功耗设计验证流程。
FPGA IIC master代码
05-26
### FPGA实现IIC Master的代码示例 以下是基于Verilog语言的一个简单IIC Master模块实现代码。该代码实现了基本的IIC通信功能，包括启动条件、停止条件、发送字节和接收应答等功能。 ```verilog module iic_master ( input wire clk, // 主时钟 input wire reset_n, // 复位信号，低电平有效 output reg sda, // 数据线SDA output reg scl, // 时钟线SCL input wire start_iic, // 启动IIC传输请求 input wire [7:0] data_out,// 要发送的数据 output reg ack_received, // 接收到ACK的状态标志 output reg busy // 总线忙状态指示 ); parameter IDLE = 2'b00; parameter START = 2'b01; parameter SEND_BYTE = 2'b10; parameter STOP = 2'b11; reg [1:0] state_reg, state_next; // 状态寄存器 reg [3:0] bit_count_reg, bit_count_next; // 计数器用于跟踪当前处理的比特位置 reg [7:0] byte_reg, byte_next; // 当前要发送的字节缓存 reg sda_reg, sda_next; // SDA内部寄存器 reg scl_reg, scl_next; // SCL内部寄存器 // 默认初始化 always @(posedge clk or negedge reset_n) begin if (!reset_n) begin state_reg <= IDLE; bit_count_reg <= 4'd0; byte_reg <= 8'h00; sda_reg <= 1'b1; scl_reg <= 1'b1; ack_received <= 1'b0; busy <= 1'b0; end else begin state_reg <= state_next; bit_count_reg <= bit_count_next; byte_reg <= byte_next; sda_reg <= sda_next; scl_reg <= scl_next; ack_received <= (state_reg == STOP && !scl_reg); busy <= !(state_reg == IDLE || state_reg == STOP); end end // 下一状态逻辑 always @(*) begin case(state_reg) IDLE: begin if(start_iic) begin state_next = START; bit_count_next = 4'd7; byte_next = data_out; sda_next = 1'b0; // 开始条件：拉低SDA scl_next = 1'b1; end else begin state_next = IDLE; bit_count_next = bit_count_reg; byte_next = byte_reg; sda_next = 1'b1; scl_next = 1'b1; end end START: begin state_next = SEND_BYTE; bit_count_next = bit_count_reg; byte_next = byte_reg; sda_next = sda_reg; scl_next = 1'b0; // 结束开始条件：释放SDA并保持SCL高 end SEND_BYTE: begin if(bit_count_reg >= 0) begin state_next = SEND_BYTE; bit_count_next = bit_count_reg - 1; byte_next = {byte_reg[6:0], 1'b0}; sda_next = byte_reg[7]; scl_next = ~scl_reg; // 切换SCL高低电平完成一位数据传输 end else begin state_next = STOP; bit_count_next = 4'd0; byte_next = 8'h00; sda_next = 1'b1; // 准备结束条件 scl_next = 1'b1; end end STOP: begin state_next = IDLE; bit_count_next = 4'd0; byte_next = 8'h00; sda_next = 1'b1; // 停止条件：先拉高SDA再拉高SCL scl_next = 1'b1; end default: begin state_next = IDLE; bit_count_next = 4'd0; byte_next = 8'h00; sda_next = 1'b1; scl_next = 1'b1; end endcase end assign sda = sda_reg; assign scl = scl_reg; endmodule ``` 此代码展示了如何通过有限状态机(FSM)来管理IIC协议中的各种操作阶段[^1]。它还涉及到了物理层的设计细节，例如SDA和SCL信号的具体驱动方法[^2]。 #### 关键点说明 - **FSM结构**：采用了一个简单的四态有限状态机(IDLE, START, SEND_BYTE, STOP)，用来控制整个IIC事务流程。 - **同步逻辑**：所有的寄存器更新都在`clk`上升沿触发，并受`reset_n`复位信号影响。 - **异步事件响应**：当检测到`start_iic`信号激活时，立即进入START状态发起新的IIC事务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值