I2C总线驱动：裸机版、应用层的使用、二级外设驱动三种方法
一、I2C总线背景知识
SOC芯片平台的外设分为：
- 一级外设：外设控制器集成在SOC芯片内部
- 二级外设：外设控制器由另一块芯片负责，通过一些通讯总线与SOC芯片相连
Inter-Integrated Circuit： 字面意思是用于“集成电路之间”的通信总线，简写：IIC(或者I2C)
i2c传输的要点就是： 传输一个字节 后面必然紧跟一个"响应"信号----应答信号.这个响应信号可能来自主机，或者是从机，具体是谁，就要看传输方向。
传输方向分两种情况(每种情况又有两种可能: A无应答和 B有应答)：
1.主机->从机，主机对从机发一个字节之后，主机要读取从机的响应信号(主机读SDA线)
A) 主机读SDA为高电平，说明从机无应答（意味着从机接收完毕，主机发送停止信号）
B) 主机读SDA为低电平，说明从机有应答。（可继续发送下一个字节）
2.从机->主机， 主机读取从机一个字节之后，主机要向从机发送一个响应信号(主机写SDA线)
A) 主机写SDA为高电平，从机收到主机的无应答信号之后，从机停止传输，等待主机的停止信号。
B) 主机写SDA为低电平，从机收到主机的应答信号之后，从机继续输出下一字节
二、Exynos4412 I2C收发实现之裸机版
I2CCON寄存器：控制寄存器
第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; /* 启用 ACK 位, 预分频器: 512, 启用 RX/TX */I2C5.I2CSTAT = 0x3 << 6 | 1<<5 | 1<<4; /* 主传输模式, 启动, 启用 RX/TX */while(!(I2C5.I2CCON & (1<<4)));I2C5.I2CDS = addr;I2C5.I2CCON &= ~(1<<4); // 清除挂起位以恢复while(!(I2C5.I2CCON & (1<<4)));// 发送数据I2C5.I2CDS = data; // 数据I2C5.I2CCON &= ~(1<<4); // 清除挂起位以恢复while(!(I2C5.I2CCON & (1<<4)));I2C5.I2CSTAT = 0xD0; // 停止I2C5.I2CCON &= ~(1<<4); // 清除挂起位以恢复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; /* 启用 ACK 位, 预分频器: 512, 启用 RX/TX 中断使能 */I2C5.I2CSTAT = 0x3 << 6 | 1<<5 | 1<<4; /* 主传输模式, 启动, 启用 RX/TX */while(!(I2C5.I2CCON & (1<<4))); /* 对应位为1表示slave_addr传输完成，线路处于挂起状态 */I2C5.I2CDS = addr;I2C5.I2CCON &= ~(1<<4); // 清除挂起位以继续传输while(!(I2C5.I2CCON & (1<<4)));I2C5.I2CSTAT = 0xD0; // 停止 第5位写0，表示要求产生stop信号// 接收数据I2C5.I2CDS = slave_addr | 0x01; // 读取I2C5.I2CCON = 1<<7 | 1<<6 | 1<<5; /* 启用 ACK 位, 预分频器: 512, 启用 RX/TX 中断使能 */I2C5.I2CSTAT = 2<<6 | 1<<5 | 1<<4; /* 主接收模式, 启动, 启用 RX/TX, 0xB0 */while(!(I2C5.I2CCON & (1<<4)));I2C5.I2CCON &= ~((1<<7) | (1<<4)); /* 恢复操作 & 无 ACK */while(!(I2C5.I2CCON & (1<<4)));I2C5.I2CSTAT = 0x90; // 停止 第5位写0，表示要求产生stop信号I2C5.I2CCON &= ~(1<<4); /* 清除中断挂起位 */*data = I2C5.I2CDS;mydelay_ms(10);
}三、Linux内核对I2C总线的支持
I2C设备驱动（driver驱动层）：即挂接在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;/* 标准驱动模型接口 */int (*probe)(struct i2c_client *, const struct i2c_device_id *);int (*remove)(struct i2c_client *);/* 与枚举无关的驱动模型接口 */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);/* 类似ioctl的命令，可用于执行特定功能 */int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);struct device_driver driver;const struct i2c_device_id *id_table;/* 用于自动设备创建的设备检测回调 */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通道的节点：
不要忘记：
- 回内核源码顶层目录执行：make dtbs
- 将新生成的dtb拷贝到/tftpboot
5.1.2 i2c总线驱动层提供了一个字符设备驱动，以便于应用层可以直接通过它去使用i2c总线通讯去操作二级外设，但需要
内核编译时添加此字符设备驱动代码(i2c-dev.c),因此需要修改make menuconfig的配置：
不要忘记：
- 回内核源码顶层目录执行：make uImage
- 将新生成的uImage拷贝到/tftpboot
5.2 应用层直接使用i2c总线的代码实现
缺点：
- 需要应用程序开发人员查阅原理图和芯片手册，增加了他们的开发负担
- 开发出的应用程序缺乏可移植性
5.2.1 调用read、write实现接收、发送
mpu6050.h
#ifndef MPU_6050_H
#define MPU_6050_H#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>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);/****************MPU6050内部寄存器地址****************/#define SMPLRT_DIV 0x19 //陀螺仪采样率，典型值：0x07(125Hz)
#define CONFIG 0x1A //低通滤波频率，典型值：0x06(5Hz)
#define GYRO_CONFIG 0x1B //陀螺仪自检及测量范围，典型值：0x18(不自检，2000deg/s)
#define ACCEL_CONFIG 0x1C //加速计自检、测量范围及高通滤波频率，典型值：0x18(不自检，2G，5Hz)
#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(正常启用)
#define WHO_AM_I 0x75 //IIC地址寄存器(默认数值0x68，只读)
#define SlaveAddress 0x68 //MPU6050-I2C地址#define I2C_SLAVE 0x0703 /* Use this slave address */
#define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */#endif
mpu6050_op_rw.c
#include "mpu6050.h"// 从MPU6050读取数据的函数
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, buf, 1);if (ret != 1){printf("write reg failed, in read_data_from_mpu6050\n");return -1; // 写入失败，返回错误}buf[0] = 0;// 读取数据ret = read(fd, buf, 1);if (ret != 1){printf("read data failed, in read_data_from_mpu6050\n");return -1; // 读取失败，返回错误}*pdata = buf[0]; // 将读取的数据存储到 pdata 中return 0; // 成功读取数据，返回0
}// 向MPU6050写入数据的函数
static int write_data_to_mpu6050(int fd, unsigned char reg, unsigned char data)
{unsigned char buf[2] = {reg, data}; // 准备要写入的寄存器地址和数据int ret = 0;// 写入数据ret = write(fd, buf, 2);if (ret != 2){printf("write data failed, in write_data_to_mpu6050\n");return -1; // 写入失败，返回错误}return 0; // 成功写入数据，返回0
}// 初始化MPU6050的函数
int init_mpu6050(int fd)
{int ret = 0;// 使用ioctl配置I2C设备，将 I2C 设备配置为使用 7 位地址模式ret = ioctl(fd, I2C_TENBIT, 0);if (ret < 0){printf("ioctl I2C_TENBIT failed, in init_mpu6050\n");return -1; // 配置失败，返回错误}//设置I2C从设备地址，将 I2C 设备的从设备地址设置为 0x68ret = ioctl(fd, I2C_SLAVE, 0x68);if (ret < 0){printf("ioctl I2C_TENBIT failed, in init_mpu6050\n");return -1; // 配置失败，返回错误}// 向MPU6050写入初始化数据，设置各个寄存器的值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, ACCEL_CONFIG, 0x19);ret += write_data_to_mpu6050(fd, GYRO_CONFIG, 0xF8);if (ret < 0){printf("write init data to mpu6050 failed, in init_mpu6050\n");return -1; // 写入初始化数据失败，返回错误}return 0; // 初始化成功，返回0
}// 读取MPU6050加速度计X轴数据的函数
int read_accelx(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 0;// 从MPU6050读取低位数据ret = read_data_from_mpu6050(fd, ACCEL_XOUT_L, &d);val = d;// 从MPU6050读取高位数据ret = read_data_from_mpu6050(fd, ACCEL_XOUT_H, &d);val |= d << 8;if (ret < 0){printf("read accel x value failed, in read_accelx\n");return -1; // 读取失败，返回错误}else{return val; // 返回读取到的加速度计X轴数据}
}
int read_accely(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 accel y value failed,in read_accely\n");return -1;}else{return val;}
}int read_accelz(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 accel z value failed,in read_accelz\n");return -1;}else{return val;}
}int read_temp(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 value failed,in read_temp\n");return -1;}else{return val;}
}int read_gyrox(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 gyro x value failed,in read_gyrox\n");return -1;}else{return val;}
}int read_gyroy(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 gyro y value failed,in read_gyroy\n");return -1;}else{return val;}
}int read_gyroz(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 gyro z value failed,in read_gyroz\n");return -1;}else{return val;}
}main.c
#include "mpu6050.h"int main(int argc, char *argv[])
{int fd = -1;if(argc < 2) {printf("Argument is too few\n");return 0;}/* open */fd = open(argv[1], O_RDWR);if(fd < 0) {printf("open %s failed\n", argv[1]);return -1;}/* init mpu6050 */init_mpu6050(fd);while(1) {sleep(2);/* read and printf data from mpu6050 */printf("Accel-X : 0x%x\n", read_accelx(fd));printf("Accel-Y : 0x%x\n", read_accely(fd));printf("Accel-Z : 0x%x\n", read_accelz(fd));printf("Temp : 0x%x\n", read_temp(fd));printf("Gyrox-X : 0x%x\n", read_gyrox(fd));printf("Gyroy-X : 0x%x\n", read_gyroy(fd));printf("Gyroz-X : 0x%x\n", read_gyroz(fd));}/* close */close(fd);fd = -1;return 0;
}
5.2.2 调用ioctl实现接收、发送
mpu6050.h
#ifndef MPU_6050_H
#define MPU_6050_H#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>#include <stdio.h>
#include <stdlib.h>
#include <string.h>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);#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 PWR_MGMT_1 0x6B#define I2C_SLAVE 0x0703 /* 使用此从设备地址 */
#define I2C_TENBIT 0x0704 /* 0 表示 7 位地址，非 0 表示 10 位地址 */
#define I2C_RDWR 0x0707 /* 组合的读/写传输（只有一个 STOP） */struct i2c_msg {unsigned short addr; /* 从设备地址 */unsigned short flags;
#define I2C_M_TEN 0x0010 /* 这是十位地址的芯片地址 */
#define I2C_M_RD 0x0001 /* 读取数据，从从设备传输到主设备 */unsigned short len; /* 消息长度 */unsigned char *buf; /* 指向消息数据的指针 */
};/* 此结构在 I2C_RDWR ioctl 调用中使用 */
struct i2c_rdwr_ioctl_data {struct i2c_msg *msgs; /* 指向 i2c_msg 的指针 */unsigned int nmsgs; /* i2c_msg 的数量 */
};
#endif
mpu6050_op_ioctl.c
#include "mpu6050.h"static int read_data_from_mpu6050(int fd,unsigned char slave,unsigned char reg,unsigned char *pdata)
{struct i2c_rdwr_ioctl_data work = {NULL};struct i2c_msg msgs[2] = {{0}};unsigned char buf1[1] = {reg};unsigned char buf2[1] = {0};int ret = 0;work.msgs = msgs;work.nmsgs = 2;msgs[0].addr = slave;msgs[0].flags = 0;msgs[0].buf = buf1;msgs[0].len = 1;msgs[1].addr = slave;msgs[1].flags = I2C_M_RD;msgs[1].buf = buf2;msgs[1].len = 1;ret = ioctl(fd,I2C_RDWR,&work);if(ret < 0){printf("ioctl I2C_RDWR failed,in read_data_from_mpu6050\n");return -1;}else{*pdata = buf2[0];return 0;}
}static int write_data_to_mpu6050(int fd,unsigned char slave,unsigned char reg,unsigned char data)
{struct i2c_rdwr_ioctl_data work = {NULL};struct i2c_msg msg = {0};unsigned char buf[2] = {reg,data};int ret = 0;work.msgs = &msg;work.nmsgs = 1;msg.addr = slave;msg.flags = 0;msg.buf = buf;msg.len = 2;ret = ioctl(fd,I2C_RDWR,&work);if(ret < 0){printf("ioctl I2C_RDWR failed,in write_data_to_mpu6050\n");return -1;}else{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 -1;}ret = ioctl(fd,I2C_SLAVE,0x68);if(ret < 0){printf("ioctl I2C_TENBIT failed,in init_mpu6050\n");return -1;}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,ACCEL_CONFIG,0x19);ret += write_data_to_mpu6050(fd,0x68,GYRO_CONFIG,0xF8);if(ret < 0){printf("write init data to mpu6050 failed,in init_mpu6050\n");return -1;}return 0;
}int read_accelx(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 accel x value failed,in read_accelx\n");return -1;}else{return val;}
}int read_accely(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 accel y value failed,in read_accely\n");return -1;}else{return val;}
}int read_accelz(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 accel z value failed,in read_accelz\n");return -1;}else{return val;}
}int read_temp(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 value failed,in read_temp\n");return -1;}else{return val;}
}int read_gyrox(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 gyro x value failed,in read_gyrox\n");return -1;}else{return val;}
}int read_gyroy(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 gyro y value failed,in read_gyroy\n");return -1;}else{return val;}
}int read_gyroz(int fd)
{unsigned short val = 0;unsigned char d = 0;int ret = 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 gyro z value failed,in read_gyroz\n");return -1;}else{return val;}
}main.c
#include "mpu6050.h"int main(int argc,char *argv[])
{int fd = -1;if(argc < 2){printf("Argument is too few\n");return 1;}/*open*/fd = open(argv[1],O_RDWR);if(fd < 0){printf("open %s failed\n",argv[1]);return 2;}/*init mpu6050*/init_mpu6050(fd);while(1){sleep(2);/*read and print data from 6050*/printf("Accel-X:0x%x\n",read_accelx(fd));printf("Accel-Y:0x%x\n",read_accely(fd));printf("Accel-Z:0x%x\n",read_accelz(fd));printf("Temp:0x%x\n",read_temp(fd));printf("GYRO-X:0x%x\n",read_gyrox(fd));printf("GYRO-Y:0x%x\n",read_gyroy(fd));printf("GYRO-z:0x%x\n",read_gyroz(fd));printf("\n");}/*close*/close(fd);fd = -1;return 0;
}六、I2C总线二级外设驱动开发方法
-
查阅原理图以便得知二级外设挂在哪条I2C总线上、二级外设的身份标识（二级外设自身的地址）
-
参照platform样式搭建二级外设驱动框架
-
查询二级外设芯片手册以便得知驱动需要用到的寄存器地址
注意：
- 此处寄存器是指二级外设内部的寄存器，每个寄存器在芯片手册里有个对应编号（也被称为地址），但不是内存地址，特别提醒此寄存器不是SOC芯片内部参与内存统一编址的寄存器，更不是ARM核-CPU的寄存器
- 通过调用i2c_tranfer函数完成与相应寄存器的数据交互
-
参照字符驱动完成其余代码编写
-
创建对应的i2c_client对象
linux-3.14\Documentation\i2c\instantiating-devices
匹配方式：
-
名称匹配
-
设备树匹配
-
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");
完整代码
mpu6050.h
#ifndef MPU_6050_H
#define MPU_6050_Hstruct accel_data
{unsigned short x;unsigned short y;unsigned short z;
};
struct gyro_data
{unsigned short x;unsigned short y;unsigned short z;
};union mpu6050_data
{struct accel_data accel;struct gyro_data gyro;unsigned short temp;
};#define MPU6050_MAGIC 'K'#define GET_ACCEL _IOR(MPU6050_MAGIC,0,union mpu6050_data)
#define GET_GYRO _IOR(MPU6050_MAGIC,1,union mpu6050_data)
#define GET_TEMP _IOR(MPU6050_MAGIC,2,union mpu6050_data)#endif
mpu6050_client.c
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>static struct i2c_board_info mpu6050_info =
{I2C_BOARD_INFO("mpu6050",0x68)
};static struct i2c_client *gpmpu6050_client = NULL;static int __init mpu6050_client_init(void)
{struct i2c_adapter *padp = NULL;padp = i2c_get_adapter(5);gpmpu6050_client = i2c_new_device(padp,&mpu6050_info);i2c_put_adapter(padp);return 0;
}static void mpu6050_client_exit(void)
{i2c_unregister_device(gpmpu6050_client);
}module_init(mpu6050_client_init);
module_exit(mpu6050_client_exit);
MODULE_LICENSE("GPL");mpu6050_drv.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>#include "mpu6050.h"/****************MPU6050内部寄存器地址****************/#define SMPLRT_DIV 0x19 //陀螺仪采样率，典型值：0x07(125Hz)
#define CONFIG 0x1A //低通滤波频率，典型值：0x06(5Hz)
#define GYRO_CONFIG 0x1B //陀螺仪自检及测量范围，典型值：0x18(不自检，2000deg/s)
#define ACCEL_CONFIG 0x1C //加速计自检、测量范围及高通滤波频率，典型值：0x18(不自检，2G，5Hz)
#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(正常启用)
#define WHO_AM_I 0x75 //IIC地址寄存器(默认数值0x68，只读)
#define SlaveAddress 0x68 //MPU6050-I2C地址#define PWR_MGMT_1 0x6Bint 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_read_byte(struct i2c_client *pclt,unsigned char reg)
{int ret = 0;char txbuf[1] = {reg};char rxbuf[1] = {0};struct i2c_msg msg[2] = {{pclt->addr,0,1,txbuf},{pclt->addr,I2C_M_RD,1,rxbuf}};ret = i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));if(ret < 0){printk("ret = %d,in mpu6050_read_byte\n",ret);return ret;}return rxbuf[0];
}int mpu6050_write_byte(struct i2c_client *pclt,unsigned char reg,unsigned char val)
{int ret = 0;char txbuf[2] = {reg,val};struct i2c_msg msg[1] = {{pclt->addr,0,2,txbuf},};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;
}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)
{return 0;
}long mpu6050_ioctl(struct file *pfile,unsigned int cmd,unsigned long 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 -EINVAL;}if(copy_to_user((void *)arg,&data,sizeof(data))){return -EFAULT;}return sizeof(data);
}void init_mpu6050(struct i2c_client *pclt)
{mpu6050_write_byte(pclt,PWR_MGMT_1,0x00);mpu6050_write_byte(pclt,SMPLRT_DIV,0x07);mpu6050_write_byte(pclt,CONFIG,0x06);mpu6050_write_byte(pclt,GYRO_CONFIG,0xF8);mpu6050_write_byte(pclt,ACCEL_CONFIG,0x19);
}struct file_operations myops = {.owner = THIS_MODULE,.open = mpu6050_open,.release = mpu6050_close,.unlocked_ioctl = mpu6050_ioctl,
};static int mpu6050_probe(struct i2c_client *pclt,const struct i2c_device_id *pid)
{int ret = 0;dev_t devno = MKDEV(major,minor);/*申请设备号*/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(NULL == pgmydev){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,mpu6050_num);init_mpu6050(pgmydev->pclt);return 0;
}static int mpu6050_remove(struct i2c_client *pclt)
{dev_t devno = MKDEV(major,minor);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 i2c_driver mpu6050_driver =
{.driver = {.name = "mpu6050",.owner = THIS_MODULE,},.probe = mpu6050_probe,.remove = mpu6050_remove,.id_table = mpu6050_ids,
};#if 0int __init mpu6050_driver_init(void){i2c_add_driver(&mpu6050_driver);}void __exit mpu6050_driver_exit(void){i2c_del_driver(&mpu6050_driver);}module_init(mpu6050_driver_init);module_exit(mpu6050_driver_exit);
#elsemodule_i2c_driver(mpu6050_driver);
#endifMODULE_LICENSE("GPL");testapp.c
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>#include <stdio.h>#include "mpu6050.h"int main(int argc,char *argv[])
{int fd = -1;union mpu6050_data data;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDONLY);if(fd < 0){printf("open %s failed \n",argv[1]);return 2;}while(1){sleep(2);ioctl(fd,GET_ACCEL,&data);printf("Accel-x=0x%x\n",data.accel.x);printf("Accel-y=0x%x\n",data.accel.y);printf("Accel-z=0x%x\n",data.accel.z);ioctl(fd,GET_GYRO,&data);printf("Gyro-x=0x%x\n",data.gyro.x);printf("Gyro-y=0x%x\n",data.gyro.y);printf("Gyro-z=0x%x\n",data.gyro.z);ioctl(fd,GET_TEMP,&data);printf("Temp=0x%x\n",data.temp);printf("\n");}close(fd);fd = -1;return 0;
}输出结果：
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");
完整代码
mpu6050.h
#ifndef MPU_6050_H
#define MPU_6050_Hstruct accel_data
{unsigned short x;unsigned short y;unsigned short z;
};
struct gyro_data
{unsigned short x;unsigned short y;unsigned short z;
};union mpu6050_data
{struct accel_data accel;struct gyro_data gyro;unsigned short temp;
};#define MPU6050_MAGIC 'K'#define GET_ACCEL _IOR(MPU6050_MAGIC,0,union mpu6050_data)
#define GET_GYRO _IOR(MPU6050_MAGIC,1,union mpu6050_data)
#define GET_TEMP _IOR(MPU6050_MAGIC,2,union mpu6050_data)#endif
mpu6050_client_probed.c
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>static unsigned short mpu6050_addr_list[] =
{0x68,0x69,I2C_CLIENT_END
};static struct i2c_client *gpmpu6050_client = NULL;static int __init mpu6050_client_init(void)
{struct i2c_adapter *padp = NULL;struct i2c_board_info mpu6050_info = {""};strcpy(mpu6050_info.type,"mpu6050");padp = i2c_get_adapter(5);gpmpu6050_client = i2c_new_probed_device(padp,&mpu6050_info,mpu6050_addr_list,NULL);i2c_put_adapter(padp);if(gpmpu6050_client != NULL){return 0;}else{return -ENODEV;}
}static void mpu6050_client_exit(void)
{i2c_unregister_device(gpmpu6050_client);
}module_init(mpu6050_client_init);
module_exit(mpu6050_client_exit);
MODULE_LICENSE("GPL");mpu6050_drv.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>#include "mpu6050.h"#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 PWR_MGMT_1 0x6Bint 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_read_byte(struct i2c_client *pclt,unsigned char reg)
{int ret = 0;char txbuf[1] = {reg};char rxbuf[1] = {0};struct i2c_msg msg[2] = {{pclt->addr,0,1,txbuf},{pclt->addr,I2C_M_RD,1,rxbuf}};ret = i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));if(ret < 0){printk("ret = %d,in mpu6050_read_byte\n",ret);return ret;}return rxbuf[0];
}int mpu6050_write_byte(struct i2c_client *pclt,unsigned char reg,unsigned char val)
{int ret = 0;char txbuf[2] = {reg,val};struct i2c_msg msg[1] = {{pclt->addr,0,2,txbuf},};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;
}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)
{return 0;
}long mpu6050_ioctl(struct file *pfile,unsigned int cmd,unsigned long 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 -EINVAL;}if(copy_to_user((void *)arg,&data,sizeof(data))){return -EFAULT;}return sizeof(data);
}void init_mpu6050(struct i2c_client *pclt)
{mpu6050_write_byte(pclt,PWR_MGMT_1,0x00);mpu6050_write_byte(pclt,SMPLRT_DIV,0x07);mpu6050_write_byte(pclt,CONFIG,0x06);mpu6050_write_byte(pclt,GYRO_CONFIG,0xF8);mpu6050_write_byte(pclt,ACCEL_CONFIG,0x19);
}struct file_operations myops = {.owner = THIS_MODULE,.open = mpu6050_open,.release = mpu6050_close,.unlocked_ioctl = mpu6050_ioctl,
};static int mpu6050_probe(struct i2c_client *pclt,const struct i2c_device_id *pid)
{int ret = 0;dev_t devno = MKDEV(major,minor);/*申请设备号*/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(NULL == pgmydev){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,mpu6050_num);init_mpu6050(pgmydev->pclt);return 0;
}static int mpu6050_remove(struct i2c_client *pclt)
{dev_t devno = MKDEV(major,minor);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 i2c_driver mpu6050_driver =
{.driver = {.name = "mpu6050",.owner = THIS_MODULE,},.probe = mpu6050_probe,.remove = mpu6050_remove,.id_table = mpu6050_ids,
};#if 0int __init mpu6050_driver_init(void){i2c_add_driver(&mpu6050_driver);}void __exit mpu6050_driver_exit(void){i2c_del_driver(&mpu6050_driver);}module_init(mpu6050_driver_init);module_exit(mpu6050_driver_exit);
#elsemodule_i2c_driver(mpu6050_driver);
#endifMODULE_LICENSE("GPL");testapp.c
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>#include <stdio.h>#include "mpu6050.h"int main(int argc,char *argv[])
{int fd = -1;union mpu6050_data data;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDONLY);if(fd < 0){printf("open %s failed \n",argv[1]);return 2;}while(1){sleep(2);ioctl(fd,GET_ACCEL,&data);printf("Accel-x=0x%x\n",data.accel.x);printf("Accel-y=0x%x\n",data.accel.y);printf("Accel-z=0x%x\n",data.accel.z);ioctl(fd,GET_GYRO,&data);printf("Gyro-x=0x%x\n",data.gyro.x);printf("Gyro-y=0x%x\n",data.gyro.y);printf("Gyro-z=0x%x\n",data.gyro.z);ioctl(fd,GET_TEMP,&data);printf("Temp=0x%x\n",data.temp);printf("\n");}close(fd);fd = -1;return 0;
}输出结果：
八、I2C总线二级外设驱动开发之设备树匹配
完整代码
mpu6050.h
#ifndef MPU_6050_H
#define MPU_6050_Hstruct accel_data
{unsigned short x;unsigned short y;unsigned short z;
};
struct gyro_data
{unsigned short x;unsigned short y;unsigned short z;
};union mpu6050_data
{struct accel_data accel;struct gyro_data gyro;unsigned short temp;
};#define MPU6050_MAGIC 'K'#define GET_ACCEL _IOR(MPU6050_MAGIC,0,union mpu6050_data)
#define GET_GYRO _IOR(MPU6050_MAGIC,1,union mpu6050_data)
#define GET_TEMP _IOR(MPU6050_MAGIC,2,union mpu6050_data)#endifmpu6050_drv.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>#include "mpu6050.h"#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 PWR_MGMT_1 0x6Bint 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_read_byte(struct i2c_client *pclt,unsigned char reg)
{int ret = 0;char txbuf[1] = {reg};char rxbuf[1] = {0};struct i2c_msg msg[2] = {{pclt->addr,0,1,txbuf},{pclt->addr,I2C_M_RD,1,rxbuf}};ret = i2c_transfer(pclt->adapter,msg,ARRAY_SIZE(msg));if(ret < 0){printk("ret = %d,in mpu6050_read_byte\n",ret);return ret;}return rxbuf[0];
}int mpu6050_write_byte(struct i2c_client *pclt,unsigned char reg,unsigned char val)
{int ret = 0;char txbuf[2] = {reg,val};struct i2c_msg msg[1] = {{pclt->addr,0,2,txbuf},};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;
}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)
{return 0;
}long mpu6050_ioctl(struct file *pfile,unsigned int cmd,unsigned long 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 -EINVAL;}if(copy_to_user((void *)arg,&data,sizeof(data))){return -EFAULT;}return sizeof(data);
}void init_mpu6050(struct i2c_client *pclt)
{mpu6050_write_byte(pclt,PWR_MGMT_1,0x00);mpu6050_write_byte(pclt,SMPLRT_DIV,0x07);mpu6050_write_byte(pclt,CONFIG,0x06);mpu6050_write_byte(pclt,GYRO_CONFIG,0xF8);mpu6050_write_byte(pclt,ACCEL_CONFIG,0x19);
}struct file_operations myops = {.owner = THIS_MODULE,.open = mpu6050_open,.release = mpu6050_close,.unlocked_ioctl = mpu6050_ioctl,
};static int mpu6050_probe(struct i2c_client *pclt,const struct i2c_device_id *pid)
{int ret = 0;dev_t devno = MKDEV(major,minor);/*申请设备号*/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(NULL == pgmydev){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,mpu6050_num);init_mpu6050(pgmydev->pclt);return 0;
}static int mpu6050_remove(struct i2c_client *pclt)
{dev_t devno = MKDEV(major,minor);cdev_del(&pgmydev->mydev);unregister_chrdev_region(devno,mpu6050_num);kfree(pgmydev);pgmydev = NULL;return 0;
}struct of_device_id mpu6050_dt[] =
{{.compatible = "invensense,mpu6050"},{}
};struct i2c_device_id mpu6050_ids[] =
{{"mpu6050",0},{}
};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,
};#if 0
int __init mpu6050_driver_init(void)
{i2c_add_driver(&mpu6050_driver);
}void __exit mpu6050_driver_exit(void)
{i2c_del_driver(&mpu6050_driver);
}
module_init(mpu6050_driver_init);
module_exit(mpu6050_driver_exit);
#else
module_i2c_driver(mpu6050_driver);
#endifMODULE_LICENSE("GPL");testapp.c
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>#include <stdio.h>#include "mpu6050.h"int main(int argc,char *argv[])
{int fd = -1;union mpu6050_data data;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDONLY);if(fd < 0){printf("open %s failed \n",argv[1]);return 2;}while(1){sleep(2);ioctl(fd,GET_ACCEL,&data);printf("Accel-x=0x%x\n",data.accel.x);printf("Accel-y=0x%x\n",data.accel.y);printf("Accel-z=0x%x\n",data.accel.z);ioctl(fd,GET_GYRO,&data);printf("Gyro-x=0x%x\n",data.gyro.x);printf("Gyro-y=0x%x\n",data.gyro.y);printf("Gyro-z=0x%x\n",data.gyro.z);ioctl(fd,GET_TEMP,&data);printf("Temp=0x%x\n",data.temp);printf("\n");}close(fd);fd = -1;return 0;
}输出结果：
相关文章：
I2C总线驱动：裸机版、应用层的使用、二级外设驱动三种方法
一、I2C总线背景知识 SOC芯片平台的外设分为： 一级外设：外设控制器集成在SOC芯片内部二级外设：外设控制器由另一块芯片负责，通过一些通讯总线与SOC芯片相连 Inter-Integrated Circuit： 字面意思是用于“集成电路之间…...
Unix Network Programming Episode 77
‘gethostbyaddr’ Function The function gethostbyaddr takes a binary IPv4 address and tries to find the hostname corresponding to that address. This is the reverse of gethostbyname. #include <netdb.h> struct hostent *gethostbyaddr (const char *addr…...
解决Ubuntu无法安装pycairo和PyGObject
环境：虚拟机Ubuntu20.04，vscode无法安装pycairo和PyGObject 虚拟机Ubuntu20.04，vscode中运行Anaconda搭建的vens 的Python3.8.10 首先在vscode中点击ctrlshiftp，选择Python3.8.10的环境，自动激活Python 最近在搞无人…...
Android Handler 机制解析
1、前言 在 Android 开发中，Handler 的机制和运行原理这方面的知识可以说是每个人都需要熟悉的。这不仅是因为 Handler 是 Android 应用的基石之一，也因为 Handler 整体设计上也是十分优秀的。接下来我就梳理总结一下常见的 Handler 相关知识点。 2、基…...
酒店固定资产管理怎么分类
在酒店业中，固定资产的管理是至关重要的一环。它不仅影响到企业的运营效率和盈利能力，而且直接影响到客户体验和品牌形象。因此，对于酒店管理者来说，合理、有效地进行固定资产管理是一项必不可少的任务。本文将探讨酒店固定资产的…...
OpenCV（三十一）：形态学操作
1.形态学操作 OpenCV 提供了丰富的函数来进行形态学操作，包括腐蚀、膨胀、开运算、闭运算等。下面介绍一些常用的 OpenCV 形态学操作函数： 腐蚀操作（Erosion）： erode(src, dst, kernel, anchor, iteration…...
Python之面向对象(二)
目录 属性和方法静态属性/方法、普通属性/方法、类方法保护和私有属性/方法魔术方法构造方法(\_\_new__/\_\_init\_\_)析构方法(\_\_del__)调用方法（\_\_call__）toString方法\_\_str__、\_\_repr\_\_\_\_getitem__、setitem、delitem\_\_add__、\_\_gt\_…...
ESP32用作经典蓝牙串口透传模块与手机进行串口通信
ESP32用作经典蓝牙串口透传模块与手机进行串口通信 简介ESP32开发板Arduino程序手机与ESP32开发板进行蓝牙串口透传通信总结 简介 ESP32-WROOM-32模组集成了双模蓝牙包括传统蓝牙（BR/EDR）、低功耗蓝牙（BLE）和 Wi-Fi，具…...
Python 操作 CSV
使用过 CSV 文件都知道：如果我们的电脑中装了 WPS 或 Microsoft Office 的话，.csv 文件默认是被 Excel 打开的，那么什么是 CSV 文件？CSV 文件与 Excel 文件有什么区别？如何通过 Python 来操作 CSV 文件呢？带…...
自动化运维工具Ansible教程(二)【进阶篇】
文章目录 前言Ansible 入门到精通自动化运维工具Ansible教程(一)【入门篇】自动化运维工具Ansible教程(二)【进阶篇】精通篇 进阶篇1. Ansible 的高级主题（例如：角色、动态清单、变量管理等）**1. 角色（Roles）**&#x…...
嵌入式Linux基础学习笔记目录
1. 嵌入式Linux应用开发基础知识 1.1 交叉编译 1.2 GCC编译器 1.3 makefire 1.4 文件I/O 1.5 Framebuffer应用编程 1.6 文字显示及图象显示 1.7 输入系统应用编程 1.8 网络编程 1.9 多线程编程 1.10 串口编程 1.11 I2C应用编程 2. 源码分析 2.1 MQTT源码 2.2 蓝牙源码 2.3 MJP…...
JVM | 垃圾回收器（GC）- Java内存管理的守护者
引言 在编程世界中，有效的内存管理是至关重要的。这不仅确保了应用程序的稳定运行，还可以大大提高性能和响应速度。作为世界上最受欢迎的编程语言之一，通过Java虚拟机内部的垃圾回收器组件来自动管理内存，是成为之一的其中一项必…...
yolov5添加ECA注意力机制
ECA注意力机制简介 论文题目：ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks 论文地址：here 基本原理 🐸 ECANet的核心思想是提出了一种不降维的局部跨通道交互策略，有效避免了降维对于通道注意…...
华为在高端智能手机市场再次撕开了一道深深的口子
智能手机市场趋于饱和，增长变得越来越难，智能手机厂商从被动卷走向了主动卷。 8月29日，华为宣布推出“HUAWEI Mate 60 Pro先锋计划”，并于当天中午在官方商城、部分线下门店上线销售新机Mate 60 Pro，它是全球首款支持卫…...
前端设计模式和设计原则之设计模式
作为前端开发，在code时，或多或少地都会践行设计模式，但是你清楚自己用到的是何种设计模式吗？ 为什么前端开发一定要懂设计模式呢？ code时不遵从设计模式，又能怎样呢？ 上面的问题可以留作思考…...
提高在速卖通产品上的曝光率——自养号测评优势全面解析！
速卖通是国际贸易的一个平台，是国内外企业之间的一个桥梁。在速卖通中，如果要让产品得到更好地推广，就必须让产品得到更多的消费者认可。而产品的认可度除了品质保障和售后服务之外，评测也是非常重要的环节。 对于速卖通店铺销量…...
指针进阶（二）
指针进阶 5.函数指针6. 函数指针数组7. 指向函数指针数组的指针8. 回调函数案例：使用回调函数，模拟实现qsort（采用冒泡的方式）。案例：测试qsort排序结构体数据 5.函数指针 补： &函数名就是函数的地址 …...
【HCIE】03.BGP高级特性
每一条BGP路由都可以携带多个路径属性，针对其属性也有特有的路由匹配工具，包括：AS Path Filter和Community Filter。 import方向的属性，出现在如策略里面，加入到BGP路由表中，再传给路由表里，出去…...
单个处理数据祖籍列表层级关系
CREATE DEFINERroot% FUNCTION sys_organization_getAncestorsNames(deptId varchar(36)) RETURNS varchar(1000) CHARSET utf8DETERMINISTIC BEGINDECLARE parentDeptId varchar(36) default ; -- 父部门iddeclare parentDeptName varchar(100) default ; -- 父部门名称decla…...
Maven部署打包多环境（开发、测试、生产）配置教程
Maven打包多环境（开发、测试、生产）配置教程 1、多环境配置的必要性1.1 没有进行多环境配置进行的操作复杂性1.2 不影响运行时配置 2、配置方案2.1 添加profile属性2.1 添加两个插件2.3 主配置文件中添加插值变量 3、效果展示3.1 勾选prod环境3.2 控制台…...
【计算思维题】少儿编程 蓝桥杯青少组计算思维 数学逻辑思维真题详细解析第9套
蓝桥杯青少组计算思维 数学逻辑思维真题详细解析第9套 第十四届蓝桥杯省赛真题 1、要把下面4张图片重新排列成蜗牛的画像，该如何排列这些图片 A、 B、 C、 D、 答案：A 考点分析：主要考查小朋友们的观察能力空...
【Hello Algorithm】贪心算法
本篇博客介绍： 简单介绍下贪心算法 贪心算法 介绍贪心算法最小字典序的字符串拼接最多会议数切棍子的最小成本IPO灯塔问题 介绍贪心算法 贪心算法是一种极具有自然智慧的算法 它会使用以一种局部最功利的标准来做出一个当前看来最好的选择 如果说我们根据局部最优…...
TOP-K问题
目录 问题描述 解法及思想 第一种方式 算法思想 具体实现 第二种方式 算法思想 具体实现 问题描述 Top-K问题是一个十分经典的问题，一般有以下两种方式来描述问题： 在10亿的数字里，找出其中最大的100个数；在一个包含n个整…...
【保姆级从0到1】UE5 蓝图入门教程1：关卡、蓝图入门
20230113 1、新建项目 新建选择 UE 5.1 项目 选择蓝图，项目位置 改变编辑器布局，选择经典布局 2、关卡与蓝图 选择 File -> New Level 准备创建关卡 选择 Basic，点击 Create 进行创建 Ctrl S 保存新建的关卡 关卡蓝图的打开 鼠标右键&…...
【码银送书第六期】《ChatGPT原理与实战：大型语言模型的算法、技术和私有化》
写在前面 2022年11月30日，ChatGPT模型问世后，立刻在全球范围内掀起了轩然大波。无论AI从业者还是非从业者，都在热议ChatGPT极具冲击力的交互体验和惊人的生成内容。这使得广大群众重新认识到人工智能的潜力和价值。对于AI从业者来说…...
redis 报错 Redis protected-mode 配置文件没有真正启动
(error) DENIED Redis is running in protected mode because protected mode is enabled Redis protected-mode 是3.2 之后加入的新特性，在Redis.conf的注释中，我们可以了解到，他的具体作用和启用条件 链接redis 时只能通过本地localhost …...
解决a标签内容中img标签和p标签垂直方向间隔太大的问题
现象如下： 对应的html结构： 解决办法：给a标签设置：display: inline-block和line-height属性。 然后问题解决： 具体原理如下（由chatgpt回答）： display: inline-block 可以减少垂直方…...
如何选择靠谱的全景平台？VR全景加盟从哪方面对比？
VR全景行业经过近几年的发展，已经逐渐普及开来，线下各个行业都有实体商家开始引入VR全景去做营销宣传推广了。不少老板也意识到线上线下双渠道的重要性，而VR全景的存在就刚好满足各行各业的需求，从这一点不难看出，VR全…...
CentOS系统环境搭建（十八）——CentOS7安装Docker20.10.12和docker compose v2
centos系统环境搭建专栏🔗点击跳转 CentOS7安装Docker20.10.12和docker compose v2 关于Docker旧版本和docker compose1.0版本的安装可以看这一篇CentOS系统环境搭建（三）——Centos7安装Docker&Docker Compose。 1.卸载旧版本 卸载do…...
NebulaGrap入门介绍和集群安装部署
长风破浪八千里，落日晚霞不回头。 ——大宁。 NebulaGrap——分布式图数据库 官方文档： NebulaGraph Database手册 官方文档 介绍 简介： NebulaGraph 一款开源、分布式图数据库，擅长处理超大规模数据集。 Nebula …...
免费的x网站域名/最近有新病毒出现吗
MySQL数据库、Qt数据库、MySQLworkbench1、Qt中的数据库编程：1、在Qt中，所有和数据库编程相关的类都归在命名空间QSql中，这些类主要包含：QSqlDriver(数据库驱动)、QSqlDatabase(数据库)、QSqlQuery(数据库在线操作)2、QSqlDriver(…...
wordpress 防火墙/百度百科词条
a转载于:https://www.cnblogs.com/menggucaoyuan/archive/2013/04/23/3036903.html...
移动互联网 商业模式/seo网站推广下载
嵌入式FPGA的未来是怎么样的？ 描述 据半导体行业观察了解，目前国内有多家FPGA公司在做eFPGA的相关业务，但eFPGA的利润比FPGA要少很多，他们的逻辑是什么？据业内专业人士指出，eFPGA相当于FPGA内核IP授权&am…...
学做网站的书籍/百度云资源链接分享群组
时间：2014.04.29 地点：基地二楼 ---------------------------------------------------------------------------------------------- 一、题目 定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。如把字符串abcdef左旋转…...
wordpress添加端口访问不了/软文大全
1.C#中的垃圾回收机制是怎样的？垃圾回收器是用来管理应用程序的内存分配和释放的。当一个应用程序在运行的时候，垃圾回收器设置了一个托管堆。每次当开发人员使用 new 运算符创建对象时，运行库都从托管堆为该对象分配内存。新创建的对象被放在…...
企业标志logo/seo课堂
目录 一、String 对象 1、属性 2、常用方法 二、Array 对象 1、属性 2、常用方法 三、Date 日期对象 1、创建 Date 日期对象 2、常用方法 四、Math 对象 一、String 对象 1、属性 length：表示字符串的长度 2、常用方法 【1】与 HTML 相关的方法 bold(…...