Linux学习笔记（22）——基于ICM20608的SPI设备驱动

最新推荐文章于 2024-02-27 06:00:00 发布
最新推荐文章于 2024-02-27 06:00:00 发布
阅读量2.3k 收藏 9
点赞数 1
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/glen_cao/article/details/105764528
版权
  1. 修改设备树文件，增加Iecspi3 节点上增加CM20608子节点
&ecspi3 {
	/* 设置当前片选数量为1, 因为就只接了一个ICM20608 */
	fsl,spi-num-chipselects = <1>;
	cs-gpio = <&gpio1 20 GPIO_ACTIVE_HIGH>;

	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_ecspi3>;
	status = "okay";

	spidev: icm20608@0 {
		compatible = "glen,icm20608";
		spi-max-frequency = <8000000>;
		reg = <0>;
		status = "okay";
	};
};
  1. 编写icm20608设备驱动程序
/* 
 * 文件名   : icm20608.c
 * 作者     : glen  
 * 描述     : icm20608驱动文件
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/input.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <linux/spi/spi.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "icm20608.h"

#define ICM20608_CNT     1
#define ICM20608_NAME    "icm20608"

/**
 * struct icm20608
 * @devid:  设备号
 * @cdev_icm:   cdev
 * @cls:  类
 * @dev_icm: 设备
 * @nd:     设备节点
 * @major:  主设备号
 * @private_data: 私有数据
 * @cs_gpio: 片选所使用的GPIO编号
 */
struct icm20608 {
    dev_t devid;
    struct cdev cdev_icm;
    struct class *cls;
    struct device *dev_icm;
    struct device_node *np;

    int major;
    void *private_data;
    
    int cs_gpio;
};

static struct icm20608 icm20608_dev;

/**
 * 从icm20608寄存器读取多个数据
 * @param   : dev icm20608设备
 * @param   : reg 要读取的寄存器首地址
 * @param   : buf 读到的数据
 * @param   : len 要读取的数据长度
 * @return  : 操作结果
 */
static int icm20608_read_reg(struct icm20608 *dev, u8 reg, void *buf, int len)
{
    int ret;
    unsigned char tx_data[len];
    struct spi_message msg;
    struct spi_transfer *ptrans = NULL;
    struct spi_device *spi = (struct spi_device *)dev->private_data;
    
    ptrans = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);
    if (ptrans == NULL) {
        ret = -EINVAL;
        goto read_fail_alloc;
    }
    
    gpio_set_value(dev->cs_gpio, 0);

    /* 发送要读取的寄存器地址 */
    tx_data[0] = reg | 0x80;
    ptrans->tx_buf = tx_data;
    ptrans->len = 1;

    spi_message_init(&msg);
    spi_message_add_tail(ptrans, &msg);
    ret = spi_sync(spi, &msg);

    /* 读取数据 */
    tx_data[0] = 0xff;
    ptrans->rx_buf = buf;
    ptrans->len = len;

    spi_message_init(&msg);
    spi_message_add_tail(ptrans, &msg);
    ret = spi_sync(spi, &msg);

    gpio_set_value(dev->cs_gpio, 1);
    kfree(ptrans);

read_fail_alloc:
    return ret;
}

/**
 * 向icm20608寄存器写入多个数据
 * @param   : dev icm20608设备
 * @param   : reg 要读取的寄存器首地址
 * @param   : buf 读到的数据
 * @param   : len 要读取的数据长度
 * @return  : 操作结果
 */
static int icm20608_write_reg(struct icm20608 *dev, u8 reg, u8 *buf, u8 len)
{
    int ret;
    unsigned char tx_data[len];
    struct spi_message msg;
    struct spi_transfer *ptrans = NULL;
    struct spi_device *spi = (struct spi_device *)dev->private_data;

    ptrans = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);
    if (ptrans == NULL) {
        ret = -EINVAL;
        goto write_fail_alloc;
    }

    gpio_set_value(dev->cs_gpio, 0);

    /* 发送要写入的寄存器地址 */
    tx_data[0] = reg & ~0x80;
    ptrans->tx_buf = tx_data;
    ptrans->len = 1;

    spi_message_init(&msg);
    spi_message_add_tail(ptrans, &msg);
    ret = spi_sync(spi, &msg);

    /* 发送要写入的数据 */
    ptrans->tx_buf = buf;
    ptrans->len = len;

    spi_message_init(&msg);
    spi_message_add_tail(ptrans, &msg);
    ret = spi_sync(spi, &msg);
    
    kfree(ptrans);
    gpio_set_value(dev->cs_gpio, 1);

write_fail_alloc:
    return ret;
}

/**
 * ICM20608内部寄存器初始化函数
 * @param   : none
 * @return  : noreturn
 */
void icm20608_reg_init(void)
{
    int ret = 0;
    u8 value;

    value = 0x80;
    icm20608_write_reg(&icm20608_dev, ICM20_PWR_MGMT_1, &value, 1);
    mdelay(50);

    value = 0x01;
    icm20608_write_reg(&icm20608_dev, ICM20_PWR_MGMT_1, &value, 1);
    mdelay(50);

    ret = icm20608_read_reg(&icm20608_dev, ICM20_WHO_AM_I, &value, 1);
    if (ret == 0) {
        printk("ICM20608 ID = %#X\r\n", value);
    }

    value = 0x00;
    icm20608_write_reg(&icm20608_dev, ICM20_SMPLRT_DIV, &value, 1);
    value = 0x18;
    icm20608_write_reg(&icm20608_dev, ICM20_GYRO_CONFIG, &value, 1);
    icm20608_write_reg(&icm20608_dev, ICM20_ACCEL_CONFIG, &value, 1);
    value = 0x04;
    icm20608_write_reg(&icm20608_dev, ICM20_CONFIG, &value, 1);
    icm20608_write_reg(&icm20608_dev, ICM20_ACCEL_CONFIG2, &value, 1);
    value = 0x00;
    icm20608_write_reg(&icm20608_dev, ICM20_PWR_MGMT_2, &value, 1);
    icm20608_write_reg(&icm20608_dev, ICM20_LP_MODE_CFG, &value, 1);
    icm20608_write_reg(&icm20608_dev, ICM20_FIFO_EN, &value, 1);
}

/**
 * 打开设备
 * @param   : inode 传递给驱动的inode
 * @param   : filp  设备文件, file结构体有个叫做private_data的成员变量, 一般在open
 *            时将private_data传递给设备结构体
 * @return  : 0 成功; 其他 失败
 */
static int icm20608_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &icm20608_dev;
    return 0;
}

/**
 * 从设备读取数据
 * @param   : filp 要打开的设备文件
 * @param   : buf 返回给用户空间的数据缓冲区
 * @param   : cnt 要读取数据长度
 * @param   : offt 相对于文件首地址的偏移
 * @return  : 读取的字节数, 为负值, 表示读取失败
 */
static ssize_t icm20608_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
{
    int ret;
    signed char data[14];
    struct icm20608 *dev;
    struct icm20608_data icm_data;

    if (filp->private_data == NULL) {
        ret = -EINVAL;
        return ret;
    }
    dev = (struct icm20608 *)filp->private_data;

    icm20608_read_reg(dev, ICM20_ACCEL_XOUT_H, data, 14);
    icm_data.accel_x_adc = (signed short)((data[0] << 8) | (data[1]));
    icm_data.accel_y_adc = (signed short)((data[2] << 8) | (data[3]));
    icm_data.accel_z_adc = (signed short)((data[4] << 8) | (data[5]));
    icm_data.temp_adc    = (signed short)((data[6] << 8) | (data[7]));
    icm_data.gyro_x_adc  = (signed short)((data[8] << 8) | (data[9]));
    icm_data.gyro_y_adc  = (signed short)((data[10] << 8) | (data[11]));
    icm_data.gyro_z_adc  = (signed short)((data[12] << 8) | (data[13]));

    ret = copy_to_user((void *)buf, (const void *)&icm_data, 14);

    return ret;
}

/**
 * 关闭/释放设备
 * @param   : filp 要关闭的设备文件(文件描述符)
 * @return  : 0 成功; 其他 失败
 */
static int icm20608_release(struct inode *inode, struct file *filp)
{
    return 0;
}

/* icm20608操作函数 */
static const struct file_operations icm20608_ops = {
    .owner = THIS_MODULE,
    .open  = icm20608_open,
    .read  = icm20608_read,
    .release = icm20608_release,
};

/**
 * spi驱动的probe函数, 当驱动与设备匹配会执行此函数
 * @param   client: spi设备
 * @param   id:     spi设备ID
 */
static int icm20608_probe(struct spi_device *spi)
{
    int ret = 0;

    /* 构建设备号 */
    if (icm20608_dev.major) {
        icm20608_dev.devid = MKDEV(icm20608_dev.major, 0);
        register_chrdev_region(icm20608_dev.devid, ICM20608_CNT, ICM20608_NAME);
    } else {
        alloc_chrdev_region(&icm20608_dev.devid, 0, ICM20608_CNT, ICM20608_NAME);
        icm20608_dev.major = MAJOR(icm20608_dev.devid);
    }
    printk("icm20608 major is: %d\n", icm20608_dev.devid);

    /* 注册设备 */
    cdev_init(&icm20608_dev.cdev_icm, &icm20608_ops);
    cdev_add(&icm20608_dev.cdev_icm, icm20608_dev.devid, ICM20608_CNT);

    /* 创建类 */
    icm20608_dev.cls = class_create(THIS_MODULE, ICM20608_NAME);
    if (IS_ERR(icm20608_dev.cls)) {
        return PTR_ERR(icm20608_dev.cls);
    }

    /* 创建设备 */
    icm20608_dev.dev_icm = device_create(icm20608_dev.cls, NULL, icm20608_dev.devid, NULL, ICM20608_NAME);
    if (IS_ERR(icm20608_dev.dev_icm)) {
        return PTR_ERR(icm20608_dev.dev_icm);
    }

    /* 获取设备树节点 */
    icm20608_dev.np = of_find_node_by_path("/soc/aips-bus@02000000/spba-bus@02000000/ecspi@02010000");
    if (icm20608_dev.np == NULL) {
        printk("ecspi3 node is not find!\n");
        return -EINVAL;
    }

    /* 获取设备树中的gpio属性, 得到CS片选所使用的GPIO编号 */
    icm20608_dev.cs_gpio = of_get_named_gpio(icm20608_dev.np, "cs-gpio", 0);
    if (icm20608_dev.cs_gpio < 0) {
        printk("Can't get cs-gpio\r\n");
        return -EINVAL;
    }

    /* 设置GPIO1_IO20为输出, 并且输出高电平 */
    ret = gpio_direction_output(icm20608_dev.cs_gpio, 1);
    if (ret < 0) {
        printk("Can't set gpio!\n");
        return -EIO;
    }

    /* 初始化spi_device */
    spi->mode = SPI_MODE_0;
    spi_setup(spi);
    icm20608_dev.private_data = spi;

    /* 初始化ICM20608内部寄存器 */
    icm20608_reg_init();
    return 0;
}

/**
 * spi驱动的remove函数，移除spi驱动的时候此函数会执行
 * @param   : client spi设备
 * @return  : 0 成功; 负值 失败
 */
static int icm20608_remove(struct spi_device *spi)
{
    /* 删除设备 */
    cdev_del(&icm20608_dev.cdev_icm);
    unregister_chrdev_region(icm20608_dev.devid, ICM20608_CNT);

    /* 注销掉类和设备 */
    device_destroy(icm20608_dev.cls, icm20608_dev.devid);
    class_destroy(icm20608_dev.cls);

    return 0;
}

/* 传统匹配方式ID列表 */
static const struct spi_device_id icm20608_id[] = {
    {"glen,icm20608", 0},
    {}
};

/* 设备树匹配列表 */
static const struct of_device_id icm20608_of_match[] = {
    {.compatible = "glen,icm20608"},
    { /* Sentinel */}
};

/* SPI驱动结构体 */
static struct spi_driver icm20608_driver = {
    .probe  = icm20608_probe,
    .remove = icm20608_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "icm20608",
        .of_match_table = icm20608_of_match,
    },
    .id_table = icm20608_id,
};


/**
 * \brief   驱动模块加载函数
 * \param   无
 * \retval  无
 */
static int __init icm20608_init(void)
{
    return spi_register_driver(&icm20608_driver);
}

/**
 * \brief   驱动模块缷载函数
 * \param   无
 * \return  无
 */
static void __exit icm20608_exit(void)
{
    spi_unregister_driver(&icm20608_driver);
}

/* 设备注册入口, 展开后
 * static initcall_t \
 *        __initcall_icm20608_init6 \
 *        __used \
 *        __attribute__((__section__(".initcall6.init"))) \
 *        = icm20608_init;
 */
module_init(icm20608_init);

/* 设备注册出口, 展开后
 * static exitcall_t \
 *        __exitcall_icm20608_exit \
 *        __exit_call \
 *        = icm20608_exit;
 */
module_exit(icm20608_exit);

/* 模块的许可证声明, 展开后
 * static const char __UNIQUE_ID_license__COUNTER__[] \
 *   __used __attribute__((section(".modinfo"), unused, aligned(1))) \
 *  = "license=GPL";
 */
MODULE_LICENSE("GPL");

/* 模块的作者声明, 展开后
 * static const char __UNIQUE_ID_author__COUNTER__[]					  \
 * __used __attribute__((section(".modinfo"), unused, aligned(1)))	  \
 * = "author=glen_cao"
 */
MODULE_AUTHOR("glen");
  1. 编写icm20608测试程序
/*
 * 文件名   :  icm20608_test.c
 * 作者     :  glen
 * 描述     :  icm20608测试程序
 */

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "linux/ioctl.h"
#include "signal.h"
#include "icm20608.h"

/**
 * @brief   : main函数
 * @par     : argc  argv数组元素的个数
 *            argv  参数数组
 * @retval  : 0 成功    其它 失败
 */
int main(int argc, char *argv[])
{
    int fd = 0;  /* 文件描述符 */
    char *filename;
    struct icm20608_data icm_data;

    int ret = 0;

    if (argc != 2) {
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];
    /* 打开驱动文件 */
    fd = open(filename, O_RDWR);       /* 阻塞访问 */
    if (fd < 0) {
        printf("Can't open file %s\r\n", filename);
        return -1;
    }

    while(1) {
        ret = read(fd, &icm_data, 14);
        if (ret == 0) {
            icm_data.accel_x_act = (float)(icm_data.accel_x_adc) / 2048;
            icm_data.accel_y_act = (float)(icm_data.accel_y_adc) / 2048;
            icm_data.accel_z_act = (float)(icm_data.accel_z_adc) / 2048;
            icm_data.gyro_x_act = (float)(icm_data.gyro_x_adc) / 16.4;
            icm_data.gyro_y_act = (float)(icm_data.gyro_y_adc) / 16.4;
            icm_data.gyro_z_act = (float)(icm_data.gyro_z_adc) / 16.4;
            icm_data.temp_act = ((float)(icm_data.temp_adc) - 25) / 326.8 + 25;

            printf("\n原始值:\n");
            printf("gx = %d, gy = %d, gz = %d\n", icm_data.gyro_x_adc, icm_data.gyro_y_adc, icm_data.gyro_z_adc);
            printf("ax = %d, ay = %d, az = %d\n", icm_data.accel_x_adc, icm_data.accel_y_adc, icm_data.accel_z_adc);
            printf("temp = %d\n", icm_data.temp_adc);

            printf("\n实际值:\n");
            printf("act gx = %.2f°/S, act gy = %.2f°/S, act gz = %.2f°/S\n", icm_data.gyro_x_act, icm_data.gyro_y_act, icm_data.gyro_z_act);
            printf("act ax = %.2fg, act ay = %.2fg, act az = %.2fg\n", icm_data.accel_x_adc, icm_data.accel_y_adc, icm_data.accel_z_adc);
            printf("temp = %.2f°C\n", icm_data.temp_act);            
        }
        usleep(200000);
    }

    /* 关闭文件 */
    ret = close(fd);
    if (ret < 0) {
        printf("file %s close failed!\r\n", argv[1]);
        return -1;
    }
    return 0;
}

拷贝到NFS文件系统目录下

glen@ubuntu:~/linux/imx6ull/linux/driver/20_spi$ sudo cp icm20608.ko icm20608 ~/linux/nfs/rootfs/lib/modules/4.1.15 -f
  1. 测试程序
    4.1. 加载驱动模块
/lib/modules/4.1.15 # insmod icm20608.ko
icm20608 major is: 261095424
ICM20608 ID = 0xae

4.2. 运行测试程序

/lib/modules/4.1.15 # ./random: nonblocking pool is initialized
/lib/modules/4.1.15 # ./icm20608_test /dev/icm20608

原始值:
gx = 37, gy = -25, gz = 10
ax = 4, ay = 7, az = -4
temp = -89

实际值:
act gx = 2.26°/S, act gy = -1.52°/S, act gz = 0.61°/S
act ax = -nang, act ay = -1.52g, act az = 0.61g
temp = 24.65°C

原始值:
gx = 34, gy = -27, gz = 47
ax = 21, ay = -46, az = -11
temp = -87

实际值:
act gx = 2.07°/S, act gy = -1.65°/S, act gz = 2.87°/S
act ax = -nang, act ay = -1.65g, act az = 2.87g
temp = 24.66°C

原始值:
gx = 37, gy = -25, gz = 9
ax = 3, ay = 2, az = -4
temp = -90

实际值:
act gx = 2.26°/S, act gy = -1.52°/S, act gz = 0.55°/S
act ax = -nang, act ay = -1.52g, act az = 0.55g
temp = 24.65°C
glen_cao
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
加速度 ICM-20608 笔记
qq_41478801的博客
08-05 2424
ICM-20608
潘多拉开发板——6轴传感器ICM-20608学习笔记
z1349548996的博客
12-07 3981
六轴传感器ICM2008
详解SPI模式下ICM-20608的驱动开发
最新发布
mftang的博客
02-27 1275
本文详细分析了ICM-20608芯片的硬件特性，驱动方式、内部框图结构，以及寄存器的参数意义。还介绍SPI接口的工作原理，时序等知识点。
裸机IIC驱动（Linux驱动开发篇）
栋哥修炼日记
02-13 1201
1.裸机驱动 单片机A和传感器B 没有借助linux内核的API来编写的，也就是裸机（单片机） 原理：A与B之间进行通信，我们需要编写驱动协议让A和B交流。其中编写驱动，分为主机驱动和设备驱动。其实二者可以合二为一成一个文件，但是为了迎合驱动的分离和分层的思想，才将其分开。这种思想的好处，请看我写的另外一篇文章Linux驱动的分离和分层。 好了，我们已经知道大致的步骤就是： 首先编写主机驱动（就是利用单片机A的各种寄存器）。然后再针对我们使用的传感器B编写一个驱动文件叫做设备驱动（借助主机驱动已经编写好的
linux使用spi读取传感器数值一直显示0
weixin_46435653的博客
10-04 1743
一、问题描述 最近在使用飞思卡尔的imx6ull的时候，要用spi协议实现和icm20608六轴传感器的通讯时，发现读取出来的数据都是0（即使读取的是ID寄存器）。 二、解决方法 1、上论坛查找问题，发现首先是忘记屏蔽掉设备树中冲突的引脚配置 pinctrl_ecspi3:icm20608{ fsl,pins=< /* MX6UL_PAD_UART2_TX_DATA__ECSPI3_SS0*/ MX6UL_PAD_UART2_TX_DATA__GPIO1_...
ICM 20608 linux 环境下的驱动程序
02-23
参考链接中的文档《ICM 20608 Linux环境下的驱动程序》提供了详细的代码实现和解释，是学习和理解这一过程的重要资源。通过阅读和实践，开发者可以掌握Linux驱动程序开发的基本技能，从而成功地为ICM 20608编写驱动...
spi_ICM-20608-G_drv.zip
07-18
在这个压缩包"spi_ICM-20608-G_drv.zip"中，我们关注的是ICM-20608-G传感器的SPI设备驱动程序。这个驱动程序对于在Linux环境下正确地控制和读取传感器数据至关重要。 ICM-20608-G是一款高性能的六轴惯性测量单元...
i.MX6ULL使用regmap驱动SPI（ICM-20608陀螺仪传感器）【Linux驱动】.zip
02-21
标题中的“i.MX6ULL使用regmap驱动SPI（ICM-20608陀螺仪传感器）”指的是在NXP的i.MX6ULL微处理器上，使用Linux内核的regmap机制来驱动SPI接口的ICM-20608陀螺仪传感器。这个过程涉及到嵌入式系统、Linux驱动开发...
ICM 20608 linux 环境下的测试程序
02-23
在Linux环境下，对ICM 20608传感器进行测试是嵌入式系统和物联网应用中的常见任务。...通过提供的文档和源代码，开发者可以学习到如何在Linux系统中有效地利用ICM 20608传感器，实现对运动和姿态的精确监测。
i.MX6ULL使用IIO驱动SPI（ICM-20608陀螺仪传感器）【Linux驱动】.zip
02-21
标题中的“i.MX6ULL使用IIO驱动SPI（ICM-20608陀螺仪传感器）”涉及到了嵌入式系统、微处理器、Linux驱动开发以及传感器技术等多个IT领域的知识点。以下是对这些主题的详细解释： 1. i.MX6ULL：i.MX6ULL是NXP（恩智...
ICM20608.PDF
11-14
ICM20608是一款惯导芯片，用在无人机飞控上，上面包含1个三轴加速计，1个三轴陀螺仪。。。。。。。。。。。。。。。。。
ICM20602(ICM20608) LGA16 封装
12-24
内含ICM20602的封装，LGA16。根据手工制版要求进行了加长修改，方便手工焊接。如果机器贴片适当减小引脚长度即可。 （需镜像！！！AD中按X即可！！！）
icm20608-master.zip
07-16
支持4种三轴加速度量程 支持4种三轴陀螺仪量程 支持零值校准。 icm20608.h 程序头文件 icm20608.c 程序源代码 SConscript RT-Thread 默认的构建脚本 README.md 软件包使用说明 icm20608_datasheet.pdf 官方数据手册
驱动程序开发：基于ICM20608六轴传感器 --- 使用Regmap API 的 SPI 读取数据 之 IIO驱动
morecrazylove的博客
02-23 1369
IIO 全称是 Industrial I/O，翻译过来就是工业 I/O，大家不要看到“工业”两个字就觉得 IIO是只用于工业领域的。 实验IIO框架驱动icm20608六轴传感器。
Linux驱动_spi驱动(ICM20608)
qq_42174306的博客
03-13 5491
参考： Linux SPI 驱动分析（1）— 结构框架_StephenZhou-CSDN博客_linux spi驱动 Linux SPI 驱动分析（2）— 框架层源码分析_StephenZhou-CSDN博客_spi_message_init SPI驱动的框架和源码分析，可以在参考博客中查看。 驱动编写测试 ： 原理图如下所示： LINUX下的SPI主机驱动已经由SOC厂商编写好了，比如I.MX6ULL的SPI主机驱动由NXP官方编写好了，我们编写设备驱动的...
韦东山 IMX6ULL和正点原子_「正点原子Linux连载」第六十二章Linux SPI驱动实验（二）...
weixin_39780784的博客
11-10 666
1)实验平台：正点原子Linux开发板2)摘自《正点原子I.MX6U嵌入式Linux驱动开发指南》关注官方微信号公众号，获取更多资料：正点原子在本章实验中，我们采用同步传输方式来完成SPI数据的传输工作，也就是spi_sync函数。综上所述，SPI数据传输步骤如下：①、申请并初始化spi_transfer，设置spi_transfer的tx_buf成员变量，tx_buf为要发送的数据。然后设置rx...
IMX6ULL裸机篇之SPI实验-ICM20608传感器
wojiaxiaohuang2014的博客
06-11 1168
ICM-20608G的 “WHO_AM_I ”寄存器，地址为 0X75，默认值是0XAF。目录下，分别为“ICM-20608-G Datasheet Revision 1.0.pdf”与 “ICM-20608-G Register Maps and Description Revision V1.0.pdf” 两个文档。“ICM-20608-G Register Maps and Description Revision V1.0.pdf” 文档是寄存器描述的手册。陀螺仪的量程范围可以编程设置，可选择±。
i.MX6ULL驱动开发 | 14 - 基于 Linux SPI 驱动框架读取ICM-20608传感器
Mculover666的博客（嵌入式）
04-12 1204
本系列文章驱动源码仓库，欢迎Star~ https://github.com/Mculover666/linux_driver_study。 一、ICM20608 1. 简介 InvenSense 的 ICM-20608 是一款 6 轴运动跟踪器件（MEMS传感器），也是 MPU-6500 的后续产品，集成了3轴加速度计和3轴陀螺仪。 相比以前的 6 轴器件，Invensense 的 ICM 20608 具有更低的功耗和噪声并采用更薄的封装。 该器件为陀螺仪提供了一种占空比工作模式，相比以前的 6 .
ICM-20608驱动编写
shouchen1的博客
03-18 433
ICM-20608传感器：包括3轴加速度和3轴陀螺仪
linux spi 驱动icm20608的代码
06-09
下面是一个简单的 Linux SPI 驱动程序，用于读取 ICM20608 传感器的数据： ```c #include <linux/spi/spi.h> #include <linux/module.h> #define ICM20608_REG_WHO_AM_I 0x75 #define ICM20608_REG_ACCEL_XOUT_H ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值