IIC那些事（四）

最新推荐文章于 2025-08-07 10:48:46 发布
原创 最新推荐文章于 2025-08-07 10:48:46 发布 · 300 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#嵌入式硬件 #i2c

博客给出I2C完整示例，提醒仿真模型可从镁光官网获取，自行实现ack不现实。强调状态机绘图要注意逻辑，理清思路后代码实现会更顺利。还提到要提高visio画图能力，而非依赖ps。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

IIC那些事（三）

I2C示例

  1. 完结篇，直接给出一个完整的示例，当然代码不全贴了。
  2. 注意仿真的模型是从镁光官网直接拿的，这个自行实现ack很不现实。
  3. 另外注意状态机的绘图要特别注意逻辑，一旦出错很难排查。
  4. 理清逻辑，思路，那么代码实现就是顺其自然的，按照小梅哥的说法叫做，照图施工。

代码实现

  1. demo代码
// iic_sda的输出，如果输出使能打开，则直接输出obuf，否则输出高阻态，表示断开三态缓冲开关
  assign iic_sda = (out_en == 1'b1) ? sda_obuf : 1'bz;
  
  // cnt计数器计数实现scl时钟，频率为100k
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      cnt <= 32'd0;
    else
      if (cnt < T_SCL - 1'b1 && cnt_en == 1'b1)
        cnt <= cnt + 1'b1;
      else
        cnt <= 32'd0;
  end
  
  // 利用上述cnt实现iic_scl
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      iic_scl <= 1'b1;
    else
      if (cnt < T_SCL/2)
        iic_scl <= 1'b1;
      else
        iic_scl <= 1'b0;
  end
  
  // scl高电平的中间点标志信号flag_high
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      flag_high <= 1'b0;
    else  
      if (cnt == T_SCL/4 - 1'b1)
        flag_high <= 1'b1;
      else  
        flag_high <= 1'b0;
  end

  // scl低电平的中间点标志信号flag_low
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      flag_low <= 1'b0;
    else
      if (cnt == (T_SCL * 3)/4 - 1'b1)
        flag_low <= 1'b1;
      else
        flag_low <= 1'b0;
  end
  
  // 状态机的处理过程，c_state表示当前状态，n_state表示下一状态
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      c_state <= IDLE;
    else
      c_state <= n_state;
  end
  
  // 状态转移过程
  always @ * begin
    case (c_state)
		// 起始状态，若检测到start_flag信号，则进行START状态
      IDLE        :     begin
        if (start_flag == 1'b1)
          n_state = START;
        else
          n_state = IDLE;
      end
		
		// START状态，若此时检测到flag_high信号，则表示
      START       :     begin
        if (flag_high == 1'b1)
          n_state = CTRL;
        else
          n_state = START;
      end
      
      CTRL        :     begin
        if (flag_low == 1'b1 && drive_cnt == 4'd8)
          n_state = CTRL_ACK;
        else
          n_state = CTRL;
      end
      
      CTRL_ACK    :     begin
        if (flag_high == 1'b1)
          if (iic_sda == 1'b0)
            if (addr_sel == 1'b1)
              n_state = HADDR;
            else
              n_state = LADDR;
          else
            n_state = START;
        else
          n_state = CTRL_ACK;
      end
      
      HADDR       :     begin
        if (flag_low == 1'b1 && drive_cnt == 4'd8)
          n_state = HADDR_ACK;
        else
          n_state = HADDR;
      end
      
      HADDR_ACK   :     begin
        if (flag_high == 1'b1)
          if (iic_sda == 1'b0)
            n_state = LADDR;
          else
            n_state = START;
        else
          n_state = HADDR_ACK;
      end
      
      LADDR       :     begin
        if (flag_low == 1'b1 && drive_cnt == 4'd8)
          n_state = LADDR_ACK;
        else
          n_state = LADDR;
      end
      
      LADDR_ACK   :     begin
        if (flag_high == 1'b1)
          if (iic_sda == 1'b0)
            if (wren == 1'b1)
              n_state = WR;
            else
              n_state = RD_START;
          else
            n_state = START;
        else
          n_state = LADDR_ACK;
      end
      
      WR          :     begin
        if (flag_low == 1'b1 && drive_cnt == 4'd8)
          n_state = WR_ACK;
        else
          n_state = WR;
      end
      
      WR_ACK      :     begin
        if (flag_high == 1'b1)
          if (iic_sda == 1'b0)
            n_state = STOP;
          else
            n_state = START;
        else
          n_state = WR_ACK;
      end
      
      STOP        :     begin
        if (flag_high == 1'b1)
          n_state = IDLE;
        else
          n_state = STOP;
      end
      
      RD_START    :     begin
        if (flag_high == 1'b1)
          n_state = RD_CTRL;
        else
          n_state = RD_START;
      end
      
      RD_CTRL     :     begin
        if (flag_low == 1'b1 && drive_cnt == 4'd8)
          n_state = RD_CTRL_ACK;
        else
          n_state = RD_CTRL;
      end
      
      RD_CTRL_ACK :     begin
        if (flag_high == 1'b1)
          if (iic_sda == 1'b0)
            n_state = RD;
          else
            n_state = START;
        else
          n_state = RD_CTRL_ACK;
      end
      
      RD          :     begin
        if (flag_low == 1'b1 && drive_cnt == 4'd8)
          n_state = NO_ACK;
        else
          n_state = RD;
      end
      
      NO_ACK      :     begin
        if (flag_high == 1'b1)
          n_state = STOP;
        else
          n_state = NO_ACK;
      end
      
      default     :     n_state = IDLE;
    endcase
  end

  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      cnt_en <= 1'b0;
    else
      case (c_state)
        IDLE          : cnt_en <= 1'b0;
        CTRL_ACK,
        HADDR_ACK,
        LADDR_ACK,
        WR_ACK,
        RD_CTRL_ACK   : begin
          if (flag_high == 1'b1)
            if (iic_sda == 1'b0)
              cnt_en <= 1'b1;
            else
              cnt_en <= 1'b0;
          else
            cnt_en <= cnt_en;
        end
        default       :   cnt_en <= 1'b1;
      endcase
  end

  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      out_en <= 1'b0;
    else
      case (c_state)
        IDLE          :   out_en <= 1'b0;
        START         :   out_en <= 1'b1;
        CTRL          :   begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            out_en <= 1'b0;
          else
            out_en <= 1'b1;
        end
        CTRL_ACK      :   out_en <= 1'b0;
        HADDR         :   begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            out_en <= 1'b0;
          else
            if (flag_low == 1'b1)
              out_en <= 1'b1;
            else
              out_en <= out_en;
        end
        HADDR_ACK     :   out_en <= 1'b0;
        LADDR         :   begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            out_en <= 1'b0;
          else
            if (flag_low == 1'b1)
              out_en <= 1'b1;
            else
              out_en <= out_en;
        end
        LADDR_ACK     :   out_en <= 1'b0;
        WR            :   begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            out_en <= 1'b0;
          else
            if (flag_low == 1'b1)
              out_en <= 1'b1;
            else
              out_en <= out_en;
        end
        WR_ACK        :   out_en <= 1'b0;
        STOP          :   begin
          if (flag_low == 1'b1)
            out_en <= 1'b1;
          else
            out_en <= out_en;
        end
        RD_START      :   begin
          if (flag_low == 1'b1)
            out_en <= 1'b1;
          else  
            out_en <= out_en;
        end
        
        RD_CTRL       :   begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            out_en <= 1'b0;
          else
            out_en <= 1'b1;
        end
        RD_CTRL_ACK   :   out_en <= 1'b0;
        RD            :   begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            out_en <= 1'b1;
          else
            out_en <= 1'b0;
        end
        
        NO_ACK        :   out_en <= 1'b1;
        
        default       :   out_en <= 1'b0;
      endcase
  end
  
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      sda_obuf <= 1'b1;
    else
      case (c_state)
        IDLE          :     sda_obuf <= 1'b1;
        START         :     begin
          if (flag_high == 1'b1)
            sda_obuf <= 1'b0;
          else
            sda_obuf <= 1'b1;
        end
        
        CTRL          :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            sda_obuf <= temp[7];
          else
            sda_obuf <= sda_obuf;
        end
        
        CTRL_ACK      :     sda_obuf <= 1'b0;
        HADDR         :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            sda_obuf <= temp[7];
          else
            sda_obuf <= sda_obuf;
        end
        
        HADDR_ACK     :     sda_obuf <= 1'b0;
        LADDR         :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            sda_obuf <= temp[7];
          else
            sda_obuf <= sda_obuf;
        end
        LADDR_ACK     :     sda_obuf <= 1'b0;
        WR            :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            sda_obuf <= temp[7];
          else
            sda_obuf <= sda_obuf;
        end
        WR_ACK        :     sda_obuf <= 1'b0;
        STOP          :     begin
          if (flag_low == 1'b1)
            sda_obuf <= 1'b0;
          else
            if (flag_high == 1'b1)
              sda_obuf <= 1'b1;
            else
              sda_obuf <= sda_obuf;
        end
        RD_START      :     begin
          if (flag_low == 1'b1)
            sda_obuf <= 1'b1;
          else
            if (flag_high == 1'b1)
              sda_obuf <= 1'b0;
            else
              sda_obuf <= sda_obuf;
        end
        RD_CTRL       :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            sda_obuf <= temp[7];
          else
            sda_obuf <= sda_obuf;
        end
        RD_CTRL_ACK   :     sda_obuf <= 1'b0;
        RD            :     begin
          if (flag_low == 1'b1 && drive_cnt == 4'd8)
            sda_obuf <= 1'b1;
          else
            sda_obuf <= sda_obuf;
        end
        NO_ACK        :     sda_obuf <= sda_obuf;
        default       :     sda_obuf <= 1'b1;
      endcase
  end
  
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      drive_cnt <= 4'd0;
    else
      case (c_state)
        IDLE        :     drive_cnt <= 4'd0;
        START       :     drive_cnt <= 4'd0;
        CTRL        :     begin
          if (flag_low == 1'b1)
            if (drive_cnt < 4'd8)
              drive_cnt <= drive_cnt + 1'b1;
            else
              drive_cnt <= 4'd0;
          else
            drive_cnt <= drive_cnt;
        end
        CTRL_ACK    :     drive_cnt <= 4'd0;
        HADDR       :     begin
          if (flag_low == 1'b1)
            if (drive_cnt < 4'd8)
              drive_cnt <= drive_cnt + 1'b1;
            else
              drive_cnt <= 4'd0;
          else
            drive_cnt <= drive_cnt;
        end
        HADDR_ACK   :     drive_cnt <= 4'd0;
        LADDR       :     begin
          if (flag_low == 1'b1)
            if (drive_cnt < 4'd8)
              drive_cnt <= drive_cnt + 1'b1;
            else
              drive_cnt <= 4'd0;
          else
            drive_cnt <= drive_cnt;
        end
        LADDR_ACK   :     drive_cnt <= 4'd0;
        WR          :     begin
          if (flag_low == 1'b1)
            if (drive_cnt < 4'd8)
              drive_cnt <= drive_cnt + 1'b1;
            else
              drive_cnt <= 4'd0;
          else
            drive_cnt <= drive_cnt;
        end
        WR_ACK      :     drive_cnt <= 4'd0;
        STOP        :     drive_cnt <= 4'd0;
        RD_START    :     drive_cnt <= 4'd0;
        RD_CTRL     :     begin
          if (flag_low == 1'b1)
            if (drive_cnt < 4'd8)
              drive_cnt <= drive_cnt + 1'b1;
            else
              drive_cnt <= 4'd0;
          else
            drive_cnt <= drive_cnt;
        end
        RD_CTRL_ACK :     drive_cnt <= 4'd0;
        RD          :     begin
          if (flag_high == 1'b1 && drive_cnt < 4'd8)
            drive_cnt <= drive_cnt + 1'b1;
          else
            if (flag_low == 1'b1 && drive_cnt == 4'd8)
              drive_cnt <= 4'd0;
            else
              drive_cnt <= drive_cnt;
        end
        NO_ACK      :     drive_cnt <= 4'd0;
        default     :     drive_cnt <= 4'd0;
      endcase
  end
  
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      temp <= 8'd0;
    else
      case (c_state)
        IDLE          :     temp <= 8'd0;
        START         :     begin
          if (flag_high == 1'b1)
            temp <= {slave_addr, 1'b0};
          else  
            temp <= temp;
        end
        CTRL          :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            temp <= temp << 1'b1;
          else
            temp <= temp;
        end
        CTRL_ACK      :     begin
          if (flag_high == 1'b1 && iic_sda == 1'b0)
            if (addr_sel == 1'b1)
              temp <= addr[15:8];
            else
              temp <= addr[7:0];
          else
            temp <= temp;
        end
        HADDR         :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            temp <= temp << 1'b1;
          else
            temp <= temp;
        end
        HADDR_ACK     :     begin
          if (flag_high == 1'b1 && iic_sda == 1'b0)
            temp <= addr[7:0];
          else
            temp <= temp;
        end
        LADDR         :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            temp <= temp << 1'b1;
          else
            temp <= temp;
        end
        LADDR_ACK     :     begin
          if (flag_high == 1'b1 && iic_sda == 1'b0)
            if (wren == 1'b1)
              temp <= wdata;
            else
              temp <= {slave_addr, 1'b1};
          else
            temp <= temp;
        end
        WR            :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            temp <= temp << 1'b1;
          else
            temp <= temp;
        end
        WR_ACK        :     temp <= 8'd0;
        STOP          :     temp <= 8'd0;
        RD_START      :     temp <= temp;
        RD_CTRL       :     begin
          if (flag_low == 1'b1 && drive_cnt < 4'd8)
            temp <= temp << 1'b1;
          else
            temp <= temp;
        end
        RD_CTRL_ACK   :     temp <= 8'd0;
        RD            :     begin
          if (flag_high == 1'b1 && drive_cnt < 4'd8)
            temp <= {temp[6:0], iic_sda};
          else
            temp <= temp;
        end
        NO_ACK        :     temp <= 8'd0;
        
        default       :     temp <= 8'd0;
      endcase
  end
  
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      iic_done <= 1'b0;
    else
      if (c_state == STOP && flag_high == 1'b1)
        iic_done <= 1'b1;
      else
        iic_done <= 1'b0;
  end
  
  always @ (posedge clk, negedge rst_n) begin
    if (rst_n == 1'b0)
      rdata <= 8'd0;
    else
      if (c_state == RD && flag_low == 1'b1 && drive_cnt == 4'd8)
        rdata <= temp;
      else
        rdata <= rdata;
  end
  1. 仿真展示
    在这里插入图片描述

写在最后

  1. 提高visio画图能力，而不是老用ps搞。
ac620_i2c_control_小梅哥_fpga_i2c_IIC_verilog
09-11
使用verilog编写的I2C控制器，非常高效简洁，已经广泛应用于各个场合，如摄像头配置，电容触控屏读取等，基于小梅哥AC620开发板验证通过。
verilog实现I2C控制器 （小梅哥思路）----详细解析
weixin_45614076的博客
08-26 1万+
verilog实现I2C控制器 （小梅哥思路）----详细解析
FPGA/数字IC求职笔试面试(1)之IIC协议详解
qq_40491102的博客
04-19 1151
FPGA/数字IC求职笔试面试(1)之IIC协议详解 文章目录FPGA/数字IC求职笔试面试(1)之IIC协议详解前言一、概述：二、具体协议1.先来大致猜测2.IIC协议时序三、协议实现步骤(以读写EEPROM为例)1.单字节写时序1.单字节地址单字节数据写入2.两字节地址单字节数据写入2.单字节读时序1.字节地址段器件单字节数据读操作时序2字节地址段器件单字节数据读操作时序四、扩展 前言 从今天起，就要正式入驻CSDN，更新关于FPGA/数字IC的求职相关知识，今天讲解的内容是IIC协议。 本文首发于
I2C控制器，兼容1字节和2字节地址段器件块
08-11
此文件包含IIC控制器模块和仿真文件，亲测无误。此verilog代码对应小梅哥讲述IIC时序的课程，希望对大家的学习有所帮助。
IIC 协议详解+Uart 串口读写 EEPROM
FPGA
07-08 4357
芯航线 FPGA 开发板，一套让你真正从零基础到成长为具备独立开发能力的 FPGA 学习平台 https://xiaomeige.taobao.com/ 芯航线电子工作室 十六、IIC 协议详解+Uart 串口读写 EEPROM 本文由杭电网友曾凯峰根据小梅哥 FPGA IIC 协议基本概念公开课内容整理并最终编写 Verilog 代码实现使用串口读写 EEPROM 的功能。 以下为原文内容： 在...
IIC协议详解
m0_68268950的博客
04-22 2495
IIC（Inter-Integrated Circuit，集成电路总线）是一种广泛使用的​​，由飞利浦（现恩智浦）公司开发，主要用于短距离板级设备间通信。
【四轴】软件IIC通信的实现
m0_75114363的博客
11-25 902
本篇博客的重心在于讲解IIC原理，代码部分为了准确性给出的是由蓝桥杯嵌入式官方资源包里的IIC驱动源码改装的代码。
IIC通信
2302_81226469的博客
04-16 2174
当不加上拉电阻时，如果主机（MUC）拥有SCL的绝对控制权，这时将SCL输出端配置成开漏输出（该模式可以将IO口强制拉高/拉低，就是直接接VSS\VDD），从机SCL端浮空/上拉输入。一主多从模式：只有一个主设备（通常是微控制器）控制整个通信过程，可以与多个从设备进行通信。开漏输出中，当输出低电平时，下管导通实现强下拉，输出高电平时，下管断开且没有上管，于是呈现浮空状态。多主多从模式： 在多主多从模式下，除了多个从设备之外，还可以有多个主设备连接到同一条I2C总线上。当一个主设备想要访问总线上的某。
IIC原理超详细讲解---值得一看
热门推荐
Z小旋
04-11 30万+
文章目录IIC 简介ＩＩＣ的物理层IIC的高阻态IIC物理层总结：ＩＩＣ的协议层IIC 总线时序图初始(空闲)状态开始信号：停止信号数据有效性应答信号IIC数据传送数据传送格式IIC发送数据IIC读数据：以AT24C02为例子软件IIC和硬件IIC IIC 简介         IIC(Inter－Integrated Circuit)总线是一种由NXP...
IIC协议解析
qq_46689721的博客
10-17 1113
第五步：接收读取的数据，从设备地址应答位后跟着的就是读到的数据了，此时主设备作为接收方，收完1byte的数据会会发送Ack到从设备，若发送的是ACK，则继续读取设备，若是NACK，则接着会发送停止位，表示本次读取数据完成，终止数据交互。IIC在进行通信时，会先发送一个起始信号，然后发送7比特的地址位和1比特的读写控制位，这8比特组成1个字节，主机发送完这一个字节后会释放总线来接收接收方的应答位，为1比特，接收到应答位后开始发送1个字节的寄存器地址（），然后释放SDA总线，等待从设备的ACK确认。
STM32实现0.96寸OLED显示模拟IIC和IIC四种实现(标准库和HAL库)
11-17
STM32实现0.96寸OLED显示模拟IIC和IIC实现(标准库和HAL库) 博客地址：https://blog.csdn.net/XiaoCaiDaYong/article/details/127907499
四线oled.zip_oled iic_oled底层_四线IIc_四线iic协议_四线oled接i2c
07-15
这是IIC协议四线OLED屏幕的底层，在KEIL环境下编译，也可以直接调用.C和.H文件
IIC.rar_msp430f5529_msp430f5529 iic_四脚oled显示msp430f5529
07-15
《IIC协议与MSP430F5529微控制器在四脚OLED显示应用》 在嵌入式系统开发中，IIC（Inter-Integrated Circuit）协议是一种广泛使用的串行通信协议，尤其在低速、短距离通信场景下，如连接微控制器与传感器、显示器等...
STM32F103ZET6_IIC_4针OLED(IIC)_oled在正点原子32上的使用_oled_iic四针_STM32F1
10-03
9. **示例代码**：在"STM32F103ZET6_IIC_4针OLED(IIC)"项目中，你可能会找到一个示例代码，展示了如何设置I2C，初始化OLED，并展示简单的文字或图形。 总结来说，这个项目涵盖了STM32微控制器与OLED显示器通过I2C...
iic 四根线的 oled
01-30
**标题解析：** "iic 四根线的 oled" 指的是使用IIC接口连接的四线式OLED显示屏。IIC（Inter-Integrated Circuit）是一种串行通信协议，常用于微控制器与外部设备如显示模块之间的通信。四线OLED屏指的是除了电源线...
IIC协议的那些事儿
卡木
05-14 2796
IIC是什么？ 答：IIC 即Inter-Integrated Circuit(集成电路总线)，这种总线类型是由飞利浦半导体公司在八十年代初设计出来的，主要是用来连接整体电路(ICS) ，IIC是一种多向控制总线，也就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实时数据传输的控制源。这种方式简化了信号传输总线接口。 以上是百科资料。IIC实际上就是随需求的增长应运而生的一种多机...
IMS的注册流程分析
sjz4860402的专栏
07-16 2万+
IMS的基础常识： https://www.cnblogs.com/moon-lights/p/7018789.html http://www.360doc.com/content/15/0624/06/9966538_480253246.shtml http://www.txrjy.com/thread-879446-1-1.html 本次的IMS注册流程分析基于MT6580_O平台。关...
嵌入式硬件中MOSFET基本控制详解
最新发布
嵌入式技术开发
08-07 169
MOSFET分N型和P型，N管源极接地，P管源极接高电平。通过在源极串联负反馈电阻可实现恒流功能，电流稳定与器件参数无关。MOSFET开关本质是对GS结电容充放电，RC电路决定开关速度。降低结电容可提高开关速度，但需权衡抗干扰能力，内阻小的回路更抗干扰。电路设计需综合考虑阻抗匹配、布局和干扰抑制，才能确保稳定性和可靠性。
嵌入式硬件中三极管推挽电路控制与实现
嵌入式技术开发
08-04 359
摘要：本文分析了PWM驱动电路中MOS管的充放电特性。当PWM为高时，12V通过1K电阻给MOS管Vgs电容充电；为低时，通过三极管放大放电电流（β倍放大）。重点讨论了放电电流计算（随C点电压变化）、三极管放大状态的影响，以及推挽电路设计（结合充放电优势）。指出该电路虽存在放电拖尾现象，但通过合理设计可满足驱动需求，同时强调电阻取值需权衡功耗与驱动能力。最后提到不同电路各具优缺点，应根据实际需求选择。
iic驱动四针oled
07-27
你好！要驱动四针OLED，你可以使用I2C接口（也称为IIC）来与OLED通信。以下是一般的步骤： 1. 连接硬件：将OLED的SDA引脚连接到I2C总线的SDA线上，将OLED的SCL引脚连接到I2C总线的SCL线上。同时，确保将OLED的GND引脚连接到地线，将OLED的VCC引脚连接到正电源。 2. 配置I2C接口：根据你使用的硬件平台和编程语言，需要配置正确的I2C接口。你可能需要使用相应的库或驱动程序来实现这一点。 3. 初始化OLED：要初始化OLED，需要发送特定的命令和数据序列。具体的命令和数据序列可能取决于你使用的OLED器件型号和厂商。你可以参考相关的数据手册或官方文档以获取更多详细信息。 4. 发送数据：一旦OLED初始化完成，你就可以向OLED发送数据了。你可以通过I2C接口发送适当的命令和数据来显示文本、图像或其他内容。 需要注意的是，具体的实现细节可能因为你使用的硬件平台、编程语言和OLED器件型号而有所不同。因此，最好查阅相关的文档和资源以获取准确的指导。希望能对你有所帮助！如果还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

IMMUNIZE

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

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

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

打赏作者

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

抵扣说明：

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

余额充值