RK3568平台（平台总线篇）IIC应用编程

已于 2024-06-25 22:45:06 修改
阅读量392 收藏 7
点赞数 3
分类专栏： 瑞芯微 文章标签： 单片机 嵌入式硬件
于 2024-06-11 23:53:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49303682/article/details/139611318
版权

一.I2C 硬件框架

IIC就是master/slave模式，通过数据线和时钟线两根线实现主从设备通信，其传输熟虑标准模式下可达100kbit/s，快速模式下可达400kbit/s，高速模式下可达3.4Mbit/s。其主要由两根线组成是SDA、SCL、上拉电阻组成。通信原理是通过对SCL和SDA线高低电平时序的控制，在总线空闲状态时，这两根线一般被上面所接的上拉电阻拉高，保持着高电平。

  • VCC：提供电源
  • GND：接地
  • SDA：串联数据线，传输数据
  • SCL：串联时钟线，起控制作用

二.I2C读写示例

ioctl函数的使用:

原型：struct ioctl(struct file *file,unsigned int cmd,unsigned long arg);

cmd有I2C_SLAVE,I2C_SLAVE_FORCE,I2C_TENBIT,I2C_SET_SPEED几个选项；

I2C_SLAVE：对应的arg取值为I2C从机地址，用来设定I2C从机地址；

I2C_SLAVE_FORCE：对应的arg取值为I2C从机地址，用来修改I2C从机地址；

I2C_TENBIT：对应的arg取值为0：从机地址为7 bit；对应的arg取值为1：从机地址为10bit。用来指定I2C从机地址的位数；

I2C_SET_SPEED：对应的arg取值为I2C总线控制器分频值。用来设置I2C总线控制器时钟频率；

读写示例：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include "Log.h"

#include "i2c.h"
static int cam_fd[FD_NUMBER];
static int bus_cnt[FD_NUMBER];
pthread_mutex_t mutex[FD_NUMBER];

int i2c_init(int bus)
{
	int ret = 0;
	char str[12] = {0};

	if (bus < 0 || bus >= FD_NUMBER)
	{
		pr_err("Invalid bus num %d", bus);
		return -1;
	}
	if (cam_fd[bus] <= 0)
	{
		snprintf(str, sizeof(str), "/dev/i2c-%d", bus);
		cam_fd[bus] = open(str, O_RDWR);
		if (cam_fd[bus] < 0)
		{
			pr_err("open i2c-%d fail\n", bus);
			return -1;
		}
		if (pthread_mutex_init(&mutex[bus], NULL) != 0)
		{
			pr_err("Init metux error.");
			close(cam_fd[bus]);
			cam_fd[bus] = -1;
			return -1;
		}
	}
	bus_cnt[bus]++;
	pr_info("bus %d bus_cnt[bus] %d cam_fd[bus] %d\n",
			bus, bus_cnt[bus], cam_fd[bus]);
	return ret;
}

int i2c_deinit(int bus)
{
	int ret = 0;

	if (bus < 0 || bus >= FD_NUMBER)
	{
		pr_err("Invalid bus num %d", bus);
		return -1;
	}
	bus_cnt[bus]--;
	if (bus_cnt[bus] == 0 && cam_fd[bus] > 0)
	{
		close(cam_fd[bus]);
		cam_fd[bus] = -1;
		pthread_mutex_destroy(&mutex[bus]);
	}

	pr_info("bus %d bus_cnt[bus] %d cam_fd[bus] %d\n",
			bus, bus_cnt[bus], cam_fd[bus]);
	return ret;
}

int i2c_read_reg16_data16(int bus, uint8_t i2c_addr, uint16_t reg_addr)
{
	int ret = 0, value = 0;
	unsigned char wr_data[2];
	unsigned char rdata[2] = {0};
	int val = 0;

	wr_data[0] = (reg_addr >> 8) & 0x00ff;
	wr_data[1] = reg_addr & 0x00ff;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = write(cam_fd[bus], wr_data, 2);
	if (ret != 2)
	{
		pr_err("write reg16_data16 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = read(cam_fd[bus], &rdata, 2);
	if (ret != 2)
	{
		pr_err("read reg16_data16 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	value = (rdata[0] << 8) | rdata[1];
	pr_info("success with value 0x%04x \n", value);
	pthread_mutex_unlock(&mutex[bus]);
	return value;
}

int i2c_read_reg16_data8(int bus, uint8_t i2c_addr, uint16_t reg_addr)
{
	int ret = 0, value = 0;
	unsigned char wr_data[2];
	unsigned char rdata = 0;
	int val = 0;

	wr_data[0] = (reg_addr >> 8) & 0x00ff;
	wr_data[1] = reg_addr & 0x00ff;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = write(cam_fd[bus], wr_data, 2);
	if (ret != 2)
	{
		pr_err("write reg16_data8 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = read(cam_fd[bus], &rdata, 1);
	if (ret != 1)
	{
		pr_err("read reg16_data8 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	value = rdata;
	pthread_mutex_unlock(&mutex[bus]);
	return value;
}

int i2c_read_reg8_data8(int bus, uint8_t i2c_addr, uint16_t reg_addr)
{
	int ret = 0, value = 0;
	unsigned char wr_data;
	unsigned char rdata = 0;
	int val = 0;

	wr_data = reg_addr;
	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = write(cam_fd[bus], &wr_data, 1);
	if (ret != 1)
	{
		pr_err("write reg8_data8 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = read(cam_fd[bus], &rdata, 1);
	if (ret != 1)
	{
		pr_err("read reg8_data8 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	value = rdata;
	pthread_mutex_unlock(&mutex[bus]);
	return value;
}

int i2c_read_reg8_data16(int bus, uint8_t i2c_addr, uint16_t reg_addr)
{
	int ret = 0, value = 0;
	unsigned char wr_data;
	unsigned char rdata[2] = {0};
	int val = 0;

	wr_data = reg_addr;
	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = write(cam_fd[bus], &wr_data, 1);
	if (ret != 1)
	{
		pr_err("write reg8_data16 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	ret = read(cam_fd[bus], &rdata, 2);
	if (ret != 2)
	{
		pr_err("read reg8_data16 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	value = (rdata[0] << 8) | rdata[1];
	pthread_mutex_unlock(&mutex[bus]);
	return value;
}

int i2c_write_reg16_data16(int bus, uint8_t i2c_addr,
						   uint16_t reg_addr, uint16_t value)
{
	int ret = 0;
	unsigned char wr_data[4];
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	wr_data[0] = (reg_addr >> 8) & 0x00ff;
	wr_data[1] = reg_addr & 0x00ff;
	wr_data[2] = (value >> 8) & 0x00ff;
	wr_data[3] = (value)&0x00ff;

	// pr_debug("0x%x camera reg(0x%04x) with value 0x%02x\n", i2c_addr , reg_addr, wr_data[2]);
	ret = write(cam_fd[bus], wr_data, 4);
	if (ret != 4)
	{
		// pr_err("write_reg16_data16 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_write_reg16_data8(int bus, uint8_t i2c_addr,
						  uint16_t reg_addr, uint8_t value)
{
	int ret = 0;
	unsigned char wr_data[3];
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		printf("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	wr_data[0] = (reg_addr >> 8) & 0x00ff;
	wr_data[1] = reg_addr & 0x00ff;
	wr_data[2] = value;

	// pr_debug("camera reg(0x%04x) with value 0x%02x ", reg_addr, wr_data[2]);
	ret = write(cam_fd[bus], wr_data, 3);
	if (ret != 3)
	{
		// pr_err("write_reg16_data8 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_write_reg8_data16(int bus, uint8_t i2c_addr,
						  uint16_t reg_addr, uint16_t value)
{
	int ret = 0;
	unsigned char wr_data[3];
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	wr_data[0] = reg_addr;
	wr_data[1] = (value >> 8) & 0x00ff;
	wr_data[2] = (value)&0x00ff;

	ret = write(cam_fd[bus], wr_data, 3);
	if (ret != 3)
	{
		// pr_err("write_reg8_data16 fail\n");
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_write_reg8_data8(int bus, uint8_t i2c_addr,
						 uint16_t reg_addr, uint8_t value)
{
	int ret = 0;
	unsigned char wr_data[2];
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}

	ret = ioctl(cam_fd[bus], I2C_SLAVE_FORCE, i2c_addr);
	if (ret < 0)
	{
		pr_err("unable open camera with addr 0x%02x ioctl I2C_SLAVE_FORCE error\n", i2c_addr);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	wr_data[0] = reg_addr;
	wr_data[1] = value;

	// pr_debug("bus %d i2c_addr 0x%x reg_addr 0x%x value 0x%x\n", bus,
	// i2c_addr, reg_addr, value);
	ret = write(cam_fd[bus], wr_data, 2);
	if (ret != 2)
	{
		// pr_err("write_reg8_data8 fail ret %d 0x%x 0x%x\n", ret, reg_addr, value);
		pthread_mutex_unlock(&mutex[bus]);
		return -1;
	}
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_write_block(int bus, uint8_t i2c_addr,
					uint16_t reg_addr, uint32_t value, uint8_t cnt)
{
	int ret = 0;
	struct i2c_rdwr_ioctl_data data;
	unsigned char sendbuf[12] = {0};
	unsigned char *ptr;
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	if (cnt > 4)
		cnt = 4;

	data.msgs = (struct i2c_msg *)calloc(4, sizeof(struct i2c_msg));

	data.nmsgs = cnt;

	ptr = sendbuf;
	data.msgs[0].len = 3;
	data.msgs[0].addr = i2c_addr;
	data.msgs[0].flags = 0;
	data.msgs[0].buf = ptr;
	data.msgs[0].buf[0] = (reg_addr >> 8) & 0xff;
	data.msgs[0].buf[1] = reg_addr & 0xff;
	data.msgs[0].buf[2] = value & 0xff;
	/*
	printf("msg0: buf[0] %x, buf[1] %x, buf[2] %x\n",
	data.msgs[0].buf[0], data.msgs[0].buf[1], data.msgs[0].buf[2]);
	*/

	ptr = sendbuf + 3;
	data.msgs[1].len = 3;
	data.msgs[1].addr = i2c_addr;
	data.msgs[1].flags = 0;
	data.msgs[1].buf = ptr;
	data.msgs[1].buf[0] = ((reg_addr + 1) >> 8) & 0xff;
	data.msgs[1].buf[1] = (reg_addr + 1) & 0xff;
	data.msgs[1].buf[2] = (value >> 8) & 0xff;

	ptr = sendbuf + 6;
	data.msgs[2].len = 3;
	data.msgs[2].addr = i2c_addr;
	data.msgs[2].flags = 0;
	data.msgs[2].buf = ptr;
	data.msgs[2].buf[0] = ((reg_addr + 2) >> 8) & 0xff;
	data.msgs[2].buf[1] = (reg_addr + 2) & 0xff;
	data.msgs[2].buf[2] = (value >> 16) & 0xff;

	ptr = sendbuf + 9;
	data.msgs[3].len = 3;
	data.msgs[3].addr = i2c_addr;
	data.msgs[3].flags = 0;
	data.msgs[3].buf = ptr;
	data.msgs[3].buf[0] = ((reg_addr + 3) >> 8) & 0xff;
	data.msgs[3].buf[1] = (reg_addr + 3) & 0xff;
	data.msgs[3].buf[2] = (value >> 24) & 0xff;

	ret = ioctl(cam_fd[bus], I2C_RDWR, (unsigned long)&data);
	if (ret < 0)
		pr_err("%s failed\n", __func__);
	free(data.msgs);
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_read_block_reg16(int bus, uint8_t i2c_addr,
						 uint16_t reg_addr, char *buf, uint32_t count)
{
	int ret = 0;
	struct i2c_rdwr_ioctl_data data;
	unsigned char sendbuf[12] = {0};
	int val = 0;

	// pr_info("read_block_reg16 reg_addr 0x%x  count %d\n", reg_addr, count);
	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	data.msgs = (struct i2c_msg *)calloc(2, sizeof(struct i2c_msg));
	data.nmsgs = 2;

	data.msgs[0].len = 2;
	data.msgs[0].addr = i2c_addr;
	data.msgs[0].flags = 0;
	data.msgs[0].buf = sendbuf;
	data.msgs[0].buf[0] = (reg_addr >> 8) & 0xff;
	data.msgs[0].buf[1] = reg_addr & 0xff;

	data.msgs[1].len = count;
	data.msgs[1].addr = i2c_addr;
	data.msgs[1].flags = 1;
	data.msgs[1].buf = buf;

	ret = ioctl(cam_fd[bus], I2C_RDWR, (unsigned long)&data);
	if (ret < 0)
		pr_err("%s failed\n", __func__);
	free(data.msgs);
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_read_block_reg8(int bus, uint8_t i2c_addr,
						uint16_t reg_addr, char *buf, uint32_t count)
{
	int ret = 0;
	struct i2c_rdwr_ioctl_data data;
	unsigned char sendbuf[12] = {0};
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	data.msgs = (struct i2c_msg *)calloc(2, sizeof(struct i2c_msg));
	data.nmsgs = 2;

	data.msgs[0].len = 2;
	data.msgs[0].addr = i2c_addr;
	data.msgs[0].flags = 0;
	data.msgs[0].buf = sendbuf;
	data.msgs[0].buf[0] = reg_addr & 0xff;

	data.msgs[1].len = count;
	data.msgs[1].addr = i2c_addr;
	data.msgs[1].flags = 1;
	data.msgs[1].buf = buf;

	ret = ioctl(cam_fd[bus], I2C_RDWR, (unsigned long)&data);
	if (ret < 0)
		pr_err("%s failed\n", __func__);
	free(data.msgs);
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}
int i2c_write_block_reg16(int bus, uint8_t i2c_addr,
						  uint16_t reg_addr, char *buf, uint32_t count)
{
	int ret = 0;
	struct i2c_rdwr_ioctl_data data;
	char *sendbuf = NULL;
	int val = 0;

	// pr_info("write_block_reg16 reg_addr 0x%x  count %d\n", reg_addr, count);
	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	sendbuf = malloc(count + 2);
	if (sendbuf == NULL)
	{
		pr_err("malloc error\n");
		return -1;
	}
	data.msgs = (struct i2c_msg *)calloc(1, sizeof(struct i2c_msg));
	data.nmsgs = 1;

	data.msgs[0].len = 2 + count;
	data.msgs[0].addr = i2c_addr;
	data.msgs[0].flags = 0;
	data.msgs[0].buf = sendbuf;
	sendbuf[0] = (reg_addr >> 8) & 0xff;
	sendbuf[1] = reg_addr & 0xff;
	memcpy(sendbuf + 2, buf, count);

	ret = ioctl(cam_fd[bus], I2C_RDWR, (unsigned long)&data);
	if (ret < 0)
		pr_err("%s failed\n", __func__);
	free(data.msgs);
	free(sendbuf);
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

int i2c_write_block_reg8(int bus, uint8_t i2c_addr,
						 uint16_t reg_addr, char *buf, uint32_t count)
{
	int ret = 0;
	struct i2c_rdwr_ioctl_data data;
	unsigned char sendbuf[12] = {0};
	int val = 0;

	val = pthread_mutex_lock(&mutex[bus]);
	if (val != 0)
	{
		pr_err("mutex lock error val %d \n", val);
		return -1;
	}
	data.msgs = (struct i2c_msg *)calloc(2, sizeof(struct i2c_msg));
	data.nmsgs = 2;

	data.msgs[0].len = 2;
	data.msgs[0].addr = i2c_addr;
	data.msgs[0].flags = 0;
	data.msgs[0].buf = sendbuf;
	data.msgs[0].buf[0] = reg_addr & 0xff;

	data.msgs[1].len = count;
	data.msgs[1].addr = i2c_addr;
	data.msgs[1].flags = 0;
	data.msgs[1].buf = buf;

	ret = ioctl(cam_fd[bus], I2C_RDWR, (unsigned long)&data);
	if (ret < 0)
		pr_err("%s failed\n", __func__);

	free(data.msgs);
	pthread_mutex_unlock(&mutex[bus]);
	return 0;
}

嵌入式_笔记
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RK3568平台开发系列讲解（驱动篇）驱动开发之I2C使用
内核笔记
01-25 3727
RK3568开发板上有 6 个片上 I2C 控制器 本文主要描述如何在该开发板上配置 I2C。 配置 I2C 可分为两大步骤： 定义和注册 I2C 设备 定义和注册 I2C 驱动
RK3568-i2c
Paper_Love的博客
08-31 669
i2c
RK3568平台（平台总线篇）IIC子系统框架
weixin_49303682的博客
10-28 236
IIC只有两条线，一条串行数据线；一条是时钟线SCL。使用SCL，SDA这两条线就实现了设备之间的数据交互。I2C通信可以（1个主设备对1个从设备），也可以（1个主设备对多个从设备）。
使用gpio模拟i2c时序代码，亲测可用
zhangjianjun521的博客
04-19 1941
参考：https://blog.csdn.net/huoyu_/article/details/53373815 ////////////////////////////////////这些代码是框架层的代码，无需修改直接使用即可///////////////////////////////////////////// #define DELAY 1 typedef unsigned ...
RK3568-I2C操作
tang0_0
09-09 885
RK3568内有6个I2C控制器，对应/dev下的，控制器支持下列功能︰。
RK3568平台开发系列讲解（驱动基础篇）RK平台I2C的使用
内核笔记
05-21 1444
📢本篇将对RK I2C 的使用进行学习。
rk3399平台imx335驱动
09-02
支持rk3399//rk3399pro平台，imx335 sendor iic驱动，配套支持所需isp配置xml文件。
iic.zip_IIC_IIC总线_iic asm
09-23
IIC（Inter-Integrated Circuit），又称为I²C或I^2C，是一种由飞利浦（现为恩智浦半导体）开发的多设备通信总线，常用于微控制器和其他电子设备之间的通信。IIC总线的设计初衷是为了简化系统内部组件间的连接，减少...
IIC.zip_iic总线编程_s12zvc单片机 iic_频率控制_飞思卡尔IIC
09-23
本篇将详细介绍飞思卡尔S12ZVC单片机的IIC总线编程，包括频率控制、数据收发验证等相关知识点。 首先，理解IIC协议的关键在于其时序。IIC总线由两条线构成：SDA（数据线）和SCL（时钟线）。数据传输由主设备（通常...
蓝桥杯CT107平台iic总线驱动代码分享
03-24
本篇文章将围绕蓝桥杯CT107平台的IIC总线驱动代码进行深入探讨，以帮助参赛者更好地理解和应用这一技术。 I2C总线是由飞利浦（现NXP半导体）公司于1982年开发的一种简单、高效的两线制通信协议。它只需要两条线——...
rk3399平台imx334驱动
09-02
在本文中，我们将深入探讨"rk3399平台imx334驱动"的相关知识点，这涉及到嵌入式系统中的硬件接口设计、驱动程序开发以及图像传感器的应用。rk3399是一款由Rockchip公司推出的高性能应用处理器，广泛应用于智能电视、...
RK3568平台开发系列讲解（驱动基础篇）I2C协议介绍
内核笔记
03-19 1275
📢I2C的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。
RK3568驱动指南｜第十五篇 I2C-第166章 初步认识I2C
最新发布
BeiJingXunWei的博客
07-01 1014
该协议巧妙地利用仅两条线路就可以实现芯片之间的互连通信,大幅简化了硬件电路设计,提高了硬件资源的利用效率,给芯片设计制造商和应用商带来了极大的好处。之后主设备和从设备就可以开始传输数据。在空闲状态下，SDA和SCL一般被上拉电阻拉高，保持高电平状态，在需要进行数据传输的时候，通过SCL和SDA的高低电平来产生I2C总线所需要的信号进行数据传递。每一个12C外设都会对应一个唯一的地址(这个地址可以从I2C外设器件的数据手册中得到），主机和从机之间的通信就是通过这个地址来确定主机要和哪个从机进行通信的。
IIC核心函数与“万能”驱动
十七阿哥的博客
04-28 261
IIC核心函数与“万能”驱动 i2c_add_adapter()函数 drivers/i2c/i2c-core-base.c 注册一个i2c适配器 int i2c_add_adapter(struct i2c_adapter *adapter) int i2c_add_numbered_adapter(struct i2c_adapter *adapter) adapter->nr：适配器的编号 参数： adapter：i2c物理控制器对应的适配器 返回值： 成功：0 失败：负数 i2c_a
rk3399 sensor i2c read-write
weixin_44981258的博客
11-12 555
rk3399 camera sensor关于i2c的读写函数 1.hardware/rockchip/camera/CameraHal$ vim CameraHal_board_xml_parse.cpp static int sensor_write_i2c( void* context, int camsys_fd, const uint32_t reg_address, const uint32_t value, int* i2c_base_
rk3568 I2C
weixin_35723192的博客
02-27 104
I2C（Inter-Integrated Circuit）总线是一种串行通信协议，由Philips（现在的NXP）公司于1980年代初开发。它最初被设计用于连接不同的集成电路和集成模块，以降低系统成本和复杂度。随着时间的推移，I2C总线已经成为连接各种设备的主要标准之一。I2C总线最初只支持100 kbit/s的数据传输速率，但现在已经发展到支持高达3.4 Mbit/s的速率。I2C总线的特点是具有简单、灵活、多功能性和低成本等优势，因此被广泛应用于各种领域，如电子消费品、工业自动化、汽车电子、医疗设备等。
RK3568平台 添加I2C模拟芯片CH423_rk3568 iic
2401_83704192的博客
04-05 1010
你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**如果你觉得这些内容对你有帮助，可以+V：Vip1104z获取！！！（备注：嵌入式）你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！更多资料点击此处获qu！！
基于rk3568解决gpio阶梯波形（适用于i2c、uart、电平转换）
daisy.skye的博客
03-08 1103
实测中遇到的是i2c问题，但是uart或者电平转换芯片都会遇到，首先保证外部是否有1k电阻的上拉，当然具体的电阻可以自行进行调节，其次需要满足开漏模式的输出（OD）。根据原理图的地址，查询rk3568的手册得到gpio的OD配置及地址，daisy.skye擅长嵌入式,Linux,Qt,等方面的知识。daisy.skye_嵌入式,Linux,Qt-CSDN博客。kernel编译（单编 boot.img 同步骤）1、理解GPIO的开漏（OD）和开集（OC）单独编译boot.img。2、查询io寄存器地址。
IIC从零都有的学习笔记
12-27
IIC（Inter-Integrated Circuit）总线是一种由飞利浦（现NXP）公司设计的简单、低功耗、双向二线制串行接口，广泛应用于嵌入式系统中，用于设备间的通信。IIC总线的主要特点是其高效和灵活性，它允许多个主控设备与...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嵌入式_笔记

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

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

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

打赏作者

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

抵扣说明：

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

余额充值