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

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

文章目录

前言

上一篇我们讲解了IIC的MASTER控制读写过程，今天我们讲一下IIC的SLAVE接收和回读的篇章，今天先开始介绍IIC的从机接收写指令的过程。

一、IIC从机接收

如下图示:
IIC
从机接收可以理解为是主机发送的逆过程，识别开始信号，主从地址握手，识别寄存器，获取寄存器值和数据值，最终完成数据接收和控制。

二、代码内容

在这里插module iic_slave #
(
   parameter               BYTE = 4             ,
   parameter               DWID = 32            ,
   parameter               UCNT = 25
)
(
   input                   clk_sys              ,
   input                   rst_sys              ,
   // 
   input       [6:0]       slave_addr           ,
   input                   contin_mode          ,
   output reg              iic_ena              ,
   output reg  [7:0]       iic_adr              ,
   output reg  [DWID-1:0]  iic_dat              ,
   //
   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  SLAV = 4'd1 ;
localparam  REGS = 4'd2 ;
localparam  MODE = 4'd3 ;
localparam  CMWRTIE  = 4'd4 ;
localparam  CMREAD   = 4'd5 ;
localparam  OMWRITER = 4'd6 ;
localparam  OMREAD   = 4'd7 ;
localparam  STOP = 4'd8 ;
// ********************************************************
// signal
// ********************************************************
reg      [3:0]             cstate = IDLE        ;
reg      [3:0]             nstate = IDLE        ;
   
wire                       start_pedge          ;
wire                       start_nedge          ;
wire                       stop_pedge           ;
wire                       stop_nedge           ;
reg                        read_start = 0       ;
reg                        write_read = 0       ;

wire                       scl_pedge            ;
wire                       scl_nedge            ;

reg      [7:0]             cnt_div = 0          ;
reg      [15:0]            cnt_us = 0           ;
reg      [15:0]            reg_us = 0           ;
reg      [7:0]             cnt_scl = 0          ;
reg      [7:0]             cnt_sda = 0          ;
reg      [7:0]             cnt_tags = 0         ;

reg      [6:0]             iic_slave = 0        ;
reg      [7:0]             reg_slave = 0        ;
reg      [7:0]             reg_regsi = 0        ;
reg      [7:0]             reg_data  = 0        ;
reg                        reg_stop  = 0        ;

reg      [3:0]             shift_cnt = 0        ;
reg      [3:0]             shift_reg = 0        ;
reg      [5:0]             shift_dat = 0        ;
reg                        readback = 0         ;

reg      [31:0]            data_value           ;
reg                        reg_sda_o = 1        ;
wire                       dly_sda_o            ;
// ********************************************************
// process
// ********************************************************
always @ ( posedge clk_sys )
begin
   if( rst_sys )
      cstate = IDLE ;
   else
      cstate = nstate ;
end

always @ ( * )
begin
   case ( cstate )
      IDLE : begin
         if( read_start )
            nstate = SLAV ;
         else 
            nstate = IDLE ;
      end
      SLAV : begin
         if(( slave_addr == iic_slave ) && readback )
            nstate = REGS ;
         else 
            nstate = SLAV ;
      end
      REGS : begin
         if( readback )
            nstate = MODE ;
         else
            nstate = REGS ;
      end
      MODE : begin
         if( contin_mode && write_read == 0 )
            nstate = CMWRTIE ;
         else if( contin_mode && write_read == 1 )
            nstate = CMREAD ;
         else if( contin_mode == 0 && write_read == 0 )
            nstate = OMWRITER ;
         else if( contin_mode == 0 && write_read == 1 )
            nstate = OMREAD ;
         else
            nstate = MODE ;
      end
      CMWRTIE : begin
         if( readback && cnt_tags == BYTE - 1 )
            nstate = STOP ;
         else 
            nstate = CMWRTIE ;
      end
      OMWRITER : begin
         if( readback )
            nstate = STOP ;
         else
            nstate = OMWRITER ;
      end
      STOP : begin
         if( stop_nedge )
            nstate = IDLE ;
         else 
            nstate = STOP ;
      end
      default : nstate = IDLE ;
   endcase
end

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

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

// ========================================================
// READBACK
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys )
      cnt_scl <= 0 ;
   else if( i2c_scl_m_i && cstate == IDLE && cnt_div == UCNT - 1 )
      cnt_scl <= cnt_scl + ~&cnt_scl ;
end

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

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      readback <= 0 ;
   else if( i2c_sda_m_o == 1'b0 && i2c_sda_m_t == 1'b0 && scl_pedge )
      readback <= 1 ;
   else 
      readback <= 0 ;
end

// ========================================================
// RECV
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys )
      read_start <= 0 ;
   else if( cstate == IDLE && start_nedge )
      read_start <= 1 ;
   else
      read_start <= 0 ;
end

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

always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate != SLAV)
      shift_cnt <= 0 ;
   else if( cstate == SLAV && scl_pedge )
      shift_cnt <= shift_cnt + ~&shift_cnt ;
   else ;   
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      iic_slave <= 0 ;
   else if( cstate == SLAV && shift_cnt == 7 )
      iic_slave <= reg_slave ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == IDLE )
      write_read <= 0 ;
   else if( cstate == SLAV && shift_cnt == 8 && scl_pedge )
   begin
      if( i2c_sda_m_i == 0 )
         write_read <= 0 ;
      else if( i2c_sda_m_i == 1 )
         write_read <= 1 ;
      else ;
   end
end
// ========================================================
// REG ADDR
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate != REGS )
      shift_reg <= 0 ;
   else if( cstate == REGS && scl_pedge )
      shift_reg <= shift_reg + ~&shift_reg ;
   else ;
end

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

// ========================================================
//
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == IDLE || readback )
      shift_dat <= 0 ;
   else if((cstate == OMWRITER || cstate == CMWRTIE ) && scl_pedge )
      shift_dat <= shift_dat + ~&shift_dat ;
   else ;
end

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

always @ ( posedge clk_sys )
begin
   if( rst_sys || cstate == IDLE )
      cnt_tags <= 0 ;
   else if( cstate == CMWRTIE && readback )
      cnt_tags <= cnt_tags + 1 ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      data_value <= 0 ;
   else if( cstate == CMWRTIE && shift_dat == 8 && scl_pedge )
      data_value <= {data_value[23:0],reg_data};
   else ;
end

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

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      iic_ena <= 0 ;
   else if( cstate == STOP && scl_pedge )
      iic_ena <= 1 ;
   else
      iic_ena <= 0 ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      iic_adr <= 0 ;
   else if( cstate == STOP && scl_pedge )
      iic_adr <= reg_regsi ;
   else ;
end

always @ ( posedge clk_sys )
begin
   if( rst_sys )
      iic_dat <= 0 ;
   else if( cstate == STOP && scl_pedge && contin_mode == 0 )
      iic_dat <= reg_data ;
   else if( cstate == STOP && scl_pedge && contin_mode == 1 )
      iic_dat <= data_value ;
end

// ========================================================
//
// ========================================================
always @ ( posedge clk_sys )
begin
   if( cstate == STOP && scl_pedge )
      reg_stop <= 1 ;
   else if( cstate == STOP && start_pedge )
      reg_stop <= 0 ;
   else ;
end
// ========================================================
//
// ========================================================
always @ ( posedge clk_sys )
begin
   if( rst_sys )
      reg_sda_o <= 1 ;
   else if( cstate == SLAV && shift_cnt == 8 && scl_nedge )
      reg_sda_o <= 0 ;
   else if( cstate == REGS && shift_reg == 0 && scl_nedge )
      reg_sda_o <= 1 ;
   else if( cstate == REGS && shift_reg == 8 && scl_nedge )
      reg_sda_o <= 0 ;
   else if( cstate == REGS && shift_reg == 9 && scl_nedge )
      reg_sda_o <= 1 ;
   else if( cstate == OMWRITER && shift_dat == 0 && scl_nedge )
      reg_sda_o <= 1 ;
   else if((cstate == OMWRITER || cstate == CMWRTIE ) && shift_dat == 8 && scl_nedge )
      reg_sda_o <= 0 ;
   else if( cstate == OMWRITER && shift_dat == 9 && scl_nedge )
      reg_sda_o <= 1 ;
   else if( cstate == CMWRTIE && shift_dat == 0 && scl_nedge )
      reg_sda_o <= 1 ;
   else if((cstate == STOP && scl_nedge )|| cstate == IDLE )
      reg_sda_o <= 1 ;
   else ;
end

assign i2c_sda_m_o = reg_sda_o ;
assign i2c_sda_m_t = reg_sda_o ; 
// ========================================================
//
// ========================================================

edge_detect u0_edge_detect
(
   //input
   .clk                          ( clk_sys               ),
   .sig_in                       ( i2c_sda_m_i           ),
   //output
   .p_edge                       ( start_pedge           ),
   .n_edge                       ( start_nedge           )
);

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

edge_detect u2_edge_detect
(
   //input
   .clk                          ( clk_sys               ),
   .sig_in                       ( reg_stop              ),
   //output
   .p_edge                       ( stop_pedge            ),
   .n_edge                       ( stop_nedge            )
);

delay_base_reg #
(
   .DATA_WIDTH                   ( 1                     ),  
   .DELAY_TAPS                   ( 2                     )   
)u_delay_base_reg
(
   //input
   .clk                          ( clk_sys               ),
   .wrenin                       ( 1'b1                  ),
   .datain                       ( reg_sda_o             ),

   //output
   .wrenout                      (                       ),
   .dataout                      ( dly_sda_o             )
);


endmodule入代码片

调试总结

总结
由图可看知，下发的IIC与解析出的IIC一致

基于FPGA的图像边缘检测（OV5640）
weixin_56481118的博客
07-08 3883
边缘主要存在于图像中目标与目标之间，目标与背景之间，区域与区域之间。边缘检测的目的就是找到图像中亮度变化剧烈的像素点构成的集合，表现出来往往是轮廓。如果图像中边缘能够精确的测量和定位，那么，就意味着实际的物体能够被定位和测量，包括物体的面积，物体的直径，物体的形状等就能被测量。基于此，边缘检测技术在许多场景下被应用，如：车牌检测与提取，物体识别等。数字图像处理是指将图像信号转换成数字信号并利用计算机对其进行处理的过程。
OV5640_top中的i2c_ctrl代码结合仿真波形理解
weixin_46312715的博客
02-15 2351
若想要实现数据的连续读/写，可持续拉高读/写使能 rd_en/wr_en，并输入有效的。写入一个时钟的高电平，表示数据读取完成，随后状态机跳转到。”，表 示执行写操作；”，表示进行读操作，控制字节写入完毕后，状态机跳转到。位存储地址或单字节存储地址写入完成后，状态机跳转到。SEND_B_ADDR_H(发送高字节地址状态)SEND_B_ADDR_L(发送低字节地址状态)SEND_D_ADDR(发送器件地址状态)；SEND_B_ADDR_L(发送低字节地址状。单字节数据，待数据读取完成户，状态机跳转到。
I2C_Slave.zip_IIC SLAVE_IIC slave VHDL_fpga IIC slave_i2c slave
07-15
这是iic Slave模式的源代码，可用于嵌入式FPGA，挂载在PLB总线上
三，基于FPGA的IIC主机与从机通用编程设计
weixin_41838250的博客
09-24 3395
1，IIC协议 IIC，即Inter-Integrated Circuit(集成电路总线)，这种总线类型是由飞利浦半导体公司在八十年代设计出来的一种简单、双向、二线制、同步串行总线。是当今电子设计中应用最为广泛的串行总线之一。在很多领域有着广泛的应用，如存储器、LED及LCD驱动器、AD/DA转换器、传感器、图像处理领域的摄像头配置（SCCB）等等。 IIC是一种多向控制总线，也就是说多个IIC设备可以连接到同一总线结构下，每个连接到总线的设备都具有唯一的地址，主机可以做为发送器...
slaveiic程序Verilog介绍：实现FPGA IIC从设备通信
最新发布
gitblog_06773的博客
05-27 346
slaveiic程序Verilog介绍：实现FPGA IIC从设备通信 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在FPGA开发领域，实现设备间的通信协议是核心需求之一。本文将向您推荐一款开源的slave iic程序（Verilog），它是一个专门为FPGA设计的IIC从设备通信协议的Verilog程序。通过使用该程序，开发者可以轻松实现IIC总线上的从设备功能，...
ov5640_top的i2c_ctrl和ov5640_cfg配合
weixin_46312715的博客
02-18 597
首先先寄存器配置等待计数器cnt_wait计数，计数到最大值-1时自动cfg_start（i2c_start）开始拉高一个时钟周期，然后才开始配置寄存器（包括有写入8位器件地址0x78、16位寄存器地址byte_addr、8位寄存器数据wr_data），当一个寄存器配置完成后，i2c_end才开始拉高一个时钟周期。
【FPGA】基于OV5640的 图像边沿检测
qq_52445967的博客
08-13 1万+
目录 一 项目结构 1.1 设计思路 1.2 设计流程 二 接口设计 2.1 摄像头配置模块 2.2 IIC_master 模块 之后就进行数据采集 2.3 采集数据模块 2.4 灰度转化 2.5 高斯滤波 2.7 二值化 2.8 Sobel边缘检测 2.9 SDRAM乒乓缓存 2.10 VGA显示 三 代码设计.........
一、FPGA Cyclone Ⅳ OV5640图像实时采集系统设计
m0_53928198的博客
10-11 2349
FPGA Cyclone Ⅳ OV5640图像实时采集系统设计
基于FPGA的IIC通讯-MASTER发送篇
junpingc的博客
04-07 444
本章节进入到IIC通讯篇章，本篇章开始就得开始付费啦，请关注的各位理解，因为代码每个人的想法不同书写的个人版权，请大家注意版权问题，IIC通讯主要分为两大部分，一个是主机读和主机写，另一个是从机接收，IIC具体的原理这里就不细讲，主要是依据IIC时序进行代码编写，本节主要是介绍IIC主机写程序，依据的是SMBUS2.0协议，它与IIC的不同在于存在IIC_SCL时钟的约束，即SMBUS是IIC的一个子集。好的，现在话不多说，我的IIC-MASTER-WRITE的代码支持什么功能呢？
基于FPGA的I2C SLAVE模式总线的设计.pdf
07-13
本文档详细介绍了如何基于现场可编程门阵列（FPGA）设计一个符合I2C SLAVE模式总线接口。I2C总线是一种串行通信协议，广泛应用于低速外围设备与主板CPU或嵌入式系统的通讯。在本设计中，将利用FPGA来实现SLAVE模式，...
基于FPGA的I2C实验Verilog源代码_代码分析_Master/Slave_fpga_verilog_i2cverific
10-04
这个实验项目名为“基于FPGA的I2C实验”，通过Verilog硬件描述语言实现了I2C协议的主（Master）和从（Slave）模式，同时提供了详细的代码分析和验证过程。 1. Verilog HDL（硬件描述语言）：Verilog是用于描述数字...
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】I2C协议
kissdragan的博客
11-28 3504
I2C 即 Inter-Integrated Circuit(集成电路总线），是由 Philips 半导体公司（现在的 NXP 半导体公司）在八十年代初设计出来的一种简单、双向、二线制总线标准。多用于主机和从机在数据量不大且传输距离短的场合下的主从通信。主机启动总线，并产生时钟用于传送数据，此时任何接收数据的器件均被认为是从机。I2C 总线由数据线 SDA 和时钟线 SCL 构成通信线路，既可用于发送数据，也可接收数据。
基于I2C的FPGA代码设计（带注释）
m0_61193692的博客
03-01 554
提供I2C的源码，并且给出具体注释讲解。可参考时序图理解程序，有问题可以留言。
FPGA常见接口及逻辑实现（二）—— I2C
alexmercer12138的博客
04-09 4555
介绍了I2C接口及其Verilog实现
I2C协议的简单介绍
木木的博客
12-16 2474
I2C协议 I2C协议有两根信号线，一根时钟线SCL，一根信号线SDA。主要用于I2C master设备和I2C slave设备之间的通信，一个master设备下面可以挂接很多个slave设备，为了能让master设备能够准确找到slave设备，每个slave设备都要有自己的slaveaddr,同个master设备下的slave设备的slaveaddr不能出现一样的情况。 协议规定slaveaddr为7个bit或者10个bit，市场上常见的器件都是设计成7个bit。 数据有效性 SDA数据线是用来传输数据的
I2C Slave
ChinaSanDuo的专栏
03-06 3932
使用I2C Slave与I2C Master通信。 同步级别：不受保护。 I2CSlave类引用 Public Member Functions I2CSlave(PinName sda, PinName scl) 创建一个I2CSlave接口，连接到指定的引脚。更多 void frequency(int hz) 设置I2C接口的频率...
GPIO实现I2C从机的设计[1]
热门推荐
IceyP
04-20 1万+
在本阶段的工作中，需要实现一个由GPIO模拟的I2C从机工程设计，以前只使用GPIO模拟I2C设计过主机，对于从机的设计，还是首次。下面就讲本次工作中从机设计思想做详细记录。I2C的简单总结对于I2C信号，需要有START，STOP，ACK，NACK，以及接收DATA。接收DATA是在SCL的低电平可能发生跳变，START和STOP是在高电平跳变。当SCL保持高电平的时候，SDA从H跳变到L，即为S
fpga axi iic slave
02-08
### FPGA 中 AXI IIC Slave 的实现与配置 #### 配置参数设置 在FPGA设计中，AXI IIC IP核可以被配置为Slave模式。通过双击AXI IIC IP可进入其内部配置界面，在此界面上能够设定诸如SCL时钟频率等重要参数。对于所提到的应用场景而言，已知建立的IIC总线采用的标准传输速率是100 KHz，并选择了7位地址寻址方式[^1]。 #### 实现过程概述 为了使AXI IIC工作于slave角色下，需确保正确连接外部master设备至该IP模块的数据输入/输出端口。此外还需注意初始化阶段要按照具体应用需求调整寄存器中的控制字节以及状态标志位等内容。当接收到启动条件后，硬件逻辑会自动响应来自Master节点发出读写请求并执行相应操作。 #### VHDL代码片段展示 下面给出一段简化版VHDL描述来说明如何定义一个简单的AXI-IIC-Slave接口： ```vhdl library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity axi_iic_slave is Port ( s_axi_aclk : in STD_LOGIC; -- Clock signal scl_i : inout STD_LOGIC := 'Z'; -- Serial clock line input/output sda_i : inout STD_LOGIC := 'Z' -- Data line input/output ); end entity; architecture Behavioral of axi_iic_slave is begin process(s_axi_aclk) begin if rising_edge(s_axi_aclk) then -- Insert your custom logic here to handle incoming/outgoing data over SDA/SCL lines. end if; end process; end architecture; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值