Linux驱动 | MPU6050驱动(I2C)

最新推荐文章于 2024-05-13 17:16:29 发布
最新推荐文章于 2024-05-13 17:16:29 发布
阅读量1.5k 收藏 16
点赞数 3
分类专栏： Linux设备驱动 文章标签： linux驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36413982/article/details/123400692
版权

MPU6050

2. MPU6050模块 — [野火]STM32模块例程介绍 文档
https://doc.embedfire.com/module/module_tutorial/zh/latest/Module_Manual/iic_class/mpu6050.html

Linux驱动 = 硬件操作 + 驱动框架
所以对于MPU6050的原理和驱动代码实现参考单片机的即可。

MPU6050驱动实现

设备树

设备树参考： 可参考NXP公板的设备树的I2C节点

&i2c1 {
	clock-frequency = <100000>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_i2c1>;
	status = "okay";
	...
	mag3110@e {
		compatible = "fsl,mag3110";
		reg = <0xe>;
		position = <2>;
	};

	fxls8471@1e {
		compatible = "fsl,fxls8471";
		reg = <0x1e>;
		position = <0>;
		interrupt-parent = <&gpio5>;
		interrupts = <0 8>;
	};
};
  • mag3110和fxls8471是NXP公板上挂在I2C1的两个芯片

编写设备树：
在imx6ull-mmc-npi.dts文件中添加节点：

&i2c1 {	
	clock-frequency = <100000>; 
	pinctrl-names = "default"; 
	pinctrl-0 = <&pinctrl_i2c1>;   
	status = "okay"; 
	#address-cells = <1>;
	#size-cells = <0>;    
   /* 设备树修改查看是否修改成功，查看内核目录/sys/bus/i2c/devices/看是否存在0x1E地址的设备 */
	
	mpu6050@68 {
		compatible = "xgj,mpu6050";
		status = "okay"; 
		reg = <0x68>;
		interrupt-parent = <&gpio5>;
		interrupts = <0 IRQ_TYPE_LEVEL_LOW>;
	};          
};

因为mpu6050芯片是挂载在i2c1，将其设备节点追加在i2c节点下

  • compatible ，驱动根据该值和设备树进行匹配
  • reg， i2c设备地址
  • interrupt-parent，芯片中断脚在哪个中断控制器下
  • interrupts ,中断引脚号0和IRQ_TYPE_LEVEL_LOW低电平触发

设备树编译：

ares@ubuntu:~/work/ebf_linux_kernel-ebf_4.19.35_imx6ul$ cat make_dtb.sh
#!/bin/sh

make ARCH=arm -j4 CROSS_COMPILE=arm-linux-gnueabihf- dtbs

将设备树拷贝系统目录：

debian@npi:~/nfs_root/driver$ cat cp_dtb_to_linux.sh
#!/bin/sh

sudo cp imx6ull-mmc-npi.dtb /usr/lib/linux-image-4.19.35-carp-imx6/
  • /usr/lib/linux-image-4.19.35-carp-imx6/ ，系统存放设备树的目录

重启系统设备树生效：

sudo reboot

通过查看系统目录 /sys/firmware/devicetree/base/ 看是否存在mpu6050的设备树节点判定设备树是否生效

驱动编写

1、MPU6050硬件操作

这部分内容和单片机程序差不多。

mpu6050_def.h ：

#ifndef _MPU6050_DEF_H_
#define _MPU6050_DEF_H_

typedef unsigned char   uint8_t;

/* register define */
#define MPU6050_SMPLRT_DIV                                  0x19     /* */
#define MPU6050_CONFIG                                      0x1A    
#define MPU6050_GYRO_CONFIG                                 0x1B
#define MPU6050_ACCEL_CONFIG                                0x1C
#define MPU6050_ACCEL_XOUT_H                                0x3B
#define MPU6050_ACCEL_XOUT_L                                0x3C
#define MPU6050_ACCEL_YOUT_H                                0x3D
#define MPU6050_ACCEL_YOUT_L                                0x3E
#define MPU6050_ACCEL_ZOUT_H                                0x3F
#define MPU6050_ACCEL_ZOUT_L                                0x40
#define MPU6050_TEMP_OUT_H                                  0x41
#define MPU6050_TEMP_OUT_L                                  0x42
#define MPU6050_GYRO_XOUT_H                                 0x43
#define MPU6050_GYRO_XOUT_L                                 0x44
#define MPU6050_GYRO_YOUT_H                                 0x45
#define MPU6050_GYRO_YOUT_L                                 0x46
#define MPU6050_GYRO_ZOUT_H                                 0x47
#define MPU6050_GYRO_ZOUT_L                                 0x48
#define MPU6050_PWR_MGMT_1                                  0x6B       /* power managemnt register */
#define MPU6050_WHO_AM_I                                    0x75       /* default value :  IIC addr 0x68 */

/* interrupt status register */
#define MPU6050_INT_STATUS                                  0x3A
#define MPU6050_INT_ENABLE                                  0x38
#define MPU6050_INT_PIN_CFG                                 0x37

// #define I2C_RETRIES                                 0x0701
// #define I2C_TIMEOUT                                 0x0702
// #define I2C_SLAVE                                   0x0703             //IIC从器件的地址设置
// #define I2C_BUS_MODE                                0x0780

// #define MPU6050_SlaveAddress                                  0xD0
// #define MPU6050_IIC_ADDR                                      0x68                  //MPU6050 IIC Address

struct mpu6050_accel {
    short x;
    short y;
    short z;
};

struct mpu6050_gyro {
    short x;
    short y;
    short z;
};

struct mpu6050_data {
    struct mpu6050_accel accel;
    struct mpu6050_gyro gyro;
};

#endif /* _MPU6050_DEF_H_ */


static int mpu6050_i2c_write_reg(struct i2c_client *client, uint8_t reg_addr, uint8_t data)
{
    int ret = 0;
    uint8_t w_buf[2];

    struct i2c_msg msg;

    w_buf[0] = reg_addr;
    w_buf[1] = data;

    msg.addr = client->addr;
    msg.buf = w_buf;
    msg.flags = 0; /* I2C direction ： write */
    msg.len = sizeof(w_buf);

    ret = i2c_transfer(client->adapter, &msg, 1);
    if (ret < 0)
        return ret;
    else if (ret != 1)
        return -EIO;

    return 0;
}

static int mpu6050_i2c_read_reg(struct i2c_client *client, uint8_t reg_addr, uint8_t *data)
{
    int ret = 0;
    struct i2c_msg msgs[2];

    msgs[0].addr = client->addr;
    msgs[0].buf = &reg_addr; /* send regsiter */
    msgs[0].flags = 0;       /* I2C direction ： write */
    msgs[0].len = 1;

    msgs[1].addr = client->addr;
    msgs[1].buf = data;       /* 读取寄存器数据 */
    msgs[1].flags = I2C_M_RD; /* I2C direction ： read */
    msgs[1].len = 1;

    ret = i2c_transfer(client->adapter, msgs, 2); /* */
    if (ret < 0)
        return ret;
    else if (ret != 2)
        return -EIO;

    return 0;
}

static int mpu6050_init(void)
{
    uint8_t reg_val = 0;
    int ret = 0;

    /* 解除休眠状态 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_PWR_MGMT_1, 0x00); /*  */

    /*  陀螺仪采样频率输出设置 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_SMPLRT_DIV, 0x07);

    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_CONFIG, 0x06);

    /* 配置加速度传感器工作在 16G 模式, 不自检 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_ACCEL_CONFIG, 0x18);

    /* 陀螺仪自检及测量范围，典型值：0x18(不自检，2000deg/s) */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_GYRO_CONFIG, 0x18);
#if MPU6050_USE_INT 
    /* 配置中断产生时中断引脚为低电平 */
    ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_INT_PIN_CFG, &reg_val);
    reg_val |= 0xC0;
    mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_INT_PIN_CFG, reg_val);

    /* 开启数据就绪中断 */
    ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_INT_ENABLE, &reg_val);
    reg_val |= 0x01;
    mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_INT_ENABLE, reg_val);
#endif
    return ret;
}

static int mpu6050_deinit(void)
{
    int ret = 0;
    /* mpu6050复位, 寄存器恢复默认值 */
    ret = mpu6050_i2c_write_reg(mpu6050_dev->client, MPU6050_PWR_MGMT_1, 0x80);
    return ret;
}

static int mpu6050_read_id(uint8_t *id)
{
    uint8_t data;
    int ret = 0;

    ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_WHO_AM_I, &data);

    if (id != NULL)
        *id = data;

    if (data != MPU6050_IIC_ADDR)
        ret = -1;

    return ret;
}

static int mpu6050_read_accel(struct mpu6050_accel *acc)
{
    int i = 0;
    int ret = 0;
    uint8_t data[6] = {0};

    for (i = 0; i < 6; i++)
    {
        ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_ACCEL_XOUT_H+i, &data[i]);
    }
    acc->x = (data[0] << 8) + data[1];
    acc->y = (data[2] << 8) + data[3];
    acc->z = (data[4] << 8) + data[5];
    return ret;
}

static int mpu6050_read_gyro(struct mpu6050_gyro *gyro)
{
    int i = 0;
    int ret = 0;
    uint8_t data[6] = {0};

    for (i = 0; i < 6; i++)
    {
        ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_GYRO_XOUT_H+i, &data[i]);
    }
    gyro->x = (data[0] << 8) + data[1];
    gyro->y = (data[2] << 8) + data[3];
    gyro->z = (data[4] << 8) + data[5];
    return ret;
}

static int mpu6050_read_temp(short *temp)
{
    int i = 0;
    int ret = 0;
    uint8_t data[2] = {0};

    for (i = 0; i < 2; i++)
    {
        ret = mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_TEMP_OUT_H+i, &data[i]);
    }
    *temp = (data[0] << 8) + data[1];
    return ret;
}

2、linux I2C 驱动框架

在测试使用中断实现，发现中断触发太快和直接读取也没啥区别。

struct mpu6050_device
{
    int irq; /* 中断号 */
    int gpio;
    dev_t dev_no; /* 设备号 */
    struct cdev chrdev;
    struct class *class;
    struct mutex m_lock;
    wait_queue_head_t wq; /* 等待队列 */
    struct mpu6050_data data;
    struct i2c_client *client;
};

static struct mpu6050_device *mpu6050_dev;

static int _drv_open(struct inode *node, struct file *file)
{
    uint8_t id;
    int ret = 0;

    file->private_data = mpu6050_dev;

    ret = mpu6050_init();
    if (ret != 0)
    {
        printk("%d-%s init failed %d\r\n", __LINE__, __FUNCTION__, ret);
        return -ENXIO;
    }

    if (mpu6050_read_id(&id) != 0)
    {
        printk("don't find %s %d\r\n", DEV_NAME, id);
        return -ENXIO;
    }

    gpio_direction_input(mpu6050_dev->gpio);

    printk("%s open %d\r\n", DEV_NAME, __LINE__);
    return 0;
}

static ssize_t _drv_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    int ret;
    int data_size;
    struct mpu6050_device *tmp_mpu6050 = filp->private_data;
    struct mpu6050_data data;
    
    data_size = sizeof(data);
    if (size != data_size)
        return -EINVAL;
#if MPU6050_USE_INT == 0
    ret = mpu6050_read_accel(&data.accel);

    ret = mpu6050_read_gyro(&data.gyro);
#else

#endif
    if (copy_to_user(buf, &data, sizeof(data)))
    {
        ret = -EFAULT;
    }
    else
    {
        ret = data_size;
    }
    return ret;
}

/* 使驱动支持多路复用IO */
static __poll_t _drv_poll(struct file *filp, struct poll_table_struct *wait)
{
    __poll_t mask = 0;

    // mutex_lock(&mpu6050_dev->m_lock);

    // poll_wait(filp, &mpu6050_dev->wq, wait);

    // mutex_unlock(&sr501.m_lock);

    return mask;
}

static long _drv_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int ret = 0;
    uint8_t result = 0;
    short buf[3];
    void __user *user_space = (void __user *)arg;

    switch (cmd)
    {
        case MPU6050_CMD_GET_ID:
            ret = mpu6050_read_id(&result);
            ret = copy_to_user(user_space, &result, sizeof(result));
            break;
        case MPU6050_CMD_GET_ACCEL:
            ret = mpu6050_read_accel((struct mpu6050_accel *)&buf);
            ret = copy_to_user(user_space, &buf, sizeof(buf));
            break;
        case MPU6050_CMD_GET_GYRO:
            ret = mpu6050_read_gyro((struct mpu6050_gyro *)&buf);
            ret = copy_to_user(user_space, &buf, sizeof(buf));
            break;
        case MPU6050_CMD_GET_TEMP:
            ret = mpu6050_read_temp(&buf[0]);
            ret = copy_to_user(user_space, &buf[0], 2);
            break;
    }

    return ret;
}

static int _drv_release(struct inode *node, struct file *filp)
{
    int ret = 0;
    struct mpu6050_device *tmp_mpu6050 = filp->private_data;

    ret = mpu6050_deinit();  
    return ret;
}

static struct file_operations mpu6050_drv_ops = {
    .owner = THIS_MODULE,
    .open = _drv_open,
    .read = _drv_read,
    .poll = _drv_poll,
    .release = _drv_release,
};

static irqreturn_t mpu6050_isr(int irq, void *dev)
{
    uint8_t reg_val;
    // printk("%s %d %s\n", __FILE__, __LINE__, __FUNCTION__);
    mpu6050_i2c_read_reg(mpu6050_dev->client, MPU6050_INT_STATUS, &reg_val);
    if (reg_val & 0x01)     
    {
        /* 唤醒进程去读取数据 */

        printk("data ready\n");
    }
    return IRQ_RETVAL(IRQ_HANDLED);
}

probe和remove函数实现：

static int _driver_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int err = 0;
    // int ret = 0;
    struct device *_dev;
    struct device_node *_dts_node;

    mpu6050_dev = (struct mpu6050_device *)kzalloc(sizeof(struct mpu6050_device), GFP_KERNEL);
    if (!mpu6050_dev)
    {
        printk("can't kzalloc mpu6050 dev\n");
        return -ENOMEM;
    }

    _dts_node = client->dev.of_node;
    if (!_dts_node)
    {
        printk("mpu6050 dts node can not found!\r\n");
        err = -EINVAL;
        goto out_free_dev;
    }

    mpu6050_dev->client = client;

    printk("mpu6050 dtsirq %d !\r\n", client->irq);
#if 1
    // mpu6050_dev->gpio = of_get_named_gpio(_dts_node, AP3216C_READY_GPIO_NAME, 0);   /* 获取gpio */
    // if (!gpio_is_valid( mpu6050_dev->gpio)) {
    //     printk("don't get mpu6050 ready gpio!\n");
    // 	err = -EINVAL;
    //     goto out_free_dev;
    // }

    // mpu6050_dev->irq = gpio_to_irq( mpu6050_dev->gpio);                              /* 通过gpio得到irq */

    // gpiod_direction_input(mpu6050_dev->gpio);          /* 设置gpio为输入 */
    mpu6050_dev->irq = client->irq;
    // mpu6050_dev->gpio = irq_to_gpio(mpu6050_dev->irq);
    err = request_irq(mpu6050_dev->irq, mpu6050_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, DEV_NAME, NULL); /* 申请中断 */
    if (err)
    {
        printk(KERN_INFO "failed to request irq %d\r\n", mpu6050_dev->irq);
        goto out_free_dev;
    }
    /* 内核自动分配设备号 */
    err = alloc_chrdev_region(&mpu6050_dev->dev_no, 0, 1, DEV_NAME);
    if (err < 0)
    {
        pr_err("Error: failed to register mbochs_dev, err: %d\n", err);

        goto out_free_irq;
    }

    cdev_init(&mpu6050_dev->chrdev, &mpu6050_drv_ops);
    err = cdev_add(&mpu6050_dev->chrdev, mpu6050_dev->dev_no, 1);
    if (err)
    {
        goto out_unregister;
    }

    mpu6050_dev->class = class_create(THIS_MODULE, DEV_NAME);
    if (IS_ERR(mpu6050_dev->class))
    {
        err = PTR_ERR(mpu6050_dev->class);
        goto out_cdev_del;
    }

    /* 创建设备节点 */
    _dev = device_create(mpu6050_dev->class, NULL, mpu6050_dev->dev_no, NULL, DEV_NAME);
    if (IS_ERR(_dev))
    { /* 判断指针是否合法 */
        err = PTR_ERR(_dev);
        goto out_class_del;
    }

    // mutex_init(&mpu6050_dev->m_lock);                 /* 初始化互斥锁  */

    printk("%s probe success\r\n", DEV_NAME);

    goto out;

out_class_del:
    class_destroy(mpu6050_dev->class);
out_cdev_del:
    cdev_del(&mpu6050_dev->chrdev);
out_unregister:
    unregister_chrdev_region(mpu6050_dev->dev_no, 1); /* 注销设备 */
out_free_irq:
    free_irq(mpu6050_dev->irq, NULL);
out_free_dev:
    kfree(mpu6050_dev);
    mpu6050_dev = NULL;
out:
#endif
    return err;
}

static int _driver_remove(struct i2c_client *client)
{
    device_destroy(mpu6050_dev->class, mpu6050_dev->dev_no);
    class_destroy(mpu6050_dev->class);
    cdev_del(&mpu6050_dev->chrdev);
    unregister_chrdev_region(mpu6050_dev->dev_no, 1); /* 注销设备 */
    free_irq(mpu6050_dev->irq, NULL); /* 释放中断*/
    kfree(mpu6050_dev);
    printk(KERN_INFO "%s success\n", DEV_NAME);

    return 0;
}
  • remove函数只要做一些清理工作，删除设备、删除class、注销设备以及释放内存等。

出口入口函数实现 ：

/* 设备树的匹配列表 */
static struct of_device_id dts_match_table[] = {
    {.compatible = MPU6050_DTS_COMPATIBLE}, /* 通过设备树来匹配 */
    {},
};

/* 传统匹配方式 ID 列表 ，即使不使用也要添加，不然probe匹配不成功 */
static const struct i2c_device_id mpu6050_id[] = {
    {MPU6050_DTS_COMPATIBLE, 0},
    {},
};

static struct i2c_driver mpu6050_driver = {
    .probe = _driver_probe,
    .remove = _driver_remove,
    .driver = {
        .name = MPU6050_DTS_COMPATIBLE,
        .owner = THIS_MODULE,
        .of_match_table = dts_match_table, /* 通过设备树匹配 */
    },
    .id_table = mpu6050_id,
};

/* 入口函数 */
static int __init _driver_init(void)
{
    int ret = 0;

    ret = i2c_add_driver(&mpu6050_driver); /* 注册I2C驱动 */
    printk("%s %s\n", DEV_NAME, __FUNCTION__);
    return ret;
}

/*  出口函数 */
static void __exit _driver_exit(void)
{
    printk("%s driver %s\n", DEV_NAME, __FUNCTION__);
    i2c_del_driver(&mpu6050_driver); /* 注销I2C驱动 */
}

module_init(_driver_init);
module_exit(_driver_exit);

MODULE_AUTHOR("Ares");
MODULE_LICENSE("GPL");

测试的app程序编写

#include "stdio.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <stdint.h>

#define DEV_NAME   "/dev/mpu6050"

struct mpu6050_accel {
    short x;
    short y;
    short z;
};

struct mpu6050_gyro {
    short x;
    short y;
    short z;
};

struct mpu6050_data {
    struct mpu6050_accel accel;
    struct mpu6050_gyro gyro;
};


void sleep_ms(unsigned int ms)
{
    struct timeval delay;
	delay.tv_sec = 0;
	delay.tv_usec = ms * 1000; 
	select(0, NULL, NULL, NULL, &delay);
}

int main(int argc, char **argv)
{
    int fd;
    int ret;
  
	/* 2. 打开文件 */
	fd = open(DEV_NAME, O_RDWR | O_NONBLOCK);   // | O_NONBLOCK

	if (fd < 0)
	{
		printf("can not open file %s, %d\n", DEV_NAME, fd);
		return -1;
	}
     
	struct mpu6050_data   mpu6050_data;
	int size = sizeof(struct mpu6050_data);

	printf("read size %d\n", size);

	while (1)
	{
		if (read(fd, &mpu6050_data, size) == size)
		{
			printf("accel x %d y %d z %d\r\n", mpu6050_data.accel.x, mpu6050_data.accel.y, mpu6050_data.accel.z);
			printf("gyro x %d y %d z %d\r\n", mpu6050_data.gyro.x, mpu6050_data.gyro.y, mpu6050_data.gyro.z);
		}
		printf("running\r\n");
		sleep_ms(500);
	}
    
	close(fd);
    
    return 0;
}
欲盖弥彰1314
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
【ARM】Linux内核驱动之I2C线驱动，读取MPU6050驱动
凉开水白菜的博客
10-02 235
i2c总线其实和platform总线的内容非常像，本质上i2c总线模型也是基于platform总线模型编写而来，本章内容可以结合platform那章的内容联合观看可以更加容易理解；i2c_board_info用于建立列出i2c设备的信息表，描述i2c相关的资源，其中 type 和 addr 这两个成员变量是必须要设置的， 一个是 I2C 设备的名字， 一个是 I2C 设备的器件地址；int irq;
linux驱动移植-I2C设备驱动移植（MPU6050）
Graceful_scenery的博客
02-22 66
MPU6050待定，这个比较常用。
[Linux] 驱动IIC外设——MPU6050
最新发布
qq_65198598的博客
05-13 165
使用Linux开发板有时不只需要在内部操作，还有大部分情况需要与外界传感器进行交互，在这篇文章为大家交流使用IIC与外界设备交互。
linux下mpu6050驱动
darcsdn
05-03 1275
linux下mpu6050驱动 代码 先上代码： github仓库链接 gitee仓库链接 设备树 在i2c的控制器下追加该设备 &i2c2 { clock_frequency = <100000>; pinctrl-names = "default"; pinctrl-0 = <&pinctrl_i2c2>; status = "okay"; mpu6050:mpu6050@68 { compatible = "dar,mpu6050"; re
#Linux系统，目标机ARM（exynos_4412）对MPU6050数据获取
m0_68738086的博客
10-21 218
exynos_4412中mpu6050-----I2C_SDA5和I2C_SCL5与芯片连接，通过芯片控制对应的i2c就可以与mpu6050传输数据，芯片i2c引脚，GPB_2,GPB_3。看说明书是第一步，才能让我们知道要控制那几个寄存器，读那几个数据位，地址是什么等等信息。要根据I2c的协议要求写。然后在main下执行函数。
esp32系列(10)：mpu6050驱动
w0shishabi的博客
03-12 3343
目录1 mpu6050 学习1.1 概述1.2 引脚1.3 关于中断信号1.4 I2C通信协议2 mpu6050驱动2.1 初始化配置2.2 获取数据2.3 测试工程3 预告 1 mpu6050 学习 1.1 概述 MPU-60X0： 具有嵌入式3轴MEMS陀螺仪、3轴MEMS加速度计和数字运动处理器（Digital Motion Processor，DMP）硬件加速器引擎，带有辅助I2C端口。 三个16位模数转换器（ADC），用于采样陀螺仪的输出。 三个16位模数转换器（ADC），用于采样加速度计的输出
基于linux i2c设备驱动 mpu6050 demo
02-09
程序测试，能够运行。希望对大家有帮助。
mpu6050 i2c驱动及测试程序
07-03
讲述Mpu6050陀螺仪i2c驱动，包含测试例程，很好的学习资料，节省开发时间
i2c.tar.gz
09-14
linux i2c驱动访问 mpu9250 ,包括 dts文件和linux驱动源码
基于linux内核的i2c子系统驱动开发.pdf
09-06
本文将深入探讨如何基于Linux 3.14内核开发I2C子系统的驱动程序，以实现对MPU6050传感器等I2C设备的控制。 **I2C子系统原理** I2C通信协议的优点在于其接口简洁（通常只需两根线：SCL和SDA），且传输速率适中，...
树莓派下MPU6500 SPI总线DMP姿态融合全码
11-22
树莓派下MPU6500 SPI总线DMP姿态融合全码. 基于I2C的代码,修改I2C为SPI,使用树莓派bcm2835内部API,使用digital motion processor官方库完美实现.带MakeFile文件.
51单片机（九）驱动mpu6050
weixin_51452951的博客
03-21 755
51单片机的mpu6050库
mpu6050六轴传感器模块驱动程序源代码分享 - 全文
weixin_30386713的博客
03-30 2003
1、MPU6050基础介绍 　　MPU6050是InvenSense公司推出的全球首款整合性6轴运动处理组件，相较于多组件方案，免除了组合陀螺仪与加速器时之轴间差的问题，减少了安装空间。 　　MPU6050内部整合了3轴陀螺仪和3轴加速度传感器，并且含有一个第二IIC接口，可用于连接外部磁力传感器，并利用自带的数字运动处理器（DMP：DigitalMoTIonProcessor）硬件...
ESP32设备驱动-MPU6050加速度计陀螺仪和温度传感器驱动
视觉与物联智能
06-30 1311
在本文中，将介绍如何使用ESP32驱动 MPU-6050 加速度计、陀螺仪传感器模块。MPU6050传感器用于测量加速度、温度、位移和角速度。 它配备了集成在 MPU6050 芯片内部的 6 轴运动跟踪传感器。 数据传输通过 I2C 协议进行。
STM32F103C8驱动MPU6050姿态与tofsense报警 （一）
weixin_46290197的博客
01-16 500
/使能USART1，GPIOA时钟。#if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.#if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
STM32CubeMX驱动MPU6050模块
qq_52158753的博客
05-01 3116
MPU6050模块是一款由InvenSense公司生产的数字运动处理器，它集成了三轴陀螺仪和三轴加速度计，采用MEMS技术，可以通过I2C接口与其他微控制器进行通信。MPU6050模块中的加速度计和陀螺仪分别测量物体在三个轴上的加速度和角速度。加速度计的输出被称为加速度，而陀螺仪的输出被称为角速度。经过一些复杂的数学运算和算法，可以将这些数据转换为物体的姿态、位置和移动方向等信息。除了加速度计和陀螺仪之外，MPU6050还具有许多其他功能。例如，它内置了一个温度传感器，可以测量环境温度并输出一个温度值。
I2C子系统–mpu6050驱动实验
weixin_48919886的博客
05-30 432
在编写单片机裸机i2c驱动时我们需要根据i2c协议手动配置i2c控制寄存器使其能够输出起始信号、停止信号、数据信息等等。在Linux系统中则采用了总线、设备驱动模型。我们之前讲解的平台设备也是采用了这种模型，只不过平台总线是一个虚拟的总线。我们知道一个i2c(例如i2c1)上可以挂在多个i2c设备，例如MPU6050、i2c接口的OLED显示屏、摄像头（摄像头通过i2c接口发送控制信息）等等， 这些设备共用一个i2c，这个i2c的驱动我们称为i2c总线驱动。
Zynq7020_PS端 uart驱动编写
分不清
06-09 2784
刚接触 zynq 网上资料也很少，整起来也比较难受。ps、pl 还有SDK。这些东西第一次用都得了解。如果你是个arm工程师，PL部分可以不用怎么了解，只要学习简单的新建硬件流就可以了。主要学习使用的是SDK。在使用方面还得对SDK进行一些配置。 所以记录自己学习zynq的过程。开发板用的是黑金的。下面开始吧！！！！ 一、串口初始化 XScuGic Intc // 中断 XGpioPs g_sGpioInstance; // gpio XUartPs Uart...
Linux 驱动 IIC_MPU6050
m0_58844968的博客
06-02 946
linuxmpu6050驱动 实验硬件及原理图： 1. 野火 IMX6ULL-MINI开发板 2.MPU6050
hal库硬件i2c驱动mpu6050
07-25
你可以使用HAL库来驱动MPU6050的硬件I2C接口。首先，确保你已经正确连接了MPU6050传感器到你的微控制器上，并且正确配置了I2C引脚。接下来，你可以按照以下步骤来实现MPU6050的硬件I2C驱动： 1. 初始化I2C总线: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

欲盖弥彰1314

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值