依据上一篇对rt-thread I2C软件框架的分析，应用层调用I2C框架的接口就可以通过系统注册的总线设备，完成对应外设的控制。本次试验的芯片型号为ROHM 的i2c 三轴加速度传感器（KX224=1053）系列。
应用层只需使用 struct rt_i2c_bus_device *rt_i2c_bus_device_find(const char *bus_name) 函数找到对应的总线设备，并通过返回的 rt_i2c_bus_device  句柄操作外设，通过rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus, struct rt_i2c_msg  msgs[],rt_uint32_t  num)控制总线完成数据的发送接收，用户层不必关系IIC总线的相关操作，从而减少开发周期，用户只需关系芯片先关的操作即可。

===========================以下进入本次的主题==========================

虽然datasheet中寄存器的描述有很多，不过根据官方的使用说明文档,要想获得三轴加速度的信息，只需设定几个参数即可，设定加速度传感器的测量范围，及输出频率，和工作模式后就能够从芯片的X,Y,Z通道读取出三轴加速度信息。

本次试验使用的BSP为官方已经适配支持\rt-thread\bsp\stm32\stm32l476-st-nucleo 开发板，进入该目录后env工具执行menuconfig配置界面开启I2C1并设置SCL和SDA线的引脚ID后I2C驱动框架相关的代码就会加入工程中进行编译。

1. #include <rtthread.h>
   
2. #include <rtdevice.h>
   
3. #include <board.h>
   
4. #include "kx224.h"
   
5. 
   
6. static rt_err_t write_reg(struct rt_i2c_bus_device *bus,rt_uint8_t reg,rt_uint8_t data)
   
7. {
   
8.         struct rt_i2c_msg msgs;
   
9.         rt_uint8_t buff[2];
   
10.         rt_size_t size = 0;
    
11.         
    
12.         buff[0] = reg;
    
13.         buff[1] = data;
    
14. 
    
15.         msgs.addr = KX224_DEVICE_ADDRESS_1E;
    
16.         msgs.flags = RT_I2C_WR;
    
17.         msgs.buf = buff;
    
18.         msgs.len = 2;
    
19. 
    
20.         if( rt_i2c_transfer(bus, &msgs, 1))
    
21.         {
    
22.                 return RT_EOK;
    
23.         }
    
24.         else
    
25.         {
    
26.                 return -RT_ERROR;
    
27.         }
    
28. }
    
29. 
    
30. static rt_err_t write_cmd(struct rt_i2c_bus_device *bus,rt_uint8_t reg)
    
31. {
    
32.         struct rt_i2c_msg msgs;
    
33.         rt_uint8_t buff[2];
    
34.         rt_size_t size = 0;
    
35.         
    
36.         buff[0] = reg;
    
37. 
    
38.         msgs.addr = KX224_DEVICE_ADDRESS_1E;
    
39.         msgs.flags = RT_I2C_WR;
    
40.         msgs.buf = buff;
    
41.         msgs.len = 1;
    
42. 
    
43.         if(rt_i2c_transfer(bus, &msgs, 1))
    
44.         {
    
45.                 return RT_EOK;
    
46.         }
    
47.         else
    
48.         {
    
49.                 return -RT_ERROR;
    
50.         }
    
51. }
    
52. 
    
53. 
    
54. static rt_err_t red_reg(struct rt_i2c_bus_device *bus,rt_uint8_t len,rt_uint8_t * buf)
    
55. {
    
56.         struct rt_i2c_msg msgs;
    
57.         rt_size_t size = 0;
    
58.         
    
59.         msgs.addr = KX224_DEVICE_ADDRESS_1E;
    
60.         msgs.flags = RT_I2C_RD;
    
61.         msgs.buf = buf;
    
62.         msgs.len = len;
    
63. 
    
64.         if(rt_i2c_transfer(bus, &msgs, 1))
    
65.         {
    
66.                 return RT_EOK;
    
67.         }
    
68.         else
    
69.         {
    
70.                 return -RT_ERROR;
    
71.         }
    
72. }
    
73. 
    
74. static rt_uint32_t _g_sens;
    
75. struct rt_i2c_bus_device* bus = NULL;
    
76. 
    
77. void kx224_init(void)
    
78. {
    
79.         rt_uint8_t deviceid = 0,reg = 0,gsel = 0;
    
80.         
    
81.     bus = rt_i2c_bus_device_find("i2c1");
    
82.         if(!bus)
    
83.         {
    
84.                 rt_kprintf("can't find i2c device\n");
    
85.                 return;
    
86.         }
    
87.         write_cmd(bus,KX224_WHO_AM_I);
    
88.         red_reg(bus,1,&deviceid);
    
89.         if(deviceid != KX224_WAI_VAL)
    
90.         {
    
91.                 rt_kprintf("can't find device\n");
    
92.                 return;
    
93.         }
    
94.           write_reg(bus,KX224_CNTL1,KX224_CNTL1_VAL);
    
95.         write_reg(bus,KX224_ODCNTL,KX224_ODCNTL_VAL);
    
96.         write_cmd(bus,KX224_CNTL1);
    
97.         red_reg(bus,1,&reg);
    
98.         gsel = reg & KX224_CNTL1_GSELMASK;
    
99.         rt_kprintf("reg is 0x%02x gsel is 0x%02x\n",reg,gsel);
    
100.         reg |= KX224_CNTL1_PC1;
     
101.         write_reg(bus,KX224_CNTL1, reg);
     
102.         switch(gsel) {
     
103.     case KX224_CNTL1_GSEL_8G :
     
104.       // (Equivalent counts) / (Range) = (32768 / 8)
     
105.       _g_sens = 4096;
     
106.     break;
     
107. 
     
108.     case KX224_CNTL1_GSEL_16G :
     
109.       // (Equivalent counts) / (Range) = (32768 / 16)
     
110.       _g_sens = 2048;
     
111.     break;
     
112. 
     
113.     case KX224_CNTL1_GSEL_32G :
     
114.       // (Equivalent counts) / (Range) = (32768 / 32)
     
115.       _g_sens = 1024;
     
116.     break;
     
117. 
     
118.     default:
     
119.     break;
     
120.   }
     
121.   rt_kprintf("_g_sens is <%d>\n",_g_sens);        
     
122. }
     
123. 
     
124. 
     
125. void kx224_get_rawval(unsigned char *data)
     
126. {
     
127. 
     
128.   write_cmd(bus,KX224_XOUT_L);
     
129.   red_reg(bus,6,data);
     
130. }
     
131. 
     
132. 
     
133. void kx224_get_val(float *data)
     
134. {
     
135.   rt_uint8_t val[6] = {0};
     
136.   rt_int16_t acc[3] = {0};
     
137.   
     
138.   kx224_get_rawval(val);
     
139.   acc[0] = ((signed short)val[1] << 8) | (val[0]);
     
140.   acc[1] = ((signed short)val[3] << 8) | (val[2]);
     
141.   acc[2] = ((signed short)val[5] << 8) | (val[4]);
     
142. 
     
143.   // Convert LSB to g
     
144.   data[0] = (float)acc[0]/_g_sens;
     
145.   data[1] = (float)acc[1]/_g_sens;
     
146.   data[2] = (float)acc[2]/_g_sens;
     
147. }

复制代码

1. #ifndef __KX224__
   
2. #define __KX224__
   
3. 
   
4. #define KX224_DEVICE_ADDRESS_1E   (0x1E)    // 7bit Addrss
   
5. #define KX224_DEVICE_ADDRESS_1F   (0x1F)    // 7bit Address
   
6. #define KX224_WAI_VAL             (0x2B)
   
7. 
   
8. #define KX224_XOUT_L              (0x06)
   
9. #define KX224_WHO_AM_I            (0x0F)
   
10. #define KX224_CNTL1               (0x18)
    
11. #define KX224_ODCNTL              (0x1B)
    
12. 
    
13. #define KX224_CNTL1_TPE           (1 << 0)
    
14. #define KX224_CNTL1_WUFE          (1 << 1)
    
15. #define KX224_CNTL1_TDTE          (1 << 2)
    
16. #define KX224_CNTL1_GSELMASK      (0x18)
    
17. #define KX224_CNTL1_GSEL_8G       (0x00)
    
18. #define KX224_CNTL1_GSEL_16G      (0x08)
    
19. #define KX224_CNTL1_GSEL_32G      (0x10)
    
20. #define KX224_CNTL1_DRDYE         (1 << 5)
    
21. #define KX224_CNTL1_RES           (1 << 6)
    
22. #define KX224_CNTL1_PC1           (1 << 7)
    
23. 
    
24. #define KX224_ODCNTL_OSA_50HZ     (2)
    
25. #define KX224_ODCNTL_LPRO         (1 << 6)
    
26. #define KX224_IIR_BYPASS          (1 << 7)
    
27. 
    
28. #define KX224_CNTL1_VAL           (KX224_CNTL1_RES | KX224_CNTL1_GSEL_8G)
    
29. #define KX224_ODCNTL_VAL          (KX224_ODCNTL_OSA_50HZ)
    
30. 
    
31. extern void kx224_get_val(float *data);
    
32. extern void kx224_init(void);
    
33. #endif /* end of KX224 */

复制代码

以上代码的设定相关代码主要如下，之后就可以读取数据了：

1. write_reg(bus,KX224_CNTL1,KX224_CNTL1_VAL);
   
2.         write_reg(bus,KX224_ODCNTL,KX224_ODCNTL_VAL);
   
3.         write_cmd(bus,KX224_CNTL1);
   
4.         red_reg(bus,1,&reg);
   
5.         gsel = reg & KX224_CNTL1_GSELMASK;
   
6.         rt_kprintf("reg is 0x%02x gsel is 0x%02x\n",reg,gsel);
   
7.         reg |= KX224_CNTL1_PC1;
   
8.         write_reg(bus,KX224_CNTL1, reg);

复制代码

读取数据的相关如下，设定完成后就可以从KX224_XOUT_L开始的寄存器来读取数据了，连续读取6个数据就会读出三轴加速度的值：

1. void kx224_get_rawval(unsigned char *data)
   
2. {
   
3. 
   
4.   write_cmd(bus,KX224_XOUT_L);
   
5.   red_reg(bus,6,data);
   
6. }

复制代码

调试过程主要遇到两个问题：①设定的地址设定的读地址和对应的写地址，后开总是从机没有响应NACK,跟了下代码发现驱动框架中会根据设备的7bit或者10bit地址自动计算读读写时对应的地址，地址设定为七地址即可。
②因为板子上的IO口模拟的IIC 总线没有上拉电阻，造成每次都是NACK,IO设定为内部上拉即可。
以上只是相对简单的方式，模块还支持中断的方式，有时间再进一步研究，存粹个人理解有什么不对的欢迎拍砖指正。

AN090-Getting-Started.pdf (523.62 KB, 下载次数: 0)

2019-6-21 13:00 上传

点击文件名下载附件

applications.zip (2.63 KB, 下载次数: 3)

2019-6-21 13:03 上传

点击文件名下载附件

KX224-1053-Specifications-Rev-2.0.pdf (2.47 MB, 下载次数: 0)

2019-6-21 13:03 上传

点击文件名下载附件

你好像屠版了哦！！！

MrJiu 发表于 2019-6-21 14:04
你好像屠版了哦！！！

？？？这个怎么讲，为啥屠版了呢

顶一个