您的位置: 首页  >  文章  >  i2c 驱动gpio模拟i2c

i2c 驱动gpio模拟i2c

分类: 文章 • 2022-11-04 23:54:57

1. 简介：

gpio模拟i2c驱动可以解决i2c控制器不足的问题，但是，相对的可能要占用更多的cpu时间，此程序依然使用的是jz2440开发板


2. 内核提供的代码分析：

我们从 i2c-gpio.c 开始，文件路径：drivers/i2c/busses

（1）i2c的gpio的私有的数据 结构体如下：

[cpp] view plain copy
 print?
  1. struct i2c_gpio_private_data {  
  2.     struct i2c_adapter adap;  
  3.     struct i2c_algo_bit_data bit_data;  
  4.     struct i2c_gpio_platform_data pdata;  
  5. };  

其中第一个成员 i2c_adapter 不在展开，他提供了i2c的通信方法

第二个成员i2c_algo_bit_data，功能和参数写在函数中，他提供了操作具体硬件上的方法

[cpp] view plain copy
 print?
  1. /* --- Defines for bit-adapters --------------------------------------- */  
  2. /* 
  3.  * 这个结构体中包含了对线的操作的函数，从名字上我们可以看出 
  4.  */  
  5. struct i2c_algo_bit_data {  
  6.     void *data;     /* private data for lowlevel routines */  
  7.     void (*setsda) (void *data, int state); /* 一些操作线的高低电平的函数 */  
  8.     void (*setscl) (void *data, int state);  
  9.     int  (*getsda) (void *data);  
  10.     int  (*getscl) (void *data);  
  11.     int  (*pre_xfer)  (struct i2c_adapter *);  
  12.     void (*post_xfer) (struct i2c_adapter *);  
  13.   
  14.     /* local settings */  
  15.     int udelay;     /* half clock cycle time in us, 
  16.                    minimum 2 us for fast-mode I2C, 
  17.                    minimum 5 us for standard-mode I2C and SMBus, 
  18.                    maximum 50 us for SMBus */  
  19.     int timeout;        /* 单位 jiffies */  
  20. };  

第三个成员i2c_gpio_platform_data，用于保存具体的硬件资源

[cpp] view plain copy
 print?
  1. /** 
  2.  * struct i2c_gpio_platform_data - Platform-dependent data for i2c-gpio 
  3.  * @sda_pin: GPIO pin ID to use for SDA 
  4.  * @scl_pin: GPIO pin ID to use for SCL 
  5.  * @udelay: signal toggle delay. SCL frequency is (500 / udelay) kHz 
  6.  * @timeout: clock stretching timeout in jiffies. If the slave keeps 
  7.  *  SCL low for longer than this, the transfer will time out. 
  8.  * @sda_is_open_drain: SDA is configured as open drain, i.e. the pin 
  9.  *  isn't actively driven high when setting the output value high. 
  10.  *  gpio_get_value() must return the actual pin state even if the 
  11.  *  pin is configured as an output. 
  12.  * @scl_is_open_drain: SCL is set up as open drain. Same requirements 
  13.  *  as for sda_is_open_drain apply. 
  14.  * @scl_is_output_only: SCL output drivers cannot be turned off. 
  15.  */  
  16. struct i2c_gpio_platform_data {  
  17.     unsigned int    sda_pin; /* sda 对应的引脚 */  
  18.     unsigned int    scl_pin; /* scl 对应的引脚 */  
  19.     int     udelay;  /* 信号触发延时，直接决定SCL引脚的频率：(500/udelay)kHz */  
  20.     int     timeout; /* 如果从设备的SCL低电平保持大于timeout jiffies，传输过程认为超时 */  
  21.     unsigned int    sda_is_open_drain:1; /* 将SDA引脚设置成开漏输出，开漏的意思是，如果设置成开漏，引脚外部没有上拉，高电平输不出来 */  
  22.     unsigned int    scl_is_open_drain:1; /* 将SCL引脚设置成开漏输出 */  
  23.     unsigned int    scl_is_output_only:1;/*  */  
  24. };  

（2）i2c_gpio_setsda_dir，设置 i2c_gpio_platform_data 结构体中的 SDA 引脚的方向：1输入，0输出

[cpp] view plain copy
 print?
  1. /* 改变SDA引脚的方向 */  
  2. static void i2c_gpio_setsda_dir(void *data, int state)  
  3. {  
  4.     struct i2c_gpio_platform_data *pdata = data; /*  */  
  5.   
  6.     if (state)  
  7.         gpio_direction_input(pdata->sda_pin);  
  8.     else  
  9.         gpio_direction_output(pdata->sda_pin, 0);  
  10. }  

（3）i2c_gpio_setsda_val，设置SDA引脚上的值高/低，state可以的取值是GPIO_HIGHT / GPIO_LOW

[cpp] view plain copy
 print?
  1. /* 
  2.  * 改变 SDA 引脚上的电平. This is only 
  3.  * valid for pins configured as open drain (i.e. setting the value 
  4.  * high effectively turns off the output driver.) 
  5.  */  
  6. static void i2c_gpio_setsda_val(void *data, int state)  
  7. {  
  8.     struct i2c_gpio_platform_data *pdata = data;  
  9.   
  10.     gpio_set_value(pdata->sda_pin, state);  
  11. }  

（4）i2c_gpio_setscl_dir，设置 SDA 引脚的输入输出方向：1入，0出

[cpp] view plain copy
 print?
  1. /* Toggle SCL by changing the direction of the pin. */  
  2. static void i2c_gpio_setscl_dir(void *data, int state)  
  3. {  
  4.     struct i2c_gpio_platform_data *pdata = data;  
  5.   
  6.     if (state)  
  7.         gpio_direction_input(pdata->scl_pin);  
  8.     else  
  9.         gpio_direction_output(pdata->scl_pin, 0);  
  10. }  

（5）i2c_gpio_setscl_val，设置 SCL 引脚上的高低电平，state可以取值是GPIO_HIGHT / GPIO_LOW

[cpp] view plain copy
 print?
  1. /* 
  2.  * Toggle SCL by changing the output value of the pin. This is used 
  3.  * for pins that are configured as open drain and for output-only 
  4.  * pins. The latter case will break the i2c protocol, but it will 
  5.  * often work in practice. 
  6.  */  
  7. static void i2c_gpio_setscl_val(void *data, int state)  
  8. {  
  9.     struct i2c_gpio_platform_data *pdata = data;  
  10.   
  11.     gpio_set_value(pdata->scl_pin, state);  
  12. }  

（6）得到 SDA , SCL 引脚上的电平，返回值的取值是 GPIO_HIGHT /GPIO_LOW

[cpp] view plain copy
 print?
  1. static int i2c_gpio_getsda(void *data)  
  2. {  
  3.     struct i2c_gpio_platform_data *pdata = data;  
  4.   
  5.     return gpio_get_value(pdata->sda_pin);  
  6. }  
  7.   
  8. static int i2c_gpio_getscl(void *data)  
  9. {  
  10.     struct i2c_gpio_platform_data *pdata = data;  
  11.   
  12.     return gpio_get_value(pdata->scl_pin);  
  13. }  

（7）然后我们来看看模块的初始化和退出

[cpp] view plain copy
 print?
  1. static int __init i2c_gpio_init(void)  
  2. {  
  3.     int ret;  
  4.   
  5.     ret = platform_driver_register(&i2c_gpio_driver); /* 将驱动注册到系统中 */  
  6.     if (ret)  
  7.         printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);  
  8.   
  9.     return ret;  
  10. }  
  11. subsys_initcall(i2c_gpio_init);  
  12.   
  13. static void __exit i2c_gpio_exit(void)  
  14. {  
  15.     platform_driver_unregister(&i2c_gpio_driver); /*  相应的释放函数 */  
  16. }  
  17. module_exit(i2c_gpio_exit);  

（8）注册的这个驱动 i2c_gpio_driver 如下

[cpp] view plain copy
 print?
  1. static struct platform_driver i2c_gpio_driver = {  
  2.     .driver     = {  
  3.         .name   = "i2c-gpio",  
  4.         .owner  = THIS_MODULE,  
  5.         .of_match_table = of_match_ptr(i2c_gpio_dt_ids),  
  6.     },  
  7.     .probe      = i2c_gpio_probe,  
  8.     .remove     = __devexit_p(i2c_gpio_remove),  
  9. };  

其中的 of_match_ptr 由于用的是平台文件的匹配方式，CONFIG_OF 这个宏(跟设备树有关)没有开启，因此，此处的 of_match_ptr 返回值是 i2c_gpio_dt_ids

[cpp] view plain copy
 print?
  1. #if defined(CONFIG_OF)  
  2. static const struct of_device_id i2c_gpio_dt_ids[] = {  
  3.     { .compatible = "i2c-gpio", },  
  4.     { /* sentinel */ }  
  5. };  
  6.   
  7. MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids);  
  8. #endif  

可以看到，即使 i2c_gpio_dt_ids 也依赖于 CONFIG_OF 这个宏，因此 .of_match_table 没有定义，根据匹配的规则，最后检查的是 .name ，这要是有 设备的名字是 i2c-gpio 就能匹配上了，匹配上，将调用 i2c_gpio_probe，此部分代码加到，部分代码将用语言代替他的实现

[cpp] view plain copy
 print?
  1. static int __devinit i2c_gpio_probe(struct platform_device *pdev)  
  2. {  
  3.     struct i2c_gpio_private_data *priv;  
  4.     struct i2c_gpio_platform_data *pdata;  
  5.     struct i2c_algo_bit_data *bit_data;  
  6.     struct i2c_adapter *adap;  
  7.     int ret;  
  8.   
  9.     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);  
  10.   
  11.     adap = &priv->adap;  
  12.     bit_data = &priv->bit_data;  
  13.     pdata = &priv->pdata;  
  14.   
  15.     if (pdev->dev.of_node) { /* 没有设备树，执行 else */  
  16.         ret = of_i2c_gpio_probe(pdev->dev.of_node, pdata);  
  17.         if (ret)  
  18.             return ret;  
  19.     } else {  
  20.         if (!pdev->dev.platform_data) return -ENXIO;  
  21.         memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));  
  22.     }  
  23.   
  24.     /* 检查 SDA 和 SCL 引脚是不是有效 */  
  25.   
  26.     if (pdata->sda_is_open_drain) { /* 这里实现的是当输出的时候，将开漏打开，引脚上有上拉电阻，输入的时候，关闭开漏，引脚上无上拉电阻 */  
  27.         gpio_direction_output(pdata->sda_pin, 1); /* 将 SDA 引脚设置成输出，并且输出为 1 */  
  28.         bit_data->setsda = i2c_gpio_setsda_val;  
  29.     } else {  
  30.         gpio_direction_input(pdata->sda_pin);  
  31.         bit_data->setsda = i2c_gpio_setsda_dir;  
  32.     }  
  33.   
  34.     if (pdata->scl_is_open_drain || pdata->scl_is_output_only) {  
  35.         gpio_direction_output(pdata->scl_pin, 1);  
  36.         bit_data->setscl = i2c_gpio_setscl_val;  
  37.     } else {  
  38.         gpio_direction_input(pdata->scl_pin);  
  39.         bit_data->setscl = i2c_gpio_setscl_dir;  
  40.     }  
  41.   
  42.     if (!pdata->scl_is_output_only) /* 绑定i2c_algo_bit_data结构体 bit_data 中的 getscl 函数 */  
  43.         bit_data->getscl = i2c_gpio_getscl;   
  44.     bit_data->getsda = i2c_gpio_getsda; /* 绑定i2c_algo_bit_data结构体 bit_data 中的 getsda 函数 */  
  45.   
  46.     if (pdata->udelay) /* 绑定udelay，用于设置scl的频率 */  
  47.         bit_data->udelay = pdata->udelay;  
  48.     else if (pdata->scl_is_output_only) /* 默认的，并且 scl 设置成单输出，频率是 10kHz */  
  49.         bit_data->udelay = 50;           /* 10 kHz */  
  50.     else  
  51.         bit_data->udelay = 5;            /* 100 kHz */  
  52.   
  53.     if (pdata->timeout)  
  54.         bit_data->timeout = pdata->timeout;  
  55.     else  
  56.         bit_data->timeout = HZ / 10;     /* 默认100 ms */  
  57.   
  58.     bit_data->data = pdata;  
  59.   
  60.     adap->owner = THIS_MODULE;  
  61.     snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id); /* i2c_adapter 的名字 */  
  62.     adap->algo_data = bit_data;  
  63.     adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;  
  64.     adap->dev.parent = &pdev->dev;  
  65.     adap->dev.of_node = pdev->dev.of_node;  
  66.   
  67.     /* 
  68.      * 如果 "dev->id" 是负数，我们认为是0. 
  69.      * The reason to do so is to avoid sysfs names that only make 
  70.      * sense when there are multiple adapters. 
  71.      */  
  72.     adap->nr = (pdev->id != -1) ? pdev->id : 0;  
  73.     ret = i2c_bit_add_numbered_bus(adap); /* adapter 跟 i2c总线关联，如果 nr = -1，i2c的号自动分配，得到适配器，返回0成功 */  
  74.     if (ret)  
  75.         goto err_add_bus;  
  76.   
  77.     of_i2c_register_devices(adap); /* CONFIG_OF_I2C和CONFIG_OF_I2C_MODULE都没定义，不执行这句 */  
  78.   
  79.     platform_set_drvdata(pdev, priv); /* ... */  
  80.   
  81.     dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",  
  82.          pdata->sda_pin, pdata->scl_pin,  
  83.          pdata->scl_is_output_only  
  84.          ? ", no clock stretching" : "");  
  85.   
  86.     return 0;  
  87.   
  88. err_add_bus:  
  89.     gpio_free(pdata->scl_pin);  
  90. err_request_scl:  
  91.     gpio_free(pdata->sda_pin);  
  92. err_request_sda:  
  93.     return ret;  
  94. }  

相应的要有删除函数

[cpp] view plain copy
 print?
  1. static int __devexit i2c_gpio_remove(struct platform_device *pdev)  
  2. {  
  3.     struct i2c_gpio_private_data *priv;  
  4.     struct i2c_gpio_platform_data *pdata;  
  5.     struct i2c_adapter *adap;  
  6.   
  7.     priv = platform_get_drvdata(pdev);  
  8.     adap = &priv->adap;  
  9.     pdata = &priv->pdata;  
  10.   
  11.     i2c_del_adapter(adap); /* 删除适配器 */  
  12.     gpio_free(pdata->scl_pin);  
  13.     gpio_free(pdata->sda_pin);   
  14.   
  15.     return 0;  
  16. }  

要用这个文件，需要做的是让内核支持，我用的内核版本是3.4.112

make menuconfig

选择 Device Drivers --->

<*> I2C support  --->

I2C Hardware Bus support  ---> 

<*> GPIO-based bitbanging I2C


重新将uImage放到开发板上，在根文件系统下会多出个节点：

./sys/bus/platform/drivers/i2c-gpio


3. 实例

对于上边的程序，在driver中已经存在，对于我们需要做的是编写 设备程序

设备可以在用户板级的配置文件中编写，也可以单独的写一个模块，然后加载，以下程序采用后者

由于手头上有个 mpu6050，所以，就以mpu6050为例，采用的传感器的小板子是 GY-521

i2c 驱动gpio模拟i2c

mpu6050_gpio_dev.c

[cpp] view plain copy
 print?
  1. #include <linux/kernel.h>  
  2. #include <linux/module.h>  
  3. #include <linux/platform_device.h>  
  4. #include <linux/i2c-gpio.h>  
  5. #include <mach/regs-gpio.h>  
  6. #include <mach/hardware.h>  
  7. #include <linux/i2c.h>  
  8. #include <linux/delay.h>  
  9.   
  10. MODULE_LICENSE("GPL");  
  11.   
  12. static struct i2c_gpio_platform_data i2c_gpio_adapter_data = {       
  13.     .sda_pin = S3C2410_GPB(8), /* 选用的引脚都是没有外部上拉电阻的 */  
  14.     .scl_pin = S3C2410_GPB(7),  
  15.     .udelay = 50, //5,100kHz 50,10kHz  
  16.     .timeout = 200,       
  17.     /* .sda_is_open_drain = 1, */ /* 从这里可以推测的是这里是设置芯片，如果是 0，则，这个引脚不设置成开漏的模式 */  
  18.     /* .scl_is_open_drain = 1, */  
  19.     /* .scl_is_output_only = 1, */  
  20. };  
  21.   
  22. static void mxs_nop_release(struct device *dev)  
  23. {  
  24.     printk("mpu6050_i2c_gpio_dev release\n");  
  25. }  
  26.   
  27. static struct platform_device i2c_gpio = {       
  28.     .name = "i2c-gpio",  
  29.     .id = 1,  
  30.     .dev = {  
  31.         .platform_data = &i2c_gpio_adapter_data,  
  32.         .release = mxs_nop_release,  
  33.     },       
  34. };       
  35.   
  36. static int mpu6050_i2c_gpio_dev_init(void)  
  37. {  
  38.     printk("mpu6050_i2c_gpio_dev_init.\n");  
  39.   
  40.     platform_device_register(&i2c_gpio);  
  41.   
  42.     return 0;  
  43. }  
  44.   
  45. static void mpu6050_i2c_gpio_dev_exit(void)  
  46. {  
  47.     printk("mpu6050_dev_exit.\n");  
  48.   
  49.     platform_device_unregister(&i2c_gpio);  
  50. }  
  51.   
  52. module_init(mpu6050_i2c_gpio_dev_init);  
  53. module_exit(mpu6050_i2c_gpio_dev_exit);  

Makefile

[cpp] view plain copy
 print?
  1. ifeq ($(KERNELRELEASE),)  
  2.   
  3. #KERNELDIR ?= /lib/modules/$(shell uname -r)/build   
  4. KERNELDIR ?= ~/wor_lip/linux-3.4.112  
  5. PWD := $(shell pwd)  
  6.   
  7. modules:  
  8.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules  
  9.   
  10. modules_install:  
  11.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install  
  12.   
  13. clean:  
  14.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules* Module*  
  15.   
  16. .PHONY: modules modules_install clean  
  17.   
  18. else  
  19.     obj-m := mpu6050_gpio_dev.o  
  20. endif  

【1】将编译生成的文件，拷贝到开发板的文件系统中去，加载后出现匹配成功的字符，会在 /dev 文件夹下创建 i2c-1 ，还有一个 i2c-0 是用控制器控制的i2c接口，前边章节有讲

【2】我们使用的时候只需要像 i2c驱动二：devfs文件系统中的方法一样就行，只需要将读取的文件改成 i2c-1 即可，应用程序如下

mpu6050_devfs.c

[cpp] view plain copy
 print?
  1. #include <stdio.h>  
  2. #include <linux/i2c.h>  
  3. #include <linux/i2c-dev.h>  
  4. #include <unistd.h>  
  5. #include <fcntl.h>  
  6. #include <sys/ioctl.h>  
  7.   
  8. #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))  
  9.   
  10. #define SMPLRT_DIV      0x19  
  11. #define CONFIG          0x1A  
  12. #define GYRO_CONFIG     0x1B  
  13. #define ACCEL_CONFIG    0x1C  
  14. #define ACCEL_XOUT_H    0x3B  
  15. #define ACCEL_XOUT_L    0x3C  
  16. #define ACCEL_YOUT_H    0x3D  
  17. #define ACCEL_YOUT_L    0x3E  
  18. #define ACCEL_ZOUT_H    0x3F  
  19. #define ACCEL_ZOUT_L    0x40  
  20. #define TEMP_OUT_H      0x41  
  21. #define TEMP_OUT_L      0x42  
  22. #define GYRO_XOUT_H     0x43  
  23. #define GYRO_XOUT_L     0x44  
  24. #define GYRO_YOUT_H     0x45  
  25. #define GYRO_YOUT_L     0x46  
  26. #define GYRO_ZOUT_H     0x47  
  27. #define GYRO_ZOUT_L     0x48  
  28. #define PWR_MGMT_1      0x6B  
  29.   
  30. #define ADDR_MPU6050    0x68  
  31.   
  32. static int mpu6050_read_byte(int fd, unsigned char reg)  
  33. {  
  34.     int ret = 0;  
  35.     unsigned char txbuf[1] = {reg};  
  36.     unsigned char rxbuf[1];  
  37.     struct i2c_rdwr_ioctl_data mpu_data;  
  38.   
  39.     ioctl(fd, I2C_TIMEOUT, 1);  
  40.     ioctl(fd, I2C_RETRIES, 2);  
  41.   
  42.     struct i2c_msg msg[] = {  
  43.         {  
  44.             .addr = ADDR_MPU6050, /* 设备的地址 */  
  45.             .flags= 0, /* 0 是写,I2C_RDWR 是读 */  
  46.             .len = ARRAY_SIZE(txbuf), /* msg 的长度 */  
  47.             .buf = txbuf  
  48.         },  
  49.         {ADDR_MPU6050, I2C_M_RD, ARRAY_SIZE(rxbuf), rxbuf},  
  50.     };  
  51.     mpu_data.msgs = msg;  
  52.     mpu_data.nmsgs = ARRAY_SIZE(msg);  
  53.   
  54.     ret = ioctl(fd, I2C_RDWR, &mpu_data);  
  55.     if (ret < 0) {  
  56.         printf("ret = %d\n", ret);  
  57.         return ret;  
  58.     }  
  59.   
  60.     return rxbuf[0];  
  61. }  
  62.   
  63. static int mpu6050_write_byte(int fd, unsigned char reg, unsigned char val)  
  64. {  
  65.     unsigned char txbuf[2] = {reg, val};  
  66.     struct i2c_rdwr_ioctl_data mpu_data;  
  67.   
  68.     ioctl(fd, I2C_TIMEOUT, 1);  
  69.     ioctl(fd, I2C_RETRIES, 2);  
  70.   
  71.     struct i2c_msg msg[] = {  
  72.         {ADDR_MPU6050, 0, ARRAY_SIZE(txbuf), txbuf},  
  73.     };  
  74.     mpu_data.msgs = msg;  
  75.     mpu_data.nmsgs = ARRAY_SIZE(msg);  
  76.   
  77.     ioctl(fd, I2C_RDWR, &mpu_data);  
  78.   
  79.     return 0;  
  80. }  
  81.   
  82. static void read_mpu6050(int fd)  
  83. {  
  84.     unsigned short accel_x = 0, accel_y = 0, accel_z = 0;  
  85.     unsigned short gyro_x = 0, gyro_y = 0, gyro_z = 0;  
  86.     unsigned short temp = 0;  
  87.   
  88.     mpu6050_write_byte(fd, PWR_MGMT_1, 0x00);  
  89.     mpu6050_write_byte(fd, SMPLRT_DIV, 0x07);  
  90.     mpu6050_write_byte(fd, CONFIG, 0x06);  
  91.     mpu6050_write_byte(fd, GYRO_CONFIG, 0x18);  
  92.     mpu6050_write_byte(fd, ACCEL_CONFIG, 0x01);  
  93.   
  94.     while(1) {  
  95.         accel_x = mpu6050_read_byte(fd, ACCEL_XOUT_L);  
  96.         accel_x |= mpu6050_read_byte(fd, ACCEL_XOUT_H) << 8;  
  97.   
  98.         accel_y =  mpu6050_read_byte(fd, ACCEL_YOUT_L);  
  99.         accel_y |= mpu6050_read_byte(fd, ACCEL_YOUT_H) << 8;  
  100.   
  101.         accel_z = mpu6050_read_byte(fd, ACCEL_ZOUT_L);  
  102.         accel_z |= mpu6050_read_byte(fd, ACCEL_ZOUT_H) << 8;  
  103.   
  104.         printf("acceleration data: x = %04x, y = %04x, z = %04x\n", accel_x, accel_y, accel_z);  
  105.   
  106.         gyro_x = mpu6050_read_byte(fd, GYRO_XOUT_L);  
  107.         gyro_x |= mpu6050_read_byte(fd, GYRO_XOUT_H) << 8;  
  108.   
  109.         gyro_y = mpu6050_read_byte(fd, GYRO_YOUT_L);  
  110.         gyro_y |= mpu6050_read_byte(fd, GYRO_YOUT_H) << 8;  
  111.   
  112.         gyro_z = mpu6050_read_byte(fd, GYRO_ZOUT_L);  
  113.         gyro_z |= mpu6050_read_byte(fd, GYRO_ZOUT_H) << 8;  
  114.   
  115.         printf("gyroscope data: x = %04x, y = %04x, z = %04x\n", gyro_x, gyro_y, gyro_z);  
  116.   
  117.         temp = mpu6050_read_byte(fd, TEMP_OUT_L);  
  118.         temp |= mpu6050_read_byte(fd, TEMP_OUT_H) << 8;  
  119.   
  120.         printf("temperature data: %x\n", temp);  
  121.   
  122.         usleep(1000*1000);  
  123.     }  
  124. }  
  125.   
  126. int main(int argc, const char *argv[])  
  127. {  
  128.     int fd;  
  129.   
  130.     fd = open("/dev/i2c-1", O_RDWR);  
  131.     if (fd < 0)  
  132.         perror("open error");  
  133.   
  134.     read_mpu6050(fd);  
  135.       
  136.     close(fd);  
  137.     return 0;  
  138. }  

【1】编译命令别忘了：

arm-none-linux-gnueabi-gcc mpu6050_devfs.c -o mpu6050_devfs -march=armv4t

【2】以下是运行成功的打印信息

i2c 驱动gpio模拟i2c

相关推荐