当前位置：首页 > article >正文

【ESP32】Arduino开发 | I2C控制器+I2C主从收发例程

article 2024/9/29 8:31:37

有关I2C控制器的详细介绍放在了IDF开发的文章中，跳转栏目目录可以找到对应的文章。

1. API

Arduino启动时就已经实例化了两个I2C设备类，分别对应Wire和Wire1对象。

1.1 初始化

bool begin(int sda, int scl, uint32_t frequency=0); // returns true, if successful init of i2c bus
bool begin(uint8_t slaveAddr, int sda, int scl, uint32_t frequency);
// Explicit Overload for Arduino MainStream API compatibility
inline bool begin()
{
    return begin(-1, -1, static_cast<uint32_t>(0));
}
inline bool begin(uint8_t addr)
{
    return begin(addr, -1, -1, 0);
}
inline bool begin(int addr)
{
    return begin(static_cast<uint8_t>(addr), -1, -1, 0);
}

初始化函数有好几个重载，最简单的就是什么参数都不传，这样会初始化一个默认的I2C主机，管脚、速率这些都是使用默认的；默认SDA管脚为21，SCL管脚为22；默认速率为100kHz。如果第一个参数填从机地址的话，就可以初始化I2C从机，后面的参数也是传不传都行，不传的话就用默认的。

但要注意的是，如果使用Wire1的话，是没有默认管脚的，一定要指定。

1.2 写数据

size_t write(uint8_t);
size_t write(const uint8_t *, size_t);
inline size_t write(const char * s)
{
    return write((uint8_t*) s, strlen(s));
}
inline size_t write(unsigned long n)
{
    return write((uint8_t)n);
}
inline size_t write(long n)
{
    return write((uint8_t)n);
}
inline size_t write(unsigned int n)
{
    return write((uint8_t)n);
}
inline size_t write(int n)
{
    return write((uint8_t)n);
}

写数据的函数是主机从机都通用的，也是有很多重载可选，最常见的就是传数组和数组长度；当然，如果发的是字符串的话，就不用传长度了，有对应的重载。因为Wire类是继承Print类的，因此写数据也可以调print、printf、println这类的函数，实现更灵活的编程。

调用这个函数并不会立刻把数据发送出去，而是拷贝到缓存中，稍后再发送。

1.3 读数据

virtual size_t readBytes(char *buffer, size_t length); // read chars from stream into buffer
virtual size_t readBytes(uint8_t *buffer, size_t length)
{
    return readBytes((char *) buffer, length);
}
size_t readBytesUntil(char terminator, char *buffer, size_t length); // as readBytes with terminator character
size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length)
{
    return readBytesUntil(terminator, (char *) buffer, length);
}
virtual String readString();
String readStringUntil(char terminator);

读数据的函数主要在Stream这个类中，读数组可以调readBytes，传入接收数组和数组长度；如果读字符串可以调readString，程序会一直读，直到字符串的终止符出现为止。

1.4 主机启动发送

void beginTransmission(uint16_t address);
void beginTransmission(uint8_t address);
void beginTransmission(int address);

传入从机的地址，这个函数主要就是做一个初始化而已。

1.5 主机结束发送

uint8_t endTransmission(bool sendStop);
uint8_t endTransmission(void);

sendStop参数表示是否发送停止信号。在调用了这个函数之后，主机才会发起真正的I2C通信。

1.6 主机请求从机数据

size_t requestFrom(uint16_t address, size_t size, bool sendStop);
uint8_t requestFrom(uint16_t address, uint8_t size, bool sendStop);
uint8_t requestFrom(uint16_t address, uint8_t size, uint8_t sendStop);
size_t requestFrom(uint8_t address, size_t len, bool stopBit);
uint8_t requestFrom(uint16_t address, uint8_t size);
uint8_t requestFrom(uint8_t address, uint8_t size, uint8_t sendStop);
uint8_t requestFrom(uint8_t address, uint8_t size);
uint8_t requestFrom(int address, int size, int sendStop);
uint8_t requestFrom(int address, int size);

address：从机地址；
size：要获取的数据量；
sendStop：是否发送停止信号。

1.7 从机注册接收回调

void onReceive( void (*)(int) );

当从机接收到数据时会调用设置的回调函数，函数的参数为接收到的数据数量。

1.8 从机注册请求回调

void onRequest( void (*)(void) );

当从机收到了主机的读请求时，会调用设置的回调函数。

2. 例程

例程中初始化一个I2C主机，SDA管脚为17，SCL管脚为18，速率为400kHz；一个I2C从机，SDA管脚为21，SCL管脚为22，速率为400kHz。主机向从机写一次数据，之后主机再从从机读一次数据，每次间隔1秒。

#include <Arduino.h>
#include <Wire.h>

const char *message = "Hello, World!";

void onRequest()
{
    Wire1.write(message);
    Serial.println("[Slave] Send message");
}

void onReceive(int len)
{
    Serial.printf("[Slave] Receive message: ");
    while (Wire1.available()) {
        Serial.write(Wire1.read());
    }
    Serial.println();
}

void setup()
{
    Serial.begin(115200);
    /* 初始化I2C主机 */
    Wire.begin(17, 18, 400000);
    /* 初始化I2C从机 */
    Wire1.begin(0x58, 21, 22, 400000);
    Wire1.onReceive(onReceive);
    Wire1.onRequest(onRequest);
}

void loop()
{
    /* 主机写从机 */
    Wire.beginTransmission(0x58);
    Wire.write(message);
    Wire.endTransmission(true);
    Serial.println("[Master] Send message");
    delay(1000);

    /* 主机读从机 */
    uint8_t read_len = Wire.requestFrom(0x58, strlen(message));
    if (read_len) {
        uint8_t read_buf[128] = {0};
        Wire.readBytes(read_buf, 128);
        Serial.printf("[Master] Receive message: %s\r\n", read_buf);
    }
    delay(1000);
}

程序输出log如下：