i2c驱动app

最新推荐文章于 2024-06-21 20:56:56 发布
最新推荐文章于 2024-06-21 20:56:56 发布
阅读量153 收藏 2
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ha_Dada/article/details/124404268
版权

查看i2c源代码

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 order;
	if (length > 32)
		length = 32;
	for (order = 1; order <= length; order++)
		data.block[order] = values[order-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 order;
	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
	                      I2C_SMBUS_I2C_BLOCK_DATA,&data))
		return -1;
	else {
		for (order = 1; order <= data.block[0]; order++)
			values[order-1] = data.block[order];
		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 order;
	if (length > 32)
		length = 32;
	for (order = 1; order <= length; order++)
		data.block[order] = values[order-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 order;
	if (length > 32)
		length = 32;
	for (order = 1; order <= length; order++)
		data.block[order] = values[order-1];
	data.block[0] = length;
	if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
	                     I2C_SMBUS_BLOCK_PROC_CALL,&data))
		return -1;
	else {
		for (order = 1; order <= data.block[0]; order++)
			values[order-1] = data.block[order];
		return data.block[0];
	}
}

static int i2c_write_1b(struct eeprom *eeprom_device_struct, __u8 buf)
{
	int return_value;
	// we must simulate a plain I2C byte write with SMBus functions
	return_value = i2c_smbus_write_byte(eeprom_device_struct->fd, buf);
	if(return_value < 0)
		fprintf(stderr, "Error i2c_write_1b: %s\n", strerror(errno));
	usleep(10);
	return return_value;
}

static int i2c_write_2b(struct eeprom *eeprom_device_struct, __u8 buf[2])
{
	int return_value;
	// we must simulate a plain I2C byte write with SMBus functions
	return_value = i2c_smbus_write_byte_data(eeprom_device_struct->fd, buf[0], buf[1]);
	if(return_value < 0)
		fprintf(stderr, "Error i2c_write_2b: %s\n", strerror(errno));
	usleep(10);
	return return_value;
}

static int i2c_write_3b(struct eeprom *eeprom_device_struct, __u8 buf[3])
{
	int return_value;
	// we must simulate a plain I2C byte write with SMBus functions
	// the __u16 data field will be byte swapped by the SMBus protocol
	return_value = i2c_smbus_write_word_data(eeprom_device_struct->fd, buf[0], buf[2] << 8 | buf[1]);
	if(return_value < 0)
		fprintf(stderr, "Error i2c_write_3b: %s\n", strerror(errno));
	usleep(10);
	return return_value;
}


#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* eeprom_device_struct)
{
	int funcs, fd, return_value;
	eeprom_device_struct->fd = eeprom_device_struct->addr = 0;
	eeprom_device_struct->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((return_value = 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( ( return_value = ioctl(fd, I2C_SLAVE, addr)) < 0)
	{
		fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
		return -1;
	}
	eeprom_device_struct->fd = fd;
	eeprom_device_struct->addr = addr;
	eeprom_device_struct->dev = dev_fqn;
	eeprom_device_struct->type = type;
	return 0;
}

int eeprom_close(struct eeprom *eeprom_device_struct)
{
	close(eeprom_device_struct->fd);
	eeprom_device_struct->fd = -1;
	eeprom_device_struct->dev = 0;
	eeprom_device_struct->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* eeprom_device_struct)
{
	ioctl(eeprom_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
	return i2c_smbus_read_byte(eeprom_device_struct->fd);
}

int eeprom_read_byte(struct eeprom* eeprom_device_struct, __u16 mem_addr)
{
	int return_value;
	ioctl(eeprom_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
	if(eeprom_device_struct->type == EEPROM_TYPE_8BIT_ADDR)
	{
		__u8 buf =  mem_addr & 0x0ff;
		return_value = i2c_write_1b(eeprom_device_struct, buf);
	} else if(eeprom_device_struct->type == EEPROM_TYPE_16BIT_ADDR) {
		__u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
		return_value = i2c_write_2b(eeprom_device_struct, buf);
	} else {
		fprintf(stderr, "ERR: unknown eeprom type\n");
		return -1;
	}
	if (return_value < 0)
		return return_value;
	return_value = i2c_smbus_read_byte(eeprom_device_struct->fd);
	return return_value;
}

int eeprom_write_byte(struct eeprom *eeprom_device_struct, __u16 mem_addr, __u8 data)
{
	if(eeprom_device_struct->type == EEPROM_TYPE_8BIT_ADDR) {
		__u8 buf[2] = { mem_addr & 0x00ff, data };
		return i2c_write_2b(eeprom_device_struct, buf);
	} else if(eeprom_device_struct->type == EEPROM_TYPE_16BIT_ADDR) {
		__u8 buf[3] = 
			{ (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
		return i2c_write_3b(eeprom_device_struct, 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 *eeprom_device_struct);
/*
 * 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* eeprom_device_struct, __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 *eeprom_device_struct);
/*
 * 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 *eeprom_device_struct, __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 *eeprom_device_struct, int addr, int size) {
	int ch, index;
	for(index = 0; index < size; ++index, ++addr) {
		die_if((ch = eeprom_read_byte(eeprom_device_struct, addr)) < 0, "read error");
		if( (index % 16) == 0 ) 
			printf("\n %.4x|  ", addr);
		else if( (index % 8) == 0 ) 
			printf("  ");
		printf("%.2x ", ch);
		fflush(stdout);
	}
	fprintf(stderr, "\n\n");
	return 0;
}

static int write_to_eeprom(struct eeprom *eeprom_device_struct, int addr) {
	int index;
	for(index=0, addr=0; index<256; index++, addr++) {
		if( (index % 16) == 0 ) 
			printf("\n %.4x|  ", addr);
		else if( (index % 8) == 0 ) 
			printf("  ");
		printf("%.2x ", index);
		fflush(stdout);
		die_if(eeprom_write_byte(eeprom_device_struct, addr, index), "write error");
	}
	fprintf(stderr, "\n\n");
	return 0;
}

int main(int argc, char** argv) {
	struct eeprom eeprom_device_struct;
	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 201930310035 ...\n", strlen("APP for 201930310035 ...\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, &eeprom_device_struct) < 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(&eeprom_device_struct, 0, 256);
		break;
	case 'w':
		fprintf(stderr, "  Writing 0x00-0xff into 24C08 \n");
		write_to_eeprom(&eeprom_device_struct, 0);
		break;
	default:
		usage_if(1);
		exit(1);
	}
	eeprom_close(&eeprom_device_struct);

	return 0;
}

编译并在Ubuntu运行

cd i2c-wdx-template
make

运行结果
在这里插入图片描述

提高项

使用 ${CROSS_COMPILE}gcc 编译各个程序

请添加图片描述

在开发板内 mount nfs,并运行各个程序

在主机创建要共享的文件夹，将 i2c 文件夹放入其中，以便能在开发板上访问 i2c 文件夹及运行里面的程序

在主机根目录建立 /nfs 并更改权限请添加图片描述请添加图片描述
添加目录到共享

sudo vim /etc/exports
/nfs *    (rw,async,wdelay,nohide,insecure,no_root_squash,no_subtree_check,sec=sys,rw,insecure,no_root_squash,no_all_squash)

请添加图片描述
启动nfs服务

/usr/sbin/exportfs -a
service nfs-kernel-server restart
service nfs-kernel-server status
登陆开发板
~/ubuntu-18.04_imx6ul_qemu_system/qemu-imx6ull-nogui.sh
mount nfs

将主机已经设定好的共享目录 /nfs 挂载(mount)到开发板的 /root/mnt 目录下

mount -t nfs -o nolock 10.0.2.2:/nfs /root/mnt

请添加图片描述

运行i2c程序
./i2c -w
./i2c -r

请添加图片描述
请添加图片描述

思考题

I2C总线的优点是什么？

I2C总线主要的优点是其简单性和有效性。由于接口直接在组件之上，因此I2C总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。总线的长度可高达25英尺，并且能够以10Kbps的传输速率支持40个组件。I2C总线的另一个优点是，它支持多主控， 其中任何能够进行发送和接收的设备都可以成为主总线。一个主控能够控制信号的传输和时钟频率。当然，在任何时间点上只能有一个主控。

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

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

Ha_Dada
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
嵌入式Ubuntu-Linux 2.6内核下的I2C驱动架构及应用
07-04
Ubuntu-Linux系统下的设备-核心-总线三层的I2C驱动架构,是合理、高效开发I2C设备驱动程序的重要参考框架。该文以结构化的视角深入分析了嵌入式Linux系统下I2C驱动的层次结构、数据结构、驱动流程等,并着重分析了2种设备层驱动方法,对I2C驱动开发具有普遍的适用性。
基于嵌入式系统的I2C驱动编写及测试
08-10
基于嵌入式系统的I2C驱动编写及测试 在嵌入式系统中，I2C（Inter-Integrated Circuit）是一种常用的总线协议，用于连接微控制器、感知器、显示器等外围设备。今天，我们将通过一个基于I2C总线的温度传感器驱动的...
正点原子linux阿尔法开发板使用——IIC驱动
梅山
06-18 1222
i2c_client：表示I2C设备，我们自己创建i2c_client，我们一般在设备树里面添加具体的I2C芯片，比如fxls8471，系统在解析设备树的时候就会知道有这个I2C设备，然后会创建对应的i2c_client。 i2c设备驱动框架，i2c_driver初始化与注册，需要II2C设备驱动编写人员编写的，IIC驱动程序就是初始化i2c_driver，然后向系统注册。注册使用、，如果注销i2c_driver使用在IIC1上接了一个AP3216C 1、修改设备树，IO,添加AP3216C的设备节点。
Linux内核的I2C驱动框架详解
cumtchw
07-31 4459
目录1 I2C驱动整体框架图 2 I2C控制器2.1 I2C控制器设备--I2C控制器在内核中也被看做一个设备2.2 i2c控制器驱动程序2.3 platform_driver结构体中的probe函数做了什么2.3.1 疑问： i2cdev_notifier_call函数哪里来的2.3.2 疑问：为什么有两个probe2.3.3 疑问：of_i2c_register_devices(adap);和bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_n
linux下i2c设备驱动程序,Linux系统IIC驱动程序 <二> I2C设备驱动
weixin_36081677的博客
05-02 2090
上次谈了Linux 下I2C的框架，这次专门以MPU9250驱动为例，学习I2C设备驱动。之前谈过，I2C设备驱动有两种模式：Adapter模式和Probe模式。前者在新kernel版本中已经不支持了，后者则是推荐方式。这次我们就以MPU9250IIC Driver 为例，分析Probe模式的I2C driver.因为具体分析的是NvidiaTegra平台，所以板目录在kernel/arch/ar...
Linux I2C 驱动实验
zhuguanlin121的博客
11-11 2056
目录Linux I2C 驱动框架简介I2C 总线驱动I2C 设备驱动I2C 设备和驱动匹配过程I.MX6U 的I2C 适配器驱动分析I2C 设备驱动编写流程I2C 设备信息描述I2C 设备数据收发处理流程硬件原理图分析实验程序编写修改设备树AP3216C 驱动编写编写测试APP运行测试编译驱动程序和测试APP运行测试 I2C 是很常用的一个串行通信接口，用于连接各种外设、传感器等器件，在裸机篇已经对I.MX6U 的I2C 接口做了详细的讲解。本章我们来学习一下如何在Linux 下开发I2C 接口器件驱动，重
LinuxI2C总线驱动
爱锻炼的程序员
02-09 1649
一.概念 I2C总线：1.回顾相关的概念 串行传输： 一个时钟周期传输1bit 并行传输： 一个时钟周期传输多字节 "一个时钟周期":CPU在时钟的高电平或者下降沿将数据发送到数据线上，那么设备在同周期的低电平或者上升沿从数据线上获取数据； 总线：硬件上实实在在存在的总线,总线上可以挂接多个外设，将来CPU通过总线来访问具体的某个外设2.I2C总线概念：两线式串行总线 "两线式":...
Linux系统驱动之编写设备驱动之i2c_client
韦东山嵌入式专栏
08-25 2831
编写设备驱动之i2c_client 参考资料： Linux内核文档: Documentation\i2c\instantiating-devices.rst Documentation\i2c\writing-clients.rst Linux内核驱动程序示例: drivers/eeprom/at24.c 本节代码：GIT仓库中 IMX6ULL\source\04_I2C\03_ap3216c_ok STM32MP157\source\A7\04_I2C\03_ap3216c_o
linux I2C驱动（Linux驱动开发篇）
栋哥修炼日记
02-13 3209
1.linux IIC驱动 由于裸机的驱动迎合驱动的分离和分层的思想，分为IIC主机驱动（接口驱动）和IIC设备驱动. 这种思想的好处，请看我写的另外一篇文章Linux驱动的分离和分层。 其中上面说的裸机驱动请看这篇文章裸机驱动 但是裸机的驱动是没有加入操作系统的 本文也是遵循Linux驱动的分离和分层的思想，因此linux内核把IIC驱动分为两个部分IIC总线驱动和IIC设备驱动 总线驱动：SOC的IIC控制器驱动，也叫做IIC适配器驱动 设备驱动：IIC设备驱动就是针对具体的IIC设备而编写的驱
Linux驱动开发05：【I2C驱动】I2C总线驱动和设备驱动
Egean的博客
07-17 4407
介绍 这里实现一种不涉及硬件的I2C总线和设备驱动，然后分析I2C驱动在系统中的注册过程。这里实现的驱动类似于之前的FIFO字符设备驱动，与之不同的是这里使用了I2C驱动框架，设备文件写入和读取将通过i2c_client传递到指定的i2c_adaper，然后在i2c_adapter中操作一段内存。这个驱动非常简单，甚至没有使用FIFO这种硬件结构，只能进行读和写，毕竟内存的操作不是中断，重点是熟...
i.MX283开发板I2C驱动——DS2460
Ruler
02-12 1826
i.MX283开发板有两个I2C接口，其中I2C0接了一个DS2460加密芯片，本文介绍Linux下如何编写I2C驱动程序读写DS2460。 Linux上I2C架构可以分为I2C核心、I2C总线驱动、I2C设备驱动三个部分： I2C核心：主要为总线驱动和设备驱动提供各种API，比如设备探测、注册、注销，设备和驱动匹配等函数。它在I2C架构中处于中间的位置。 I2C总线驱动：I2C总线驱动维护...
嵌入式linux 用户空间 测试 I2C总线 demo程序
12-06
用户空间APP测试i2c接口或总线，用于嵌入式设备驱动开发或者应用开发都可以。
firefly-rk3288j开发板--linux I2C实验之eeprom驱动，包含驱动源码、测试app
06-10
适用用于linux内核驱动学习，参考
pcf8563_i2c1_r8_ruoge_ov2640通过给RTC驱动增加设备节点读取秒钟成功+直接读取I2C1获取秒钟值20160626_2201.7z
06-26
pcf8563_i2c1_r8_ruoge_ov2640通过给RTC驱动增加设备节点读取秒钟成功+直接读取I2C1获取秒钟值20160626_2201.7z http://blog.csdn.net/21cnbao/article/details/7919055 在Android源码树中添加userspace I2C读写...
ESP8266-I2C-Driver:固定的内置I2C驱动程序，用于Arduino ESP8266内核
05-18
ESP8266-I2C驱动修复了用于Arduino ESP8266内核的内置MasterI²C驱动程序。 抱歉，它不支持从I²C模式。 木板SDA SCL 等级ESP8266 GPIO4 GPIO5 3.3v / 5v ESP8266 ESP-01 GPIO0 / D5 GPIO2 / D3 3.3v / 5v NodeMCU ...
十九、I2C驱动及应用
qq_28938511的博客
12-02 3639
一、概述 1、Linux主机驱动和外设驱动分离思想 外设驱动→API→主机驱动→板级逻辑--具体的i2c设备（camera，ts，eeprom等等） 主机驱动：根据控制器硬件手册，操作具体的寄存器，产生波形。（单片机工程师肯定有强烈的冲动去配置i2c寄存器，产生波形！）。 linux应用工程师：屏蔽了驱动和硬件。 linux驱动工程师：屏蔽硬件！提供标准的主机驱动，驱动工程师需要完成“外设驱动” 内核函数接口：(API)。主机...
【Linux】Xshell和Xftp简介_安装_VMware虚拟机使用
wosixiaokeai的博客
06-19 1117
Xftp是一个功能强大的SFTP、FTP文件传输软件，它允许MS Windows用户安全地在UNIX/Linux和Windows PC之间传输文件。Xftp支持SFTP协议，确保所有通过该软件的网络流量都是加密的。它采用了标准的Windows风格的向导，用户界面直观易用，可以很好地与其他Windows应用程序协同工作。Xftp的特色功能包括同步功能、直接编辑远程文件、多窗格支持、文件交换协议（FXP）支持等，这些功能使得文件传输更加容易和快捷。
Linux中文件查找相关命令比较
lurenyi168的专栏
06-16 438
Linux中与文件定位的命令有find、locate、whereis、which，type。
Linux开发讲课7---Linux sysfs文件系统
最新发布
qq_42837317的博客
06-21 665
Sysfs通过文件和目录的方式组织信息，其中每个文件或目录对应于系统中的一个设备、驱动程序或者其他内核对象。当内核中的设备、驱动程序等对象被创建时，相应的Kobject也会被创建，然后通过Sysfs将其信息暴露给用户空间。Sysfs通常被挂载在/sys目录下，它提供了一种方便的方式，让用户空间的程序可以动态地获取和管理系统中的设备信息，而无需直接访问内核数据结构。（2）创建sysfs文件。其中attr表示将要创建的文件（属性），而show和store分别表示对应的sysfs文件在读和写操作时的回调函数。
esp32 I2S 驱动
07-29
对于ESP32的I2S驱动，你可以使用ESP-IDF（Espressif IoT Development Framework）中提供的I2S API来进行配置和控制。以下是一个简单的示例代码，用于初始化I2S并设置其参数： ```c #include #include "driver/i2s....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值