【I2C总线驱动】

最新推荐文章于 2024-06-09 18:09:24 发布
最新推荐文章于 2024-06-09 18:09:24 发布
阅读量562 收藏 8
点赞数 22
分类专栏： LV16 驱动开发高级 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46112340/article/details/137224627
版权

一、I2C总线背景知识

SOC芯片平台的外设分为：

  1. 一级外设：外设控制器集成在SOC芯片内部
  2. 二级外设：外设控制器由另一块芯片负责，通过一些通讯总线与SOC芯片相连

在这里插入图片描述

Inter-Integrated Circuit： 字面意思是用于“集成电路之间”的通信总线，简写：IIC(或者I2C)

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述在这里插入图片描述

i2c传输的要点就是： 传输一个字节 后面必然紧跟一个"响应"信号----应答信号.这个响应信号可能来自主机，或者是从机，具体是谁，就要看传输方向。
传输方向分两种情况(每种情况又有两种可能: A无应答和 B有应答)：

1.主机->从机，主机对从机发一个字节之后，主机要读取从机的响应信号(主机读SDA线)

A) 主机读SDA为高电平，说明从机无应答（意味着从机接收完毕，主机发送停止信号）
 B) 主机读SDA为低电平，说明从机有应答。（可继续发送下一个字节）

2.从机->主机， 主机读取从机一个字节之后，主机要向从机发送一个响应信号(主机写SDA线)

​ A) 主机写SDA为高电平，从机收到主机的无应答信号之后，从机停止传输，等待主机的停止信号。
​ B) 主机写SDA为低电平，从机收到主机的应答信号之后，从机继续输出下一字节

二、Exynos4412 I2C收发实现之裸机版

I2CCON寄存器：控制寄存器

2CCON.jpg&pos_id=img-L9mxFvbm-1711939845422)

第7位：决定是否允许产生应答信号，无论发送还是接收前，需置1

第6位：传输时时钟线分频，一般选置1

第5位：决定是否开启发送或接收结束时发通知，无论发送还是接收前，需置1

第4位：接收或发送是否完毕可以通过检查此位是否为1，接收或发送完毕后需置0

在这里插入图片描述

I2CSTAT寄存器：状态寄存器

在这里插入图片描述

第6、7位：每次传输前需选择传输模式

第5位：置0产生将产生终止信号，传输前置1产生起始信号

第4位：使能数据输出，传输前需置1

I2CDS寄存器：数据寄存器，发送前被发送的数据存放处，接收后结果也从此处读取

2.1 发送

在这里插入图片描述

在这里插入图片描述

void iic_write (unsigned char slave_addr, unsigned char addr, unsigned char data)
{
    //从设备寻址
    I2C5.I2CDS = slave_addr;
    I2C5.I2CCON = 1<<7 | 1<<6 | 1<<5;/*ENABLE ACK BIT, PRESCALER:512, ,ENABLE RX/TX */
     
    I2C5.I2CSTAT = 0x3 << 6 | 1<<5 | 1<<4;/*Master Trans mode ,START ,ENABLE RX/TX ,*/
    while(!(I2C5.I2CCON & (1<<4)));
 
    I2C5.I2CDS = addr;
    I2C5.I2CCON &= ~(1<<4);   //Clear pending bit to resume.
    while(!(I2C5.I2CCON & (1<<4)));
 
    //发送数据
    I2C5.I2CDS = data;  // Data
    I2C5.I2CCON &= ~(1<<4);   //Clear pending bit to resume.
    while(!(I2C5.I2CCON & (1<<4)));
 
    I2C5.I2CSTAT = 0xD0; //stop
 
    I2C5.I2CCON &= ~(1<<4);//Clear pending bit to resume.
 
    mydelay_ms(10);
}

2.2 接收

在这里插入图片描述在这里插入图片描述

void iic_read(unsigned char slave_addr, unsigned char addr, unsigned char *data)
{
    //从设备寻址
    I2C5.I2CDS = slave_addr;
 
    I2C5.I2CCON = 1<<7 | 1<<6 | 1<<5;/*ENABLE ACK BIT, PRESCALER:512, ENABLE RX/TX Interrupt-enable */
    I2C5.I2CSTAT = 0x3 << 6 | 1<<5 | 1<<4;/*Master Trans mode ,START ,ENABLE RX/TX ,*/
    while(!(I2C5.I2CCON & (1<<4))); /*对应位为1表示slave_addr传输完成，线路处于挂起状态*/
 
    I2C5.I2CDS = addr;
    I2C5.I2CCON &= ~(1<<4);   //Clear pending bit to resume. 继续传输
    while(!(I2C5.I2CCON & (1<<4)));
     
     
    I2C5.I2CSTAT = 0xD0; //stop  第5位写0，表示要求产生stop信号
 
    //接收数据
    I2C5.I2CDS = slave_addr | 0x01; // Read
    I2C5.I2CCON = 1<<7 | 1<<6 | 1<<5;/*ENABLE ACK BIT, PRESCALER:512, ENABLE RX/TX Interrupt-enable */
 
    I2C5.I2CSTAT = 2<<6 | 1<<5 | 1<<4;/*Master receive mode ,START ,ENABLE RX/TX , 0xB0*/
    while(!(I2C5.I2CCON & (1<<4)));
 
    I2C5.I2CCON &= ~((1<<7) | (1<<4));/* Resume the operation  & no ack*/
    while(!(I2C5.I2CCON & (1<<4)));
 
    I2C5.I2CSTAT = 0x90; //stop  第5位写0，表示要求产生stop信号
    I2C5.I2CCON &= ~(1<<4);       /*clean interrupt pending bit  */
 
    *data = I2C5.I2CDS;
    mydelay_ms(10);
}

三、Linux内核对I2C总线的支持

在这里插入图片描述

**I2C设备驱动：**即挂接在I2C总线上的二级外设的驱动，也称客户（client）驱动，实现对二级外设的各种操作，二级外设的几乎所有操作全部依赖于对其自身内部寄存器的读写，对这些二级外设寄存器的读写又依赖于I2C总线的发送和接收

**I2C总线驱动：**即对I2C总线自身控制器的驱动，一般SOC芯片都会提供多个I2C总线控制器，每个I2C总线控制器提供一组I2C总线（SDA一根+SCL一根），每一组被称为一个I2C通道，Linux内核里将I2C总线控制器叫做适配器（adapter），适配器驱动主要工作就是提供通过本组I2C总线与二级外设进行数据传输的接口，每个二级外设驱动里必须能够获得其对应的adapter对象才能实现数据传输

**I2C核心：**承上启下，为I2C设备驱动和I2C总线驱动开发提供接口，为I2C设备驱动层提供管理多个i2c_driver、i2c_client对象的数据结构，为I2C总线驱动层提供多个i2c_algorithm、i2c_adapter对象的数据结构

四大核心对象之间的关系图

在这里插入图片描述

i2c二级外设驱动开发涉及到核心结构体及其相关接口函数：

struct i2c_board_info {
    char        type[I2C_NAME_SIZE];
    unsigned short  flags;
    unsigned short  addr;
    void        *platform_data;
    struct dev_archdata *archdata;
    struct device_node *of_node;
    int     irq;
};
/*用来协助创建i2c_client对象
重要成员
type：用来初始化i2c_client结构中的name成员
flags：用来初始化i2c_client结构中的flags成员
addr：用来初始化i2c_client结构中的addr成员
platform_data：用来初始化i2c_client结构中的.dev.platform_data成员
archdata：用来初始化i2c_client结构中的.dev.archdata成员
irq:用来初始化i2c_client结构中的irq成员
 
关键就是记住该结构和i2c_client结构成员的对应关系。在i2c子系统不直接创建i2c_client结构，只是提供struct i2c_board_info结构信息，让子系统动态创建，并且注册。
*/

struct i2c_client {
    unsigned short flags;
    unsigned short addr;
    char name[I2C_NAME_SIZE];
    struct i2c_adapter *adapter;
    struct i2c_driver *driver;
    struct device dev;
    int irq;
    struct list_head detected;
};
/*重要成员：
flags:地址长度，如是10位还是7位地址，默认是7位地址。如果是10位地址器件，则设置为I2C_CLIENT_TEN
addr：具体I2C器件如(at24c02)，设备地址,低7位
name:设备名，用于和i2c_driver层匹配使用的，可以和平台模型中的平台设备层platform_driver中的name作用是一样的。
adapter:本设备所绑定的适配器结构(CPU有很多I2C适配器，类似单片机有串口1、串口2等等，在linux中每个适配器都用一个结构描述)
driver：指向匹配的i2c_driver结构，不需要自己填充，匹配上后内核会完成这个赋值操作
dev:内嵌的设备模型，可以使用其中的platform_data成员传递给任何数据给i2c_driver使用。
irq：设备需要使用到中断时，把中断编号传递给i2c_driver进行注册中断，如果没有就不需要填充。(有的I2C器件有中断引脚编号，与CPU相连)
*/
 
/* 获得/释放 i2c_adapter 路径：i2c-core.c linux-3.5\drivers\i2c */
/*功能：通过i2c总线编号获得内核中的i2c_adapter结构地址，然后用户可以使用这个结构地址就可以给i2c_client结构使用，从而实现i2c_client进行总线绑定，从而增加适配器引用计数。
返回值：
NULL：没有找到指定总线编号适配器结构
非NULL：指定nr的适配器结构内存地址*/
struct i2c_adapter *i2c_get_adapter(int nr);
 
 
/*减少引用计数：当使用·i2c_get_adapter·后，需要使用该函数减少引用计数。（如果你的适配器驱动不需要卸载，可以不使用）*/
void i2c_put_adapter(struct i2c_adapter *adap);
 
/*
功能：根据参数adap，info，addr，addr_list动态创建i2c_client并且进行注册
参数：
adap：i2c_client所依附的适配器结构地址
info：i2c_client基本信息
addt_list: i2c_client的地址(地址定义形式是固定的，一般是定义一个数组，数组必须以I2C_CLIENT_END结束，示例：unsigned short ft5x0x_i2c[]={0x38,I2C_CLIENT_END};
probe:回调函数指针，当创建好i2c_client后，会调用该函数，一般没有什么特殊需求传递NULL。
返回值：
非NULL:创建成功，返回创建好的i2c_client结构地址
NULL：创建失败
*/
struct i2c_client * i2c_new_probed_device
(
 struct i2c_adapter *adap,
 struct i2c_board_info *info,
 unsigned short const *addr_list,
 int (*probe)(struct i2c_adapter *, unsigned short addr)
);
/*示例：
struct i2c_adapter *ad;
struct i2c_board_info info={""};
 
unsigned short addr_list[]={0x38,0x39,I2C_CLIENT_END};
 
//假设设备挂在i2c-2总线上
ad=i2c_get_adapter(2);
 
//自己填充board_info 
strcpy(inf.type,"xxxxx");
info.flags=0;
//动态创建i2c_client并且注册
i2c_new_probed_device(ad,&info,addr_list,NULL);
 
i2c_put_adapter(ad);
*/
 
/*注销*/
void i2c_unregister_device(struct i2c_client *pclt)
 
 
 struct i2c_client * i2c_new_device
 (
     struct i2c_adapter *padap,
     struct i2c_board_info const *pinfo
 );
/*示例：
struct i2c_adapter *ad;
struct i2c_board_info info={
    I2C_BOARD_INFO(name,二级外设地址)
};
//假设设备挂在i2c-2总线上
ad=i2c_get_adapter(2);
 
//动态创建i2c_client并且注册
i2c_new_device(ad,&info);
 
i2c_put_adapter(ad);
*/

struct i2c_driver {
    unsigned int class;
 
    /* Standard driver model interfaces */
    int (*probe)(struct i2c_client *, const struct i2c_device_id *);
    int (*remove)(struct i2c_client *);
 
    /* driver model interfaces that don't relate to enumeration  */
    void (*shutdown)(struct i2c_client *);
    int (*suspend)(struct i2c_client *, pm_message_t mesg);
    int (*resume)(struct i2c_client *);
    void (*alert)(struct i2c_client *, unsigned int data);
 
    /* a ioctl like command that can be used to perform specific functions
     * with the device.
     */
    int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
 
    struct device_driver driver;
    const struct i2c_device_id *id_table;
 
    /* Device detection callback for automatic device creation */
    int (*detect)(struct i2c_client *, struct i2c_board_info *);
    const unsigned short *address_list;
    struct list_head clients;
};
/*重要成员：
probe：在i2c_client与i2c_driver匹配后执行该函数
remove：在取消i2c_client与i2c_driver匹配绑定后后执行该函数
driver：这个成员类型在平台设备驱动层中也有，而且使用其中的name成员来实现平台设备匹配，但是i2c子系统中不使用其中的name进行匹配，这也是i2c设备驱动模型和平台设备模型匹配方法的一点区别
id_table:用来实现i2c_client与i2c_driver匹配绑定，当i2c_client中的name成员和i2c_driver中id_table中name成员相同的时候，就匹配上了。
 
补充：i2c_client与i2c_driver匹配问题
- i2c_client中的name成员和i2c_driver中id_table中name成员相同的时候
- i2c_client指定的信息在物理上真实存放对应的硬件，并且工作是正常的才会绑定上，并执行其中的probe接口函数这第二点要求和平台模型匹配有区别，平台模型不要求设备层指定信息在物理上真实存在就能匹配
*/
 
/*功能：向内核注册一个i2c_driver对象
返回值：0成功，负数 失败*/
#define i2c_add_driver(driver)     i2c_register_driver(THIS_MODULE, driver)
int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
 
/*功能：从内核注销一个i2c_driver对象
返回值：无 */
void i2c_del_driver(struct i2c_driver *driver);

struct i2c_msg {
    __u16 addr; /* slave address            */
    __u16 flags;
#define I2C_M_TEN       0x0010  /* this is a ten bit chip address */
#define I2C_M_RD        0x0001  /* read data, from slave to master */
    __u16 len;      /* msg length               */
    __u8 *buf;      /* pointer to msg data          */
};
/* 重要成员：
addr:要读写的二级外设地址
flags：表示地址的长度，读写功能。如果是10位地址必须设置I2C_M_TEN，如果是读操作必须设置有I2C_M_RD······，可以使用或运算合成。
buf：要读写的数据指针。写操作：数据源 读操作：指定存放数据的缓存区
len：读写数据的数据长度
*/
 
/*i2c收发一体化函数,收还是发由参数msgs的成员flags决定*/
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
/*
功能：根据msgs进行手法控制
参数：
adap：使用哪一个适配器发送信息，一般是取i2c_client结构中的adapter指针作为参数
msgs：具体发送消息指针，一般情况下是一个数组
num:表示前一个参数msgs数组有多少个消息要发送的
返回值：
负数：失败
> 0 表示成功发送i2c_msg数量
*/
 
/*I2C读取数据函数*/
int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
/*功能：实现标准的I2C读时序，数据可以是N个数据，这个函数调用时候默认已经包含发送从机地址+读方向这一环节了
参数：
client：设备结构
buf：读取数据存放缓冲区
count：读取数据大小 不大于64k
返回值：
失败：负数
成功：成功读取的字节数
*/
     
/*I2C发送数据函数*/
int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
/*功能：实现标准的I2C写时序，数据可以是N个数据，这个函数调用时候默认已经包含发送从机地址+写方向这一环节了
参数：
client：设备结构地址
buf：发送数据存放缓冲区
count：发送数据大小 不大于64k
返回值：
失败：负数
成功：成功发送的字节数
*/

四、MPU6050

三轴角速度+三轴加速度+温度传感器

在这里插入图片描述

#define SMPLRT_DIV  0x19 //陀螺仪采样率，典型值：0x07(125Hz)
#define CONFIG   0x1A //低通滤波频率，典型值：0x06(5Hz)
#define GYRO_CONFIG  0x1B //陀螺仪自检及测量范围，典型值：0xF8(不自检，+/-2000deg/s)
#define ACCEL_CONFIG 0x1C //加速计自检、测量范围，典型值：0x19(不自检，+/-G)
#define ACCEL_XOUT_H 0x3B
#define ACCEL_XOUT_L 0x3C
#define ACCEL_YOUT_H 0x3D
#define ACCEL_YOUT_L 0x3E
#define ACCEL_ZOUT_H 0x3F
#define ACCEL_ZOUT_L 0x40
#define TEMP_OUT_H  0x41
#define TEMP_OUT_L  0x42
#define GYRO_XOUT_H  0x43
#define GYRO_XOUT_L  0x44
#define GYRO_YOUT_H  0x45
#define GYRO_YOUT_L  0x46
#define GYRO_ZOUT_H  0x47
#define GYRO_ZOUT_L  0x48
#define PWR_MGMT_1  0x6B //电源管理，典型值：0x00(正常启用)

五、应用层直接使用I2C通道

5.1 预备工作：

5.1.1 exynos4412平台每个i2c通道的信息是通过设备树提供的，因此需要首先在exynos4412-fs4412.dts中增加5通道的节点：

在这里插入图片描述

不要忘记：

  1. 回内核源码顶层目录执行：make dtbs
  2. 将新生成的dtb拷贝到/tftpboot

5.1.2 i2c总线驱动层提供了一个字符设备驱动，以便于应用层可以直接通过它去使用i2c总线通讯去操作二级外设，但需要

内核编译时添加此字符设备驱动代码(i2c-dev.c),因此需要修改make menuconfig的配置：

在这里插入图片描述

不要忘记：

  1. 回内核源码顶层目录执行：make uImage
  2. 将新生成的uImage拷贝到/tftpboot

5.2 应用层直接使用i2c总线的代码实现

5.2.1 调用read、write实现接收、发送

#include "mpu6050.h"
static int read_data_from_mpu6050(int fd,unsigned char reg,unsigned char *pdata)
{
   int ret=0;
   unsigned char buf[1]={reg};
   
   ret=write(fd,reg,1);
   if(ret <0)
   {
   	printf("write reg failed in read_data_from_mpu6050.\n");
   	return -1;
   }
   buf[0]=0;
   ret=read(fd,buf,1);
   if(ret <0)
   {
   	printf("read data failed in read_data_from_mpu6050.\n");
   	return -1;
   }
   *pdata=buf[0];
   return 0;

}
static int write_data_to_mpu6050(int fd,unsigned char reg,unsigned char data)
{
   int ret=0;
   unsigned char buf[2]={reg,data};
   ret=write(fd,buf,2);
   if(ret <0)
   {
   	printf("write reg and data failed in write_data_to_mpu6050.\n");
   	return -1;
   }
   return 0;

}
int init_mpu6050(int fd)
{
   int ret=0;
   ret=ioctl(fd,I2C_TENBIT,0);
   if(ret<0)
   {
   printf("ioctl I2C_TENBIT failed in init_mpu6050.\n");
   return 0;
   }
   ret=ioctl(fd,I2C_SLAVE,0x68);
   if(ret<0)
   {
   printf("ioctl I2C_SLAVE failed in init_mpu6050.\n");
   return 0;
   }
   ret=write_data_to_mpu6050(fd,PWR_MGMT_1,0x00);
   ret+=write_data_to_mpu6050(fd,SMPLRT_DIV,0x07);
   ret+=write_data_to_mpu6050(fd,GYRO_CONFIG,0xF8);
   ret+=write_data_to_mpu6050(fd,ACCEL_CONFIG,0x19);
   if(ret<0)
   {
   printf("write init data_to_mpu6050 failed,in init_mpu6050.\n");
   return -1;
   
   }
   return 0;
}

int read_accelx(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,ACCEL_XOUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,ACCEL_XOUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read accelx failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}
int read_accely(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,ACCEL_YOUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,ACCEL_YOUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read accely failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}
int read_accelz(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,ACCEL_ZOUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,ACCEL_ZOUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read accelz failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}
int read_temp(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,TEMP_OUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,TEMP_OUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read temp failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}
int read_gyrox(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,GYRO_XOUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,GYRO_XOUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read gyrox failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}
int read_gyroy(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,GYRO_YOUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,GYRO_YOUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read gyroy failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}
int read_gyroz(int fd)
{
   int ret=0;
   unsigned short val=0;
   unsigned char d=0;

   ret=read_data_from_mpu6050(fd,GYRO_ZOUT_L,&d);
   val=d;
   ret=read_data_from_mpu6050(fd,GYRO_ZOUT_H,&d);
   val|=d<<8;
   if(ret < 0)
   {
   	printf("read gyroz failed.\n");
   	return -1;
   }
   else
   {
   return val;
   }
}

5.2.2 调用ioctl实现接收、发送

#ifndef MPU6050_H
#define MPU6050_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/ioctl.h>
#define PWR_MGMT_1 0x6B
#define SMPLRT_DIV 0x19
#define CONFIG 0x1A
#define GYRO_CONFIG 0x1B
#define ACCEL_CONFIG 0x1C
#define ACCEL_XOUT_H 0x3B
#define ACCEL_XOUT_L 0x3C
#define ACCEL_YOUT_H 0x3D
#define ACCEL_YOUT_L 0x3E
#define ACCEL_ZOUT_H 0x3F
#define ACCEL_ZOUT_L 0x40
#define TEMP_OUT_H  0x41
#define TEMP_OUT_L  0x42
#define GYRO_XOUT_H  0x43
#define GYRO_XOUT_L  0x44
#define GYRO_YOUT_H  0x45
#define GYRO_YOUT_L  0x46
#define GYRO_ZOUT_H  0x47
#define GYRO_ZOUT_L  0x48
#define I2C_SLAVE	0x0703	/* Use this slave address */
#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) */

struct i2c_msg {
	unsigned short addr;	/* slave address			*/
	unsigned short flags;
#define I2C_M_TEN		0x0010	/* this is a ten bit chip address */
#define I2C_M_RD		0x0001	/* read data, from slave to master */
	unsigned short len;		/* msg length				*/
	unsigned char *buf;		/* pointer to msg data			*/
};

struct i2c_rdwr_ioctl_data {
	struct i2c_msg *msgs;	/* pointers to i2c_msgs */
	unsigned char  nmsgs;			/* number of i2c_msgs */
};
int init_mpu6050(int fd);
int read_accelx(int fd);
int read_accely(int fd);
int read_accelz(int fd);
int read_temp(int fd);
int read_gyrox(int fd);
int read_gyroy(int fd);
int read_gyroz(int fd);
#endif

#include "mpu6050.h"
#include <sys/ioctl.h>
static int read_data_from_mpu6050(int fd,unsigned char slave,unsigned char reg,unsigned char *pdata)
{
	int ret=0;
	struct i2c_rdwr_ioctl_data work;
	struct i2c_msg msgs[2]={{0}};
	unsigned char buf1[1]={reg};
	unsigned char buf2[1]={0};

	work.msgs=msgs;
	work.nmsgs=2;
	msgs[0].addr=slave;
	msgs[0].flags=0;
	msgs[0].len=1;
	msgs[0].buf=buf1;


	msgs[1].addr=slave;
	msgs[1].flags=I2C_M_RD;
	msgs[1].len=1;
	msgs[1].buf=buf2;
	ret=ioctl(fd,I2C_RDWR,&work);
	if(ret<0)
	{
	 printf("ioctl failed in read_data_from_mpu6050.\n");
	 return -1;
	}
	*pdata=buf2[0];
	return 0;

}
static int write_data_to_mpu6050(int fd,unsigned char slave,unsigned char reg,unsigned char data)
{
	int ret=0;
	unsigned char buf[2]={reg,data};
	struct i2c_rdwr_ioctl_data work;
	struct i2c_msg msgs={0};
	work.msgs=&msgs;
	work.nmsgs=1;

	msgs.addr=slave;
	msgs.flags=0;
	msgs.len=2;
	msgs.buf=buf;

	ret=ioctl(fd,I2C_RDWR,&work);
	if(ret<0)
	{
	 printf("ioctl failed in read_data_from_mpu6050.\n");
	 return -1;
	}

	return 0;

}
int init_mpu6050(int fd)
{
	int ret=0;
	ret=ioctl(fd,I2C_TENBIT,0);
	if(ret<0)
	{
	printf("ioctl I2C_TENBIT failed in init_mpu6050.\n");
	return 0;
	}
	ret=ioctl(fd,I2C_SLAVE,0x68);
	if(ret<0)
	{
	printf("ioctl I2C_SLAVE failed in init_mpu6050.\n");
	return 0;
	}
	ret=write_data_to_mpu6050(fd,0x68,PWR_MGMT_1,0x00);
	ret+=write_data_to_mpu6050(fd,0x68,SMPLRT_DIV,0x07);
	ret+=write_data_to_mpu6050(fd,0x68,GYRO_CONFIG,0xF8);
	ret+=write_data_to_mpu6050(fd,0x68,ACCEL_CONFIG,0x19);
	if(ret<0)
	{
	printf("write init data_to_mpu6050 failed,in init_mpu6050.\n");
	return -1;
	
	}
	return 0;
}

int read_accelx(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,ACCEL_XOUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,ACCEL_XOUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read accelx failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}
int read_accely(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,ACCEL_YOUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,ACCEL_YOUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read accely failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}
int read_accelz(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,ACCEL_ZOUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,ACCEL_ZOUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read accelz failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}
int read_temp(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,TEMP_OUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,TEMP_OUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read temp failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}
int read_gyrox(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,GYRO_XOUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,GYRO_XOUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read gyrox failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}
int read_gyroy(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,GYRO_YOUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,GYRO_YOUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read gyroy failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}
int read_gyroz(int fd)
{
	int ret=0;
	unsigned short val=0;
	unsigned char d=0;

	ret=read_data_from_mpu6050(fd,0x68,GYRO_ZOUT_L,&d);
	val=d;
	ret=read_data_from_mpu6050(fd,0x68,GYRO_ZOUT_H,&d);
	val|=d<<8;
	if(ret < 0)
	{
		printf("read gyroz failed.\n");
		return -1;
	}
	else
	{
	return val;
	}
}

缺点：

  1. 需要应用程序开发人员查阅原理图和芯片手册，增加了他们的开发负担
  2. 开发出的应用程序缺乏可移植性

六、I2C总线二级外设驱动开发方法

  1. 查阅原理图以便得知二级外设挂在哪条I2C总线上、二级外设的身份标识（二级外设自身的地址）

  2. 参照platform样式搭建二级外设驱动框架

  3. 查询二级外设芯片手册以便得知驱动需要用到的寄存器地址

    注意：

    1. 此处寄存器是指二级外设内部的寄存器，每个寄存器在芯片手册里有个对应编号（也被称为地址），但不是内存地址，特别提醒此寄存器不是SOC芯片内部参与内存统一编址的寄存器，更不是ARM核-CPU的寄存器
    2. 通过调用i2c_tranfer函数完成与相应寄存器的数据交互

  4. 参照字符驱动完成其余代码编写

  5. 创建对应的i2c_client对象

    linux-3.14\Documentation\i2c\instantiating-devices

    匹配方式：

    1. 名称匹配

    2. 设备树匹配

    3. ACPI匹配

      Advanced Configuration and Power Management Interface 高级配置和电源管理接口

      PC机平台采用的一种硬件配置接口

i2c二级外设驱动框架：

//其它struct file_operations函数实现原理同硬编驱动
 
static int mpu6050_probe(struct i2c_client *pclt,const struct i2c_device_id *pid)
{
    //做硬编驱动模块入口函数的活
}
 
static int mpu6050_remove(struct i2c_client *pclt)
{
    //做硬编驱动模块出口函数的活
}
 
/*名称匹配时定义struct i2c_device_id数组*/
static struct i2c_device_id mpu6050_ids = 
{
    {"mpu6050",0},
    //.....
    {}
};
 
/*设备树匹配时定义struct of_device_id数组*/
static struct of_device_id mpu6050_dts =
{
    {.compatible = "invensense,mpu6050"},
    //....
    {}
};
 
/*通过定义struct i2c_driver类型的全局变量来创建i2c_driver对象，同时对其主要成员进行初始化*/
struct i2c_driver mpu6050_driver = 
{
    .driver = {
        .name = "mpu6050",
        .owner = THIS_MODULE,
        .of_match_table = mpu6050_dts,
    },
    .probe = mpu6050_probe,
    .remove = mpu6050_remove,
    .id_table = mpu6050_ids,
};
 
/*以下其实是个宏，展开后相当于实现了模块入口函数和模块出口函数*/
module_i2c_driver(mpu6050_driver);
 
MODULE_LICENSE("GPL");

七、I2C总线二级外设驱动开发之名称匹配

这种匹配方式需要自己创建i2c_client对象

创建i2c_client对象有三种方式：

  1. i2c_register_board_info

    1.当开发板上电内核跑起来的时候，肯定是架构相关的程序首先运行，也就是mach-xxx.c
2. mach-xxx.c文件里首先会定义i2c_board_info的结构体数组，在mach-xxx.c的初始化函数里调用
i2c_register_board_info函数把i2c_board_inifo链接进内核的i2c_board_list链表当中去
3.在驱动i2c目录下和开发板板对应的驱动文件i2c-xxx.c里，创建i2c_adapter对象
4.这种方式严重依赖平台，缺乏灵活性，基本会被遗弃

  2. i2c_new_device：明确二级外设地址的情况下可用

    i2c二级外设client框架：

    #include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
 
static struct i2c_board_info mpu6050_info = 
{
 I2C_BOARD_INFO("mpu6050",二级外设地址)   
};
 
static struct i2c_client *mpu6050_client;
static int __init mpu6050_dev_init(void)
{
    struct i2c_adapter *padp = NULL;
    padp = i2c_get_adapter(i2c通道编号);
    mpu6050_client = i2c_new_device(padp,&mpu6050_info);
    i2c_put_adapter(padp);
    return 0;
}
module_init(mpu6050_dev_init);
 
static void __exit mpu6050_dev_exit(void)
{
    i2c_unregister_device(mpu6050_client);
}
module_exit(mpu6050_dev_exit);
MODULE_LICENSE("GPL");

  3. i2c_new_probed_device

    i2c二级外设client框架：不明确二级外设地址，但是知道是可能几个值之一的情况下可用

    #include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
 
static const unsigned short addr_list[] = 
{
 0x68,
    //.....
    I2C_CLIENT_END
};
 
static struct i2c_client *mpu6050_client;
static int __init mpu6050_dev_init(void)
{
    struct i2c_adapter *padp = NULL;
    struct i2c_board_info mpu6050_info = {""};
     
    strcpy(mpu6050_info.type,"mpu6050");
     
    padp = i2c_get_adapter(i2c通道编号);
    mpu6050_client = i2c_new_probed_device(padp,&mpu6050_info,addr_list,NULL);
    i2c_put_adapter(padp);
    if(mpu6050_client != NULL)
    {
        return 0;
    }
    else
    {
     return -ENODEV;
    }
}
module_init(mpu6050_dev_init);
 
static void __exit mpu6050_dev_exit(void)
{
    i2c_unregister_device(mpu6050_client);
}
module_exit(mpu6050_dev_exit);
MODULE_LICENSE("GPL");

八、I2C总线二级外设驱动开发之设备树匹配

在这里插入图片描述

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/atomic.h>
#include "mpu6050.h"
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#define BUF_LEN 100
#include "mpu6050.h"

#define mpu6050_DEV_CNT 3


int major = 11;
int minor = 0;
int mpu6050_num=1;
struct mpu6050_dev
{
	struct cdev mydev;
	struct i2c_client *pclt;

};

struct mpu6050_dev *pgmydev=NULL;


int mpu6050_open(struct inode *pnode,struct file *pfile)
{
	pfile->private_data =(void *) (container_of(pnode->i_cdev,struct mpu6050_dev,mydev));

	return 0;
}



int mpu6050_close(struct inode *pnode,struct file *pfile)
{

	//struct mpu6050_dev *pmydev = (struct mpu6050_dev *)pfile->private_data;

		return 0;
}
int mpu6050_read_byte(struct i2c_client *pclt,unsigned char reg)
{
	int ret=0;
	char txbuf[1]={reg};
	char rdbuf[1]={};
	struct i2c_msg msg[2]=
	{
		{pclt->addr,0,1,txbuf},
		{pclt->addr,I2C_M_RD,1,rdbuf},
	};
	ret=i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));
	if(ret<0)
	{
	printk("ret= %d in mpu6050_read_byte.\n",ret);
	return ret;
	}
	return rdbuf[0];
}
int write_data(struct i2c_client *pclt,unsigned char reg,unsigned char val)
{
	
	int ret=0;
	char buf[2]={reg,val};
	struct i2c_msg msg[1]=
	{
		{pclt->addr,0,2,buf},
	};
	
	ret=i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));
	if(ret<0)
	{
	printk("ret= %d in mpu6050_write_byte.\n",ret);
	return ret;
	}
	return 0;
}

long mpu6050_ioctl(struct file *pfile,unsigned int cmd,unsigned int arg)
{
	struct mpu6050_dev *pmydev = (struct mpu6050_dev *)pfile->private_data;
	union mpu6050_data data;
	
		switch (cmd)
		{
		case GET_ACCEL:
			data.accel.x=mpu6050_read_byte(pmydev->pclt,ACCEL_XOUT_L);
			data.accel.x|=mpu6050_read_byte(pmydev->pclt,ACCEL_XOUT_H)<<8;

			data.accel.y=mpu6050_read_byte(pmydev->pclt,ACCEL_YOUT_L);
			data.accel.y|=mpu6050_read_byte(pmydev->pclt,ACCEL_YOUT_H)<<8;
			
			data.accel.z=mpu6050_read_byte(pmydev->pclt,ACCEL_ZOUT_L);
			data.accel.z|=mpu6050_read_byte(pmydev->pclt,ACCEL_ZOUT_H)<<8;
			break;
		case GET_GYRO:
			data.gyro.x=mpu6050_read_byte(pmydev->pclt,GYRO_XOUT_L);
			data.gyro.x|=mpu6050_read_byte(pmydev->pclt,GYRO_XOUT_H)<<8;

			data.gyro.y=mpu6050_read_byte(pmydev->pclt,GYRO_YOUT_L);
			data.gyro.y|=mpu6050_read_byte(pmydev->pclt,GYRO_YOUT_H)<<8;
			
			data.gyro.z=mpu6050_read_byte(pmydev->pclt,GYRO_ZOUT_L);
			data.gyro.z|=mpu6050_read_byte(pmydev->pclt,GYRO_ZOUT_H)<<8;
			break;	
		case GET_TEMP:
			data.temp=mpu6050_read_byte(pmydev->pclt,TEMP_OUT_L);
			data.temp|=mpu6050_read_byte(pmydev->pclt,TEMP_OUT_H)<<8;
			break;

		default:
			return -EFAULT;
		}
		if(copy_to_user((void *)arg,&data,sizeof(data)))
		{

		return -EFAULT;
		}
		
		return sizeof(data);
}

void init_mpu6050(struct i2c_client *pclt)
{
	write_data(pclt,PWR_MGMT_1,0X00);
	write_data(pclt,PWR_MGMT_1,0X00);
	write_data(pclt,PWR_MGMT_1,0X00);
	write_data(pclt,PWR_MGMT_1,0X00);
	write_data(pclt,PWR_MGMT_1,0X00);

}


struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = mpu6050_open,
	.release = mpu6050_close,
};




static int  mpu6050_probe(struct i2c_client *pclt,const struct i2c_device_id *pid)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	//int i = 0;

	/*申请设备号*/
	ret = register_chrdev_region(devno,mpu6050_num,"mpu6050");
	if(ret)
	{
		ret = alloc_chrdev_region(&devno,minor,mpu6050_num,"mpu6050");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//容易遗漏，注意
	}

	pgmydev=(struct mpu6050_dev *)kmalloc(sizeof(struct mpu6050_dev),GFP_KERNEL);
	if(pgmydev==NULL)
	{
		unregister_chrdev_region(devno,mpu6050_num);
		printk("kmalloc failed\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct mpu6050_dev));

	pgmydev->pclt=pclt;
	/*给struct cdev对象指定操作函数集*/	
	cdev_init(&pgmydev->mydev,&myops);

	/*将struct cdev对象添加到内核对应的数据结构里*/
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,1);

	init_mpu6050(pgmydev->pclt);
		return 0;
}

static int  mpu6050_remove(struct i2c_client *pclt)
{
	dev_t devno = MKDEV(major,minor);
	//int i = 0;

	cdev_del(&pgmydev->mydev);
 	unregister_chrdev_region(devno,mpu6050_num);

	kfree(pgmydev);
	pgmydev=NULL;

	return 0;
}

struct i2c_device_id mpu6050_ids[]=
{
	{"mpu6050",0},
	{},
};

struct of_device_id mpu6050_dt[]=
{
	{.compatible="invensense,mpu6050"},
	{},
};
struct i2c_driver mpu6050_driver ={
	.driver={
		.name="mpu6050",
		.owner=THIS_MODULE,
		.of_match_table=mpu6050_dt,
	},
	.probe= mpu6050_probe,
	.remove= mpu6050_remove,
	.id_table= mpu6050_ids,
	};

int __init mpu6050_driver_init(void)
{
	i2c_add_driver(&mpu6050_driver);
	return 0;
}
void __exit mpu6050_driver_exit(void)
{
	i2c_del_driver(&mpu6050_driver);
}
	
MODULE_LICENSE("GPL");

module_init(mpu6050_driver_init);
module_exit(mpu6050_driver_exit);
字母哥先生
关注
  • 22
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
I2C总线驱动
m0_73492050的博客
01-08 1731
Inter-Integrated Circuit： 字面意思是用于“集成电路之间”的通信总线，简写：IIC(或者I2C)i2c传输的要点就是： 传输一个字节 后面必然紧跟一个"响应"信号----应答信号.这个响应信号可能来自主机，或者是从机，具体是谁，就要看传输方向。传输方向分两种情况(每种情况又有两种可能: A无应答和 B有应答)：1.主机->从机，主机对从机发一个字节之后，主机要读取从机的响应信号(主机读SDA线)
I2c总线驱动
Wozart_Kate的博客
03-30 4766
通过一台总设备（控制与计算中心设备，及单片机） 与多台从设备（一共210=1023（加一台单片机）） 以I2c总线的方式 接口 功能 使用标准 GND 所有设备共地 SCK 时钟 频率 SDA 数据传输 详见电平时序图 对应时序图的基本函数 void I2C_Configuration(void); { GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_
i2c总线驱动详解
Herok
04-14 2933
I2c总线应用也是很广泛的，i2c总线经常挂载eeprom、温度传感器、湿度传感器等设备。I2c总线下可以挂载多个设备，识别设备采用一个地址，这个地址在一条i2c总线是独一无二的。I2c总线驱动与spi总线驱动框架是一致的，都是采用控制器、core、设备三层驱动。下面开始讲解i2c总线驱动流程。强烈建议读者看完本篇文章。 首先看一下设备树文件，本次示例程序是一个i2c控制器下挂在eeprom设备...
Linux驱动开发05：【I2C驱动】I2C总线驱动和设备驱动
Egean的博客
07-17 4400
介绍 这里实现一种不涉及硬件的I2C总线和设备驱动，然后分析I2C驱动在系统中的注册过程。这里实现的驱动类似于之前的FIFO字符设备驱动，与之不同的是这里使用了I2C驱动框架，设备文件写入和读取将通过i2c_client传递到指定的i2c_adaper，然后在i2c_adapter中操作一段内存。这个驱动非常简单，甚至没有使用FIFO这种硬件结构，只能进行读和写，毕竟内存的操作不是中断，重点是熟...
浅析I2C总线驱动
Peter_tang6的博客
09-06 2314
最近在看驱动程序的时候，学习了解了I2C总线，前面有platform平台总线，是一种虚拟的总线，用于分离设备和驱动，便于驱动工程师移植程序。而I2C是一种实实在在的，具备多主机系统所需的包括总线裁决和高低速器件同步功能的高性能串行总线，I2C总线是两线式的串行总线，用于连接微控制器及其外围设备，如果我们的外设是用I2C总线连接的，那就意味着我们可以直接使用I2C驱动来控制设备了，那么我们为什么要使用
51单片机I2C总线驱动
叶子丶de花 博客
02-16 2085
51单片机I2C总线驱动，仅有.h文件，无.c文件。 适合EEPROM存储和PCF8591A/D-D/A转换等。。 /************************************************************************************* ************** *************************************...
STM32-I2C总线驱动程序分析
weixin_44681745的博客
04-22 2079
文章目录I2C硬件电路原理图I2C 简介添加相应的文件并添加进工程文件I2C驱动程序结构I2C驱动程序分析LM75A温度传感器电路原理图LM75A温度传感器驱动程序分析 杨桃32学习笔记，本文图片文字皆为转述 I2C硬件电路原理图 I2C要点 I2C总线是板级总线，连接线一般不超2米。 电路连接：两线总线连接，1～10K上拉电阻，复用开漏模式。 器件地址：每个器件都有唯一地址（7位16进制数），最多127个器件地址，新版I2C规范中最大器件地址数量可达1023个。 所有设备与单片机需要共地。 杨桃电
Linux之I2C驱动
风间琉璃的博客
09-28 4457
在 Linux 内核中 I2C 的体系结构分为 3 个部分：①： I2C 核心提供了I2C 总线驱动和设备驱动的注册、 注销方法②： I2C 总线驱动是对I2C 硬件体系结构中适配器端的实现， 适配器可由CPU 控制， 甚至可以直接集成在 CPU 内部。I2C 总线驱动就是 SOC 的，也叫做。③： I2C 设备驱动是对，设备一般挂接在受 CPU 控制的 I2C 适配器上， 通过 I2C 适配器与 CPU 交换数据。
Linux I2C 总线驱动恢复机制！
求变，从思想开始
04-01 3563
I2C是经常使用的一种bus方式，工程师们也经常调试I2C驱动设备；但是总会碰到各种各样的 问题；但是还有一种问题，就是非常小概率问题，又不好重现，怎么处理呢？ 好在linux提供一种非常 牛逼的方法，可以在总线被挂住的情况下恢复，然后设备可以继续使用。下面就把相关的代理列举下。 但是你的平台是否配置此功能需要验证下，并打开相关的功能。 Linux I2C 总线驱动...
一文搞懂I2C通信总线
热门推荐
不脱发的程序猿
03-27 9万+
本来不打算写这篇文章，因为网上关于I2C总线通信的资料很多很全。但是最近刚换工作，主要做驱动开发，第一个驱动就是I2C通信，想了想还是结合网上的资料再整理下思路，方便今后的查阅和温习。
用i2c总线驱动OLED程序
04-12
本包的程序主要讲解了如何通过i2c总线驱动以及字符设备驱动实现将用户所输字符显示到OLED上
C51单片机模拟I2C总线驱动程序
01-23
C51单片机模拟I2C总线驱动程序,觉得不错的资料,模拟方式I2C ,总线
基于Verilog的I2C总线驱动设计
08-21
基于Verilog的I2C总线驱动设计，有代码和文档详解
buspirate:Bus Pirate Linux I2C 总线驱动程序
06-19
#Bus Pirate I2C 总线驱动程序这是 Dangerous Prototypes“Bus Pirate”板的 I2C 总线驱动程序 ( )。 Bus Pirate 是各种嵌入式总线协议（I2C、SPI、JTAG 等）的总线分析器和主控器。 此驱动程序仅实现 I2C 端。 BP ...
嵌入式Linux中I2C总线驱动程序设计.pdf
09-06
嵌入式Linux中I2C总线驱动程序设计 本文将详细介绍嵌入式Linux中I2C总线驱动程序的设计。I2C总线是一种同步串行总线协议，由菲利浦公司开发，用于连接微控制器及其外围设备。在嵌入式系统中，I2C总线常用于连接RAM...
Linux fallocate工具用于预分配或释放文件空间的块
最新发布
不积跬步，无以至千里；不积小流，无以成江海。
06-09 298
命令，您需要在具有适当权限的环境中运行它，例如通过SSH登录到Linux服务器或在Linux终端中运行。请确保指定的路径存在且可写。文件中未使用的磁盘空间。请注意，这不会改变文件的大小，只是释放了未使用的磁盘空间。之前，建议了解文件系统和存储设备的特性，以避免潜在的性能问题。是一个Linux命令行工具，用于预分配或释放文件空间的块。文件的大小截断为5MB。大于5MB的部分将被删除。文件的10MB偏移量处开始预分配5MB的磁盘空间。文件的10MB偏移量处开始的5MB磁盘空间。文件预分配10MB的磁盘空间。
嵌入式Linux系统编程 — 3.4 access、chmod和 umask函数修改文件访问权限
几度春风里的博客
06-09 920
文件的权限检查不仅讨论文件本身的权限，还需要涉及到文件所在目录的权限， 只有同时都满足了，才能通过操作系统的权限检查，进而才可以对文件进行相关操作；所以，程序当中对文件进行相关操作之前，需要先检查执行进程的用户是否对该文件拥有相应的权限。需要进行权限检查的文件路径。F_OK：检查文件是否存在R_OK：检查是否拥有读权限W_OK：检查是否拥有写权限X_OK：检查是否拥有执行权限检查项通过则返回 0，表示拥有相应的权限并且文件存在；
树莓派 linux ARM 如何更新libc库
南七小僧的学海无涯
06-07 124
到 http://www.gnu.org/software/libc/libc.html 或 Index of /pub/gnu/libc下载你要的LIBC库。如果你的开发板用的是Ubunt的根文件系统，那么恭喜你，你要更新LIBC库就变得很简单。笔者采用的是nfs根文件系统更新ARM上的库。3. 拷贝PC使用的交叉编译工具的arm-linux-gnueabihf/libc/usr/lib 的所有。/arm/lib/arm-linux-gnueabi/ -d //-d 代表拷贝软连接。
i2c总线驱动和设备驱动
03-31
I2C总线驱动和设备驱动是嵌入式系统中的两个重要部分。 I2C总线驱动通常是嵌入式系统内核中的一个模块，负责控制I2C总线的物理层，并提供I2C总线的访问接口。它可以通过向I2C总线发送和接收数据来与I2C设备通信。I2C总线驱动通常包括以下功能： 1. 初始化I2C总线和I2C控制器。 2. 提供读写I2C设备的接口。 3. 实现I2C总线的中断处理。 4. 支持I2C总线的多主机模式。 设备驱动是控制嵌入式系统中特定设备的软件模块。它负责管理设备的硬件资源，并提供设备的访问接口。设备驱动通常包括以下功能： 1. 初始化设备并分配资源。 2. 提供访问设备的接口。 3. 实现设备的中断处理。 4. 实现设备的数据传输。 5. 实现设备的控制接口。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值