I2C（IIC）常用模板

已于 2023-06-01 12:04:04 修改
阅读量255 收藏 1
点赞数 1
文章标签： c语言 嵌入式硬件
于 2023-05-31 10:22:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X6W1B8/article/details/130963478
版权

I2C总线初始化模板

  1. 引入Wire库
  2. 设置setup函数，初始化I2C总线
  3. 设置loop函数，循环执行其他操作，此处没有具体的I2C通信操作。
#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  // 循环执行其他操作
}

I2C设备扫描模板

  1. 引入Wire库，用于I2C通信
  2. 设置setup函数，初始化I2C总线和串口通信，并调用scanI2C函数扫描I2C设备
  3. 设置loop函数，留空，可以执行其他操作
  4. 设置scanI2C函数，打印扫描开始提示信息，循环扫描I2C设备地址1~127，开始I2C通信，向设备发送地址，结束I2C通信，获取返回值。如果返回值为0，表示成功连接到该设备，打印连接成功提示信息，并打印设备地址。

// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(); // 初始化I2C总线
Serial.begin(9600); // 初始化串口通信，波特率9600
scanI2C(); // 扫描I2C设备
}

void loop() {
// 此处留空，可以执行其他操作
}

void scanI2C() {
Serial.println("Scanning I2C devices..."); // 打印扫描开始提示信息
for (byte i = 1; i < 127; i++) { // 扫描I2C设备地址1~127
Wire.beginTransmission(i); // 开始I2C通信，向设备发送地址
byte error = Wire.endTransmission(); // 结束I2C通信，获取返回值
if (error == 0) { // 如果返回值为0，表示成功连接到该设备
Serial.print("I2C device found at address 0x"); // 打印连接成功提示信息
if (i < 16) Serial.print("0"); // 如果地址小于16，补齐0位
Serial.println(i, HEX); // 打印设备地址，HEX表示16进制输出
}
}
}

I2C设备写入单个字节模板

​​​​

  1. 引入Wire库
  2. 设置setup函数，初始化I2C总线
  3. 设置loop函数，调用writeData函数写入数据并循环执行其他操作
  4. 设置writeData函数，开始向地址为0x50的设备写入数据，写入寄存器地址为0x00，写入数据为0x12，结束写入。
#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  writeData(); // 写入数据
  // 循环执行其他操作
}

void writeData() {
  Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
  Wire.write(0x00); // 写入寄存器地址
  Wire.write(0x12); // 写入数据
  Wire.endTransmission(); // 结束写入
}

I2C设备读取单个字节模板

  1. 引入Wire库
  2. 设置setup函数，初始化I2C总线和串口
  3. 设置loop函数，调用readData函数读取数据并循环执行其他操作
  4. 设置readData函数，请求从地址为0x50的设备读取1个字节数据，如果有数据可读，则读取数据并通过串口打印出来。
#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
  Serial.begin(9600); // 初始化串口
}

void loop() {
  readData(); // 读取数据
  // 循环执行其他操作
}

void readData() {
  Wire.requestFrom(0x50, 1); // 请求从地址为0x50的设备读取1个字节
  if (Wire.available()) { // 如果有数据可读
    int data = Wire.read(); // 读取数据
    Serial.println(data); // 打印数据
  }
}

I2C设备读取多个字节模板

  1. 引入Wire库，用于I2C通信
  2. 设置setup函数，初始化I2C总线和串口通信
  3. 设置loop函数，调用readData函数读取数据并留空，可以执行其他操作
  4. 设置readData函数，开始向地址为0x50的设备写入数据，写入寄存器地址，即要读取的数据的地址，结束写入。然后请求从地址为0x50的设备读取2个字节数据，定义一个数组，用于存储读取到的数据，定义一个计数器，用于记录已经读取的数据的数量。如果有数据可读，读取数据，并存储到数组中，计数器加1。将两个字节合并成一个16位整数，打印读取到的数据。
// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(); // 初始化I2C总线
Serial.begin(9600); // 初始化串口通信，波特率9600
}

void loop() {
readData(); // 读取数据
// 此处留空，可以执行其他操作
}

void readData() {
Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
Wire.write(0x00); // 写入寄存器地址，即要读取的数据的地址
Wire.endTransmission(); // 结束写入

Wire.requestFrom(0x50, 2); // 请求从地址为0x50的设备读取2个字节
byte data[2]; // 定义一个数组，用于存储读取到的数据
int i = 0; // 定义一个计数器，用于记录已经读取的数据的数量
while (Wire.available()) { // 如果有数据可读
data[i] = Wire.read(); // 读取数据，并存储到数组中
i++; // 计数器加1
}
int value = (data[0] << 8) | data[1]; // 将两个字节合并成一个16位整数
Serial.println(value); // 打印读取到的数据
}

I2C设备写入多个字节模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  writeData(); // 写入数据
  // 循环执行其他操作
}

void writeData() {
  byte data[3] = {0x00, 0x12, 0x34}; // 要写入的数据
  Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
  Wire.write(data, 3); // 写入数据
  Wire.endTransmission(); // 结束写入
}

I2C设备读取字符串模板

#include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
Serial.begin(9600); // 初始化串口
}

void loop() {
readData(); // 读取数据
// 循环执行其他操作
}

void readData() {
Wire.requestFrom(0x50, 10); // 请求从地址为0x50的设备读取10个字节
byte data[10]; // 定义一个长度为10的字节数组
int i = 0;
while (Wire.available()) { // 如果有数据可读
data[i] = Wire.read(); // 读取数据
i++;
}
String str = String((char*)data); // 将字节数组转换为字符串
Serial.println(str); // 打印数据
}

I2C设备写入字符串模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  writeData(); // 写入数据
  // 循环执行其他操作
}

void writeData() {
  String str = "Hello, world!"; // 要写入的字符串
  byte data[str.length() + 1];
  str.getBytes(data, str.length() + 1); // 将字符串转换为字节数组
  Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
  Wire.write(data, str.length() + 1); // 写入数据
  Wire.endTransmission(); // 结束写入
}

I2C设备读取16位整数模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
  Serial.begin(9600); // 初始化串口
}

void loop() {
  readData(); // 读取数据
  // 循环执行其他操作
}

void readData() {
  Wire.requestFrom(0x50, 2); // 请求从地址为0x50的设备读取2个字节
  byte data[2];
  int i = 0;
  while (Wire.available()) { // 如果有数据可读
    data[i] = Wire.read(); // 读取数据
    i++;
  }
  int value = (data[0] << 8) | data[1]; // 将两个字节合并成一个16位整数
  Serial.println(value); // 打印数据
}

I2C设备写入16位整数模板

#include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
writeData(); // 写入数据
// 循环执行其他操作
}

void writeData() {
int value = 0x1234; // 要写入的16位整数
byte data[2]; // 定义一个长度为2的字节数组
data[0] = value >> 8; // 分别取高位和低位
data[1] = value & 0xFF;
Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
Wire.write(data, 2); // 写入数据
Wire.endTransmission(); // 结束写入
}

I2C设备读取32位整数模板

#include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
Serial.begin(9600); // 初始化串口
}

void loop() {
readData(); // 读取数据
// 循环执行其他操作
}

void readData() {
Wire.requestFrom(0x50, 4); // 请求从地址为0x50的设备读取4个字节
byte data[4]; // 定义一个长度为4的字节数组
int i = 0;
while (Wire.available()) { // 如果有数据可读
data[i] = Wire.read(); // 读取数据
i++;
}
long value = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]; // 将四个字节合并成一个32位整数
Serial.println(value); // 打印数据
}

I2C设备写入32位整数模板

#include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
writeData(); // 写入数据
// 循环执行其他操作
}

void writeData() {
long value = 0x12345678; // 要写入的32位整数
byte data[4]; // 定义一个长度为4的字节数组
data[0] = value >> 24; // 取出高位字节
data[1] = value >> 16 & 0xFF; // 取出次高位字节
data[2] = value >> 8 & 0xFF; // 取出次低位字节
data[3] = value & 0xFF; // 取出低位字节
Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
Wire.write(data, 4); // 写入数据
Wire.endTransmission(); // 结束写入
}

I2C设备读取浮点数模板

#include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
Serial.begin(9600); // 初始化串口
}

void loop() {
readData(); // 读取数据
// 循环执行其他操作
}

void readData() {
Wire.requestFrom(0x50, 4); // 请求从地址为0x50的设备读取4个字节
byte data[4]; // 定义一个长度为4的字节数组
int i = 0;
while (Wire.available()) { // 如果有数据可读
data[i] = Wire.read(); // 读取数据
i++;
}
float value;
memcpy(&value, &data, sizeof(value)); // 将字节数组转换为浮点数
Serial.println(value); // 打印数据
}
// Wire.requestFrom()用于请求从设备读取数据
// Wire.available()返回可读取的数据量
// Wire.read()用于读取一个字节数据
// memcpy()函数用于将字节数组转换为浮点数
// Serial.println()用于打印数据

I2C设备写入浮点数模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  writeData(); // 写入数据
  // 循环执行其他操作
}

void writeData() {
  float value = 3.14; // 要写入的浮点数
  byte data[sizeof(value)];
  memcpy(&data, &value, sizeof(value)); // 将浮点数转换为字节数组
  Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
  Wire.write(data, sizeof(value)); // 写入数据
  Wire.endTransmission(); // 结束写入
}

I2C设备读取多个寄存器模板

include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
Serial.begin(9600); // 初始化串口
}

void loop() {
readData(); // 读取数据
// 循环执行其他操作
}

void readData() {
Wire.beginTransmission(0x50); // 开始向地址为0x50的设备写入数据
Wire.write(0x00); // 写入起始寄存器地址
Wire.endTransmission(); // 结束写入

Wire.requestFrom(0x50, 4); // 请求从地址为0x50的设备读取4个字节
byte data[4]; // 定义一个长度为4的字节数组
int i = 0;
while (Wire.available()) { // 如果有数据可读
data[i] = Wire.read(); // 读取数据
i++;
}
int value = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]; // 将四个字节合并成一个32位整数
Serial.println(value); // 打印数据
}
// Wire.beginTransmission()用于开始向设备写入数据
// Wire.write()用于向设备写入一个字节数据
// Wire.endTransmission()用于结束写入
// Wire.requestFrom()用于请求从设备读取数据
// Wire.available()返回可读取的数据量
// Wire.read()用于读取一个字节数据
// Serial.println()用于打印数据

I2C设备读取单个寄存器的模板

  1. 发送I2C设备地址和要读取的寄存器地址
  2. 发送读取命令
  3. 等待I2C设备响应
  4. 读取数据
  5. 结束I2C通信
#include <Wire.h>

int deviceAddress = 0x50; // I2C设备地址
int registerAddress = 0x00; // 要读取的寄存器地址
int data; // 读取的数据

void setup() {
  Serial.begin(9600);
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  Wire.beginTransmission(deviceAddress); // 发送I2C设备地址
  Wire.write(registerAddress); // 发送要读取的寄存器地址
  Wire.endTransmission(); // 结束I2C通信

  Wire.requestFrom(deviceAddress, 1); // 发送读取命令
  if (Wire.available()) {
    data = Wire.read(); // 读取数据
    Serial.println(data); // 打印读取的数据
  }

  delay(1000); // 延迟1秒
}

发送数据到I2C从设备模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  Wire.beginTransmission(0x3F); // 发送数据到I2C从设备0x3F
  Wire.write(0x01); // 发送数据
  Wire.endTransmission(); // 结束传输
}

从I2C从设备读取数据模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  Wire.requestFrom(0x3F, 1); // 从I2C从设备0x3F请求1个字节的数据
  while (Wire.available()) { // 如果有数据可用
    char c = Wire.read(); // 读取数据
    Serial.println(c); // 输出数据
  }
}

使用I2C从设备的特定寄存器模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  Wire.beginTransmission(0x3F); // 发送数据到I2C从设备0x3F
  Wire.write(0x00); // 发送寄存器地址
  Wire.write(0x01); // 发送数据
  Wire.endTransmission(); // 结束传输

  Wire.beginTransmission(0x3F); // 发送数据到I2C从设备0x3F
  Wire.write(0x01); // 发送寄存器地址
  Wire.endTransmission(); // 结束传输

  Wire.requestFrom(0x3F, 1); // 从I2C从设备0x3F请求1个字节的数据
  while (Wire.available()) { // 如果有数据可用
    char c = Wire.read(); // 读取数据
    Serial.println(c); // 输出数据
  }
}

设置I2C从设备的地址模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
  Wire.beginTransmission(0x3F); // 发送数据到I2C从设备0x3F
  Wire.write(0x00); // 发送寄存器地址
  Wire.write(0x01); // 发送数据
  Wire.endTransmission(); // 结束传输
}

void loop() {
  // 读取I2C从设备0x3F的数据
  Wire.requestFrom(0x3F, 1); // 从I2C从设备0x3F请求1个字节的数据
  while (Wire.available()) { // 如果有数据可用
    char c = Wire.read(); // 读取数据
    Serial.println(c); // 输出数据
  }
}

设置I2C总线的速度模板

// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(400000); // 初始化I2C总线，设置速度为400kHz
}

void loop() {
// 发送数据到I2C从设备0x3F
Wire.beginTransmission(0x3F); // 发送I2C起始信号，指定从设备地址
Wire.write(0x01); // 发送要读取的寄存器地址
Wire.endTransmission(); // 发送I2C停止信号

// 读取I2C从设备0x3F的数据
Wire.requestFrom(0x3F, 1); // 请求从从设备读取1个字节的数据
while (Wire.available()) { // 判断是否有数据可读
char c = Wire.read(); // 读取数据
Serial.println(c); // 打印读取到的数据
}
}

检查I2C从设备是否可用模板

#include <Wire.h> // 引入Wire库

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
if (Wire.available(0x3F)) { // 检查I2C从设备0x3F是否可用
Wire.requestFrom(0x3F, 1); // 从I2C从设备0x3F读取1个字节数据
while (Wire.available()) { // 如果有数据可读
char c = Wire.read(); // 读取数据
Serial.println(c); // 打印数据
}
}
}
// Wire.available()返回可读取的数据量
// Wire.requestFrom()用于请求从设备读取数据
// Wire.read()用于读取一个字节数据
// Serial.println()用于打印数据

处理I2C传输错误模板

// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
Wire.beginTransmission(0x3F); // 发送I2C起始信号，指定从设备地址
Wire.write(0x01); // 发送要读取的寄存器地址
int result = Wire.endTransmission(); // 结束传输并获取结果

if (result == 0) { // 如果传输成功
// 从I2C从设备0x3F读取数据
Wire.requestFrom(0x3F, 1); // 请求从从设备读取1个字节的数据
while (Wire.available()) { // 判断是否有数据可读
char c = Wire.read(); // 读取数据
Serial.println(c); // 打印读取到的数据
}
} else { // 如果传输失败
Serial.println("I2C传输错误"); // 打印错误信息
}
}

发送多字节数据到I2C从设备模板

// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
byte data[] = {0x01, 0x02, 0x03}; // 要发送的数据
Wire.beginTransmission(0x3F); // 发送数据到I2C从设备0x3F
Wire.write(data, sizeof(data)); // 发送多字节数据
Wire.endTransmission(); // 结束传输

Wire.requestFrom(0x3F, 3); // 从I2C从设备0x3F请求3个字节的数据
byte dataReceived[3]; // 存储读取到的数据
int i = 0;
while (Wire.available()) { // 如果有数据可用
dataReceived[i] = Wire.read(); // 读取数据
i++;
}
// 输出读取到的数据
Serial.print("Received data: ");
for (int j = 0; j < sizeof(dataReceived); j++) {
Serial.print(dataReceived[j]); // 输出读取到的数据
Serial.print(", "); // 输出分隔符
}
Serial.println(); // 输出换行符
}

使用I2C从设备的多个寄存器模板


// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
// 向I2C从设备0x3F的寄存器0x00和0x01写入数据
Wire.beginTransmission(0x3F); // 发送I2C起始信号，指定从设备地址
Wire.write(0x00); // 发送要写入的寄存器地址
Wire.write(0x01); // 向寄存器中写入1个字节的数据
Wire.endTransmission(); // 发送I2C停止信号

// 读取I2C从设备0x3F的寄存器0x02的数据
Wire.beginTransmission(0x3F); // 发送I2C起始信号，指定从设备地址
Wire.write(0x02); // 发送要读取的寄存器地址
Wire.endTransmission(); // 发送I2C停止信号
Wire.requestFrom(0x3F, 1); // 请求从从设备读取1个字节的数据
while (Wire.available()) { // 判断是否有数据可读
char c = Wire.read(); // 读取数据
Serial.println(c); // 打印读取到的数据
}
}

模拟I2C主设备模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(8); // 模拟I2C主设备，地址为8
  Wire.onRequest(requestEvent); // 注册请求事件处理函数
}

void loop() {
  // 主设备的其他代码
}

void requestEvent() {
  Wire.write("Hello World"); // 发送数据到I2C从设备
}

模拟I2C从设备模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(0x3F); // 模拟I2C从设备，地址为0x3F
  Wire.onReceive(receiveEvent); // 注册接收事件处理函数
}

void loop() {
  // 从设备的其他代码
}

void receiveEvent(int numBytes) {
  while (Wire.available()) {
    char c = Wire.read(); // 读取数据
    Serial.println(c); // 处理数据
  }
}

使用I2C多个从设备模板


// 引入Wire库，用于I2C通信
#include <Wire.h>

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
// 向I2C从设备0x3F的寄存器0x00写入数据
Wire.beginTransmission(0x3F); // 发送I2C起始信号，指定从设备地址
Wire.write(0x00); // 发送要写入的寄存器地址
Wire.write(0x01); // 向寄存器中写入1个字节的数据
Wire.endTransmission(); // 发送I2C停止信号

// 向I2C从设备0x40的寄存器0x00写入数据
Wire.beginTransmission(0x40); // 发送I2C起始信号，指定从设备地址
Wire.write(0x00); // 发送要写入的寄存器地址
Wire.write(0x02); // 向寄存器中写入1个字节的数据
Wire.endTransmission(); // 发送I2C停止信号

// 读取I2C从设备0x3F的寄存器0x01的数据
Wire.beginTransmission(0x3F); // 发送I2C起始信号，指定从设备地址
Wire.write(0x01); // 发送要读取的寄存器地址
Wire.endTransmission(); // 发送I2C停止信号
Wire.requestFrom(0x3F, 1); // 请求从从设备读取1个字节的数据
while (Wire.available()) { // 判断是否有数据可读
char c = Wire.read(); // 读取数据
Serial.print("0x3F: "); // 打印从设备地址
Serial.println(c); // 打印读取到的数据
}

// 读取I2C从设备0x40的寄存器0x01的数据
Wire.beginTransmission(0x40); // 发送I2C起始信号，指定从设备地址
Wire.write(0x01); // 发送要读取的寄存器地址
Wire.endTransmission(); // 发送I2C停止信号
Wire.requestFrom(0x40, 1); // 请求从从设备读取1个字节的数据
while (Wire.available()) { // 判断是否有数据可读
char c = Wire.read(); // 读取数据
Serial.print("0x40: "); // 打印从设备地址
Serial.println(c); // 打印读取到的数据
}
}

使用I2C扩展器控制多个设备模板

#include <Wire.h> // 引入Wire库

void setup() {
  Wire.begin(); // 初始化I2C总线
  // 设置I2C扩展器的输出端口
  Wire.beginTransmission(0x20); 
  Wire.write(0x00); 
  Wire.write(0x00); // 设置为输出
  Wire.endTransmission();
}

void loop() {
  // 控制I2C扩展器的输出端口
  Wire.beginTransmission(0x20); 
  Wire.write(0x14); // 第21个端口
  Wire.write(0x01); // 设置为高电平
  Wire.endTransmission();

  // 控制其他设备的代码
}

使用I2C EEPROM 存储数据模板

#include <Wire.h> // 引入Wire库

#define EEPROM_ADDR 0x50 // EEPROM的地址

void setup() {
  Wire.begin(); // 初始化I2C总线
}

void loop() {
  // 写入数据到EEPROM
  byte data[] = {0x01, 0x02, 0x03}; // 要写入的数据
  int address = 0x0000; // 要写入的地址
  for (int i = 0; i < sizeof(data); i++) {
    Wire.beginTransmission(EEPROM_ADDR);
    Wire.write((address >> 8) & 0xFF); // 写入高地址
    Wire.write(address & 0xFF); // 写入低地址
    Wire.write(data[i]); // 写入数据
    Wire.endTransmission();
    delay(10); // 等待写入完成
    address++; // 下一个地址
  }

  // 从EEPROM读取数据
  address = 0x0000; // 要读取的地址
  for (int i = 0; i < sizeof(data); i++) {
    Wire.beginTransmission(EEPROM_ADDR);
    Wire.write((address >> 8) & 0xFF); // 写入高地址
    Wire.write(address & 0xFF); // 写入低地址
    Wire.endTransmission();
    Wire.requestFrom(EEPROM_ADDR, 1);
    while (Wire.available()) {
      Serial.print(Wire.read());
      Serial.print(" ");
    }
    address++; // 下一个地址
  }
  Serial.println();
}

使用I2C OLED 显示屏显示图形模板

#include <Wire.h> // 引入Wire库
#include <Adafruit_GFX.h> // 引入Adafruit_GFX库
#include <Adafruit_SSD1306.h> // 引入Adafruit_SSD1306库

#define SCREEN_WIDTH 128 // OLED显示屏宽度
#define SCREEN_HEIGHT 32 // OLED显示屏高度
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1); // 创建显示对象

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // 初始化显示屏
  display.clearDisplay(); // 清空显示内容
  display.display(); // 更新显示
}

void loop() {
  display.clearDisplay(); // 清空显示内容
  display.setTextSize(1); // 设置字体大小
  display.setTextColor(WHITE); // 设置字体颜色
  display.setCursor(0, 0); // 设置光标位置
  display.println("Hello, world!"); // 显示文本
  display.drawLine(0, 10, 50, 10, WHITE); // 显示线条
  display.drawRect(0, 15, 20, 10, WHITE); // 显示矩形
  display.drawCircle(50, 20, 5, WHITE); // 显示圆形
  display.display(); // 更新显示
}

使用I2C加速度计传感器模板

// 引入Wire库，用于I2C通信
#include <Wire.h>

// 定义加速度计传感器的地址和寄存器地址
#define ACCEL_ADDR 0x19
#define ACCEL_CTRL_REG1_A 0x20
#define ACCEL_OUT_X_L_A 0x28

void setup() {
Wire.begin(); // 初始化I2C总线

// 配置加速度计控制寄存器1
Wire.beginTransmission(ACCEL_ADDR); // 发送I2C起始信号，指定传感器地址
Wire.write(ACCEL_CTRL_REG1_A); // 发送要设置的寄存器地址
Wire.write(0x57); // 向寄存器中写入设置值，设置采样率和分辨率
Wire.endTransmission(); // 发送I2C停止信号
}

void loop() {
// 读取加速度计X轴数据
Wire.beginTransmission(ACCEL_ADDR); // 发送I2C起始信号，指定传感器地址
Wire.write(ACCEL_OUT_X_L_A); // 发送要读取的寄存器地址
Wire.endTransmission(); // 发送I2C停止信号
Wire.requestFrom(ACCEL_ADDR, 2); // 请求从传感器读取2个字节的数据
int accelData = Wire.read() | (Wire.read() << 8); // 读取数据并拼接为16位整数
Serial.println(accelData); // 打印读取到的加速度计数据
}

使用I2C温度传感器模板

#include <Wire.h> // 引入Wire库

#define TEMP_ADDR 0x48 // 温度传感器的地址
#define TEMP_REG 0x00 // 温度数据寄存器

void setup() {
Wire.begin(); // 初始化I2C总线
}

void loop() {
// 读取温度数据
Wire.beginTransmission(TEMP_ADDR); // 向温度传感器发送开始信号
Wire.write(TEMP_REG); // 向温度传感器写入温度数据寄存器地址
Wire.endTransmission(); // 结束信号
Wire.requestFrom(TEMP_ADDR, 2); // 请求2字节数据
int tempData = Wire.read() << 8 | Wire.read(); // 读取温度数据
float temperature = tempData * 0.0625; // 计算温度值
Serial.println(temperature); // 打印温度值
}

使用I2C RTC时钟模块模板

//导入I2C库
#include <Wire.h>

//定义I2C设备地址
#define RTC_ADDRESS 0x68

//定义寄存器地址
#define RTC_SECOND 0x00 //秒寄存器地址
#define RTC_MINUTE 0x01 //分寄存器地址
#define RTC_HOUR 0x02 //时寄存器地址
#define RTC_DAY 0x03 //日寄存器地址
#define RTC_MONTH 0x04 //月寄存器地址
#define RTC_YEAR 0x05 //年寄存器地址

//初始化RTC模块
void initRTC() {
Wire.begin(); //启动I2C总线
}

//设置RTC时间
void setRTCtime(byte second, byte minute, byte hour, byte day, byte month, byte year) {
Wire.beginTransmission(RTC_ADDRESS); //发送起始信号
Wire.write(RTC_SECOND); //发送寄存器地址
Wire.write(second); //发送秒数据
Wire.write(minute); //发送分数据
Wire.write(hour); //发送时数据
Wire.write(day); //发送日数据
Wire.write(month); //发送月数据
Wire.write(year); //发送年数据
Wire.endTransmission(); //发送停止信号
}

//获取RTC时间
void getRTCtime(byte* second, byte* minute, byte* hour, byte* day, byte* month, byte* year) {
Wire.beginTransmission(RTC_ADDRESS); //发送起始信号
Wire.write(RTC_SECOND); //发送寄存器地址
Wire.endTransmission(); //发送停止信号
Wire.requestFrom(RTC_ADDRESS, 7); //请求7个字节的数据
*second = Wire.read(); //读取秒数据
*minute = Wire.read(); //读取分数据
*hour = Wire.read(); //读取时数据
*day = Wire.read(); //读取日数据
*month = Wire.read(); //读取月数据
*year = Wire.read(); //读取年数据
}

北辰青衿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
I2CScan：I2C测试实用程序
02-10
I2C扫描 I2C测试实用程序
咸鱼Micropython—I2C
咸鱼菌
10-08 3379
咸鱼Micropython—I2C I2C是two-wire serial protocol（双线串行通信协议，有 的地方也叫做Inter-integrated circuit）的简称，它是嵌入式系统中最常用的接口之一。I2C只需要使用SDA和SCL两个信号线，就可以和其他带 有I2C接口的芯片连接，一个I2C总线上可以挂载多个芯片，因此可以减 少连线的数量。I2C接口的主要特点是信号线采用开...
STM32F1之I2C通信·软件I2C代码编写
时光の尘的博客
05-24 1319
SCL低电平期间，从机将数据位依次放到SDA线上(高位先行)，然后释放SCL，主机将在SCL高电平期间读取数据位，所以SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可接收一个字节(主机在接收之前,需要释放SDA)。发送一个字节: SCL低电平期间，主机将数据位依次放到SDA线上(高位先行) ，然后释放SCL，从机将在SCL高电平期间读取数据位，所以SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可发送一个字节。终止条件下，SCL高电平期间，SDA从低电平切换到高电平。
TMS320F28377D库函数操作（IIC初始化及使用）
weixin_51686526的博客
07-31 1150
IIC作为低速环境下使用非常广泛的协议，还是要学一学滴。TI的IIC是硬件（看什么看，说的就是你ST，这么大一个厂一个硬件IIC做的还有bug）这两年TI还是不错的，以前TI做的IIC还是专属，鬼知道怎么搞，非常难调。不过这两年TI貌似光明正大地说起来了（难道是NXP开发出来I3C后对I2C管控放松了？不应该吧）虽说与正点原子写的软件IIC还是有区别和不理解，但是最终还是调出来了，回过头来看程序还算能理解吧。
2.2.I2C编程实践
qq_33001335的博客
03-12 606
访问硬件的方式最普遍的思路是通过编写自己的驱动程序进而访问I2C设备，而I2C_Tools可以直接对I2C控制器上的I2C设备进行访问，我们可以通过编写APP（应用程序）来操作I2C_Tools进而来访问I2C设备，对I2C设备进行驱动。有如下函数i2c_transfer：该函数会从i2c_adapter中找到根本的传输函数：algo.master_xfer进行调用，然后从i2c_msg中找到设备的设备地址以及设备读写标志位信息，num则是传输多少个数据消息。，而大家都知道I2C控制器提供。
蓝桥杯单片机程序模板
12-20
【iic.c】和【iic.h】是一对I2C通信协议的源代码和头文件。I2C是一种多主设备、串行总线接口，常用于连接微控制器和外部设备如传感器、EEPROM等。这两个文件提供了I2C协议的实现和相关的函数声明，使得单片机能通过I...
全志T3/A40I 部分外设接口说明书
最新发布
08-13
IIC（Inter-Integrated Circuit，也称为I2C）接口是一种串行通信总线，用于连接低速外围设备。在全志T3和A40I中，IIC接口通常用于与传感器、EEPROM等设备进行通信。 UART（通用异步收发传输器）接口是一种常用的串行...
STM32学习_stm32_CANSTM32_expressjlc_IIC_LED_
09-30
STM32的IIC接口通常包括I2C初始化、发送和接收数据、处理中断等功能。编程时需要配置时钟速度、地址模式、启动和停止条件等。 在该资源包中，LED的控制可能涉及到GPIO（General Purpose Input/Output）接口。STM32...
iar stm8工程模版_stm8s_工程模板_库函数_iarforstm8_
10-04
描述中的"IIC SPI ADC CAN等模块工程模板"意味着这个压缩包中包含了一些常用通信协议（如I2C、SPI、ADC）和总线（如CAN）的工程模板。这些模板涵盖了微控制器中常见的外设接口，有助于开发者理解和应用STM8S的硬件...
RT1052 软IIC模拟 oled12864.zip
05-15
在没有硬连线I2C接口的情况下，可以通过软件模拟I2C通信，即软IIC，来实现与OLED屏的交互。 软IIC模拟涉及到对GPIO引脚的精确控制，模拟时序来发送和接收数据。在RT1052上实现软IIC，需要编写控制GPIO的函数，包括...
【ESP32】【micropython】IIC接口的使用及用esp32读取mpu6050数据
zhgfn4056100的博客
04-21 5289
【ESP32】【micropython】I2C相关函数介绍及用esp32读取mpu6050数据I2C接口介绍micropython相关函数i2c类实例化i2c类中的函数介绍I2C.init(scl, sda, freq)I2C.scan()I2C.start()I2C.stop()I2C.write(buf)I2C.readinto(buf, nack=True)【例子】用esp32读取mpu6050数据 I2C接口介绍 micropython相关函数 i2c类实例化 I2C是设备之间的两线通信协议。在物理
Linux下I2C-tools工具使用
热门推荐
weixin_43824344的博客
10-10 1万+
1.i2cdetect 扫描I2C总线上的设备 i2ctransfer -y -f 1 w2@0x62 0x00 0x00 r32 1.1 i2cdetect -l查看当前系统的I2C总线 总线挂载了I2C设备,可通过i2cdetect扫描每一个总线的所有设备 i2cdetect -y -r 1:查看总线1上的所有从设备("–"表示地址被检测到了,但是没有芯片,"UU"表示地址正在被某一个驱动使用,而16进制的地址号60,1e和50则表示发现了一个外部片选从地址为0x60,0x13(AP3216)和0x
MicroPython内核开发笔记书内软件用例 ：I2C部分的实验
TSINGHUAJOKING
07-01 1222
本文给出了 [**MicroPython内核开发笔记：书内嵌入实验任务**](https://zhuoqing.blog.csdn.net/article/details/125522325) 中的 I2C 件用例部分内容。
Micropython——关于通信I2C协议的应用和原理讲解
Xa_L
03-29 4101
1、I2C总线是什么？ I2C：俗称集成电路总线，是一种简单、双向二线制同步串行通信总线，使用多主从架构。它只需要两根线即可在连接于总线上的器件之间传送信息。 主器件用于启动总线传送数据，并产生时钟以开放传送的器件，此时任何被寻址的器件均被认为是从器件．在总线上主和从、发和收的关系不是恒定的，而取决于此时数据传送方向。如果主机要发送数据给从器件，则主机首先寻址从器件，然后主动发送数据至从器件，最后由主机终止数据传送；如果主机要接收从器件的数据，首先由主器件寻址从器件．然后主机接收从器件发送的数据，最后由
物联网开发121 - Micropython ESP32 C3连接TCS34725颜色识别传感器模块（I2C通信）
zhusongziye的博客
07-12 1466
如何使用合宙ESP32 C3，连接TCS34725颜色识别传感器模块，识别颜色
微雪树莓派PICO笔记——6. I2C（集成电路总线）
weixin_51684355的博客
09-25 3044
微雪PICO笔记
#硬件扫描I2C从设备，扫描函数
qq_55416018的博客
02-29 238
【代码】#硬件扫描I2C从设备，扫描函数。
如何用python的i2c教程_[MicroPython]TPYBoard I2C的用法
weixin_39690401的博客
12-09 251
原创版权归山东萝卜科技有限公司所有,转载必须以链接形式注明作者和原始出处。先看看基本用法：frompybimportI2Ci2c=I2C(1)#createonbus1i2c=I2C(1,I2C.MASTER)#createandinitasamasteri2c.init(I2C.MAS...
【Micropython教程】I2C的使用
m0_62599305的博客
03-01 1930
MicroPython 是一种精简的 Python 实现，旨在运行在微控制器和嵌入式系统上。在嵌入式开发中，与外部设备进行通信是一项常见任务。而 I2C（Inter-Integrated Circuit）是一种常用的串行通信协议，适用于连接各种传感器、显示器和其他外设。在 MicroPython 中，通过 machine 模块提供的 I2C 类，可以轻松地实现对硬件 I2C 总线的控制，并与外部设备进行通信。
wire库的endTransmission()函数是干什么的
06-10
Wire库是Arduino中用于I2C通信的库，endTransmission()函数用于结束I2C传输并返回传输状态。在发送完所有数据之后，该函数将向目标设备发送停止信号，并等待目标设备的响应。如果目标设备成功接收了数据，则返回0，否则返回非0值表示失败。该函数的语法为：int endTransmission(bool stop);其中，stop表示是否发送停止信号，默认为true。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值