在Linux 应用层 基于i2c-dev.h 实现i2c读写

最新推荐文章于 2024-04-14 16:38:17 发布
最新推荐文章于 2024-04-14 16:38:17 发布
阅读量8.8k 收藏 16
点赞数 2
分类专栏： 项目-LPC3250
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/psvoldemort/article/details/40300715
版权 
/*
    i2c-dev.h - i2c-bus driver, char device interface

    Copyright (C) 1995-97 Simon G. Vogl
    Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>

    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.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
    MA 02110-1301 USA.
*/

#ifndef _LINUX_I2C_DEV_H
#define _LINUX_I2C_DEV_H

#include <linux/types.h>
#include <sys/ioctl.h>
#include <stddef.h>


/* -- i2c.h -- */


/*
 * I2C Message - used for pure i2c transaction, also from /dev interface
 */
struct i2c_msg {
	__u16 addr;	/* slave address			*/
	unsigned short flags;
#define I2C_M_TEN	0x10	/* we have a ten bit chip address	*/
#define I2C_M_RD	0x01
#define I2C_M_NOSTART	0x4000
#define I2C_M_REV_DIR_ADDR	0x2000
#define I2C_M_IGNORE_NAK	0x1000
#define I2C_M_NO_RD_ACK		0x0800
	short len;		/* msg length				*/
	char *buf;		/* pointer to msg data			*/
};

/* To determine what functionality is present */

#define I2C_FUNC_I2C			0x00000001
#define I2C_FUNC_10BIT_ADDR		0x00000002
#define I2C_FUNC_PROTOCOL_MANGLING	0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
#define I2C_FUNC_SMBUS_PEC		0x00000008
#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL	0x00008000 /* SMBus 2.0 */
#define I2C_FUNC_SMBUS_QUICK		0x00010000
#define I2C_FUNC_SMBUS_READ_BYTE	0x00020000
#define I2C_FUNC_SMBUS_WRITE_BYTE	0x00040000
#define I2C_FUNC_SMBUS_READ_BYTE_DATA	0x00080000
#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA	0x00100000
#define I2C_FUNC_SMBUS_READ_WORD_DATA	0x00200000
#define I2C_FUNC_SMBUS_WRITE_WORD_DATA	0x00400000
#define I2C_FUNC_SMBUS_PROC_CALL	0x00800000
#define I2C_FUNC_SMBUS_READ_BLOCK_DATA	0x01000000
#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
#define I2C_FUNC_SMBUS_READ_I2C_BLOCK	0x04000000 /* I2C-like block xfer  */
#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK	0x08000000 /* w/ 1-byte reg. addr. */

#define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
                             I2C_FUNC_SMBUS_WRITE_BYTE)
#define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
                                  I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
#define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \
                                  I2C_FUNC_SMBUS_WRITE_WORD_DATA)
#define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
                                   I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
#define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
                                  I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)

/* Old name, for compatibility */
#define I2C_FUNC_SMBUS_HWPEC_CALC	I2C_FUNC_SMBUS_PEC

/*
 * Data for SMBus Messages
 */
#define I2C_SMBUS_BLOCK_MAX	32	/* As specified in SMBus standard */
#define I2C_SMBUS_I2C_BLOCK_MAX	32	/* Not specified but we use same structure */
union i2c_smbus_data {
	__u8 byte;
	__u16 word;
	__u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
	                                            /* and one more for PEC */
};

/* smbus_access read or write markers */
#define I2C_SMBUS_READ	1
#define I2C_SMBUS_WRITE	0

/* SMBus transaction types (size parameter in the above functions)
   Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
#define I2C_SMBUS_QUICK		    0
#define I2C_SMBUS_BYTE		    1
#define I2C_SMBUS_BYTE_DATA	    2
#define I2C_SMBUS_WORD_DATA	    3
#define I2C_SMBUS_PROC_CALL	    4
#define I2C_SMBUS_BLOCK_DATA	    5
#define I2C_SMBUS_I2C_BLOCK_BROKEN  6
#define I2C_SMBUS_BLOCK_PROC_CALL   7		/* SMBus 2.0 */
#define I2C_SMBUS_I2C_BLOCK_DATA    8


/* /dev/i2c-X ioctl commands.  The ioctl's parameter is always an
 * unsigned long, except for:
 *	- I2C_FUNCS, takes pointer to an unsigned long
 *	- I2C_RDWR, takes pointer to struct i2c_rdwr_ioctl_data
 *	- I2C_SMBUS, takes pointer to struct i2c_smbus_ioctl_data
 */
#define I2C_RETRIES	0x0701	/* number of times a device address should
				   be polled when not acknowledging */
#define I2C_TIMEOUT	0x0702	/* set timeout in units of 10 ms */

/* NOTE: Slave address is 7 or 10 bits, but 10-bit addresses
 * are NOT supported! (due to code brokenness)
 */
#define I2C_SLAVE	0x0703	/* Use this slave address */
#define I2C_SLAVE_FORCE	0x0706	/* Use this slave address, even if it
				   is already in use by a driver! */
#define I2C_TENBIT	0x0704	/* 0 for 7 bit addrs, != 0 for 10 bit */

#define I2C_FUNCS	0x0705	/* Get the adapter functionality mask */

#define I2C_RDWR	0x0707	/* Combined R/W transfer (one STOP only) */

#define I2C_PEC		0x0708	/* != 0 to use PEC with SMBus */
#define I2C_SMBUS	0x0720	/* SMBus transfer */


/* This is the structure as used in the I2C_SMBUS ioctl call */
struct i2c_smbus_ioctl_data {
	__u8 read_write;
	__u8 command;
	__u32 size;
	union i2c_smbus_data *data;
};

/* This is the structure as used in the I2C_RDWR ioctl call */
struct i2c_rdwr_ioctl_data {
	struct i2c_msg *msgs;	/* pointers to i2c_msgs */
	__u32 nmsgs;			/* number of i2c_msgs */
};

#define  I2C_RDRW_IOCTL_MAX_MSGS	42


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, const __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 */
/* Until kernel 2.6.22, the length is hardcoded to 32 bytes. If you
   ask for less than 32 bytes, your code will only work with kernels
   2.6.23 and later. */
static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command,
                                                  __u8 length, __u8 *values)
{
	union i2c_smbus_data data;
	int i;

	if (length > 32)
		length = 32;
	data.block[0] = length;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
	                     length == 32 ? I2C_SMBUS_I2C_BLOCK_BROKEN :
	                      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,
                                                   const __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_BROKEN, &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];
	}
}


#endif /* _LINUX_I2C_DEV_H */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include "i2c-dev.h"


#define u8 unsigned char
#define u32 unsigned int

#define I2C_DEV "/dev/i2c-1"
#define I2C_ADDR 0x38

#define    FTS_PACKET_LENGTH        128

#define FTS_UPGRADE_LOOP	3

#define FT_UPGRADE_AA	0xAA
#define FT_UPGRADE_55 	0x55
#define FT_UPGRADE_EARSE_DELAY		1500
/*upgrade config of FT5x06(x=2,3,4)*/
#define FT5X06_UPGRADE_AA_DELAY 		50
#define FT5X06_UPGRADE_55_DELAY 		30
#define FT5X06_UPGRADE_ID_1			0x79
#define FT5X06_UPGRADE_ID_2			0x03
#define FT5X06_UPGRADE_READID_DELAY 	1


#define FW_FILE_NAME "ft5406_0X13_app.i"

static unsigned char CTPM_FW[]=
{
	#include FW_FILE_NAME
};



/* 基于ft5x06_ts.c */
/*将读写i2c_msg放在一个ioctl函数来完成，导致读失败*/
/*
int ft5x0x_i2c_Read(int fd, int chip_addr, char *writebuf,
		    int writelen, char *readbuf, int readlen)
{
	int ret;
	struct i2c_rdwr_ioctl_data ioctl_data;
	if (writelen > 0) {//一个i2c_msg对应一个s一个p
		struct i2c_msg msgs[] = {
			{
			 .addr = chip_addr,
			 .flags = 0,//写
			 .len = writelen,
			 .buf = writebuf,
			 },
			{
			 .addr = chip_addr,
			 .flags = I2C_M_RD,//读
			 .len = readlen,
			 .buf = readbuf,
			 },
		};

		ioctl_data.nmsgs = 2;
		ioctl_data.msgs  = msgs;
	//	ret = i2c_transfer(client->adapter, msgs, 2);
		ret = ioctl(fd,I2C_RDWR,&ioctl_data);
		if (ret < 0)
			printf("f%s: i2c read error.\n",__func__);
	} else {
		struct i2c_msg msgs[] = {
			{
			 .addr = chip_addr,
			 .flags = I2C_M_RD,
			 .len = readlen,
			 .buf = readbuf,
			 },
		};

		ioctl_data.nmsgs = 1;
		ioctl_data.msgs  = msgs;
		
	//	ret = i2c_transfer(client->adapter, msgs, 1);
		ret = ioctl(fd,I2C_RDWR,&ioctl_data);
		if (ret < 0)
			printf("f%s: i2c read error.\n",__func__);
		}
	return ret;
}

*/

/* 基于ft5x06_ts.c */
/*
*将读写i2c_msg放在一个ioctl函数来完成，导致读失败
*把两个读写i2c_msg分别ioctl 
*/

int ft5x0x_i2c_Read(int fd, int chip_addr, char *writebuf,
		    int writelen, char *readbuf, int readlen)
{
	int ret;
	struct i2c_rdwr_ioctl_data ioctl_data;
	if (writelen > 0) {//一个i2c_msg对应一个s一个p
		struct i2c_msg msgs[] = {
			{
			 .addr = chip_addr,
			 .flags = 0,//写
			 .len = writelen,
			 .buf = writebuf,
			 },
			{
			 .addr = chip_addr,
			 .flags = I2C_M_RD,//读
			 .len = readlen,
			 .buf = readbuf,
			 },
		};

		ioctl_data.nmsgs = 1;
		ioctl_data.msgs  = &msgs[0];
	//	ret = i2c_transfer(client->adapter, msgs, 2);
		ret = ioctl(fd,I2C_RDWR,&ioctl_data);
		if (ret < 0)
			printf("f%s: i2c read error.\n",__func__);

		ioctl_data.nmsgs = 1;
		ioctl_data.msgs  = &msgs[1];
	//	ret = i2c_transfer(client->adapter, msgs, 2);
		ret = ioctl(fd,I2C_RDWR,&ioctl_data);
		if (ret < 0)
			printf("f%s: i2c read error.\n",__func__);
	} else {
		struct i2c_msg msgs[] = {
			{
			 .addr = chip_addr,
			 .flags = I2C_M_RD,
			 .len = readlen,
			 .buf = readbuf,
			 },
		};

		ioctl_data.nmsgs = 1;
		ioctl_data.msgs  = msgs;
		
	//	ret = i2c_transfer(client->adapter, msgs, 1);
		ret = ioctl(fd,I2C_RDWR,&ioctl_data);
		if (ret < 0)
			printf("f%s: i2c read error.\n",__func__);
		}
	return ret;
}


int ft5x0x_i2c_Write(int fd, int chip_addr, char *writebuf, int writelen)
{
	int ret;

	struct i2c_rdwr_ioctl_data ioctl_data;
	struct i2c_msg msg[] = {
		{
		 .addr = chip_addr,
		 .flags = 0,
		 .len = writelen,
		 .buf = writebuf,
		 },
	};

	ioctl_data.nmsgs = 1;
	ioctl_data.msgs  = msg;

//	ret = i2c_transfer(client->adapter, msgs, 1);
	ret = ioctl(fd,I2C_RDWR,&ioctl_data);

	if (ret < 0)
		printf("f%s: i2c write error.\n",__func__);

	return ret;
}

int ft5x0x_read_reg(int fd,int chip_addr, u8 regaddr, u8 * regvalue)
{
	return ft5x0x_i2c_Read(fd, chip_addr, &regaddr, 1, regvalue, 1);
}

int ft5x0x_write_reg(int fd,int chip_addr, u8 regaddr, u8 regvalue)
{
	unsigned char buf[2] = {0};
	buf[0] = regaddr;
	buf[1] = regvalue;
	
	return ft5x0x_i2c_Write(fd,chip_addr, buf, sizeof(buf));
}


/*
可能是由于FT5x06芯片的电器特性，需要delay一段时间
所以读FT5x06芯片不能使用直接i2c_smbus_read_byte_data函数
而是分别使用i2c_smbus_write_byte和i2c_smbus_read_byte
*/

/*
int ft5x06_read_byte(int fd, __u8 addr)
{
	
	if(i2c_smbus_write_byte(fd, addr) <0 )
	{
		printf("i2c_smbus_write_byte error\n");
		return -1;
	}
	usleep(10); //延时
	
	return i2c_smbus_read_byte(fd);
}


int ft5x06_read_bytes(int fd, __u8 addr , int size , char * buf)
{

	int i;
	char c;
	for(i=0;i < size; ++i, ++addr)
	{
		if((c = ft5x06_read_byte( fd, addr)) < 0 )
		{
			
			return -1;
		} else 
			buf[i] = c;
	}
	
	return 0;
}

int ft5x06_write_bytes(int fd, __u8 addr , int size , const char * buf)
{
	int i;
	for(i=0;i<size;i++,addr ++)
	{
		if(i2c_smbus_write_byte_data(fd, addr, buf[i]) <0 )
		{	
			printf("i2c_smbus_write_byte_data error\n");
			return -1;
		}
	}

	return 0;
}
*/

int  fts_ctpm_fw_upgrade(int fd,int chip_addr, u8* pbt_buf, u32 dw_lenth)
{
	
	
}


/*
upgrade with *.i file
*/
int fts_ctpm_fw_upgrade_with_i_file(int fd,int chip_addr)
{

}


static u8 fts_ctpm_get_i_file_ver(void)
{
    unsigned short ui_sz;
    ui_sz = sizeof(CTPM_FW);
    if (ui_sz > 2)
    {
        return CTPM_FW[ui_sz - 2];
    }
    else
    {
        return 0x00; /*default value*/
    }
}

int main()
{
	int fd;
	unsigned char ver = 0;
	unsigned char fw_file_ver = 0;
	
	fd = open(I2C_DEV,O_RDWR);
	if(fd == -1)
	{
		printf("open error\n");
		return -1;
	}

	if(ioctl(fd,I2C_SLAVE,I2C_ADDR) < 0)
	{
		printf("set addr error\n");
		close(fd);
		return -1;
	}

	fw_file_ver = fts_ctpm_get_i_file_ver();
	printf("[FTS] %s Firmware version = 0x%x\n",FW_FILE_NAME, fw_file_ver);

	if(fw_file_ver == 0)
	{
		printf("Get Firmware version from File %s Error\n",FW_FILE_NAME);
		goto exit;
	}

	ft5x0x_read_reg(fd, I2C_ADDR, 0xa6, &ver);
	printf("[FTS] Firmware version Before Upgrade = 0x%x\n",ver);

	
	/*
	if(ver == fw_file_ver)
	{
		printf("[FTS] Upgrade is not necessary\n");
		goto exit;
	}
	*/

	if(ver != 0x11)
	{
		printf("[FTS] Upgrade is not necessary\n");
		printf("[FTS] Upgrade program is only for 0x11 to 0x13\n");
		goto exit;
	}
	
	//更新
	fts_ctpm_fw_upgrade_with_i_file(fd,I2C_ADDR);

	ft5x0x_read_reg(fd, I2C_ADDR, 0xa6, &ver);
	printf("[FTS] Firmware version After Upgrade = 0x%x\n",ver);


	if(ver == fw_file_ver)
	{
		printf("[FTS] Firmware Update Success!\n");
	} else {
		printf("[FTS] Firmware Update Fail!\n");
	}

exit:	
	close(fd);
	return 0;
}

psvoldemort
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
应用层读写I2C代码
06-12
可在应用层读写 8位，或者16位地址的I2C设备
Arduino I2Cdev库
06-04
Ardino的I2Cdev库,可用于开发MPU6050陀螺仪,或用于其它Arduino I2C开发.
Linux应用开发笔记（七）IIC应用层开发及其框架
最新发布
sincerelover的博客
04-14 987
之前笔者在STM32和FPGA中已经多次讲述了IIC的基础知识，这里不在展开“扫盲”，感兴趣的朋友可以看一下往期笔记，此次仅仅带大家简单回顾并展开Linux下的IIC体系的学习。
Linux i2c-dev简析
飞翔de刺猬
08-04 6249
上篇文章简要分析了如何编写一个Linux下的I2C设备驱动程序。编写驱动程序毕竟有一定的门槛，需要熟悉内核各种相关的开发规范，有时为了快速的测试一款I2C设备的功能，临时编写驱动程序可能会使得工期比较紧张；并且有时I2C设备十分的简单，为此编写一个单独的驱动程序未免有点“兴师动众”。 i2c-dev框架很好的解决了上面的问题，使用该框架可以使我们在用户空间上编写I2C通信程序。i2c-dev在内核中封装了关于I2C通信所需要的所有通信细节，通过ioctl接口将这些功能暴露给用户空间程序调用。用户应用程序使用
转：I2C驱动分析
weixin_30325971的博客
03-26 127
实际上在较新的代码中（如笔者现在用的linux-2.6.30）里面其实己经有一个通用的I2C驱动了。所以在一些简单的场合，我们其实可以不用再去写驱动，只要会用就可以了，但是会用也不是一件很简单的事情，因为关于这方面的内容很少，有些时候，我们不得不去分析一下代码，才能明白如何去用。 I2C的代码是比较少的，因为协议本身也不是很复杂。我们可以从他的代码目录开始讲起。 Linux中，关于I2C的驱动...
Linux环境下I2C应用程序编写
propor的专栏
03-20 966
linux,i2c
I2C知识大全系列六 —— I2C应用之Linux下的I2C
phmatthaus的专栏
10-24 4072
本文是I2C知识大全系列文章的第六篇，介绍了Linux下的I2C应用。
用I2c_dev.c设备驱动读写EEPROM
11-15
在实际应用中，`i2c_I2c_dev.c_app`可能是一个示例应用程序，用于演示如何使用驱动来读写EEPROM。这个应用程序可能会包括设置I2C总线适配器，找到目标设备，然后执行读写操作的代码。 总之，通过使用`I2C_dev.c`...
linux i2c应用编程库
10-01
本篇将详细介绍Linux I2C应用编程库以及相关的API接口，帮助开发者理解和掌握如何在Linux环境下与I2C总线进行交互。 1. **I2C框架** Linux内核提供了I2C子系统，它为用户空间应用程序提供了与硬件I2C总线交互的...
I2C.tar.gz_i2c
09-14
在Linux内核中，I2C被实现为一个子系统，它提供了与硬件I2C控制器交互的抽象层。Linux 2.6.22.6内核版本对I2C的支持已经相当成熟，包括设备驱动模型的集成，使得驱动程序可以方便地注册到I2C总线上，与各种I2C设备...
i2c_transf.rar
12-25
`i2c_transf.rar`这个压缩包很可能包含了用于Linux应用层进行I2C读写操作的源代码。下面将详细介绍I2C协议的基本概念，以及在Linux环境下如何进行I2C通信，特别是通过应用层工具进行读写操作。 I2C协议由Philips...
I2Cdev.zip
03-14
这个库用于arduino使用六轴姿态传感器mpu6050，我的博客内有详细使用说明，其他库文件，及源代码
arduino I2Cdev库
04-06
arduino 的I2Cdev库，用于I2C协议通信，下载后移动解压到arduino安装目录\libraries即可
i2c驱动app
SHIROooo的博客
04-26 96
I2C总线原理 1）什么是I2C总线？ I2C即Inter IC，由Philips公司开发，是当今电子设计中应用非常广泛的串行总线之一，主要用于电压、温度监控，EEPROM(电可擦可编程只读存储器)数据的读写，光模块的管理等。I2C总线只有两根线，SCL和SDA，SCL即Serial Clock，串行时钟，SDA即Serial Data，串行数据。 2）I2C总线的速率能达到多少？ 标准模式下：100Kbps 快速模式下：400Kbps 高速模式下：3.4Mb...
IIC协议——i2c-dev的使用
weixin_53361650的博客
06-06 3662
/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* i2c-dev.h - i2c-bus driver, char device interface Copyright (C) 1995-97 Simon G. Vogl Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl> This program is free soft
【嵌入式】使用Linux自带的i2c-dev操作EEPROM（Userspace Driver）
欢迎光临
11-15 5966
Linux系统自带了I2C总线的子系统，没有了解这个I2C的子系统是如何工作的不过既然系统提供了这个功能就可以使用文件操作的方式直接使用I2C总线了。说到I2C总线第一个想到的还是EEPROM存储芯片，例如AT24C02这个芯片有256字节的存储空间，使用范围较广。 AT24C02芯片采用I2C总线与主机通信，具体细节参见数据手册。Linux的I2C设备为/dev/i2c-0和/dev/i2c-
linux i2c dev.h freq,STM32F103ZET（基于秉火开发板）+Cubemx（F1 V1.60库）+IIC+AT24C02（修复官方例程读写死机bug）...
weixin_39593519的博客
05-16 285
首先说明下开发条件：1、开发板：秉火霸道，STM32F103ZET2、软件：Cubemx V4.23(F1 V1.60库)3、硬件：AT24C02 256KByte问题描述：Cubemx生成IIC代码会出现死机问题，或者压根运行不了！问题原因：1、ST为了规避飞利浦IIC专利问题，将STM32的硬件IIC设计的比较复杂，而且稳定性不怎么好，所以一般教程都不推荐使用。2、Cubemx生成的代码有Bu...
linux i2c dev.h freq,I2C总线驱动程序(2.6.35.7内核)
weixin_36096137的博客
05-16 152
tiny210_i2c_bus.c驱动源码：#include "linux/kernel.h"#include "linux/module.h"#include "linux/i2c.h"#include "linux/init.h"#include "linux/time.h"#include "linux/interrupt.h"#include "linux/delay.h"#include...
I2Cdev库翻译
acktomas的博客
10-16 2058
https://github.com/jrowberg/i2cdevlib I2Cdev.h // I2Cdev library collection - Main I2C device class header file // Abstracts bit and byte I2C R/W functions into a convenient class // 2013-06-05 by Je...
linux应用层读写i2c
07-19
在Linux应用层读写I2C，我们可以使用内核提供的i2c-dev驱动来实现。以下是一种基本的方法： 1. 打开I2C设备 首先，我们需要在应用程序中打开I2C设备文件。设备文件的路径通常为"/dev/i2c-N"，其中N为I2C控制器的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值