ESP32 软件I2C

已于 2023-05-22 15:46:35 修改
阅读量2.3k 收藏 20
点赞数
分类专栏： ESP32 文章标签： 单片机 嵌入式硬件 c语言 stm32 开发语言
于 2023-02-01 15:39:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maomaochong666/article/details/128797941
版权

一、概述

        1.1 I2C简介

                I2C(Inter-Integrated Circuit)是一种串行通信总线,由飞利浦公司在1980年代为了让主机连接其它外设而定制的一种低速通信协议，目前广泛应用于手机、电脑、家电等嵌入式设备。

图1.0 典型的I2C总线(挂载多个从设备)

         1.2 电气特性

                I2C使用两根数据总线，一根是数据线（SDA）,一根是时钟线（SCL），采用双向漏极开路，并使用电阻进行上拉，I2C允许比较大的工作电压范围，但一般采用3.3V或者5V。设备地址使用7位长度和10位长度。I2C 传输速率有不同的模式：

                ·标准模式：100Kbit/s

                ·快速模式：400Kbit/s

                ·高速模式：3.4Mbit/s

图1.1 I2C内部结构图

                 1.3 I2C 协议层  

                        1.3.1 I2C读写帧格式

 图1.2 I2C写一个字节数据

 图1.3 I2C读一个字节数据

                         1.3.2 I2C起始信号

                                当主机要与从机开始通信时需要发送起始信号，SCL线在高电平时，SDA线由高变为低。一般流程是拉高SCL线与SDA线保持4us，再拉低SDA线保持4us,最后拉低SCL。

图1.4 I2C起始信号

                         1.3.3 I2C停止信号

                                当主机要与从机结束通信时需要发送停止信号，SCL线在高电平时，SDA线由低变为高。一般流程是拉低SCL线和SDA线保持4us，再拉高SCL线和SDA线保持4us。

 图1.5 I2C停止信号

                         1.3.4 I2C应答信号

                                应答信号也相当于一位数据，SCL为高时，数据线拉低，表示为应答。

图1.6 I2C应答信号 

                         1.3.5 I2C非应答信号 

                                非应答信号也相当于一位数据，SCL为高时，数据线拉高，表示为非应答。

 图1.7 I2C非应答信号

                         1.3.6 I2C数据

                                数据的传输格式，高位先发，SCL为高时数据有效，SCL为低时数据变化。

 图1.8 一个字节数据传输示例

二、程序

        源文件

#include "bsp_iic.h"
#include "esp_log.h"
#include "unistd.h"

static const char *TAG = "I2C";

void I2cInit(void)
{
	const gpio_config_t   io_config = {
        .intr_type      = GPIO_INTR_DISABLE,
        .mode           = GPIO_MODE_OUTPUT,
        .pull_down_en   = GPIO_PULLDOWN_DISABLE,
        .pull_up_en     = GPIO_PULLUP_ENABLE,
        .pin_bit_mask   = (1ULL << I2C_SCL_PIN) 
                        | (1ULL << I2C_SDA_PIN) 
    };
    gpio_config(&io_config);
	I2C_SDA_HIGH;
	I2C_SCL_HIGH;
}

esp_err_t I2cSdaIn(void)
{
	const gpio_config_t   io_config = {
        .intr_type      = GPIO_INTR_DISABLE,
        .mode           = GPIO_MODE_INPUT,
        .pull_down_en   = GPIO_PULLDOWN_DISABLE,
        .pull_up_en     = GPIO_PULLUP_ENABLE,
        .pin_bit_mask   = (1ULL << I2C_SDA_PIN) 
    };
    return gpio_config(&io_config);
}

esp_err_t I2cSdaOut(void)
{
	const gpio_config_t   io_config = {
        .intr_type      = GPIO_INTR_DISABLE,
        .mode           = GPIO_MODE_OUTPUT,
        .pull_down_en   = GPIO_PULLDOWN_DISABLE,
        .pull_up_en     = GPIO_PULLUP_ENABLE,
        .pin_bit_mask   = (1ULL << I2C_SDA_PIN) 
    };
    return gpio_config(&io_config);
}


void I2cStart(void)
{
	I2cSdaOut();
	I2C_SDA_HIGH;
	I2C_SCL_HIGH;
	usleep(4);
	I2C_SDA_LOW;
	usleep(4);
	I2C_SCL_LOW;
}

void I2cStop(void)
{
	I2cSdaOut();
	I2C_SCL_LOW;
	I2C_SDA_LOW;
	usleep(4);
	I2C_SCL_HIGH;
	I2C_SDA_HIGH;
	usleep(4);
}

uint8_t I2cWaitAck(void)
{
	uint8_t ErrTime = 0;

	I2C_SDA_HIGH;
	usleep(1);
	I2cSdaIn();
	I2C_SCL_HIGH;
	usleep(1);
	while(I2C_SDA == 1)
	{
		ErrTime++;
		if(ErrTime > 200)
		{
			I2cStop();
			return 1;
		}
	}
	I2C_SCL_LOW;
	return 0;
}

void I2cAck(void)
{
	I2cSdaOut();
	I2C_SCL_LOW;
	I2C_SDA_LOW;
	usleep(2);
	I2C_SCL_HIGH;
	usleep(2);
	I2C_SCL_LOW;
}

void I2cNack(void)
{
	I2cSdaOut();
	I2C_SCL_LOW;
	I2C_SDA_HIGH;
	usleep(2);
	I2C_SCL_HIGH;
	usleep(2);
	I2C_SCL_LOW;
}

void I2cWriteByte(uint8_t Data)
{
    uint8_t i;

    I2cSdaOut();
    I2C_SCL_LOW;
    for(i = 0;i < 8;i++)
    {
		if((Data & 0x80) >> 7)
		{
			I2C_SDA_HIGH;
		}
		else
		{
			I2C_SDA_LOW;
		}
		Data <<= 1;
		usleep(2);
		I2C_SCL_HIGH;
		usleep(2);
		I2C_SCL_LOW;
		usleep(2);
    }
}

uint8_t I2cReadByte(uint8_t isAck)
{
	uint8_t i;
	uint8_t Data = 0x0;

	I2cSdaIn();

    for(i = 0;i < 8;i++)
	{
    	I2C_SCL_LOW;
    	usleep(2);
		I2C_SCL_HIGH;
		Data <<= 1;
        if(I2C_SDA == 1)
		{
        	Data++;
		}
        usleep(1);
    }
    if(isAck)
	{
    	I2cNack();
	}
    else
	{
		I2cAck();
	}
    return Data;
}

void EspI2cWriteByte(uint8_t dev_addr,uint8_t reg_addr,uint8_t write_data)
{
	I2cStart();
	I2cWriteByte((dev_addr << 1) | I2C_MASTER_WRITE);
	I2cWaitAck();
	I2cWriteByte(reg_addr);
	I2cWaitAck();
	I2cWriteByte(write_data);
	I2cWaitAck();
	I2cStop();
}

void EspI2cReadByte(uint8_t dev_addr,uint8_t reg_addr,uint8_t *read_data)
{
	I2cStart();
	I2cWriteByte((dev_addr << 1) | I2C_MASTER_WRITE);
	I2cWaitAck();
	I2cWriteByte(reg_addr);
	I2cWaitAck();

	I2cStart();
	I2cWriteByte((dev_addr << 1) | I2C_MASTER_READ);
	*read_data = I2cReadByte(NACK_VAL);
	I2cStop();
}

void EspI2cWriteBytes(uint8_t dev_addr,uint8_t reg_addr,uint8_t *write_data,uint8_t write_len)
{
	uint8_t i;

	I2cStart();

	I2cWriteByte((dev_addr << 1) | I2C_MASTER_WRITE);
	I2cWaitAck();

	I2cWriteByte(reg_addr);
	I2cWaitAck();

    for(i = 0;i < write_len;i++)
    {
		I2cWriteByte(write_data[i]);
		I2cWaitAck();
    }
	I2cStop();
}

void EspI2cReadBytes(uint8_t dev_addr,uint8_t reg_addr,uint8_t *read_data,uint8_t read_len)
{
    uint8_t i = 0;

	I2cStart();

	I2cWriteByte((dev_addr << 1) | I2C_MASTER_WRITE);
	I2cWaitAck();

	I2cWriteByte(reg_addr);
	I2cWaitAck();

	I2cStart();
	I2cWriteByte((dev_addr << 1) | I2C_MASTER_READ);
	I2cWaitAck();

	if(read_len > 1)
	{
		for(i = 0;i < read_len - 1;i++)
		{
			read_data[i] = I2cReadByte(ACK_VAL);
		}
	}
	read_data[i] = I2cReadByte(NACK_VAL);

	I2cStop();
}

void I2cDetect(void)
{
	uint8_t i;
	uint8_t j;
    uint8_t address;
	uint8_t ret = 0;

    printf("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
    for(i = 0;i < 128;i += 16) 
	{
        printf("%02x: ", i);
        for (j = 0;j < 16;j++) 
		{
            fflush(stdout);
            address = i + j;

			I2cStart();
			I2cWriteByte((address << 1) | I2C_MASTER_WRITE);
			ret = I2cWaitAck();
			I2cStop();
			
            if(ret == 0) 
			{
                printf("%02x ",address);
            } 
			else 
			{
                printf("-- ");
            }
        }
        printf("\r\n");
    }
}

        头文件

#ifndef _BSP_IIC_H_
#define _BSP_IIC_H_

#include "sdkconfig.h"
#include "driver/gpio.h"
#include "driver/i2c.h"

#define ACK_VAL                 0x0        
#define NACK_VAL                0x1       
#define ACK_CHECK_EN            0x1     
#define ACK_CHECK_DIS           0x0                                                                                       

#define ESP32_GPIO_OUT_W1TS(gpio_num)       GPIO.out_w1ts =  (0x01 << gpio_num)                 //gpio_num:0 ~ 31    GPIO OUT HIGH
#define ESP32_GPIO_OUT_W1TC(gpio_num)       GPIO.out_w1tc = (0x01 << gpio_num)                  //gpio_num:0 ~ 31    GPIO OUT LOW

#define ESP32_GPIO_OUT1_W1TS(gpio_num)      GPIO.out1_w1ts.data =  (0x01 << (gpio_num - 32))    //gpio_num:32 ~ 39   GPIO OUT HIGH
#define ESP32_GPIO_OUT1_W1TC(gpio_num)      GPIO.out1_w1tc.data = (0x01 << (gpio_num - 32))     //gpio_num:32 ~ 39   GPIO OUT LOW

#define ESP32_GPIO_IN(gpio_num)             ((GPIO.in >> gpio_num) & 0x1)                        //gpio_num:0 ~ 31    GPIO IN VALUE
#define ESP32_GPIO_IN1(gpio_num)            ((GPIO.in1.data  >> gpio_num) & 0x1)                 //gpio_num:32 ~ 39   GPIO IN VALUE

#define GpioReadBit(gpio_num)	            ESP32_GPIO_IN(gpio_num)
                                            
#define GpioSetBit(gpio_num)			     if(gpio_num < 32)\
                                                ESP32_GPIO_OUT_W1TS(gpio_num);\
                                            else\
                                                ESP32_GPIO_OUT1_W1TS(gpio_num); 

#define GpioResetBit(gpio_num)		        if(gpio_num < 32)\
                                                ESP32_GPIO_OUT_W1TC(gpio_num);\
                                            else\
                                                ESP32_GPIO_OUT1_W1TC(gpio_num); 

#define I2C_SCL_PIN                         GPIO_NUM_4      
#define I2C_SDA_PIN                         GPIO_NUM_5 

#define I2C_SDA_HIGH                        GpioSetBit  (I2C_SDA_PIN)	  
#define I2C_SDA_LOW                         GpioResetBit(I2C_SDA_PIN)

#define I2C_SCL_HIGH                        GpioSetBit  (I2C_SCL_PIN)
#define I2C_SCL_LOW                         GpioResetBit(I2C_SCL_PIN)

#define I2C_SDA                             GpioReadBit (I2C_SDA_PIN)

// #define I2C_SDA				                gpio_get_level(I2C_SDA_PIN)

void I2cInit(void);

void I2cStart(void);

void I2cStop(void);

uint8_t I2cWaitAck(void);

void I2cAck(void);

void I2cNack(void);

void I2cWriteByte(uint8_t Data);

uint8_t I2cReadByte(uint8_t isAck);

void EspI2cWriteByte(uint8_t dev_addr,
                     uint8_t reg_addr,
                     uint8_t write_data);

void EspI2cReadByte(uint8_t dev_addr,
                    uint8_t reg_addr,
                    uint8_t *read_data);

void EspI2cWriteBytes(uint8_t dev_addr,
                      uint8_t reg_addr,
                      uint8_t *write_data,
                      uint8_t write_len);   

void EspI2cReadBytes(uint8_t dev_addr,
                     uint8_t reg_addr,
                     uint8_t *read_data,
                     uint8_t read_len);  
					 
void I2cDetect(void);                    

#endif
李法师_
关注
  • 0
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
STM32F1之I2C通信·软件I2C代码编写
时光の尘的博客
05-24 1235
SCL低电平期间，从机将数据位依次放到SDA线上(高位先行)，然后释放SCL，主机将在SCL高电平期间读取数据位，所以SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可接收一个字节(主机在接收之前,需要释放SDA)。发送一个字节: SCL低电平期间，主机将数据位依次放到SDA线上(高位先行) ，然后释放SCL，从机将在SCL高电平期间读取数据位，所以SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可发送一个字节。终止条件下，SCL高电平期间，SDA从低电平切换到高电平。
ESP32学习6：I2C总线
sssxlxwbwz的博客
12-16 1万+
一、概述 I2C 通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，被广泛地使用在系统内多个集成电路(IC)间的通讯。 I2C总线由数据线SDA和时钟线SCL两条线构成通讯线路，即可发送数据，也可接收数据。在CPU与被控IC之间、IC与IC之间都可以进行双向传递，最高传送速率为400kbps,各种被控器件均并联在总线上，但每个器件都有唯...
温湿度采集与OLED显示
xyh3123334836的博客
06-18 1029
软件I2C（也称为Bit-Banging I2C）是一种通过软件方法实现I2C通信协议的方式。在没有专用硬件I2C接口的微控制器或系统中，开发者可以通过编程直接控制通用的数字输入/输出（GPIO）引脚的电平变化，来模拟I2C总线的时序信号，包括启动条件、停止条件、应答位、数据位等。硬件I2C是指微控制器或系统中集成的专用硬件模块，用于实现I2C（Inter-Integrated Circuit）通信协议。
ESP32 的 I2C 原理 & 应用入门
ESP 技术分享，推动万物互联
07-18 7803
ESP32 I2C
【史上最全面arduino esp32教程】I2C的使用
m0_62599305的博客
03-23 3081
在本篇文章中，我们将带您了解如何使用I2C（Inter-Integrated Circuit）通信协议在Arduino ESP32上进行数据交换。I2C是一种常见的串行通信协议，适用于连接多个设备并在它们之间传输数据。我们将介绍I2C通信的基本原理和Arduino ESP32上的I2C库函数使用方法，帮助您快速上手并开始使用I2C进行数据通信。通过本教程，我们详细了解了Arduino ESP32上的I2C通信。我们了解了I2C的基本原理和层次结构，以及它在连接多个设备时的优势。
ESP32-I2C简要理解
努力加油，冲~
07-19 6818
概述 I2C是一种串行，同步，半双工通信协议，允许在同一总线上同时存在多个主机和从机。I2C总线由两条线组成：串行数据线（SDA）和串行时钟（SCL）。两条线都需要上拉电阻。 I2C总线由两条线组成：串行数据线（SDA）和串行时钟（SCL）。两条线都需要上拉电阻。 ESP32有两个I2C控制器（也称为端口），负责处理两条I2C总线上的通信。每个I2C控制器都可以作为主机或从机运行。例如，一个控制器可以同时充当主控制器，另一个可以充当从控制器。 I2C通信规则 这里我不介绍底层的脉冲发送与接收时序规则，既然选
ESP32 Arduino 两路IIC使用方法
hujiaoyin9875的博客
10-25 2115
由于项目需要两路IIC，但是我不想复用IIC接口。现做如下更改。
esp32-i2c-lcd1602-示例
最新发布
06-26
$ cd esp32-i2c-lcd1602-example.git $ idf.py menuconfig # set your serial configuration and the I2C GPIO - see below $ idf.py build $ idf.py -p (PORT) flash monitor 该程序应该检测您所连接的设备并在 LCD...
esp32_SoundRecorder：ESP32录音机，在arduino-esp32中具有简单的代码。 （I2S接口）
02-02
本项目"esp32_SoundRecorder"是一个基于Arduino-ESP32平台的简单录音机实现，利用了ESP32的音频处理能力，通过I2S接口进行声音数据的捕获。 **1. ESP32与Arduino框架** Arduino是一种开源电子原型平台，提供了易用...
esp32-i2s-slm：带有ESP32和I2S MEMS麦克风的声级计
02-01
**ESP32-I2S-SLM项目概述** ...总之，ESP32-I2S-SLM项目结合了嵌入式硬件和软件技术，提供了一种实用的声级测量解决方案，不仅展示了ESP32的强大功能，也为音频应用和噪声监测提供了有价值的工具。
esp32-1.0.3.zip
12-25
它还支持多种外设接口，如I2C、SPI、UART，以及模拟ADC和数字DAC，便于扩展应用。 5. 应用实例： ESP32常用于智能灯控、环境监测、远程控制、智能家居网关等场景。通过编写程序，可以实现Wi-Fi远程控制、传感器...
ESP-I2C-OLED:ESP8266 I2C OLED 演示
06-23
该项目中的其他有用模块包括： i2c.h/i2c.c 是软件 bitbanged I2C 驱动程序shell.h/shell.c/shell_cmds.c 在 UART0 (9600,8,N,1) 上实现命令行 shell，具有基本的行编辑功能。 dmsg.h/dmsg.c 在 UART1 (74480,8,N,1...
基于固件库的软件i2c
qq_56926420的博客
02-13 976
软件i2c通过模拟i2c时序配置普通的gpio引脚，首先封装一个函数 static void OLED_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; /* 定义一个gpio结构体 */ RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE); /* 打开gpioc使能时钟 */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO...
I2C软件和硬件总结及实验过程
Simple-Beauty的博客
01-08 741
首先关于stm32使用最多的是软件I2C 关于软件I2C的配置过程，很可能存在一些问题，很多时候硬件会上拉一个上拉电阻，使得多个I2C设备可以挂载在一条总线上。 但是如果外接上拉线路断路了，I2C还可以正常通讯吗 存在一种情况 即 I2C不管发送什么地址，都会有应答， 原因：I2C的SDA引脚配置为开漏输出，并没有输出高电平的能力，当SDA拉高，等待从机应答时，由于从机不管是否应答，SDA上的电平都是低电平，所以一直会有应答。 解决方法：I2C在IO的配置成上拉模式，即可解决这个问题。 实验1 当外接上拉时
I2C软件模拟（亲测可用）
chenguanging080的博客
08-27 1570
I2C软件时序模拟
esp32cam 0.96寸oled软IIC控制
406156440的博客
11-29 1287
因为esp32cam大部分引脚都被camera占用了, 导致了想用IIC的oled就不能使用硬件IIC来控制, 查看了很多oled控制都是些直接用硬件iic也就是A4 A5引脚操作的, 所以就有了这篇解决方案
ESP32那些事儿(七)：功能开发之I2S和I2C驱动
荷兰风车
10-31 6836
1、I2S的使用      I2S为三线总线，3个信号分别为： ① 串行时钟SCK，也叫位时钟（BCK）。即每发送1位数字音频数据，SCK上都有1个脉冲。SCK的频率=2×采样频率×采样位数。在数据传输过程中，I2S总线的发送器和接收器都可以作为系统的主机来提供系统的时钟频率。 ② 帧时钟WS，即命令（声道）选择，用于切换左右声道的数据。WS的频率等于采样频率，由系统主机提供。WS为“1”表示传...
IO口软件模拟IIC
热门推荐
zhejfl的博客
09-28 2万+
  一、IIC时序 IIC(Inter-Integrated Circuit, 内部集成电路)总线是飞利浦公司开发的两线式串行总线，用于短距离传输，常用语微控制器及其外围设备。它是由数据线SDA和时钟线SCL构成的串行总线，可发送和接收数据。 I2C总线通过上拉电阻接正电源。即当总线空闲时，两根线均为高电平。如此，连在总线上的任一器件输出的低电平，都可以使得总线的信号变低，也就是说各器件...
ESP32 开发笔记（十四）ESP32 I2C Slave 实现
InfiniteYuan
11-22 3785
这篇文章将介绍使用 ESP32 作为 I2C 实现 Random Read/Write 和 Sequential Read/Write 时序。
esp32c3 i2c
06-07
3. ESP32-C3 I2C支持标准（100kbps）和快速（400kbps）模式，可以通过软件设置。 4. 可以使用ESP-IDF中的I2C驱动程序来控制ESP32-C3 I2C总线。 5. 可以使用Arduino IDE或MicroPython来编写ESP32-C3 I2C应用程序。 ...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值