I2C应用

原创 已于 2022-05-03 23:30:56 修改 · 1.9k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络协议 #网络 #ubuntu

于 2022-04-28 23:29:56 首次发布

I2C简介

        I2C(Inter－Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，最初为音频和视频设备开发，如今主要在服务器管理中使用，其中包括单个组件状态的通信。例如管理员可对各个组件进行查询，以管理系统的配置或掌握组件的功能状态，如电源和系统风扇。可随时监控内存、硬盘、网络、系统温度等多个参数，增加了系统的安全性，方便了管理。

I2C工作原理

I2C总线是由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，最高传送速率100kbps。各种被控制电路均并联在这条总线上，但就像电话机一样只有拨通各自的号码才能工作，所以每个电路和模块都有唯一的地址，在信息的传输过程中，I2C总线上并接的每一模块电路既是主控器（或被控器），又是发送器（或接收器），这取决于它所要完成的功能。CPU发出的控制信号分为地址码和控制量两部分，地址码用来选址，即接通需要控制的电路，确定控制的种类；控制量决定该调整的类别（如对比度、亮度等）及需要调整的量。这样，各控制电路虽然挂在同一条总线上，却彼此独立，互不相关。

1. 查看 I2C 源代码

vim 24cxx.h 24cXX.c eeprog.c

24cXX.c:

/***************************************************************************
    copyright            : (C) by 2003-2004 Stefano Barbato
    email                : stefano@codesink.org
    $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <linux/fs.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <assert.h>
#include <string.h>
#include "24cXX.h"
 
 
static inline __s32 i2c_smbus_access(int file, char read_write, __u8 command, 
                                     int size, union i2c_smbus_data *data)
{
	struct i2c_smbus_ioctl_data args;
 
	args.read_write = read_write;
	args.command = command;
	args.size = size;
	args.data = data;
	return ioctl(file,I2C_SMBUS,&args);
}
 
 
static inline __s32 i2c_smbus_write_quick(int file, __u8 value)
{
	return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,NULL);
}
	
static inline __s32 i2c_smbus_read_byte(int file)
{
	union i2c_smbus_data data;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,&data))
		return -1;
	else
		return 0x0FF & data.byte;
}
 
static inline __s32 i2c_smbus_write_byte(int file, __u8 value)
{
	return i2c_smbus_access(file,I2C_SMBUS_WRITE,value,
	                        I2C_SMBUS_BYTE,NULL);
}
 
static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)
{
	union i2c_smbus_data data;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
	                     I2C_SMBUS_BYTE_DATA,&data))
		return -1;
	else
		return 0x0FF & data.byte;
}
 
static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command, 
                                              __u8 value)
{
	union i2c_smbus_data data;
	data.byte = value;
	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                        I2C_SMBUS_BYTE_DATA, &data);
}
 
static inline __s32 i2c_smbus_read_word_data(int file, __u8 command)
{
	union i2c_smbus_data data;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
	                     I2C_SMBUS_WORD_DATA,&data))
		return -1;
	else
		return 0x0FFFF & data.word;
}
 
static inline __s32 i2c_smbus_write_word_data(int file, __u8 command, 
                                              __u16 value)
{
	union i2c_smbus_data data;
	data.word = value;
	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                        I2C_SMBUS_WORD_DATA, &data);
}
 
static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value)
{
	union i2c_smbus_data data;
	data.word = value;
	if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                     I2C_SMBUS_PROC_CALL,&data))
		return -1;
	else
		return 0x0FFFF & data.word;
}
 
 
/* Returns the number of read bytes */
static inline __s32 i2c_smbus_read_block_data(int file, __u8 command, 
                                              __u8 *values)
{
	union i2c_smbus_data data;
	int i;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
	                     I2C_SMBUS_BLOCK_DATA,&data))
		return -1;
	else {
		for (i = 1; i <= data.block[0]; i++)
			values[i-1] = data.block[i];
		return data.block[0];
	}
}
 
static inline __s32 i2c_smbus_write_block_data(int file, __u8 command, 
                                               __u8 length, __u8 *values)
{
	union i2c_smbus_data data;
	int i;
	if (length > 32)
		length = 32;
	for (i = 1; i <= length; i++)
		data.block[i] = values[i-1];
	data.block[0] = length;
	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                        I2C_SMBUS_BLOCK_DATA, &data);
}
 
/* Returns the number of read bytes */
static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command,
                                                  __u8 *values)
{
	union i2c_smbus_data data;
	int i;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
	                      I2C_SMBUS_I2C_BLOCK_DATA,&data))
		return -1;
	else {
		for (i = 1; i <= data.block[0]; i++)
			values[i-1] = data.block[i];
		return data.block[0];
	}
}
 
static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command,
                                               __u8 length, __u8 *values)
{
	union i2c_smbus_data data;
	int i;
	if (length > 32)
		length = 32;
	for (i = 1; i <= length; i++)
		data.block[i] = values[i-1];
	data.block[0] = length;
	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                        I2C_SMBUS_I2C_BLOCK_DATA, &data);
}
 
/* Returns the number of read bytes */
static inline __s32 i2c_smbus_block_process_call(int file, __u8 command,
                                                 __u8 length, __u8 *values)
{
	union i2c_smbus_data data;
	int i;
	if (length > 32)
		length = 32;
	for (i = 1; i <= length; i++)
		data.block[i] = values[i-1];
	data.block[0] = length;
	if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                     I2C_SMBUS_BLOCK_PROC_CALL,&data))
		return -1;
	else {
		for (i = 1; i <= data.block[0]; i++)
			values[i-1] = data.block[i];
		return data.block[0];
	}
}
 
static int i2c_write_1b(struct eeprom *e, __u8 buf)
{
	int r;
	// we must simulate a plain I2C byte write with SMBus functions
	r = i2c_smbus_write_byte(e->fd, buf);
	if(r < 0)
		fprintf(stderr, "Error i2c_write_1b: %s\n", strerror(errno));
	usleep(10);
	return r;
}
 
static int i2c_write_2b(struct eeprom *e, __u8 buf[2])
{
	int r;
	// we must simulate a plain I2C byte write with SMBus functions
	r = i2c_smbus_write_byte_data(e->fd, buf[0], buf[1]);
	if(r < 0)
		fprintf(stderr, "Error i2c_write_2b: %s\n", strerror(errno));
	usleep(10);
	return r;
}
 
static int i2c_write_3b(struct eeprom *e, __u8 buf[3])
{
	int r;
	// we must simulate a plain I2C byte write with SMBus functions
	// the __u16 data field will be byte swapped by the SMBus protocol
	r = i2c_smbus_write_word_data(e->fd, buf[0], buf[2] << 8 | buf[1]);
	if(r < 0)
		fprintf(stderr, "Error i2c_write_3b: %s\n", strerror(errno));
	usleep(10);
	return r;
}
 
 
#define CHECK_I2C_FUNC( var, label ) \
	do { 	if(0 == (var & label)) { \
		fprintf(stderr, "\nError: " \
			#label " function is required. Program halted.\n\n"); \
		exit(1); } \
	} while(0);
 
int eeprom_open(char *dev_fqn, int addr, int type, struct eeprom* e)
{
	int funcs, fd, r;
	e->fd = e->addr = 0;
	e->dev = 0;
	
	fd = open(dev_fqn, O_RDWR);
	if(fd <= 0)
	{
		fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
		return -1;
	}
 
	// get funcs list
	if((r = ioctl(fd, I2C_FUNCS, &funcs) < 0))
	{
		fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
		return -1;
	}
 
	
	// check for req funcs
	CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_BYTE );
	CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_BYTE );
	CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_BYTE_DATA );
	CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_BYTE_DATA );
	CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_WORD_DATA );
	CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_WORD_DATA );
 
	// set working device
	if( ( r = ioctl(fd, I2C_SLAVE, addr)) < 0)
	{
		fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
		return -1;
	}
	e->fd = fd;
	e->addr = addr;
	e->dev = dev_fqn;
	e->type = type;
	return 0;
}
 
int eeprom_close(struct eeprom *e)
{
	close(e->fd);
	e->fd = -1;
	e->dev = 0;
	e->type = EEPROM_TYPE_UNKNOWN;
	return 0;
}
 
#if 0
int eeprom_24c32_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)
{
	__u8 buf[3] = { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
	return i2c_write_3b(e, buf);
}
 
 
int eeprom_24c32_read_current_byte(struct eeprom* e)
{
	ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
	return i2c_smbus_read_byte(e->fd);
}
 
int eeprom_24c32_read_byte(struct eeprom* e, __u16 mem_addr)
{
	int r;
	ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
	__u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
	r = i2c_write_2b(e, buf);
	if (r < 0)
		return r;
	r = i2c_smbus_read_byte(e->fd);
	return r;
}
#endif
 
 
int eeprom_read_current_byte(struct eeprom* e)
{
	ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
	return i2c_smbus_read_byte(e->fd);
}
 
int eeprom_read_byte(struct eeprom* e, __u16 mem_addr)
{
	int r;
	ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
	if(e->type == EEPROM_TYPE_8BIT_ADDR)
	{
		__u8 buf =  mem_addr & 0x0ff;
		r = i2c_write_1b(e, buf);
	} else if(e->type == EEPROM_TYPE_16BIT_ADDR) {
		__u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
		r = i2c_write_2b(e, buf);
	} else {
		fprintf(stderr, "ERR: unknown eeprom type\n");
		return -1;
	}
	if (r < 0)
		return r;
	r = i2c_smbus_read_byte(e->fd);
	return r;
}
 
int eeprom_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)
{
	if(e->type == EEPROM_TYPE_8BIT_ADDR) {
		__u8 buf[2] = { mem_addr & 0x00ff, data };
		return i2c_write_2b(e, buf);
	} else if(e->type == EEPROM_TYPE_16BIT_ADDR) {
		__u8 buf[3] = 
			{ (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
		return i2c_write_3b(e, buf);
	} 
	fprintf(stderr, "ERR: unknown eeprom type\n");
	return -1;
}

24cXX.h

/***************************************************************************
    copyright            : (C) by 2003-2004 Stefano Barbato
    email                : stefano@codesink.org
    $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef _24CXX_H_
#define _24CXX_H_
#include <linux/i2c-dev.h>
#include <linux/i2c.h>
 
#define EEPROM_TYPE_UNKNOWN	0
#define EEPROM_TYPE_8BIT_ADDR	1
#define EEPROM_TYPE_16BIT_ADDR 	2
 
struct eeprom
{
	char *dev; 	// device file i.e. /dev/i2c-N
	int addr;	// i2c address
	int fd;		// file descriptor
	int type; 	// eeprom type
};
 
/*
 * opens the eeprom device at [dev_fqn] (i.e. /dev/i2c-N) whose address is
 * [addr] and set the eeprom_24c32 [e]
 */
int eeprom_open(char *dev_fqn, int addr, int type, struct eeprom*);
/*
 * closees the eeprom device [e] 
 */
int eeprom_close(struct eeprom *e);
/*
 * read and returns the eeprom byte at memory address [mem_addr] 
 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 
 */
int eeprom_read_byte(struct eeprom* e, __u16 mem_addr);
/*
 * read the current byte
 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 
 */
int eeprom_read_current_byte(struct eeprom *e);
/*
 * writes [data] at memory address [mem_addr] 
 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 
 */
int eeprom_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data);
 
#endif

eeprog.c

/***************************************************************************
    copyright            : (C) by 2009 Guangzhou FriendlyaRM, in China
    email                : capbily@163.com
    website                      : arm9.net
 ***************************************************************************/
 
#include <stdio.h>
#include <fcntl.h>
#include <getopt.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "24cXX.h"
 
#define DEVICE_FILE_STRING "/dev/i2c/0"
#define DEVICE_ADDRESS 0x50
 
#define usage_if(a) do { do_usage_if( a , __LINE__); } while(0);
void do_usage_if(int b, int line) {
        const static char *eeprog_usage =
                "I2C-24C08(256 bytes) Read/Write Program, ONLY FOR TEST!\n"
                "FriendlyARM Computer Tech. 2009\n";
        if(!b)
                return;
        fprintf(stderr, "%s\n[line %d]\n", eeprog_usage, line);
        exit(1);
}
 
 
#define die_if(a, msg) do { do_die_if( a , msg, __LINE__); } while(0);
void do_die_if(int b, char* msg, int line) {
        if(!b)
                return;
        fprintf(stderr, "Error at line %d: %s\n", line, msg);
        fprintf(stderr, "       sysmsg: %s\n", strerror(errno));
        exit(1);
}
 
 
static int read_from_eeprom(struct eeprom *e, int addr, int size) {
        int ch, i;
        for(i = 0; i < size; ++i, ++addr) {
                die_if((ch = eeprom_read_byte(e, addr)) < 0, "read error");
                if( (i % 16) == 0 )
                        printf("\n %.4x|  ", addr);
                else if( (i % 8) == 0 )
                        printf("  ");
                printf("%.2x ", ch);
                fflush(stdout);
        }
        fprintf(stderr, "\n\n");
}
 
static int write_to_eeprom(struct eeprom *e, int addr) {
        int i;
        for(i=0, addr=0; i<256; i++, addr++) {
                if( (i % 16) == 0 )
                        printf("\n %.4x|  ", addr);
                else if( (i % 8) == 0 )
                        printf("  ");
                printf("%.2x ", i);
                fflush(stdout);
                die_if(eeprom_write_byte(e, addr, i), "write error");
        }
        fprintf(stderr, "\n\n");
        return 0;
}
 
int main(int argc, char** argv) {
        struct eeprom e;
        int op;
 
        op = 0;
 
        usage_if(argc != 2 || argv[1][0] != '-' || argv[1][2] != '\0');
        op = argv[1][1];
 
        //TODO: 将数字改为自己的学号。
        write(STDOUT_FILENO, "APP for 123456789012345 ...\n", strlen("APP for 123456789012345 ...\n"));
        fprintf(stderr, "Open %s with 8bit mode\n", DEVICE_FILE_STRING);
        die_if(eeprom_open(DEVICE_FILE_STRING, DEVICE_ADDRESS, EEPROM_TYPE_8BIT_ADDR, &e) < 0,
                        "unable to open eeprom device file "
                        "(check that the file exists and that it's readable)");
        switch(op) {
        case 'r':
                fprintf(stderr, "  Reading 256 bytes from 0x0\n");
                read_from_eeprom(&e, 0, 256);
                break;
        case 'w':
                fprintf(stderr, "  Writing 0x00-0xff into 24C08 \n");
                write_to_eeprom(&e, 0);
                break;
        default:
                usage_if(1);
                exit(1);
        }
        eeprom_close(&e);
 
        return 0;
}

2. 编译并运行

3. 思考题

I2C总线的优点是什么？

     （1.）I2C总线只需要一根数据线和一根时钟线两根线，总线接口已经集成在芯片内部，优化主板空间和成本。

     （2.）无论总线上有多少设备，都只使用两条线，保持低引脚/信号数

     （3.）真正的支持多主机设备，但是同一时刻只允许一台主机

     （4.）I2C总线具有低功耗、抗干扰强的优点，传输距离长的特点。

     （5.）连接到相同总线的IC 数量只受到总线的最大电容400pF 限制

I2C总线的启动信号和结束信号有什么特点？

          启动信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。

          结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。

参考：

i2c总线的启动信号和停止信号-与非网

I2C总线介绍_John.Ma的博客-优快云博客_i2c总线

hellohellohhw
关注
I2C子系统驱动框架及应用
韩朋的博客
06-01 6726
I2C子系统框架： 应用程序层（app层） ——————————————————————————————————– i2c driver层： 从设备驱动层（TS Sensor等） 1. 需要和应用层交互（fops cdev） 2. 封装数据，但是不知道数据如何写入到硬件，需要调用adapter层的相关函数去写 —————
LinuxI2C应用编程——I2C-Tools的使用
NRWHF的博客
07-09 2857
LinuxI2C应用编程——I2C-Tools的使用
I2C总线原理及应用实例
11-06
I2C总线原理及应用实例I2C总线原理及应用实例I2C总线原理及应用实例I2C总线原理及应用实例
《I2C总线接口技术的应用》
04-27
《I2C的应用》《I2C的应用》《I2C的应用》
STM32系列I2C应用总结
06-04
STM32的I2C模块，有些坑要绕过去，这是一总结的文档。
i2c驱动设备的应用
Hleang的博客
04-26 1439
i2c驱动设备的应用 I2C总线原理 I2C即Inter IC，由Philips公司开发，是当今电子设计中应用非常广泛的串行总线之一，主要用于电压、温度监控，EEPROM(电可擦可编程只读存储器)数据的读写，光模块的管理等。I2C总线只有两根线，SCL和SDA，SCL即Serial Clock，串行时钟，SDA即Serial Data，串行数据。 I2C总线的速率 标准模式下：100Kbps 快速模式下：400Kbps 高速模式下：3.4Mbps I2C总线结构如下图所示： 1.阅读理
I2C应用实例
acktomas的博客
03-02 4683
topicI²C实用教学：基于Arduino Micro的温度传感器导语I²C介绍I²C和Arduino温度传感器DS1621管脚连接Arduino与DS1621通讯发送数据读取数据 I²C实用教学：基于Arduino Micro的温度传感器 http://haipeng.me/2017/10/31/thermostat_with_arduino_micro_via_i2c/ 导语 I²C，即In...
USB转I2C/IIC适配器上位机应用程序
06-21
【USB转I2C/IIC适配器上位机应用程序】是一种专为I2C（Inter-Integrated Circuit）通信协议设计的工具，它通过USB接口将个人计算机转换为能够与I2C设备交互的控制器。这个适配器使得开发者和工程师能够方便地对支持I...
STM32 HAL库 硬件I2C对MPU6050的使用
11-02
在这个主题中，我们将深入探讨如何使用STM32 HAL库来操作硬件I2C接口，以与MPU6050六轴陀螺仪和加速度计通信，并实现DMP（数字运动处理器）功能。 MPU6050是一款集成的惯性测量单元，包含三轴陀螺仪和三轴加速度计...
I2C驱动框架分析（2）：I2C框架源码分析
weixin_43952192的博客
10-27 2037
i2c是低速模块中最常见的模块之一，也是linux系统的最基础的框架，本系列内容主要针对dw厂商的i2c IP进行分析
I2C使用经典例程
01-07
给新手的一份很好的学习机会！很切中要害，对了解学习使用stm32嵌入式有帮助
【物联网】I2C（IIC）通信协议详解与应用
热门推荐
Goforyouqp的博客
07-03 2万+
I2C（Inter-Integrated Circuit）是一种常见的串行通信协议，用于在集成电路（IC）之间进行通信。它由飞利浦半导体（现在是恩智浦）在1982年首次提出，并广泛应用于各种电子设备和系统中。本文将详细介绍I2C的工作原理、特性和常见的应用场景。
I2C技术及应用
tianjinzhangli的专栏
04-18 934
I2C总线原理与应用      2010年1月27日 14:27  21ic  一.简介I2C(Inter－Integrated Circuit)总线是一种由Philips公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，
I2C 原理及应用
u013177084的专栏
09-12 3948
I2C 原理及应用(下) 6. S5PC100下的I2C控制器介绍 S5PC100处理器支持多主机I2C串行总线接口，并且它支持主机发送模式、主机接收模式、从机发送模式和从机接收模式4种模式，图4所示为I2C总线的概括图。 图4 I2C总线的概括图 7. I2C总线控制寄存器详解 表1为I2C总线控制寄存器描述。 表1        I2C总线控制寄存器 I2CCON
I2C协议&应用（嵌入式学习）
JiaYu的博客
06-25 1367
I2C是Inter-Integrated Circuit的缩写，它是一种广泛使用的串行通信协议。它由飞利浦（现在是NXP Semiconductors）开发，并已成为各种电子设备中集成电路（IC）之间通信的标准。I2C是一种由两根线组成的接口，分别是串行数据线（SDA）和串行时钟线（SCL）。多个设备可以连接到同一总线上，每个设备都有一个唯一的地址，用于与总线上特定设备进行通信。I2C协议支持主设备和从设备。主设备发起通信并生成时钟信号，而从设备则响应主设备的命令或请求。
I2C协议指南：基础知识、工作原理与高级应用
嵌入式极客小张
06-16 1887
首先，你可能会问：“I2C协议是什么？”好问题！I2C（Inter-Integrated Circuit）是一种用于短距离通信的串行通信协议，通常用于在单片机和各种外围设备（如传感器、显示屏、存储器等）之间进行数据传输。I2C协议由飞利浦公司在1982年发明，现已成为嵌入式系统中广泛使用的标准。
I2C应用程序编程
最新发布
weixin_62822414的博客
08-04 1264
此篇文章旨在对I2C和SMBus进行介绍和学习，所学来自百问网
I2C 应用编程
weixin_48856218的博客
12-11 1705
传输数据，我们需要把数据从主设备发送到从设备上去，也需要把数据从从设备传送到主设备上去，数据涉及到双向传输。设备，我们还会放一个上拉电阻（放一个上拉电阻的原因以后我们再说）。每传输一字节数据，接收方要有一个回应信号（确定数据是否接受完成。每传输一字节数据，接收方要有一个回应信号（确定数据是否接受完成。◼ 它构造好一系列的数据，发给 I2C。个时钟用来传输回应信号。双方设备中，某个设备发送数据时，另一方怎样才能不影响。数据发送完之后，主芯片就会发送一个停止信号。数据发送完之后，主芯片就会发送一个停止信号。
I2C从原理到应用
weixin_45386293的博客
04-24 566
I2C协议是一种双向二线制同步串行总线，由Philips公司开发，用于连接微控制器及其外围设备。它具有线路简单、硬件开销小、软件编程容易等优点。I2C总线由数据线SDA和时钟线SCL构成，可连接多个器件，支持多种通信速度。I2C协议作为一种高效、简单的通信方式，为现代电子系统提供了强大的支持。通过深入了解I2C协议的工作原理和特点，我们可以更好地应用它于实际项目中，提高系统的性能和稳定性。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值