一、I2C总线协议
- j% v; w( r" r2 W/ D1 F6 V% c       I2C（Inter Integrated Circuit）总线是 PHILIPS 公司开发的一种半双工、双向二线制同步串行总线。I2C 总线传输数据时只需两根信号线，一根是双向数据线 SDA（serial data），另一根是双向时钟线 SCL（serial clock）。SPI 总线有两根线分别用于主从设备之间接收数据和发送数据，而 I2C 总线只使用一根线进行数据收发。I2C 以主从的方式工作，并允许同时有多个主设备存在，每个连接到总线上的器件都有唯一的地址，主设备启动数据传输并产生时钟信号，从设备被主设备寻址，同一时刻只允许有一个主设备。
8 u$ f0 P6 }9 L( I: c
        I2C 总线主要的数据传输格式：
) b. o) _2 |, l5 m/ z# p* y, y# E


        当总线空闲时，SDA 和 SCL 都处于高电平状态，当主机要和某个从机通讯时，会先发送一个开始条件，然后发送从机地址和读写控制位，接下来传输数据（主机发送或者接收数据），数据传输结束时主机会发送停止条件。传输的每个字节为8位，高位在前，低位在后。

9 u0 H9 h) ~/ T6 z' ?7 [        开始标记：SCL 为高电平时，主机将 SDA 拉低，表示数据传输即将开始；

# y0 a$ ^* U" T4 |" a        从设备地址（或叫从机地址）：主机发送的第一个字节为从机地址，高 7 位为地址，最低位为 R/W 读写控制位，1 表示读操作，0 表示写操作。一般从机地址有 7 位地址模式和 10 位地址模式两种，如果是 10 位地址模式，需要用两个字节（16位）来表述，第一个字节的头 7 位 是 11110XX 的组合，其中最后两位（XX）是 10 位地址的两个最高位，第二个字节为 10 位从机地址的剩下8位：        

# k- B+ l4 V# x! S+ n& |* ]
  W1 H) q: W/ ^/ K! I
         应答： 每传输完成一个字节的数据，接收方就需要回复一个 ACK（acknowledge）。写数据时由从机发送 ACK，读数据时由主机发送 ACK。当主机读到最后一个字节数据时，可发送 NACK（Not acknowledge）然后跟停止条件。

9 M& k9 v; _% a$ |        数据： 从机地址发送完后可能会发送一些指令，依从机而定，然后开始传输数据，由主机或者从机发送，每个数据为 8 位，数据的字节数没有限制。

/ y4 o5 K0 Q5 L" e# P  z        重复开始： 在一次通信过程中，主机可能需要和不同的从机传输数据或者需要切换读写操作时，主机可以再发送一个开始条件。
1 G, l9 ], a( H! G. t
' f) V$ z+ L2 Q: F  l$ z- H5 Y0 A; a        停止标记： 在 SDA 为低电平时，主机将 SCL 拉高并保持高电平，然后在将 SDA 拉高，表示传输结束。
+ z8 Y* ^) z5 L4 g- u

二、I2C协议的两种从机应对方式
9 A$ J  [$ T7 ?2 X9 D- f, e. o1 l4 t        从机对I2C协议通讯我本人认为提供了两种实现方式：
8 Q& I; m( M! g  B: e! H
        寄存器直接访问方式：这种方式是从机直接将其参数、采集数据放置存储区域，并将存储地址暴露给主机，让主机直接按存储地址获取数据，或修改存储地址上的数据，从机感知数据变化做应对处理，从而实现对从机下行控制。我个人管这种方式叫从机地址+寄存器地址。

- v+ C7 s6 _6 A7 O* J% i
4 |6 q( J( P' i- V! [* p# y( H( ?
         命令接口间接访问方式：这种方式从机对主机采用问答式服务，不会提供存储地址给主机，只是给出相关指令信息给主机，这些指令相当于从机对外提供的业务接口，例如主机需要读取某个数值，需要先向从机发送读取指令，从机将需要的数据做准备并等待主机下一次指令，主机再去读取数据。我个人管这种方式叫从机地址+CMD指令。
8 |* b  S* H1 O0 U5 L


         我们再看HLA标准库提供I2C接口API，也支持这两种方式：

1. //从机地址+CMD
   
2. HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData,
   
3.                                           uint16_t Size, uint32_t Timeout);
   
4. HAL_StatusTypeDef HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData,
   
5. 
   ( Z, V: V( b' a7 a- m
6. //从机地址+寄存器地址
   
7. HAL_StatusTypeDef HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress,
   
8.                                     uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout);
   
9. HAL_StatusTypeDef HAL_I2C_Mem_Read(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress,
   
10.                                    uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout);

复制代码

        PS：I2C在写入和读取时，从机地址是不同的，例如一般“读取从机地址=写入从机地址+1”，在实际使用HAL标准库已经做了内部处理，所以我们就不管读还是写操作，只传入写地址即可，HAL库的读写函数会调用I2C_TransferConfig来完成相关配置，包括从机地址问题，开始条件问题、时钟问题等。

1. /**
   . c5 e9 U4 T! J8 `
2.   * @brief  Handles I2Cx communication when starting transfer or during transfer (TC or TCR flag are set).
   
3.   * @param  hi2c I2C handle.
   
4.   * @param  DevAddress Specifies the slave address to be programmed.
   
5.   * @param  Size Specifies the number of bytes to be programmed.
   
6.   *   This parameter must be a value between 0 and 255.
   7 h0 f- `6 p* I& ~5 ~% e9 r
7.   * @param  Mode New state of the I2C START condition generation.
   
8.   *   This parameter can be one of the following values:
   8 o1 j- t3 ]% h3 A" l, ?" B' p
9.   *     @arg @ref I2C_RELOAD_MODE Enable Reload mode .
   
10.   *     @arg @ref I2C_AUTOEND_MODE Enable Automatic end mode.
    9 u1 j0 v' T% ]5 N
11.   *     @arg @ref I2C_SOFTEND_MODE Enable Software end mode.
    
12.   * @param  Request New state of the I2C START condition generation.
    
13.   *   This parameter can be one of the following values:
    
14.   *     @arg @ref I2C_NO_STARTSTOP Don't Generate stop and start condition.
    * m8 Z2 M4 B* Y' G& I8 t& s
15.   *     @arg @ref I2C_GENERATE_STOP Generate stop condition (Size should be set to 0).
    " k5 Q1 R6 x! l
16.   *     @arg @ref I2C_GENERATE_START_READ Generate Restart for read request.
    
17.   *     @arg @ref I2C_GENERATE_START_WRITE Generate Restart for write request.
    3 K1 F) r1 e7 ?: f
18.   * @retval None
    
19.   */
    
20. static void I2C_TransferConfig(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode,
    8 I4 V, t$ }/ m& L  J9 e
21.                                uint32_t Request)

复制代码

# j: a+ C/ B0 E三、传感器信息
9 N" d) N% R1 F& g2 B( i$ }: K        本文采用STM32L496VGTX的ali开发板， 该开发板已经连接了以下5个传感器，下图蓝色部分标注的5个传感器就是本文需要实现的（音频、摄像头不仅仅I2C接口，还需要其他接口支持，暂时不在本文展开）：



1 V. g3 K/ I* u: C; j         这些传感器的硬件原理图如下：
        1）SHTC1温湿度传感器


6 s- s3 t4 {$ _; s) R, w
        2)LTR-553ALS光感及接近传感器，注：它除了I2C支持，还需要一个额外的GPIO引脚
. w+ a5 a8 K$ q8 @: t8 F; u% g
- m  _0 p  }% D, D5 |. M6 O+ i
. \* T7 d8 `( f$ i
+ {- K) `! Y# V' W! a( a9 k: M         3)BMP280气压传感器



        4） LSM6DSL加速度及角速度传感器


, Y& X/ |. n. N# g$ u
        5） MMC3680KJ三轴磁传感器
7 l9 Y) \1 ^3 O& Z& A9 I6 e
' j! v  G+ l0 t6 s
; v" H& k$ k% e0 w- y+ v& l) I
         这些传感器都是通过I2C总线连接到STM32L496VGT3的MCU上，MCU的I2C引脚接口如下：
& {7 R2 b* Z- D" m1 Y

$ b4 ^, _: n8 d2 j" @* W
, z' B: q( D* G; L( z4 q4 l/ }3 g
4 N; \( {# T: c: \1 L5 V
2 \7 q$ n' g/ X$ o& n        另外 LTR-553ALS还需要一个GPIO引脚辅助
. X0 E) J8 ]+ u+ v( G
) A" C; F( f& Z) }& n2 o  {

! K1 I$ m% a, n# {4 c
, D5 W$ V) z4 n+ T四、工程创建及引脚配置
' \8 l/ W4 D4 x        本文新建了一个STM32L496VGTX_I2C工程，并移植了前面已经实现过的串口调试输出及OLED屏幕输出文字的源码

        假设已经基于STM32L496VGTX的MCU上实现了lpusart调试信息输出，和SPI1的oled屏幕显示，接下来配置I2C2和I2C4接口及PA15引脚。
% D2 k) M' W1 c* _
        1）开启I2C2配置，参数保持默认，注意从机地址7bit长度的

* X) F9 x# S4 n2 p! ^  b

- t+ i+ i0 p& f         2）开启I2C2的DMA支持和中断支持（本文代码实现暂时没采用DMA，只是先开启）
  I  C, c* I' M' i; F% u
6 j/ f& P9 W+ D


& O- j4 E8 T. w/ t
( D/ W- Y0 O/ t3 U/ o         3）同样开启I2C4接口以及开启其DMA功能和中断功能
5 O) _( v8 K1 i

% ?, P" M; H$ _
         I2C4的DMA及中断功能
; ?& }* a5 j; Y* Q- d

' t( \7 x3 |2 f! J; ^4 Q
+ U5 x! o3 R& J( Q8 q  E
5 b7 Y. f* P3 f0 C4 F6 ?" o
        4） I2C2、I2C4引脚参数配置

  ~7 k; M' _" A( v/ J* Y# E

         5）配置LTR-553ALS传感器需要的PA15引脚，并开启该PA15的中断功能支持


8 `" B  x, t% V  h

# w, \$ e: u. b) [' t: z2 ?
% j$ M* F. }; b        配置完成后点击保存或生成代码按钮，完成图形配置到代码生产的输出。

; g! l' F3 \+ R  p" ]& N 五、STCH1传感器实现
        在ICore源码目录下添加STCH1文件夹，并在该文件夹下添加STCH1.h和STCH1.c文件作为STCH1传感器的驱动文件。

        本人去网上下载了一份STCH1传感器的数据手册，读取分析发现采用前面所述的从机地址+CMD指令方式，先明确STCH1的设备地址是0X70，而开发板给出的地址是0XE0，STCH1集成到开发板是经过了微调（0XE0=(0X70<<1）)，那我们采用0XE0就好：
! i. m9 }  p" b0 q2 T2 [' u1 F


        MCU通过I2C协议读取STCH1传感器的温湿度数据需要经历以下几个过程：

# U4 I( _) y* c) [. g8 A        1）STCH1传感器的ID号确认，简单描述就是向STCH1写入两字节的0XEF 0XC8（告诉STCH1我要稍后来读取这个注册地址的数据，请准备好），再读取两个字节数据（16bit）,取0~5bit的数据如果是0X07就表明OK。
3 ?2 w  T( e# X# i' o% S- {  X
. R& B0 N' n: b+ P& g0 e! p
3 J2 \3 D$ c$ |6 T- x& I* Z, L
+ s7 F4 e1 ?  L) ~         2）STCH1软重置要求，就是向STCH1写入两字节（16bit）的0X80 0X5D数据即可实现软重置。
" o3 d8 ^" l. T9 ~0 ?  O' L
& Q- a! k# j* Z/ ]8 I( B+ m. h$ a

$ z. X8 m7 y5 I# x
- S7 ]$ M  V" ~3 H         3）STCH1读取数据前，需要明确数据读取组合格式，意思就是I2C开启Clock Stretching时，向STCH1写入16bit的0X7C 0XA2数据，再去读取数据时就是温度数据在前、湿度数据灾后，其他类似，如下图，是否开启Clock Stretching和是否温度在前组合共有四种组合方式。
2 T1 v5 t) Q+ F+ H: e
6 K. E' B/ }& w
/ j' O9 @1 v2 r0 }  N3 j* b
$ m: [$ t. i) {6 W         4）下图指出如何读取数据，在告知数据组合方式后，需要读取六字节（6*8 bit）的数据，其中第三和第六字节是CRC数据，剩余的是温湿度数据，第一、第二字节组成一个具体数据，最高有效位(MSB)在前、最低有效位(LSB)在后，第三、第四字节组成一个具体数据，第一、第二字节是温度还是湿度数据，由读取前写入指令确定，详见3）。
" h$ L! R8 e+ |/ ^& L% V- s


         5）数据换算到的原数据，需要经过换算公式换算后，才能表示实际的温湿度数值。
- V3 N9 v+ l  T" N4 O6 R5 M
' V9 m8 i+ Z2 k  n4 V$ s  V

0 O6 Q" L* v/ {7 s2 Z         6）伪代码设计：
" U7 {* O5 Q+ w+ c

1. init:
   ; C; _; {  `& r
2. write 0xef 0xc8 to 0XE0
   5 u' B* [5 h* O5 g
3. read  两字节Data     from 0XE0
   9 v. O% ?- I3 d% l* j6 }, @
4. 取出 Data的0~5位数据与0X07比较完成ID识别
   * y. W& ~; b$ [, w
5. write 0X80, 0X5D to 0XE0 完成重置
   
6. 
   
7. read data
   ) Q3 ]2 a. F+ n
8. write 读取方式指令，例如0X7C 0XA2 to 0XE0
   
9. read 六字节Data from 0XE0
   
10. Data 1、2字节为温度原始数据，经换算公式获得实际温度值
    
11. Data 3、4字节为湿度原始数据，经换算公式获得实际湿度值

复制代码

         7）源码STCH1.h和STCH1.c文件内容如下：
% c2 l/ N% ]8 p! M) [% F
/ z5 v3 @) r: I+ v        STCH1.h

1. #ifndef SHTC1_SHTC1_H_
   
2. #define SHTC1_SHTC1_H_
   2 Z2 |  ?! @3 u. t
3. 
   
4. #include "main.h"
   
5. 
   
6. void shtc1_init();
   
7. uint8_t read_ht(float *cur_humi,float *cur_temp);
   4 L+ S8 ~+ _6 S0 |& Y
8. 
   
9. #endif /* SHTC1_SHTC1_H_ */

复制代码

% ?( R# q; @$ h7 |         STCH1.c，注意的是由于STCH1传感器采用从机地址+CMD指令方式实现，所以驱动文件调用的是HAL_I2C_Master_Transmit和HAL_I2C_Master_Receive完成I2C数据收发，有别于后面涉及的4种传感器。
: K& r, d7 U. x. ^) ]0 L5 s

1. #include <stdio.h>
   
2. #include "SHTC1.h"
   7 d) @$ g5 Y9 J2 U
3. 
   
4. extern I2C_HandleTypeDef hi2c2;
   
5. 
   : B) i$ C/ D! i) m- }- U
6. #define SHTC1_I2C_SLAVE_ADDR 0x70
   
7. 
   
8. #define SHTC1_ADDR_TRANS(n) ((n) << 1)
   9 @5 D) `# h; k& P+ s$ ]0 X
9. #define SHTC1_I2C_ADDR SHTC1_ADDR_TRANS(SHTC1_I2C_SLAVE_ADDR)
   
10. 
    : D; U4 ]2 q2 X) A6 G& }
11. /* delays for non-blocking i2c commands, both in ms */
    
12. #define SHTC1_NONBLOCKING_WAIT_TIME_HPM 15
    
13. #define SHTC1_NONBLOCKING_WAIT_TIME_LPM 1
      M- _: K' t* r( j! e  p* ^, e
14. 
    . r# Q4 {) h2 S6 Y$ \8 i! O7 P
15. #define SHTC1_CHIP_ID_VAL 0x07
    . x7 b7 H/ c) D) c. t' x2 N' b
16. #define SHTC1_ID_REG_MASK 0x1f
    
17. 
    $ f. d4 g2 C4 X& ~8 P# r
18. #define SHTC1_CMD_LENGTH 2
    , W1 }3 Y- H1 d) ~  L- ]
19. #define SHTC1_RESPONSE_LENGTH 6
    
20. 
    3 C' |4 z; y( M8 m0 |  @
21. #define SHTC1_DATA_READ_MIN_INTERVAL 200 /* in millisecond */
    
22. 
    # N( L& y1 [$ i: w3 F* W
23. typedef enum
    
24. {
    
25.     FLAG_INIT_TEMP = 0,
    2 |2 Y' T- f8 C- h3 R2 x
26.     FLAG_INIT_HUMI,
    
27. } FLAG_INIT_BIT;
    
28. 
    
29. typedef enum
    
30. {
    5 Z) i$ N* L1 W/ h; E% p
31.     SHTC1_CMD_read_id_reg,
    ( ]5 |! G( E' }8 N, f9 Z/ L
32.     SHTC1_CMD_measure_blocking_hpm,
    : \0 Y6 \7 s  p9 G, B
33.     SHTC1_CMD_measure_nonblocking_hpm,
    
34.     SHTC1_CMD_measure_blocking_lpm,
    ; q0 a2 b" \/ q( L- i- e3 z5 m
35.     SHTC1_CMD_measure_nonblocking_lpm,
    / [' c# d: ^- _  }
36.     SHTC1_CMD_END
    
37. } CMD_SHTC1_ENUM;
    
38. 
      h$ `! T) f9 b
39. uint8_t SHTC1_id_check()
    
40. {
    
41.         HAL_StatusTypeDef hi2c2_status = 0x00;
    
42.         uint8_t data[SHTC1_CMD_LENGTH] = { 0xef, 0xc8 };
    " u5 {# j" b: s# ], ]7 q' x
43.         hi2c2_status = HAL_I2C_Master_Transmit(&hi2c2,SHTC1_I2C_ADDR,data,SHTC1_CMD_LENGTH,1000);
    8 s7 k- g) j5 J; A9 S
44.         if(HAL_OK!=hi2c2_status){
    ' T9 z: G# T! {, z
45.                 printf("set SHTC1_id error\r\n");
    
46.                 return 1;
    
47.         }
    2 k3 C3 X  D# K" v' j0 \4 U' @% R+ j
48.         uint8_t value[2] = { 0 };
    
49.         hi2c2_status = HAL_I2C_Master_Receive(&hi2c2,SHTC1_I2C_ADDR,value,2,1000);
    
50.         if(HAL_OK!=hi2c2_status){
    
51.                 printf("get SHTC1_id error\r\n");
    2 `; Q6 V4 U) ~1 b, [! q1 b
52.                 return 1;
    ' i5 K) I0 d8 Q# \2 p1 Z, J
53.         }
    
54.         printf("SHTC1_id:0X%02X%02X\r\n",value[0],value[1]);
    
55.         //SHTC1_ID_REG_MASK=0X1F,SHTC1_CHIP_ID_VAL=0X07
    
56.         if ((value[1] & SHTC1_ID_REG_MASK) != SHTC1_CHIP_ID_VAL) {
    - c! G0 K5 N* ]
57.         return 1;
    * S; ~; t4 Y/ d) g" j& H
58.     }
    " t6 c* _' ~/ q; ^4 X' K0 D) M
59.         printf("SHTC1_id check successfully\r\n");
    7 I3 ~3 K  y/ L, r3 [
60.         return 0;
    ' ]4 i' g$ c6 K
61. }
    
62. //软重置
    2 j* L: w& I1 n  Z# k8 V4 {% Z
63. void reSet()
    
64. {
    
65.         HAL_StatusTypeDef hi2c2_status = 0x00;
    ' A: Z9 a, M$ F$ W. X: D) ?; h
66.     uint8_t temp[2] = {0X80, 0X5D};
    
67.     hi2c2_status = HAL_I2C_Master_Transmit(&hi2c2,SHTC1_I2C_ADDR,temp,2,1000);
    6 o. F( M6 v9 B/ I4 C
68.     if(HAL_OK!=hi2c2_status){
    * t. g$ |4 w, I9 c/ U
69.                 printf("SHTC1 reset error\r\n");
    0 |( j8 x0 N- o: i2 M) q
70.                 return;
    
71.         }
    
72.     printf("SHTC1 reSet successfully\r\n");
    ( K5 ~( ?; J" Q: W; e
73. }
    : H: n- X  E3 B1 d; ^# @" e  t
74. 
    
75. /*SHTC1提供了定义测量期间的传感器行为以及测量结果的传输序列的可能性。
    
76. *每个测量命令都会同时触发温度测量和湿度测量。
    , ~. u# E( B" P+ T4 Q9 W
77. *bool enabled时钟是否启用，bool humi是否在前*/
    . d" [! r: L- s) B7 p6 i# ]9 ^
78. void clock_set(uint8_t enabled,uint8_t humi)
    
79. {
    
80.     uint8_t temp[2] = {0, 0};
    - Q  O5 G- w$ a  d6 ^- q
81.     if(enabled){
    ! x7 y- d8 E- f2 J3 ?2 y) h/ X* X
82.         /*时钟拉伸 已启用*/
    0 x) |: S- a" ~8 g! |; f
83.         if(humi){
    7 h! e+ i: b  {! r0 I3 A7 u
84.             /*湿度、温度*/
    
85.             temp[0] = 0x5C;
    
86.             temp[1] = 0x24;
    1 o* a) U. ?* }& T$ u
87.         }else{
    
88.             /*温度、湿度*/
    ) T* U' w0 q9 k; X# `6 M7 B+ a
89.             temp[0] = 0x7C;
    " G5 ]7 q/ m& X# U
90.             temp[1] = 0xA2;
    0 B% `" _) g& N* C
91.         }
    6 c9 L. @9 K. `, b3 g, {! b
92.     }else{
    & D! _5 v2 V4 N
93.         /*时钟拉伸 丧失能力的*/
    
94.         if(humi){
    8 b& {0 x3 b: h" R' ^
95.             /*湿度、温度*/
    
96.             temp[0] = 0x58;
    
97.             temp[1] = 0xE0;
    8 f! |' a8 `& x' r
98.         }else{
    : m% _* L  d3 c' Q  J
99.             /*温度、湿度*/
    ) Z5 m3 P/ n6 T! P: w9 K& b! D1 _
100.             temp[0] = 0x78;
     
101.             temp[1] = 0x66;
     
102.         }
     
103.     }
     / G- S$ f0 e' t* }- i& {4 b& B
104.     printf("out model:");
     
105.     for(uint8_t i=0; i<2; i++ )
     0 x* u1 n- v( x3 ^3 S: h3 |
106.     {
     
107.         printf("%02X ", temp[i]);
     
108.     }
     
109.     printf("\n");
     
110.     HAL_I2C_Master_Transmit(&hi2c2,SHTC1_I2C_ADDR,temp,2,1000);
     
111. }
     8 G. b2 u; k$ U5 v/ u: E9 s
112. 
     8 F: I$ J2 n" M3 K# p. }
113. void shtc1_init()
     ' f+ I5 F# m. K5 z: `
114. {
     
115.         SHTC1_id_check();
     " k0 {) e% ?2 q& [$ D& m+ }8 @
116.     reSet();
     0 ^0 {- w3 P  `
117.     HAL_Delay(1000);
     
118.     /*温度在前*/
     
119.     clock_set(1,0);
     
120.     HAL_Delay(1000);
     
121. }
     
122. 
     
123. uint8_t read_ht(float *cur_humi,float *cur_temp)
     ; K# ?7 ?. b7 ?( _$ f) y/ z1 x6 x* b1 K
124. {
     
125.         /* 1、先发送要读取确认 */
     
126.         clock_set(1,0);/*时钟拉伸 已启用 && 温度、湿度->0X7C 0XA2*/
     , O7 n$ e$ b7 x' P* u+ T, \
127.         /* 2、读取数据 */;
     8 A- B5 b/ L( S% N
128.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
129.         uint8_t retval[SHTC1_RESPONSE_LENGTH] = {0x00};
     + z0 T3 ]$ a1 `1 z- A( e- b
130.         hi2c2_status = HAL_I2C_Master_Receive(&hi2c2, SHTC1_I2C_ADDR, retval, 6, 1000);
     
131.         if(HAL_OK!=hi2c2_status)
     / ?$ l0 d6 _/ b  D
132.                 return 1;
     ' O( X4 b; E7 _/ \7 Y
133.         else{
     
134.             uint32_t val01 = (retval[0] << 8 | retval[1]);
     
135.             uint32_t val02 = (retval[3] << 8 | retval[4]);
     , U' n$ H+ O% p% H! c6 |) L, X
136.             printf("val01:%d,val02:%d\n",(int)val01,(int)val02);
     * s6 z; D% r) h4 F& R
137.             /* 温度数据转换 */
     
138.             *cur_temp =  val01 * 175.0 / (1 << 16) - 45;
     
139.             //*cur_temp = (int32_t)((21875 * val01) >> 13) - 45000;//千位表示
     
140.             /* 湿度数据转换 */
     
141.             *cur_humi = val02 * 100.0 / (1 << 16);
     0 r+ ^6 [; @) h3 I& I6 V
142.             //*cur_humi = (uint32_t)((12500 * val02) >> 13);
     # o# ^8 i- |6 D) }
143.             //lpusart
     
144.             printf("\nread shtc1 sensor humidity   : %d.%d\n", (int)(*cur_humi), (int)((*cur_humi) * 100) % 100);
     
145.             if( (*cur_temp) >= 0 )
     : ]. O# Q; Y  x) g" F8 q, I2 X
146.                 {
     + S( @- I! R' k4 P  n; K" n
147.                     printf("read shtc1 sensor temperature: %d.%d\n", (int)(*cur_temp), (int)((*cur_temp) * 100) % 100);
     
148.                 }else{
     * F" N  n/ ?+ Z. q+ o/ D
149.                         printf("read shtc1 sensor temperature: %d.%d\n", (int)(*cur_temp), (int)(-(*cur_temp) * 100) % 100);
     * t1 ]" k6 [* h& J
150.             }
     % W7 x8 z9 n- `9 k5 R$ V! C( Y8 \; O
151.                 return 0;
     * ^: B, k9 u; i1 T$ {
152.         }
     . p: h& E. x8 p
153. }

复制代码

六、LTR_553ALS传感器（light sensor [ALS] and proximity sensor）
        在ICore目录下，创建LTR-553ALS-WA文件夹，并在该文件夹下创建LTR-553ALS-WA.h和LTR-553ALS-WA.c源码文件，作为LTR-553ALS传感器驱动。
" ]5 H+ a" U" l0 n' H5 L0 ?
        本人在网上下载了一份LTR-553ALS-WA的数据手册文档，进行分析其实是我们前面所述的从机地址+寄存器地址方式来实现的，那么主要就是分析寄存器地址及相关含义即可，从机地址如下（0X46=0X23<<1）,显然开发板做了调整：
9 v# b7 z: Y1 g2 z& }2 t


! `6 t2 M5 O: H$ e) z5 O' C9 m        1）先看LTR-553ALS的I2C通信格式，下图是写入通信，典型从机地址（Slave address）+寄存器地址（Register Address）方式+写入数据（Register Command）。
; @8 k6 j" K# g4 i% Q8 C
1 A2 r+ Y9 S; O8 u8 G2 x: a0 A

         读通信方式，类似写入方式。


6 V4 L. G8 ]( l7 H. N

) _; X3 J" N( _2 I         2）下图是LTR-553ALS-WA的总寄存器地址描述表，可以看出0X80是ALS（光感应）的模式控制、重置的功能地址，OX81是PS（接近感应）的模式控制，0X82是PS_LED取值地址，0X84、0X85是ALS、PS的激活地址，0X86、0X87是设备的ID验证地址，0X88、0X89、0X8A、0X8B是ALS 数值存储地址，0X8D、0X8E是PS数值存储地址。


8 l# T% C/ s6 E. \
( m$ s- M, x/ q: ~         3）设备ID验证，就是读取0X86的PART_ID数据，正确返回值是0X92，读取0X87的manufac_id数据，正确返回值是0X05.



% l7 ~2 z! g8 ~; i; j( f( s         4）ALS的启用，主要：1.就是向0X85写入激活mode。设置检测time 和 rate，
* \! T+ P6 Z1 V3 W
3 r) [1 c  C6 {8 ^7 K: ~

                 2.向0X80写入contr mode，开启或关闭ACTIVE，如果想保留原来设置，可先读取oldconf，再oldconf&需要的设值，重新写入实现增加或删减支持模式,0X80还支持 software reset.
! B/ H- \, q1 \, {2 y, Y/ q
2 `' W1 L' t* n4 M# M* i

* y3 \# a# h; N, W5 p( N2 V        5)PS的启用，类似于ALS设置，0X84开启Meas Rate激活PS，具体功能支持参考一下图。

$ R! G% G9 e( v
8 t0 |( d0 x# @
; ]9 X: ~$ z( e7 Z% d3 [8 D         向0X81写入数据设置contr mode，开启或关闭ACTIVE
7 c9 C6 Y) I2 Q" Q, U, q4 E


         6）ALS数据读取，最低有效位在前，0X88、0X89读取通道1(ch1)数据


+ m$ a2 u8 C/ a$ M8 q
         0X8A、0X8B读取通道0(ch0)数据
% S6 g- L& V2 q4 O

' N5 b7 @' ~2 d  |. u, g
         7）读取PS数据，访问0X8D、0X8E地址，最低有效位在前。
3 h/ G% E9 r8 g' j+ H


         8）读取ALS（光感应）、PS（接近感应）数据伪代码实现：

1. 从机地址是0x46
   9 x% Y- ]& i8 n8 D6 F  W
2. Init：
   + B4 I" z; o) X3 d
3. read data1 from 从机0x46 寄存地址 0X86
   
4. read data2 from 从机0x46 寄存地址 0X87
   5 p/ X# `. j1 S0 N6 j  K
5. 确保data1=0x92,data2=0x05
   
6. 
   
7. ALS init
   ) a3 k9 s* V9 ^4 b5 d
8. write 设值 to 从机0x46 寄存地址 0X85 设置Measure Time and Rate
   % O( d0 W) T' J% ^' I$ \) j: T
9. write 设值 to 从机0x46 寄存地址 0X80 设置 Active
   
10. 
    
11. PS init
    
12. write 设值 to 从机0x46 寄存地址 0X84 设置Measure Rate
    ; N, @' c2 g) B  z. X# D1 F
13. write 设值 to 从机0x46 寄存地址 0X81 设置 Active
    
14. 
    
15. 读取数据
    
16. 
    
17. ALS read 前提确保0X80 设置 Active开启
    0 J$ V3 k1 C: J
18. read data1~4 from 从机0x46 寄存地址 0X88 0X89 0X8A 0X8B
    - h: n" U1 l, @# i
19. 对data1~4数据进行换算处理
    
20. 
    
21. PS read 前提确保0X81 设置 Active开启
    
22. read data1~2 from 从机0x46 寄存地址 0X8D 0X8E
    3 P, R8 q" o" Z; ?! w' X6 p
23. 对data1~2数据进行换算处理

复制代码

" _1 z! a% @' Z- m8 S4 G        9）LTR-553ALS传感器驱动具体代码，见LTR-553ALS-WA.h和LTR-553ALS-WA.c文件

1. #ifndef _LTR_553ALS_WA_H_
   
2. #define _LTR_553ALS_WA_H_
   
3. 
   . B, l) [5 I: e3 G
4. #include "main.h"
   
5. 
   
6. void LTR_ALS_init();
   
7. void LTR_PS_init();
   ! f* W  J& U( X) y' s6 h
8. 
   
9. uint8_t ltr553_als_open();
   5 r! |+ X. i2 R9 _) k9 V  C
10. uint8_t ltr553_als_close();
    ' j* F, l5 ]  c8 _8 \
11. 
    
12. uint8_t ltr553_ps_open();
    
13. uint8_t ltr553_ps_close();
    
14. 
    " M, w& A% }, U1 t' @
15. uint8_t read_als(uint32_t *als_data);
    ( `# _5 F1 ~. A/ R9 O4 ]
16. uint8_t read_ps(uint32_t *ps_data);
    
17. 
    
18. #endif /* LTR_553ALS_WA_LTR_553ALS_WA_H_ */

复制代码

         LTR-553ALS-WA.c，由于是从机地址+寄存器地址方式，驱动文件调用了HAL标准库的HAL_I2C_Mem_Write和HAL_I2C_Mem_Read函数实现I2C收发。

1. #include <stdio.h>
   2 b7 c! A. G% T; {% c
2. #include "LTR-553ALS-WA.h"
   - a0 p+ |& S4 h9 ]& s- e+ |; }
3. 
   1 l7 w4 B1 I% q, E
4. #define WAIT_FOREVER 0xffffffffu
   
5. 
   
6. extern I2C_HandleTypeDef hi2c2;
   - v$ h/ v; Y& v- M$ t
7. 
   ! M, Z, q3 t0 f, {3 o  U' u9 ~
8. #define LTR553_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
   
9. #define LTR553_PS_CONTR 0x81  /* PS operation mode */
   + _& p! k) c* ?0 L
10. #define LTR553_PS_LED 0x82    /* LED pulse freq, current duty, peak current */
    & P2 y5 ~& S. Q, i, |1 H2 b
11. #define LTR553_PS_MEAS_RATE 0x84  /* measurement rate*/
    
12. #define LTR553_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
    
13. #define LTR553_PART_ID 0x86
    5 T9 i0 {& g* c0 @" X0 P
14. #define LTR553_MANUFAC_ID 0x87
    
15. #define LTR553_ALS_DATA1_L 0x88
    
16. #define LTR553_ALS_DATA1_H 0x89
    
17. #define LTR553_ALS_DATA0_L 0x8a
    * A, V( M1 X( G( K  O/ E
18. #define LTR553_ALS_DATA0_H 0x8b
    
19. #define LTR553_ALS_PS_STATUS 0x8c
    / g% _1 l* z) j& M! Z8 x3 ]+ E
20. #define LTR553_PS_DATA_L 0x8d
    0 C7 }' h. Y. t
21. #define LTR553_PS_DATA_H 0x8e
    
22. #define LTR553_INTR 0x8f           /* output mode, polarity, mode */
    
23. #define LTR553_PS_THRESH_UP 0x90   /* 11 bit, ps upper threshold */
    
24. #define LTR553_PS_THRESH_LOW 0x92  /* 11 bit, ps lower threshold */
    5 K% J0 o' H, Q! P8 ?8 j0 R0 a
25. #define LTR553_ALS_THRESH_UP 0x97  /* 16 bit, ALS upper threshold */
    ( d. `; i+ r' w# K& j7 W! z4 d
26. #define LTR553_ALS_THRESH_LOW 0x99 /* 16 bit, ALS lower threshold */
    9 N, o3 k# H  [: O% J4 l
27. #define LTR553_INTR_PRST 0x9e      /* ps thresh, als thresh */
    2 x9 o! b4 t2 \1 y# W& l& l
28. #define LTR553_MAX_REG 0x9f
    
29. 
    
30. #define LTR553_I2C_SLAVE_ADDR 0x23
    
31. 
    
32. #define LTR553_ADDR_TRANS(n) ((n) << 1)
    ! ?  U1 e) B1 P. {
33. #define LTR553_I2C_ADDR LTR553_ADDR_TRANS(LTR553_I2C_SLAVE_ADDR)
    ( E* k* o, }9 J* x/ i% [  X
34. #define LTR553_PART_ID_VAL 0x92
    
35. #define LTR553_MANUFAC_ID_VAL 0x05
    
36. 
    7 c6 `9 ]3 t# U( t8 C: Q
37. #define LTR553_ALS_CONTR_REG_ALS_GAIN__POS (2)
    3 d/ G+ K1 ]% J6 I* U- z) E
38. #define LTR553_ALS_CONTR_REG_ALS_GAIN__MSK (0x1c)
    $ ~, P7 i6 N2 x2 h
39. #define LTR553_ALS_CONTR_REG_ALS_GAIN__REG (LTR553_ALS_CONTR)
    & u( P6 G. k8 z8 {6 w, g  O
40. 
    ; e2 T, x$ Y5 M/ o: g
41. #define LTR553_ALS_CONTR_REG_ALS_MODE__POS (0)
    ' w0 O$ J# J6 _! Z1 [+ p! H
42. #define LTR553_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
    ) A7 m7 Q9 ?. w# V8 S
43. #define LTR553_ALS_CONTR_REG_ALS_MODE__REG (LTR553_ALS_CONTR)
    
44. 
    
45. #define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__POS (3)
    
46. #define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__MSK (0x38)
    % e3 R8 W5 c7 ]7 E
47. #define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__REG (LTR553_ALS_MEAS_RATE)
    9 i; T' `- r2 F8 a5 o
48. 
    ! e* a/ O/ B- ]9 {( @2 v% F  U# z
49. #define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__POS (0)
    
50. #define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
    & ^* P7 R: \% W1 |
51. #define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_ALS_MEAS_RATE)
    ; z, Y" Z) e  E
52. 
    2 t/ U& f! |7 H5 ^. V6 V
53. #define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__POS (2)
    9 z$ _4 W- S5 W" v1 |6 \
54. #define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__MSK (0x04)
    
55. #define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__REG (LTR553_ALS_PS_STATUS)
    - K+ d  v( J2 p/ A+ e/ _- w: @( T
56. 
    8 H: y" g& ~3 L! i4 n
57. #define LTR553_PS_CONTR_REG_PS_GAIN__POS (2)
    
58. #define LTR553_PS_CONTR_REG_PS_GAIN__MSK (0x0c)
    
59. #define LTR553_PS_CONTR_REG_PS_GAIN__REG (LTR553_PS_CONTR)
      [" v& u5 y  |4 D" x
60. 
    ' K" h3 A1 D. ?. }) N# K( E
61. #define LTR553_PS_CONTR_REG_PS_MODE__POS (0)
    # q/ `- f: t! F) N2 l# i* V
62. #define LTR553_PS_CONTR_REG_PS_MODE__MSK (0x03)
    
63. #define LTR553_PS_CONTR_REG_PS_MODE__REG (LTR553_PS_CONTR)
    ; y! ]7 K9 F) a9 _! F
64. 
    
65. #define LTR553_PS_LED_REG_PLUSE_FREQ__POS (5)
    
66. #define LTR553_PS_LED_REG_PLUSE_FREQ__MSK (0xe0)
    ! f$ ]) B7 G  q
67. #define LTR553_PS_LED_REG_PLUSE_FREQ__REG (LTR553_PS_LED)
    
68. 
    $ l( Q+ K1 Y3 a( S5 x
69. #define LTR553_PS_LED_REG_CURRENT_DUTY__POS (3)
    
70. #define LTR553_PS_LED_REG_CURRENT_DUTY__MSK (0x18)
    ! k3 Q/ E  ^6 p1 K" F" _9 Q4 s
71. #define LTR553_PS_LED_REG_CURRENT_DUTY__REG (LTR553_PS_LED)
    1 m/ y8 |' N5 ?) V+ p: k5 v
72. 
    
73. #define LTR553_PS_LED_REG_CURRENT__POS (0)
    ' z0 j7 k, b# I( Z! E
74. #define LTR553_PS_LED_REG_CURRENT__MSK (0x07)
    ; d5 k6 V! O6 S$ j9 n
75. #define LTR553_PS_LED_REG_CURRENT__REG (LTR553_PS_LED)
    " M! F0 H0 E/ ]- l! Z2 H
76. 
    & Q& w/ C: e" G* y& n6 Z
77. #define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
    
78. #define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x0F)
    
79. #define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_PS_MEAS_RATE)
    4 x# v" G$ E4 l) ~* n; P$ S
80. 
    
81. #define LTR553_ALS_PS_STATUS_REG_PS_STATUS__POS (0)
      P2 z1 v9 k) K; A2 l
82. #define LTR553_ALS_PS_STATUS_REG_PS_STATUS__MSK (0x01)
    
83. #define LTR553_ALS_PS_STATUS_REG_PS_STATUS__REG (LTR553_ALS_PS_STATUS)
    
84. 
    6 K8 _& y1 n6 e- B+ B/ {( P9 P. L
85. #define LTR553_GET_BITSLICE(regvar, bitname) \
    7 h) ?, g) C- L+ q& ]1 L2 \+ x
86.     ((regvar & bitname##__MSK) >> bitname##__POS)
    
87. #define LTR553_SET_BITSLICE(regvar, bitname, val) \
    ( S8 e7 ]5 k. t: n
88.     ((regvar & ~bitname##__MSK) | ((val << bitname##__POS) & bitname##__MSK))
    
89. 
    
90. #define LTR553_WAIT_TIME_PER_CHECK (10)
    
91. #define LTR553_WAIT_TIME_TOTAL (1000)
    
92. 
    
93. typedef enum
    ( B0 h$ ~# C3 b- j
94. {
    
95.     AG_GAIN_1X  = 0x0, /* 1 lux to 64k lux (default) */
    ) ^0 A7 o3 i; O; M/ P: c; ~
96.     AG_GAIN_2X  = 0x1, /* 0.5 lux to 32k lux */
    
97.     AG_GAIN_4X  = 0x2, /* 0.25 lux to 16k lux */
    ' h; p+ l1 _& ^
98.     AG_GAIN_8X  = 0x3, /* 0.125 lux to 8k lux */
    
99.     AG_GAIN_48X = 0x6, /* 0.02 lux to 1.3k lux */
    ' c- [* N" Z/ w2 P) x; T- D# C
100.     AG_GAIN_96X = 0x7, /* 0.01 lux to 600 lux */
     * D' g0 y! g! T1 v9 {3 H
101. } CFG_ALS_Gain;
     
102. 
     
103. typedef enum
     8 v: J: q8 S  y9 H6 i# Z
104. {
     ! U& c2 D, n9 K6 J; o+ g
105.     PG_GAIN_X16 = 0x0, /* X16 (default) */
     2 }" B* U$ n* n, {1 M
106.     PG_GAIN_X32 = 0x2, /* X32 */
     
107.     PG_GAIN_X64 = 0x3, /* X64 */
     
108. } CFG_PS_Gain;
     
109. 
     
110. typedef enum
     
111. {
     
112.     LPMF_PERIOD_30K  = 0x0, /* LED pulse period = 30kHz */
     / e" M/ f! g6 J8 r2 K7 Q& l
113.     LPMF_PERIOD_40K  = 0x1, /* LED pulse period = 40kHz */
     & o  ^, W4 k$ Z" q
114.     LPMF_PERIOD_50K  = 0x2, /* LED pulse period = 50kHz */
       o" R3 A# x3 ~2 j6 s+ k; J
115.     LPMF_PERIOD_60K  = 0x3, /* LED pulse period = 60kHz(default) */
     
116.     LPMF_PERIOD_70K  = 0x4, /* LED pulse period = 70kHz */
     " }# W% W9 `/ B, A5 H% Q1 G
117.     LPMF_PERIOD_80K  = 0x5, /* LED pulse period = 80kHz */
     
118.     LPMF_PERIOD_90K  = 0x6, /* LED pulse period = 90kHz */
     
119.     LPMF_PERIOD_100K = 0x7, /* LED pulse period = 100kHz */
     - }3 b( |; Q. \6 S) q7 q. W
120. } CFG_LED_pulse_Modulation_Frequency;
     , m. k% ~) g- G7 h7 Y0 E
121. 
     
122. typedef enum
     : w) H* [5 g8 i
123. {
     ' S* U/ F& Z: y# ^
124.     LCD_PER_25  = 0x0, /* DUTY = 25% */
     , p" X9 Z1 k3 _
125.     LCD_PER_50  = 0x1, /* DUTY = 50% */
     
126.     LCD_PER_75  = 0x2, /* DUTY = 75% */
     
127.     LCD_PER_100 = 0x3, /* DUTY = 100%(default) */
     / c4 u- u5 {' d* l6 B
128. } CFG_LED_Current_DUTY;
     
129. 
     
130. typedef enum
     
131. {
     8 T9 }. O& `+ o1 c/ E5 ~; p
132.     LC_LEVEL_5   = 0x0, /* LED pulse current level = 5mA */
     
133.     LC_LEVEL_10  = 0x1, /* LED pulse current level = 10mA */
     
134.     LC_LEVEL_20  = 0x2, /* LED pulse current level = 20mA */
     4 Q/ X9 _) O1 M5 V; O3 v
135.     LC_LEVEL_50  = 0x3, /* LED pulse current level = 50mA */
     
136.     LC_LEVEL_100 = 0x4, /* LED pulse current level = 100mA(default) */
     / {- u( U$ _# C1 P. t5 y) ~
137. } CFG_LED_Current;
     
138. 
     
139. typedef enum
     
140. {
     
141.     PMR_RATE_50   = 0x0, /* PS Measurement Repeat Rate = 50ms */
     
142.     PMR_RATE_70   = 0x1, /* PS Measurement Repeat Rate = 70ms */
     
143.     PMR_RATE_100  = 0x2, /* PS Measurement Repeat Rate = 100ms(default) */
     . n! c  u/ d# Y/ u
144.     PMR_RATE_200  = 0x3, /* PS Measurement Repeat Rate = 200ms */
     - g( N, c# ?- x' z  y
145.     PMR_RATE_500  = 0x4, /* PS Measurement Repeat Rate = 500ms */
     
146.     PMR_RATE_1000 = 0x5, /* PS Measurement Repeat Rate = 1000ms */
     
147.     PMR_RATE_2000 = 0x6, /* PS Measurement Repeat Rate = 2000ms */
     5 r- h- n* f5 K4 s' j/ j: p- |( E
148.     PMR_RATE_10   = 0x8, /* PS Measurement Repeat Rate = 10ms */
     + D3 }4 w" }8 N1 [" t/ L
149. } CFG_PS_measurement_rate;
     # N" |# s  e; K# x& s; L, X
150. 
     % [$ W- J# Z% n% w! Y6 O
151. typedef enum
     0 n: b) _. D! T* o4 q
152. {
     
153.     AIT_TIME_100 = 0x0, /* ALS integration_time = 100ms(default) */
     
154.     AIT_TIME_50  = 0x1, /* ALS integration_time = 50ms */
     
155.     AIT_TIME_200 = 0x2, /* ALS integration_time = 200ms */
     
156.     AIT_TIME_400 = 0x3, /* ALS integration_time = 400ms */
     
157.     AIT_TIME_150 = 0x4, /* ALS integration_time = 150ms */
     
158.     AIT_TIME_250 = 0x5, /* ALS integration_time = 250ms */
     $ [1 z  i& P3 p* F0 Q
159.     AIT_TIME_300 = 0x6, /* ALS integration_time = 300ms */
     , ?* _2 }% w6 f
160.     AIT_TIME_350 = 0x7, /* ALS integration_time = 350ms */
     . i+ @  S$ Y3 W& \1 t
161. } CFG_ALS_integration_time;
     " Y" i, j' Z% {
162. 
     
163. typedef enum
     
164. {
     ' }" X; O8 ]+ a# `+ U: [
165.     AMR_RATE_50   = 0x0, /* ALS Measurement Repeat Rate = 50ms */
     . r2 I8 i$ C  a/ _8 \
166.     AMR_RATE_100  = 0x1, /* ALS Measurement Repeat Rate = 100ms */
     
167.     AMR_RATE_200  = 0x2, /* ALS Measurement Repeat Rate = 200ms */
     : q' t: W$ A# `; c# O, t
168.     AMR_RATE_500  = 0x3, /* ALS Measurement Repeat Rate = 500ms(default) */
     , ~' }, ]) @- O1 f; c& D
169.     AMR_RATE_1000 = 0x4, /* ALS Measurement Repeat Rate = 1000ms */
     % i$ `5 S- ]' O. L
170.     AMR_RATE_2000 = 0x5, /* ALS Measurement Repeat Rate = 2000ms */
     
171. } CFG_ALS_measurement_rate;
     
172. 
     
173. typedef enum
     ) `% d. k# X4 X/ z5 q
174. {
       }8 i% A8 t6 D# c. m
175.     PM_MODE_STANDBY = 0,
     
176.     PM_MODE_ACTIVE  = 3,
     
177. } CFG_PS_mode;
     
178. 
     2 K1 A9 c0 t3 e
179. typedef enum
     * ]4 G( \- U8 C
180. {
     
181.     AM_MODE_STANDBY = 0,
     
182.     AM_MODE_ACTIVE  = 1,
     9 T" I! d+ }1 p6 _: b, i: l
183. } CFG_ALS_mode;
     
184. 
     8 W4 l, E5 ^! P+ [
185. typedef enum
     
186. {
     2 ?0 F$ P$ T, \3 ]0 G. G
187.     ADS_STATUS_OLD = 0,
     # G* P" Y' y6 D1 x4 O4 Y' ]
188.     ADS_STATUS_NEW = 1,
     
189. } CFG_ALS_data_status;
     " N" S5 l8 y2 V& I8 w
190. 
     
191. typedef enum
     
192. {
     
193.     PDS_STATUS_OLD = 0,
     % f/ u4 m8 n' D* R$ `5 Z4 T5 {
194.     PDS_STATUS_NEW = 1,
     
195. } CFG_PS_data_status;
     
196. 
     . r0 h2 H) _2 A/ W+ H
197. typedef enum
     
198. {
     ( y* b* {9 t0 _: T/ f- O( _
199.     FLAG_INIT_ALS = 0,
     + G" c8 V- _% b( R+ g- e
200.     FLAG_INIT_PS,
     ) N- C6 t. O) R
201. } FLAG_INIT_BIT;
     
202. 
     ' X8 b6 E6 ~* F! [, q
203. typedef enum {
     
204.     DEV_POWER_OFF = 0,
     
205.     DEV_POWER_ON,
     
206.     DEV_SLEEP,
     6 G. v  k" T- i1 V% l% V3 c) r4 @. e6 I
207.     DEV_SUSPEND,
     ( x+ O; c' K+ {9 X( {
208.     DEV_DEEP_SUSPEND,
     
209. } LTR_power_mode;
     % ^# O+ l( B/ A$ V; f
210. 
     6 P% k" ]( \) d" z8 l; ?
211. uint8_t LTR553_id_check()
     & @! X! V3 I% |
212. {
     - {- p- Z- S) ]6 F; z% b; Z
213.         HAL_StatusTypeDef hi2c2_status = 0x00;
     . B- {+ Q. F/ j- @
214.         /*ID check*/
     
215.         //LTR553_PART_ID=0X86,LTR553_MANUFAC_ID=0X87
     
216.         //LTR553_PART_ID_VAL=0X92,LTR553_MANUFAC_ID_VAL=0X05
     
217.         uint8_t id_addr_val[6] = {LTR553_PART_ID,LTR553_PART_ID_VAL,0x00,LTR553_MANUFAC_ID,LTR553_MANUFAC_ID_VAL,0x00};
     
218.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,id_addr_val[0],1,&id_addr_val[2],1,1000);
     1 ?) f* L; E0 |& w: l$ G
219.         if(HAL_OK!=hi2c2_status){
     
220.                 printf("get part_id error\r\n");
     9 [8 s) z) v" Q" g3 e
221.                 return 1;
     
222.         }
     
223.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,id_addr_val[3],1,&id_addr_val[5],1,1000);
     0 }6 G, `6 p" b* q  b- ^
224.         if(HAL_OK!=hi2c2_status){
     
225.                 printf("get manufac_id error\r\n");
     7 K- {% t8 V4 Q1 E: }
226.                 return 1;
     & K$ i: F! B' d, s6 V+ `' A
227.         }
     
228.         if(id_addr_val[1]!=id_addr_val[2]||id_addr_val[4]!=id_addr_val[5]){
     
229.                 printf("drv_als_ps_liteon_ltr553_validate_id is error\r\n");
     1 n' P) D% H3 H! M8 q
230.                 return 1;
     / _5 e+ c2 y4 q9 P  P6 G( F
231.         }
     ! z! T/ |8 C/ B  j; D- q7 @
232.         printf("part_id:%02X,manufac_id:%02X\r\n",id_addr_val[2],id_addr_val[5]);
     / ?' m+ Z7 `  I2 N) {$ L- c7 c
233.         return 0;
     
234. }
     
235. 
     , p9 W) b3 f2 g- V1 R) G3 w# D
236. uint8_t ltr553_als_set_power_mode(LTR_power_mode mode)
     
237. {
     
238.         HAL_StatusTypeDef hi2c2_status = 0x00;
     9 W& n; A- U7 v  ^( t
239.         uint8_t dev_mode  = 0;
     
240.         uint8_t value     = 0;
     
241. 
     
242.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_CONTR,1,&value,1,WAIT_FOREVER);
     
243.         if(HAL_OK!=hi2c2_status){
     
244.                 printf("get als_contr error\r\n");
     
245.                 return 1;
     ) f% I6 m" z$ {! L. o
246.         }
     
247.         printf("ALS_CONTR old:%02X\r\n",value);
     
248.     switch (mode) {
     
249.         case DEV_POWER_OFF:
     
250.         case DEV_SLEEP:
     
251.             dev_mode = LTR553_SET_BITSLICE(dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_STANDBY);
     & U/ s, G- P( u/ {! r) b
252.             break;
     - r3 Q/ R, w& B8 {7 Z) j% V1 |
253.         case DEV_POWER_ON:
     1 ]' V- a  k5 d# s
254.             dev_mode = LTR553_SET_BITSLICE(dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_ACTIVE);
     
255.             break;
     
256.         default:
     
257.             return 1;
     
258.     }
       x( t! S6 E- ^1 z
259.     printf("ALS_CONTR new:%02X\r\n",dev_mode);
     
260.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_CONTR,1,&dev_mode,1,WAIT_FOREVER);
     + m6 X! G& Q0 u1 ^' P* J  A
261.         if(HAL_OK!=hi2c2_status){
     ; a& d+ U' R* H8 b& B* ]
262.                 printf("set ALS_CONTR error\r\n");
     
263.                 return 1;
     
264.         }
     
265.         printf("successfully LTR553_ALS set_power_mode!\r\n");
     - Y; [( ?) K) d
266.     return 0;
     : u( X! [7 b+ M+ ~
267. }
     + j8 d' A+ H  U# C+ ^
268. 
     
269. uint8_t ltr553_ps_set_power_mode(LTR_power_mode mode)
     * j1 W7 j. G+ A, M% J+ P. E
270. {
     
271.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
272.         uint8_t dev_mode  = 0;
     
273.         uint8_t value     = 0;
     
274. 
     5 U2 z. C/ i4 f8 l3 m
275.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,LTR553_PS_CONTR,1,&value,1,WAIT_FOREVER);
     : A7 T, `4 e3 r. |9 E, g- n" N
276.         if(HAL_OK!=hi2c2_status){
     
277.                 printf("get ps_contr error\r\n");
     
278.                 return 1;
     7 Y0 M5 E- U% \7 @; F. p8 b( m8 Q* m; W
279.         }
     6 k" x  [! r- }# a# W+ ]: ?
280.         printf("PS_CONTR old:%02X\r\n",value);
     , C" a4 `8 W3 z* \2 B3 a6 o9 }
281.     switch (mode) {
     
282.         case DEV_POWER_OFF:
     
283.         case DEV_SLEEP:
     
284.             dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE,PM_MODE_STANDBY);
     ! Z! J. C& k. Z4 C: f' @. }. M
285.             break;
     
286.         case DEV_POWER_ON:
     $ z! N' I* K4 \0 ?
287.             dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE,PM_MODE_ACTIVE);
     
288.             break;
     
289.         default:
     
290.             return 1;
     " k( P" W% B0 t7 \  y& W" h: }
291.     }
     
292.     printf("ALS_CONTR new:%02X\r\n",dev_mode);
     + q) u6 ?6 S" L$ l
293.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_PS_CONTR,1,&dev_mode,1,WAIT_FOREVER);
     0 V; @0 ~' f  ?
294.         if(HAL_OK!=hi2c2_status){
     5 G. [* H* M7 R
295.                 printf("set PS_CONTR error\r\n");
     
296.                 return 1;
     , {! l% n$ g; I& a- H8 s
297.         }
     
298.         printf("successfully LTR553_PS set_power_mode!\r\n");
     ) |, B- h: Q7 _; |
299.     return 0;
     
300. }
     . u4 W. P2 L6 ~0 E! W
301. 
     + f, B  W8 `" [3 D. H5 A
302. uint8_t ltr553_als_is_ready()
     " _' r5 G( E& S/ V3 E! `
303. {
     ! ~& b# Y7 t8 g" [) V
304.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
305.         uint8_t value = 0;
     
306.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_PS_STATUS,1,&value,1,WAIT_FOREVER);
     % y# B$ b- w$ V& `+ l
307.         if(HAL_OK!=hi2c2_status){
     4 ]$ Z  X& v( i9 s: U
308.                 printf("get ps_contr error\r\n");
     
309.                 return 0;
     
310.         }
     
311. //        printf("PS_CONTR old:%02X\r\n",value);
     
312.         uint8_t ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_ALS_STATUS) == ADS_STATUS_NEW)? 1 : 0;
     
313.         return ret;
     + W5 G7 S' o& a  x3 I1 ?% Q
314. }
     
315. 
     
316. uint8_t ltr553_ps_is_ready()
     7 l3 `, g+ T1 f. U3 ]+ S
317. {
     
318.         HAL_StatusTypeDef hi2c2_status = 0x00;
     2 e/ m" n: v# h2 p8 V
319.         uint8_t value = 0;
     4 g# E. l1 N# R; ~# l
320.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_PS_STATUS,1,&value,1,WAIT_FOREVER);
     # U' A' O% G+ k+ Y
321.         if(HAL_OK!=hi2c2_status){
     
322.                 printf("get ps_contr error\r\n");
     1 Z; |( H) a0 Q" C7 n6 j  S
323.                 return 0;
       S1 {. J+ Q% l" X: J, s
324.         }
     : A& Z, f% ~+ B# L+ U
325. //        printf("PS_CONTR old:%02X\r\n",value);
     , r, }6 C- }- j% D; h0 s  T
326.         uint8_t ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_PS_STATUS) == PDS_STATUS_NEW)? 1 : 0;
     , U* v8 A: C) E( ^
327.         return ret;
     
328. }
     
329. 
     
330. uint8_t ltr553_als_set_default_config()
     : l6 Z- M; U: }! I
331. {
     
332.         HAL_StatusTypeDef hi2c2_status = 0x00;
     0 ^! d# H' k6 R- z
333.         uint8_t value = 0;
     * Y+ @# _& Q+ N* ^3 k1 G  Q0 V+ i/ v
334.         value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_INTEG_TIME,AIT_TIME_100);
     , M2 M. b- n- j4 f4 W4 G
335.         value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_MEAS_RATE,AMR_RATE_100);
     
336.         printf("ALS_MEAS_RATE:%02X\r\n",value);
     
337.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_MEAS_RATE,1,&value,1,WAIT_FOREVER);
     ) y! A' |' h7 t- W2 L$ Y$ l
338.         if(HAL_OK!=hi2c2_status){
     
339.                 printf("set ALS_MEAS_RATE error\r\n");
     
340.                 return 1;
     + F0 E* \/ G: B8 Q
341.         }
     2 l2 H, Q) c4 s2 k
342.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_CONTR,1,&value,1,WAIT_FOREVER);
     6 E7 H+ x. @# U7 H, N2 m
343.         if(HAL_OK!=hi2c2_status){
     
344.                 printf("get als_contr error\r\n");
     + J. ~; y: p9 q, @9 J  @/ ]
345.                 return 1;
     / O5 L3 B3 }" \* i8 i: W. {, Q1 ^
346.         }
     
347.         printf("ALS_CONTR old:%02X\r\n",value);
     ; {1 w1 e6 U1 m4 u0 x7 k
348.         value =        LTR553_SET_BITSLICE(value, LTR553_ALS_CONTR_REG_ALS_GAIN, AG_GAIN_1X);
     " ]/ t2 }# p- j5 ^5 V& w, N4 W3 {
349.         printf("ALS_CONTR new:%02X\r\n",value);
     
350.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_ALS_CONTR,1,&value,1,WAIT_FOREVER);
     
351.         if(HAL_OK!=hi2c2_status){
     & R& R) j; o. z$ C( y+ @5 \
352.                 printf("get ALS_CONTR error\r\n");
     3 L) l$ ?4 K; f" y7 o& h( ~- ~
353.                 return 1;
     
354.         }
     3 j6 b5 J( g2 T/ [: I% }
355.         printf("successfully LTR553_ALS_default_config!\r\n");
     % }8 B9 \5 H& W3 F9 L' E8 }6 B
356.         return 0;
     
357. }
     % ^: ?6 D$ s! [: x: |$ c3 x3 V
358. 
       _. {7 f. _0 n' ]$ {+ ^# ]
359. uint8_t ltr553_ps_set_default_config()
     
360. {
     ; |! H) h1 s$ v; @
361.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
362.         //LTR553_PS_MEAS_RATE=0X84,LTR553_PS_LED=0X82,LTR553_PS_CONTR=0X81
     
363.         uint8_t value = 0;
     
364.         value = LTR553_SET_BITSLICE(value, LTR553_PS_MEAS_RATE_REG_MEAS_RATE,PMR_RATE_100);
     1 L: I2 ]* Z8 a* X0 c
365.         printf("PS_MEAS_RATE:%02X\r\n",value);
     
366.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_PS_MEAS_RATE,1,&value,1,1000);
     
367.         if(HAL_OK!=hi2c2_status){
     - `- s2 }+ W* q! V2 s5 O, O4 E# g
368.                 printf("set PS_MEAS_RATE error\r\n");
       R2 O% y1 |1 s% e  c. i
369.                 return 1;
     ) }/ g% n7 [0 F; m8 A* Z
370.         }
     
371.         //value default 0X7F
     
372.         value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_PLUSE_FREQ, LPMF_PERIOD_60K);
     
373.         value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT_DUTY, LCD_PER_100);
     
374.         value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT, LC_LEVEL_100);
     ; M) W7 [/ P$ c! s# _
375.         printf("PS_LED:%02X\r\n",value);
     8 C/ t# D- y4 G
376.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_PS_MEAS_RATE,1,&value,1,1000);
     
377.         if(HAL_OK!=hi2c2_status){
     ' L" c; ?8 t  Y/ u5 h& ^: K* k
378.                 printf("get PS_LED error\r\n");
     ; ]2 U5 t; w5 s$ f' Q/ S
379.                 return 1;
     # h0 t" }( r5 o6 A4 M$ M: Y
380.         }
     + V( @* G) d" \! |+ y% [. ]
381.         //check
     9 q* E( G# O6 p4 l# W
382.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,LTR553_PS_CONTR,1,&value,1,WAIT_FOREVER);
     
383.         if(HAL_OK!=hi2c2_status){
     
384.                 printf("get ps_contr error\r\n");
     * Y0 N& Q+ l7 a& |  z
385.                 return 1;
     
386.         }
     2 Z2 c. Z  K; y. G
387.         printf("PS_CONTR old:%02X\r\n",value);
     1 G' Q0 S$ U2 b& k
388.         value = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_GAIN, PG_GAIN_X16);
     # F" ]/ T0 L+ y, [  C. Y
389.         printf("PS_CONTR new:%02X\r\n",value);
     
390.         //
     
391.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,LTR553_I2C_ADDR,LTR553_PS_CONTR,1,&value,1,1000);
     
392.         if(HAL_OK!=hi2c2_status){
     
393.                 printf("get PS_CONTR error\r\n");
     
394.                 return 1;
     
395.         }
     
396.         printf("successfully LTR553_PS default_config!\r\n");
     
397.         return 0;
     
398. }
     ' }7 C$ i$ k- Q9 _" }6 z
399. 
     7 w; H; F. C, s! w2 c0 q3 b) j) [$ G
400. uint8_t ltr553_als_open()
     
401. {
     7 @8 w6 U# D4 r+ {8 l  {( [! x
402.         uint8_t ret = 0;
     
403. 
     & a' z3 S' ~% Q  P  O& f
404.         ret = ltr553_als_set_power_mode(DEV_POWER_ON);
     
405.     if (ret>0) {
     
406.         return 1;
     
407.     }
     
408.     printf("successfully LTR553_ALS Open!\r\n");
     
409.     return 0;
     4 M4 l% x% e' o/ F7 R! V& j7 B
410. }
     
411. 
     ' D9 }  g0 r8 _
412. uint8_t ltr553_als_close()
     # r4 f7 c5 [9 L3 \  |- G% Q
413. {
     . H/ {* f2 o3 i- G
414.         uint8_t ret = 0;
     
415. 
     0 p+ s, R: u  N! B+ O/ b
416.         ret = ltr553_als_set_power_mode(DEV_POWER_OFF);
       @) N0 F% X  _. d' F6 X, A1 b
417.     if (ret>0) {
     0 m6 r% Z# w  \2 R/ M% J/ b/ e  S
418.         return 1;
     
419.     }
     
420.     printf("successfully LTR553_ALS Close!\r\n");
     
421.     return 0;
     , A2 D  x3 B* V6 b: s
422. }
     
423. 
     , h0 B* m5 o) H
424. uint8_t ltr553_ps_open()
     
425. {
     
426.         uint8_t ret = 0;
     
427. 
       Q8 l5 U7 ]. k) G" o
428.         ret = ltr553_ps_set_power_mode(DEV_POWER_ON);
     
429.     if (ret>0) {
     
430.         return 1;
     , p9 y- e. F' g9 n5 t8 N
431.     }
     
432.     printf("successfully LTR553_ALS Open!\r\n");
     & E( U: O5 G, l% O2 ~* \- X
433.     return 0;
     
434. }
     
435. 
     
436. uint8_t ltr553_ps_close()
     " V% c  R/ F* R% T9 m
437. {
     
438.         uint8_t ret = 0;
     ! o# Y5 o/ H8 \
439. 
     8 X& M1 C' k1 Y* p1 Y
440.         ret = ltr553_ps_set_power_mode(DEV_POWER_OFF);
     
441.     if (ret>0) {
     
442.         return 1;
     " R" n( a3 g  I: v! U
443.     }
     
444.     printf("successfully LTR553_ALS Close!\r\n");
     1 E) L. ]( F3 }
445.     return 0;
     $ A% u( u& \1 {3 p
446. }
     
447. 
     
448. void LTR_ALS_init()
     
449. {
     * V5 f; c( N& }8 P
450.         /*ID check*/
     5 Z6 a) `  r# \; f
451.         if(LTR553_id_check()>0){
     $ a  ~/ M, }( G  X% G$ ?0 R
452.                 return;
     . E  g% s  s0 J9 _: \7 |
453.         }
     
454.         if(ltr553_als_set_default_config()>0)
     
455.                 return;
     & f  }5 b) o5 Z9 B" Z4 U) K
456.         printf("successfully LTR553_ALS_init!\r\n");
     - S* @- h, d4 a. [. b# M2 n
457. }
     
458. 
     
459. void LTR_PS_init()
     ) Y; h9 H9 K4 q+ p1 i
460. {
     
461.         /*ID check*/
     
462.         if(LTR553_id_check()){
     / {4 h7 C9 ]8 `( e9 y! d
463.                 return;
     
464.         }
     
465.         /*PS check*/
     * y, O* ?9 W% Z- O
466.         if(ltr553_ps_set_default_config()>0)
     + K- s0 U4 k  C3 E, t
467.                 return;
     
468.         printf("successfully LTR553_PS_init!\r\n");
     ; o* e6 u( q& u( \( h) |3 A
469. }
     
470. 
       X6 s. Y, s* y- C: `+ N
471. uint8_t read_als(uint32_t *als_data)
     0 H: A# T" k1 M! _5 ~) F
472. {
     5 ], d; y" _$ m1 N9 j" \
473.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
474.         /*
     
475.          * LTR553_ALS_DATA1_L=0X88,LTR553_ALS_DATA1_H=0X89
     
476.          * LTR553_ALS_DATA0_L=0X8A,LTR553_ALS_DATA0_H=0X8B
     - ]2 \  [+ }4 o7 Q! Z/ T. h
477.          */
       o6 M' t3 J# H: V& w
478.         uint8_t ALS_addr[4] = {LTR553_ALS_DATA1_L,LTR553_ALS_DATA1_H
     2 p# u- ~2 h: }  ?% i$ L8 x+ h
479.                         ,LTR553_ALS_DATA0_L,LTR553_ALS_DATA0_H};
     
480.         uint8_t ALS_data[4] = {0x00};
     
481.         for(uint8_t i=0; i<4; i++){
     
482.                 hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,ALS_addr[i],1,&ALS_data[i],1,1000);
     
483.                 if(HAL_OK!=hi2c2_status){
     2 X  {  B, d+ k- D  z/ Q
484.                                 return 1;
     4 L) S( g, r% _
485.                 }
     ) V# i/ o  ^7 g+ |) x( \& n
486.         }
     
487.         uint32_t val01 = ALS_data[0]|(ALS_data[1]<<8);
     
488.     uint32_t val02 = ALS_data[2]|(ALS_data[3]<<8);
     
489.     printf("val01:%lu,val02:%lu\n",val01,val01);
     1 T4 c( n- W7 S& z2 x0 L  C
490.     *als_data =  (uint32_t)((val01 + val02) >> 1);
     
491.     printf("als_data: %lu\r\n",*als_data);
     
492.     return 0;
     , `! |$ r5 }0 T$ e( M
493. }
     
494. 
     5 H8 u; m, U4 H7 c" E, @
495. uint8_t read_ps(uint32_t *ps_data)
     , B( M4 ?1 u5 u- y: j8 b
496. {
     $ c1 w, `* x1 w0 }' u* q
497.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
498.         /*
     
499.          * LTR553_PS_DATA_L=0X8D,LTR553_PS_DATA_H=0X8E
     
500.          */
     
501.     uint8_t PS_addr[2] = {LTR553_PS_DATA_L,LTR553_PS_DATA_H};
     
502.     uint8_t PS_data[2] = {0x00};
     + w# Y) @( [' B0 `8 h4 l& d
503.     for(uint8_t i=0; i<2; i++){
     ) z1 h% @4 h- ]+ y
504.                 hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,LTR553_I2C_ADDR,PS_addr[i],1,&PS_data[i],1,1000);
     
505.                 if(HAL_OK!=hi2c2_status){
     & |9 Q) ]5 |' _% U  k2 s" D# e
506.                                 return 1;
     
507.                 }
     
508.         }
     1 y9 }4 \: O) n; M: q9 `
509.     uint32_t val03 = PS_data[0]|(PS_data[1]<<8);
     7 k) t" A3 P4 o% _0 x: z
510.     printf("val03:%lu\n",val03);
     6 N( Y' Z# ~; i
511.     *ps_data = val03;
     . o$ q# ~8 E/ s9 Z$ \* H6 z, h
512.     printf("ps_data: %lu\r\n",*ps_data);
     - x8 R$ i$ D7 f' \5 V3 w8 d- @
513.     return 0;
     
514. }

复制代码

七、BMP280传感器（气压传感器）
        在ICore源码目录下，创建bmp280文件夹，再在该目录下创建bmp280.h和bmp280.c源码文件，作为BMP280传感器驱动。
        同样在网上查找下载bmp280数据手册，逐步分析，bmp280的从设备地址(0XEE=0X77<<1),开发板同样做了微调，采用从机地址+寄存器地址+数据等方式通信，支持SPI或I2C通信，我们只研究I2C通信，如下：

# ~/ m2 j: K) I" S; V
) K7 q! i2 ~0 \+ \
! }/ Z; H2 Q5 ?' x: p0 {, M5 f        1）I2C读写通信设计如下
/ f; p2 |; J( X4 u& h: y




         2）设备ID寄存器地址0XD0，正确返回值应该是0X58，及软重置寄存器地址XE0，写入数据是0XB6重置生效，其他值无效。
6 e- g% Q- V) X1 e! w
, C1 D' ~5 _& h. a3 c: V* k
  M/ Y9 {; n8 q  m
         3）power模式设置地址0XF4，bit0~1设置0X03（0000 0011）开启正常模式，可以读取数据。bit5~7设置温度相关，bit2~4设置气压相关.


& j3 b8 V6 m) ?& `6 k0 P  B


         4）设备参数配置地址0XF5，可设置设备作业的rate, filter and interface。I2C通信需要设置5~7bit。
1 B! q: E/ [: f, k, W! @' v
! T% Y* r" h% W& X+ v9 c

& j2 D) S# x4 ~- o$ ]% |( N


5 z2 t0 [( ~7 ?/ s/ s& [3 `         5）数据读取时的微调参数配置，其中dig_T1、dig_T2、dig_T3是为温度数据调整使用，dig_P1~9是气压数据调整时使用。


8 p8 c: A" D9 \0 R6 \( r! @& C/ j
9 r, |9 x) g! g1 n; R

3 d7 ~& d$ f+ M% ]* X8 j( S4 g2 p, S         6）读取数据，0XF7~F9读取气压相关数据，共3字节（24bit），0XFA~FC读取温度相关数据，共3字节（24bit）




( |# ~9 P6 ]. s
9 V# G$ T9 U& Z9 B* U+ @- U         7）至此可设计出BMP280的伪代码
$ P. ^+ k, D0 x: f! @

1. bmp280从机地址0XEE
   ( Q; N- B0 v  G1 ]
2. init：
     m0 ^6 D+ H/ U4 I
3. read data1 from 从机地址0XEE 寄存器地址 0XD0
   
4. 确保data1==0X58
   
5. write 0XB6 to 从机地址0XEE 寄存器地址 0XE0 完成软重置
   
6. write val1 to 从机地址0XEE 寄存器地址 0XF4 完成设备模式设置
   & d# h& F% L8 c9 G. M/ m2 z9 @( R
7. write val2 to 从机地址0XEE 寄存器地址 0XF5 完成设备参数设置
   " P8 j$ W( h+ W
8. read conf1~24 from 从机地址0XEE 寄存器地址 0X88~0XA1 获取数据换算微调参数
   6 D# j8 _% ~) y
9. 
   
10. 读取数据：
    " z. g, r# a1 W5 F, A; m. {
11. 确保设备为正常模式，例如write 0X03 to 从机地址0XEE 寄存器地址 0XF4 完成设备模式设置
    
12. read P1~3 from 从机地址0XEE 寄存器地址 0XF7~F9
    & q" O9 R; L+ ~- q' f& P, D
13. 将P1~3与conf4~24进行换算处理得到实际数据
    4 t( F4 R8 l4 P! K& \
14. read t1~3 from 从机地址0XEE 寄存器地址 0XFA~FC
    
15. 将t1~3与conf1~3进行换算处理得到实际数据

复制代码

         8)依据上面伪代码描述及数据手册分析，BMP280传感器驱动文件源码如下：
8 z4 b+ a/ p0 E4 s5 L! J4 w: y! \
        bmp280.h

1. #ifndef _BMP280_H_
   
2. #define _BMP280_H_
   , H4 P: k) Q0 e. ]* J, i0 _& N
3. 
   - Z+ h& _2 w9 r6 D  s' a- s
4. #include "main.h"
   
5. 
   0 K; j2 F9 {% w/ S2 v5 r
6. void BMP280_init();
   ' M. _& G4 A% l* j. c5 x
7. uint8_t bmp280_open(void);
   
8. uint8_t bmp280_close(void);
   
9. uint8_t read_bmp280_temp(uint32_t *comp_temp);
   
10. uint8_t read_bmp280_baro(uint32_t *comp_baro);
    - Y9 ^# `; O' z! _
11. #endif /* BMP280_BMP280_H_ */

复制代码

  d% R, y, Y6 P6 O' f5 P         bmp280.c
1 h5 E7 [' o, y* \  \

1. #include <stdio.h>
   . d/ n# B. N! G& n$ f. @; [
2. #include "bmp280.h"
   
3. 
   
4. extern I2C_HandleTypeDef hi2c2;
   
5. 
   7 I: r0 }* M; Z9 [( p. D! ~
6. #define BMP280_TEMPERATURE_CALIB_DIG_T1_LSB_REG (0x88)
   ' f' K& z/ |  p4 M; Q
7. #define BMP280_TEMPERATURE_CALIB_DIG_T1_MSB_REG (0x89)
   
8. #define BMP280_TEMPERATURE_CALIB_DIG_T2_LSB_REG (0x8A)
   
9. #define BMP280_TEMPERATURE_CALIB_DIG_T2_MSB_REG (0x8B)
   
10. #define BMP280_TEMPERATURE_CALIB_DIG_T3_LSB_REG (0x8C)
    
11. #define BMP280_TEMPERATURE_CALIB_DIG_T3_MSB_REG (0x8D)
    
12. #define BMP280_PRESSURE_CALIB_DIG_P1_LSB_REG (0x8E)
    - g; y3 S" ~9 e. y. s3 L
13. #define BMP280_PRESSURE_CALIB_DIG_P1_MSB_REG (0x8F)
    5 O5 D6 N( s# y& |: V# M9 V5 E
14. #define BMP280_PRESSURE_CALIB_DIG_P2_LSB_REG (0x90)
    
15. #define BMP280_PRESSURE_CALIB_DIG_P2_MSB_REG (0x91)
    
16. #define BMP280_PRESSURE_CALIB_DIG_P3_LSB_REG (0x92)
    
17. #define BMP280_PRESSURE_CALIB_DIG_P3_MSB_REG (0x93)
    $ \5 o. h' r: S! a7 H
18. #define BMP280_PRESSURE_CALIB_DIG_P4_LSB_REG (0x94)
    
19. #define BMP280_PRESSURE_CALIB_DIG_P4_MSB_REG (0x95)
    2 ~: A. d' f$ T3 N3 q" m' M
20. #define BMP280_PRESSURE_CALIB_DIG_P5_LSB_REG (0x96)
    
21. #define BMP280_PRESSURE_CALIB_DIG_P5_MSB_REG (0x97)
    , }# E/ `: V, S1 y3 J4 s
22. #define BMP280_PRESSURE_CALIB_DIG_P6_LSB_REG (0x98)
    
23. #define BMP280_PRESSURE_CALIB_DIG_P6_MSB_REG (0x99)
    " }- U! w  w  k% K* I$ F
24. #define BMP280_PRESSURE_CALIB_DIG_P7_LSB_REG (0x9A)
    
25. #define BMP280_PRESSURE_CALIB_DIG_P7_MSB_REG (0x9B)
    
26. #define BMP280_PRESSURE_CALIB_DIG_P8_LSB_REG (0x9C)
    
27. #define BMP280_PRESSURE_CALIB_DIG_P8_MSB_REG (0x9D)
    ) V3 U& Q+ M# u1 X# F" ^" y- b$ h0 B3 V
28. #define BMP280_PRESSURE_CALIB_DIG_P9_LSB_REG (0x9E)
    ' D4 c( R0 Q4 b6 ]9 p4 A. Z
29. #define BMP280_PRESSURE_CALIB_DIG_P9_MSB_REG (0x9F)
    & i, Q& i7 e" H, V' s
30. 
    
31. 
    * o( r6 V5 P% k  f# S: X- A
32. #define BMP280_CHIP_ID_REG (0xD0)
    
33. #define BMP280_RST_REG (0xE0)
    % M8 |0 p' Y: P' Z  W0 h( c
34. #define BMP280_STAT_REG (0xF3)
    
35. #define BMP280_CTRL_MEAS_REG (0xF4)
    5 U6 B  t! t! m/ y( V8 Q; q
36. #define BMP280_CONFIG_REG (0xF5)
    1 `  q0 g. r6 H8 x/ e  w
37. #define BMP280_PRESSURE_MSB_REG (0xF7)
    * N, [& |. e7 _. |% x+ T
38. #define BMP280_PRESSURE_LSB_REG (0xF8)
    ! ^: i! Y6 }2 G8 j% g
39. #define BMP280_PRESSURE_XLSB_REG (0xF9)
    
40. #define BMP280_TEMPERATURE_MSB_REG (0xFA)
    4 g3 K. l; b7 Z6 z% @5 A
41. #define BMP280_TEMPERATURE_LSB_REG (0xFB)
    
42. #define BMP280_TEMPERATURE_XLSB_REG (0xFC)
    3 G( [6 @. J: _
43. 
    1 X  q" y) Z4 Z
44. 
    2 K% `/ V% Y8 h+ y' @) @
45. #define BMP280_SHIFT_BY_01_BIT (1)
    
46. #define BMP280_SHIFT_BY_02_BITS (2)
    
47. #define BMP280_SHIFT_BY_03_BITS (3)
    2 n- z2 c3 g8 I. l; n
48. #define BMP280_SHIFT_BY_04_BITS (4)
    , X) l# v) t. D' S, \
49. #define BMP280_SHIFT_BY_05_BITS (5)
    & ]: I9 q& ~' [" d$ V# _1 ?/ j
50. #define BMP280_SHIFT_BY_08_BITS (8)
    7 }* ]7 h6 X$ [# B( X
51. #define BMP280_SHIFT_BY_11_BITS (11)
      n9 B; v, d/ H5 U1 _
52. #define BMP280_SHIFT_BY_12_BITS (12)
    + T# ?& C% Z2 S6 Z
53. #define BMP280_SHIFT_BY_13_BITS (13)
    $ Z. A$ E! c+ i' u2 P
54. #define BMP280_SHIFT_BY_14_BITS (14)
    & o$ J0 \+ T$ a% J! T
55. #define BMP280_SHIFT_BY_15_BITS (15)
    ( U) F2 h/ v  \# Q  I0 C1 t
56. #define BMP280_SHIFT_BY_16_BITS (16)
    ! U5 u' R) n, Q+ M
57. #define BMP280_SHIFT_BY_17_BITS (17)
    7 g* t; W  {( [; r. Y% q5 Y, R- G
58. #define BMP280_SHIFT_BY_18_BITS (18)
    
59. #define BMP280_SHIFT_BY_19_BITS (19)
    " Y9 `3 o( n5 E7 t( ]
60. #define BMP280_SHIFT_BY_25_BITS (25)
    + M: ^: H: }( Z( C! o
61. #define BMP280_SHIFT_BY_31_BITS (31)
    
62. #define BMP280_SHIFT_BY_33_BITS (33)
    
63. #define BMP280_SHIFT_BY_35_BITS (35)
    
64. #define BMP280_SHIFT_BY_47_BITS (47)
    " ~* K3 w5 b6 j
65. 
    
66. 
    6 V, \2 x$ h7 O  J
67. #define BMP280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH (24)
    
68. #define BMP280_GEN_READ_WRITE_DATA_LENGTH (1)
    
69. #define BMP280_REGISTER_READ_DELAY (1)
    
70. #define BMP280_TEMPERATURE_DATA_LENGTH (3)
    
71. #define BMP280_PRESSURE_DATA_LENGTH (3)
    ' `6 a" t+ c( z- H2 J& Q
72. #define BMP280_ALL_DATA_FRAME_LENGTH (6)
    
73. #define BMP280_INIT_VALUE (0)
    
74. #define BMP280_CHIP_ID_READ_COUNT (5)
    
75. #define BMP280_CHIP_ID_READ_SUCCESS (0)
    
76. #define BMP280_CHIP_ID_READ_FAIL ((int8_t)-1)
    
77. #define BMP280_INVALID_DATA (0)
    , C3 s2 b" W% M# n
78. 
    $ f$ u- j) [1 b* V% _' j
79. 
    
80. #define BMP280_TEMPERATURE_DATA_SIZE (3)
    ' a: F0 ?/ R' X. o$ v
81. #define BMP280_PRESSURE_DATA_SIZE (3)
    ) c6 F% d2 v# y, @' ~1 H
82. #define BMP280_DATA_FRAME_SIZE (6)
    ( p$ g" R' X/ e) S1 C5 a1 G
83. #define BMP280_CALIB_DATA_SIZE (24)
    
84. 
    0 U: p' a$ }2 F6 j/ x
85. #define BMP280_TEMPERATURE_MSB_DATA (0)
    . k) i9 q5 k/ A- n% T
86. #define BMP280_TEMPERATURE_LSB_DATA (1)
    
87. #define BMP280_TEMPERATURE_XLSB_DATA (2)
    
88. 
    
89. 
    4 U3 E5 B2 l: ~( E
90. #define BMP280_I2C_ADDRESS1 (0x76)
    
91. #define BMP280_I2C_ADDRESS2 (0x77)
    8 \5 q6 ~8 a, {; W* M1 _
92. 
    
93. 
    
94. #define BMP280_SLEEP_MODE (0x00)
    
95. #define BMP280_FORCED_MODE (0x01)
    
96. #define BMP280_NORMAL_MODE (0x03)
    
97. #define BMP280_SOFT_RESET_CODE (0xB6)
    
98. 
    / Q; h" v) {( g3 [" L/ g# T+ X2 X, W
99. 
    
100. #define BMP280_STANDBY_TIME_1_MS (0x00)
     * B3 c2 `+ B# e" o: |) Q" F. c
101. #define BMP280_STANDBY_TIME_63_MS (0x01)
     
102. #define BMP280_STANDBY_TIME_125_MS (0x02)
     
103. #define BMP280_STANDBY_TIME_250_MS (0x03)
     ' Y( ?* n6 b/ e  q
104. #define BMP280_STANDBY_TIME_500_MS (0x04)
     
105. #define BMP280_STANDBY_TIME_1000_MS (0x05)
     - @  L% K/ n3 J8 D
106. #define BMP280_STANDBY_TIME_2000_MS (0x06)
     
107. #define BMP280_STANDBY_TIME_4000_MS (0x07)
       a* @% B0 @: `/ [, k' i
108. 
     
109. 
     
110. #define BMP280_OVERSAMP_SKIPPED (0x00)
     
111. #define BMP280_OVERSAMP_1X (0x01)
     9 S- d( s/ H  A
112. #define BMP280_OVERSAMP_2X (0x02)
     
113. #define BMP280_OVERSAMP_4X (0x03)
     
114. #define BMP280_OVERSAMP_8X (0x04)
     
115. #define BMP280_OVERSAMP_16X (0x05)
     
116. 
     5 @8 H% f1 }' E2 [' V: g: W. j8 V2 }
117. #define BMP280_FILTER_COEFF_OFF (0x00)
     
118. #define BMP280_FILTER_COEFF_2 (0x01)
     ' V* U" z5 h2 u7 G  m/ S  A$ p
119. #define BMP280_FILTER_COEFF_4 (0x02)
     ' N, \: H% ^+ C% C  C0 g) o; k9 [
120. #define BMP280_FILTER_COEFF_8 (0x03)
     % Y; s, |* C! _( c
121. #define BMP280_FILTER_COEFF_16 (0x04)
     
122. 
     # s, ?4 t: m7 D( ^! @' I  G- b
123. 
     
124. #define BMP280_ULTRA_LOW_POWER_MODE (0x00)
     
125. #define BMP280_LOW_POWER_MODE (0x01)
     . U0 b! a! I" D- o, m: \0 y
126. #define BMP280_STANDARD_RESOLUTION_MODE (0x02)
     ( L, }( l) S% y; z& F+ b3 X) N
127. #define BMP280_HIGH_RESOLUTION_MODE (0x03)
     
128. #define BMP280_ULTRA_HIGH_RESOLUTION_MODE (0x04)
     5 d7 y6 q* U; I) X7 I
129. 
     
130. #define BMP280_ULTRALOWPOWER_OVERSAMP_PRESSURE BMP280_OVERSAMP_1X
     " l' t* |4 K! N; n
131. #define BMP280_ULTRALOWPOWER_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
     
132. 
     2 o8 W, W! f7 E* D# n& Y
133. #define BMP280_LOWPOWER_OVERSAMP_PRESSURE BMP280_OVERSAMP_2X
     + a6 n1 x' g) U& J9 k' Z! \; N# C
134. #define BMP280_LOWPOWER_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
     " z* K  X! |  a3 `, t& Z: }# i
135. 
     1 g, o& b$ o: w8 [+ v$ }
136. #define BMP280_STANDARDRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_4X
     - W% L) c* K; i
137. #define BMP280_STANDARDRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
     
138. 
     2 j8 B. G, v: h2 Y( N- Y5 k
139. #define BMP280_HIGHRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_8X
     - R, Y, P, b6 D4 ]
140. #define BMP280_HIGHRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
     + ?. j% H4 P4 C5 q$ Q; \  C+ g& p
141. 
     
142. #define BMP280_ULTRAHIGHRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_16X
     # E% L- _- m6 c1 F2 [, a% ^8 G: K0 E
143. #define BMP280_ULTRAHIGHRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_2X
     ; Y7 h* ?# ~9 L: Q1 l
144. 
     ' @+ i9 a: q' v( E2 \. J4 M& P" i
145. 
     
146. #define BMP280_STATUS_REG_MEASURING__POS (3)
     
147. #define BMP280_STATUS_REG_MEASURING__MSK (0x08)
     
148. #define BMP280_STATUS_REG_MEASURING__LEN (1)
     
149. #define BMP280_STATUS_REG_MEASURING__REG (BMP280_STAT_REG)
     0 A9 B: ?- ~* c% d
150. 
     
151. #define BMP280_STATUS_REG_IM_UPDATE__POS (0)
     # O3 w& I. r& P  z* f! F5 `
152. #define BMP280_STATUS_REG_IM_UPDATE__MSK (0x01)
     * C; w! O- z$ R* K
153. #define BMP280_STATUS_REG_IM_UPDATE__LEN (1)
     
154. #define BMP280_STATUS_REG_IM_UPDATE__REG (BMP280_STAT_REG)
     4 ~% H; g2 O  {9 o. J" L
155. 
     
156. 
     + |" q* p. M/ q6 p  O* L* b
157. #define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__POS (5)
     ) I; h  g% W" D2 t* e" B
158. #define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__MSK (0xE0)
     
159. #define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__LEN (3)
     ! E* V. s) n. t" C, G) P# P
160. #define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__REG (BMP280_CTRL_MEAS_REG)
     , C( x6 r9 [8 R6 o/ X2 T3 a
161. 
     
162. 
     % I6 D1 u' b0 d
163. #define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__POS (2)
     
164. #define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__MSK (0x1C)
     
165. #define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__LEN (3)
     & S0 a" T1 U% M$ C) n' K& v4 \
166. #define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__REG (BMP280_CTRL_MEAS_REG)
     
167. 
     . D* i. O1 q% }+ |5 p3 a
168. #define BMP280_CTRL_MEAS_REG_POWER_MODE__POS (0)
     3 l( S: e% {4 `  m! f2 E- L
169. #define BMP280_CTRL_MEAS_REG_POWER_MODE__MSK (0x03)
     $ U) e$ P+ F' Y! g! ^9 x9 ^( d) ^
170. #define BMP280_CTRL_MEAS_REG_POWER_MODE__LEN (2)
     
171. #define BMP280_CTRL_MEAS_REG_POWER_MODE__REG (BMP280_CTRL_MEAS_REG)
     ! j% u( q  s( d( t/ Y5 Y$ @! J
172. 
     6 V- J9 V! l2 ]2 T+ l
173. 
     1 c, m9 C- k$ B
174. #define BMP280_CONFIG_REG_STANDBY_DURN__POS (5)
     " ~. I) q  N- P7 @7 e
175. #define BMP280_CONFIG_REG_STANDBY_DURN__MSK (0xE0)
     9 v; {5 u- ~; j+ I1 s+ J
176. #define BMP280_CONFIG_REG_STANDBY_DURN__LEN (3)
     , o1 G$ C0 ~2 D6 q2 k
177. #define BMP280_CONFIG_REG_STANDBY_DURN__REG (BMP280_CONFIG_REG)
     5 a5 a/ b9 `( r; G9 N: S
178. 
     
179. #define BMP280_CONFIG_REG_FILTER__POS (2)
     . {. F3 k+ d9 Q! P2 N. {
180. #define BMP280_CONFIG_REG_FILTER__MSK (0x1C)
     4 u, B6 y' _" \6 l3 {
181. #define BMP280_CONFIG_REG_FILTER__LEN (3)
     
182. #define BMP280_CONFIG_REG_FILTER__REG (BMP280_CONFIG_REG)
     ! q& h  O. ]9 j8 h4 a" _+ N
183. 
     
184. 
     ! m! q0 Q0 _# P% U5 [. y, @  Y2 Y  r+ |
185. #define BMP280_CONFIG_REG_SPI3_ENABLE__POS (0)
     
186. #define BMP280_CONFIG_REG_SPI3_ENABLE__MSK (0x01)
     
187. #define BMP280_CONFIG_REG_SPI3_ENABLE__LEN (1)
     " U# s$ t& |% A( o
188. #define BMP280_CONFIG_REG_SPI3_ENABLE__REG (BMP280_CONFIG_REG)
     + H  f" g0 q# V) o+ j2 u" j, X; _- Z
189. 
     
190. 
     # r  ]- o+ Z$ W" K9 W0 e
191. #define BMP280_PRESSURE_XLSB_REG_DATA__POS (4)
     
192. #define BMP280_PRESSURE_XLSB_REG_DATA__MSK (0xF0)
     7 \7 F& h/ m7 A1 ~* W  S/ F4 ~
193. #define BMP280_PRESSURE_XLSB_REG_DATA__LEN (4)
     ) z5 ~: |& ~+ V) p; I1 E0 u
194. #define BMP280_PRESSURE_XLSB_REG_DATA__REG (BMP280_PRESSURE_XLSB_REG)
     
195. 
     6 t. k- D0 E: ?! ]
196. #define BMP280_TEMPERATURE_XLSB_REG_DATA__POS (4)
     
197. #define BMP280_TEMPERATURE_XLSB_REG_DATA__MSK (0xF0)
     ' j/ Q; z8 D7 A& l" T- ~  {( b2 D
198. #define BMP280_TEMPERATURE_XLSB_REG_DATA__LEN (4)
     ; h2 Z* B- C/ G  `+ y
199. #define BMP280_TEMPERATURE_XLSB_REG_DATA__REG (BMP280_TEMPERATURE_XLSB_REG)
     0 D& P& Z6 m. ^) v9 [
200. 
     
201. #define BMP280_TEMPERATURE_MSB_DATA (0)
       z% q6 K8 R9 M- u% H( B6 ?9 V2 F
202. #define BMP280_TEMPERATURE_LSB_DATA (1)
     * d/ ]& ?* L* i9 o3 S
203. #define BMP280_TEMPERATURE_XLSB_DATA (2)
     / B2 T1 a/ S& T) |6 f. y
204. 
     ) k& E/ ^" |: d7 E, R9 }" `
205. #define BMP280_PRESSURE_MSB_DATA (0)
     9 k6 B9 k# `2 q: J3 h
206. #define BMP280_PRESSURE_LSB_DATA (1)
     
207. #define BMP280_PRESSURE_XLSB_DATA (2)
     2 Z  G& O' }) w2 n2 g, V
208. 
     5 r, q% e9 D) c1 w6 V; _
209. #define BMP280_DATA_FRAME_PRESSURE_MSB_BYTE (0)
     
210. #define BMP280_DATA_FRAME_PRESSURE_LSB_BYTE (1)
     ( L3 J& W9 b" ?5 i
211. #define BMP280_DATA_FRAME_PRESSURE_XLSB_BYTE (2)
     & ]  H5 Y5 _' d
212. #define BMP280_DATA_FRAME_TEMPERATURE_MSB_BYTE (3)
     & O; l, G: e% h" Y5 X  {
213. #define BMP280_DATA_FRAME_TEMPERATURE_LSB_BYTE (4)
     
214. #define BMP280_DATA_FRAME_TEMPERATURE_XLSB_BYTE (5)
     - S3 f/ b$ s2 X( g3 z$ E
215. 
     " }" l6 z: F. Z
216. #define BMP280_TEMPERATURE_CALIB_DIG_T1_LSB (0)
     
217. #define BMP280_TEMPERATURE_CALIB_DIG_T1_MSB (1)
     ( j2 M8 j; k( x" n7 @
218. #define BMP280_TEMPERATURE_CALIB_DIG_T2_LSB (2)
     * k7 x- S1 T5 p; s9 Q8 a
219. #define BMP280_TEMPERATURE_CALIB_DIG_T2_MSB (3)
     
220. #define BMP280_TEMPERATURE_CALIB_DIG_T3_LSB (4)
     8 P6 @* J. a+ [; r* W9 q  p
221. #define BMP280_TEMPERATURE_CALIB_DIG_T3_MSB (5)
     
222. #define BMP280_PRESSURE_CALIB_DIG_P1_LSB (6)
     7 _# Z7 K# K3 Y/ M
223. #define BMP280_PRESSURE_CALIB_DIG_P1_MSB (7)
     
224. #define BMP280_PRESSURE_CALIB_DIG_P2_LSB (8)
     
225. #define BMP280_PRESSURE_CALIB_DIG_P2_MSB (9)
     
226. #define BMP280_PRESSURE_CALIB_DIG_P3_LSB (10)
     
227. #define BMP280_PRESSURE_CALIB_DIG_P3_MSB (11)
     
228. #define BMP280_PRESSURE_CALIB_DIG_P4_LSB (12)
     
229. #define BMP280_PRESSURE_CALIB_DIG_P4_MSB (13)
     ) \( a  O: `  ]' D3 J- d
230. #define BMP280_PRESSURE_CALIB_DIG_P5_LSB (14)
     
231. #define BMP280_PRESSURE_CALIB_DIG_P5_MSB (15)
     
232. #define BMP280_PRESSURE_CALIB_DIG_P6_LSB (16)
     9 s6 R) F3 e0 `% q0 j" L$ Q
233. #define BMP280_PRESSURE_CALIB_DIG_P6_MSB (17)
     . H$ q1 m$ c, w7 e' k8 z( o) s
234. #define BMP280_PRESSURE_CALIB_DIG_P7_LSB (18)
     
235. #define BMP280_PRESSURE_CALIB_DIG_P7_MSB (19)
     " o- A) ~6 r+ x! R4 N( y
236. #define BMP280_PRESSURE_CALIB_DIG_P8_LSB (20)
     
237. #define BMP280_PRESSURE_CALIB_DIG_P8_MSB (21)
     9 P' w2 k& [4 `! z% N) V
238. #define BMP280_PRESSURE_CALIB_DIG_P9_LSB (22)
     * f" F+ w  \: N8 H& i
239. #define BMP280_PRESSURE_CALIB_DIG_P9_MSB (23)
     
240. 
     1 B0 \- v. H# l+ g
241. #define BMP280_SOFT_RESRT_VALUE (0XB6)
     7 E2 C; Z7 @: O$ C& D. Q* {, C
242. 
     7 o9 |& d6 V0 F# u
243. #define BMP280_I2C_SLAVE_ADDR_LOW (0X76)
     7 l/ m$ p( Z# ]# N7 [
244. #define BMP280_I2C_SLAVE_ADDR_HIGH (0X77)
     
245. 
     0 @& S+ V1 R0 S* ?. }
246. #define BMP280_DEFAULT_ODR_1HZ (1)
     , w: h0 q$ ?2 H. T" G2 w: U. d
247. 
     
248. #define BMP280_BIT(x) ((uint8_t)(x))
     0 ?& R  c$ l' K
249. #define BMP280_CHIP_ID_VAL BMP280_BIT(0X58)
     
250. #define BMP280_I2C_ADDR_TRANS(n) ((n) << 1)
     
251. #define BMP280_I2C_ADDR BMP280_I2C_ADDR_TRANS(BMP280_I2C_SLAVE_ADDR_HIGH)
     
252. 
     
253. 
     $ o3 ~. o! i( o( Z! _
254. #define BMP280_GET_BITSLICE(regvar, bitname) \
     
255.     ((regvar & bitname##__MSK) >> bitname##__POS)
     
256. #define BMP280_SET_BITSLICE(regvar, bitname, val) \
     $ g1 a: k& |  \1 {
257.     ((regvar & ~bitname##__MSK) | ((val << bitname##__POS) & bitname##__MSK))
     # |9 p+ |% k6 A2 A6 P9 I0 U  `
258. 
     : L* J; W8 h3 a1 e1 s
259. typedef struct bmp280_calib_param_t
     . o; G% A  ^9 w8 `
260. {
     3 G/ v8 M' k7 \/ N5 m
261.     uint16_t dig_T1;
     
262.     int16_t  dig_T2;
     1 [7 T9 E/ G. F& r% ]7 D/ D
263.     int16_t  dig_T3;
     
264.     uint16_t dig_P1;
     
265.     int16_t  dig_P2;
     ! W% I% y3 r" U& O. _: s4 }
266.     int16_t  dig_P3;
     / @' I% i$ j2 Y+ d/ s- z6 i# n
267.     int16_t  dig_P4;
     
268.     int16_t  dig_P5;
     , s$ S7 `2 f8 `0 g9 A) ~
269.     int16_t  dig_P6;
     # `3 |/ g' }0 o+ I: T" D* k, ]
270.     int16_t  dig_P7;
     ! |6 t* N3 A0 I. N" X# o. Y" i
271.     int16_t  dig_P8;
     7 O  K, b$ n9 |  H
272.     int16_t  dig_P9;
     7 @5 r% A* W# q' i/ _! e" s( [1 }, Y
273.     int      t_fine;
     
274. } bmp280_calib_param_t;
     % m0 m6 U( C$ B0 X; T( W
275. 
     6 l* {9 ?& x; B0 ?8 Q, i# {2 @- c
276. typedef struct bmp280_device_cfg_t
     , V. C; ?' [% [
277. {
     
278.     uint8_t odr;
     ' f3 k$ B) b6 G. ?/ r) l( M/ e# n
279.     uint8_t mode_filter;
     ) m  d4 q5 N/ @
280.     uint8_t mode_baro;
     
281.     uint8_t mode_temp;
     1 q, m# {5 e* t/ c
282.     uint8_t mode_power;
     7 {3 i& c5 G& a* ~* W* F$ v6 M
283.     uint8_t oversamp_temp;
     , m+ J1 w1 R) B" a
284.     uint8_t oversamp_baro;
     
285. } bmp280_device_cfg_t;
     " Q) s5 ?% `8 \+ z  g
286. 
     : d+ c1 T' R6 |9 n7 I+ s
287. typedef enum {
     % ?6 m/ _3 B) E
288.     DEV_POWER_OFF = 0,
     " ^* T) k" C) _1 C- t0 J
289.     DEV_POWER_ON,
     
290.     DEV_SLEEP,
     
291.     DEV_SUSPEND,
     
292.     DEV_DEEP_SUSPEND,
     & P3 X5 s: `2 l; v8 M, b
293. } bmp280_power_mode;
     
294. 
     4 `" {4 s/ e" a; H
295. typedef enum {
     + T1 C* c1 z+ Y! Y) a
296.     SENSOR_IOCTL_ODR_SET = 1,
     ' O; d! z5 {$ _1 k% {3 Q
297.     SENSOR_IOCTL_RANGE_SET,
     - e9 E- v. E! ~8 Z
298.     SENSOR_IOCTL_SET_POWER,
     , W, M- T1 f3 ?* X+ r! ]
299.     SENSOR_IOCTL_GET_INFO,
     3 @6 s' i8 W/ a: X
300.     SENSOR_IOCTL_MAX
     
301. } cmd_type;
     % v0 q4 d$ Y% {. X
302. 
     1 P; _) S# ~' k$ B" M
303. static bmp280_calib_param_t g_bmp280_calib_table;
     
304. 
     ! `! l$ P5 W8 j3 Y5 \
305. 
     
306. uint8_t bmp280_id_check()
     ; I! l  A5 ]# A+ j, W
307. {
     
308.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
309.         /*ID check*/
     
310.         //BMP280_CHIP_ID_REG = 0XD0,BMP280_CHIP_ID_VAL = 0X58
     
311.         uint8_t id_addr_val[3] = {0xD0,0x58,0x00};
     ; D9 E' v) m( l$ G% ]5 V! i
312.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,id_addr_val[0],1,&id_addr_val[2],1,1000);
     ; S6 x, V! ]9 _3 @
313.         if(HAL_OK!=hi2c2_status){
     
314.                 printf("get part_id error\r\n");
     
315.                 return 1;
     
316.         }
     7 i6 k: X& j" }8 g6 h4 W
317.         if(id_addr_val[1]!=id_addr_val[2]){
     5 K1 K5 D9 e5 P% A7 O# Q  W
318.                 printf("bmp280_validate_id is error\r\n");
     
319.                 return 1;
     
320.         }
     
321.         printf("bmp280_id:%02X\r\n",id_addr_val[2]);
     * y* f! N) z' t* b( L, t: U/ P
322.         return 0;
     
323. }
     ! i) i" t- P# [8 T  y3 v: t, Q
324. 
     
325. uint8_t bmp280_reset()
     & g/ E7 Z* O' r
326. {
     
327.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
328.         /*reset*/
     ) Z* _1 }1 l5 C5 ]
329.         //BMP280_RST_REG = 0XE0,BMP280_SOFT_RESRT_VALUE=0XB6
     
330.         uint8_t addr_val[2] = {BMP280_RST_REG,BMP280_SOFT_RESRT_VALUE};
     
331.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,BMP280_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     5 [# W- E3 G( {7 M& ?& K) b0 H
332.         if(HAL_OK!=hi2c2_status){
     
333.                 printf("bmp280_reset error\r\n");
     
334.                 return 1;
     2 B" W( ]: v9 ?7 b( e( x
335.         }
     
336.         return 0;
     1 F) N( T( r" ~, F# b8 m" W: o
337. }
     
338. 
     ! G5 D% b8 i  y1 w
339. uint8_t bmp280_set_power_mode(bmp280_power_mode mode)
     
340. {
     1 L5 l8 f* p+ X+ v  a
341.         uint8_t dev_mode = 0x00;
     
342.     switch (mode) {
     
343.         case DEV_POWER_OFF:
     
344.         case DEV_SLEEP: {
     + w2 l% b: W' L  [7 c1 b  i) u9 H
345.             dev_mode = (uint8_t)BMP280_SLEEP_MODE;
     
346.             break;
     
347.         }
     ) |- K+ @4 I1 s$ \3 y0 N. y4 c7 V) h  f
348.         case DEV_POWER_ON: {
     7 d( Z  L" x/ P- w
349.             dev_mode = (uint8_t)BMP280_NORMAL_MODE;
     ' Z9 ?# }' P3 ~9 d6 z: u8 g
350.             break;
     
351.         }
     
352.         default:
     + m$ B# ^/ G7 n2 f& u  p  j" Y
353.             return 1;
     
354.     }
     4 w6 q& ~  u+ u
355.         HAL_StatusTypeDef hi2c2_status = 0x00;
     ! G9 F  C/ C9 n5 K
356.         //BMP280_CTRL_MEAS_REG=0XF4
     5 h, p9 y% K9 y1 h
357.         uint8_t mode_addr_val[3] = {BMP280_CTRL_MEAS_REG,0x00,dev_mode};
     
358.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,mode_addr_val[0],1,&mode_addr_val[1],1,1000);
     
359.         if(HAL_OK!=hi2c2_status){
     
360.                 printf("get bmp280_power_mode error\r\n");
     
361.                 return 1;
     ! k4 J& X8 y- ?, o1 c
362.         }
     
363.         printf("bmp280 mode_val[1]:%02X\r\n",mode_addr_val[1]);
     
364.         mode_addr_val[1] = BMP280_SET_BITSLICE(mode_addr_val[1], BMP280_CTRL_MEAS_REG_POWER_MODE, mode_addr_val[2]);
     ( V* ~2 z6 f8 F# T* v8 R) S
365.         printf("bmp280 mode_val[1]:%02X\r\n",mode_addr_val[1]);
     # [$ B( ^! U. Q9 T
366.         /*reset*/
     
367.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,BMP280_I2C_ADDR,mode_addr_val[0],1,&mode_addr_val[1],1,1000);
     6 V) c6 ]9 {3 b3 q
368.         if(HAL_OK!=hi2c2_status){
       E4 e9 K! Q; I, @3 y# f! f% W
369.                 printf("bmp280_set_power_mode error\r\n");
     6 N1 G; k0 e+ T3 O3 T
370.                 return 1;
     
371.         }
     ' |8 Z- W6 I' S6 I
372.         return 0;
     % K$ e3 `! }6 P: X) w2 J* E/ O
373. }
     % o; q6 p( `  z$ ?4 N
374. uint8_t bmp280_set_odr(uint8_t odr)
     3 r/ z1 C/ |2 `  m2 G. ?
375. {
     
376.         HAL_StatusTypeDef hi2c2_status = 0x00;
     7 L6 q% A  D0 D, M" T
377.         //BMP280_CONFIG_REG_STANDBY_DURN__REG=0XF5
     
378.         uint8_t odr_addr_val[2] = {BMP280_CONFIG_REG_STANDBY_DURN__REG,0x00};
     & u& n2 ^. |# X4 s. }. ~0 [- v: f# g9 G
379.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,odr_addr_val[0],1,&odr_addr_val[1],1,1000);
     . s% l, c) q2 e, U! D* L8 u7 d) C2 C
380.         if(HAL_OK!=hi2c2_status){
     . ~' s; H1 P7 x" p$ H4 d
381.                 printf("get bmp280_odr error\r\n");
     
382.                 return 1;
     
383.         }
     - L: P. a9 |  E% A! a
384.         printf("bmp280 odr_val[1]:%02X\r\n",odr_addr_val[1]);
     
385.         //BMP280_DEFAULT_ODR_1HZ = 0X01
     
386.         odr_addr_val[1] = BMP280_SET_BITSLICE(odr_addr_val[1], BMP280_CONFIG_REG_STANDBY_DURN, odr);
     
387.         printf("bmp280 odr_val[1]:%02X\r\n",odr_addr_val[1]);
     3 M) i1 ]- y2 v
388.         /*reset*/
     
389.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,BMP280_I2C_ADDR,odr_addr_val[0],1,&odr_addr_val[1],1,1000);
     ! v! l) J2 S( S+ ^* @1 O, l
390.         if(HAL_OK!=hi2c2_status){
     
391.                 printf("bmp280_set_odr error\r\n");
     
392.                 return 1;
     
393.         }
     4 @1 v  g/ n1 T
394.         return 0;
     
395. }
     
396. 
     - @( R; Q1 s* U) f
397. static uint8_t bmp280_hz2odr(int hz)
     # o% \9 k$ `1 i0 B
398. {
     
399.     if (hz > 80) {
     2 u. K+ T: V' J
400.         return BMP280_STANDBY_TIME_1_MS;
     
401.     } else if (hz > 13) {
     5 W1 r8 T" D8 S3 z( q
402.         return BMP280_STANDBY_TIME_63_MS;
       o- X5 _% H2 p; P  h
403.     } else if (hz > 7) {
     
404.         return BMP280_STANDBY_TIME_125_MS;
     
405.     } else if (hz > 3) {
     + s8 a' h% g1 r8 i
406.         return BMP280_STANDBY_TIME_250_MS;
     
407.     } else {
     
408.         return BMP280_STANDBY_TIME_500_MS;
     ) J" P5 n( i6 B+ W  P2 s) ^) L
409.     }
     
410. }
     
411. 
     
412. 
     - ~5 M" w8 l' G& A& b8 k
413. uint8_t bmp280_ioctl(cmd_type cmd,uint32_t arg)
     
414. {
     " {5 z# o- q2 K- H$ }3 U
415.         uint8_t ret = 0;
     ( ^. l5 P" H% i3 l' B7 F# l; L, Q
416.     switch (cmd) {
     
417.         case SENSOR_IOCTL_ODR_SET: {
     
418.             uint8_t odr = bmp280_hz2odr(arg);
     
419.             ret         = bmp280_set_odr( odr);
     ) W, C# w8 R- W( n4 }7 b
420.             if (ret>0) {
     $ Z- E3 I+ S+ P9 M
421.                 return 1;
     % b8 ^) Y* n, v2 F' B7 E
422.             }
     
423.         } break;
     - I$ C/ E+ [, ^2 r$ F, \7 ]
424.         case SENSOR_IOCTL_SET_POWER: {
     
425.             ret = bmp280_set_power_mode(arg);
     : G# M7 r( K/ B$ g
426.             if (ret>0) {
     
427.                 return 1;
     
428.             }
     ! G7 _0 R& ^: f- w% c; w; x
429.         } break;
     ) b; k& j7 A, o0 S; u4 ^
430.         case SENSOR_IOCTL_GET_INFO: {
     
431. 
     
432.         } break;
     ' M2 y. C. ?' f; j1 _
433. 
     
434.         default:
     
435.             break;
     ( M1 {+ N! s, h3 l- t- \
436.     }
     
437.     return 0;
     3 ~! {; }. [2 x  }$ N7 ~7 E
438. }
     + K0 ^* i8 b  R/ t# i
439. 
     " d- u3 b$ w- u5 s9 v7 k4 w- M
440. uint8_t bmp280_set_default_config()
     
441. {
     6 |! h+ i, L0 h; H6 |* t
442.         uint8_t ret = bmp280_set_power_mode(DEV_SLEEP);
     
443.         if(ret>0)
     : J; O" h" j/ Z* |+ R% z) y1 I3 M: q
444.                 return 1;
     
445.         ret = bmp280_set_odr(BMP280_DEFAULT_ODR_1HZ);
     / X6 D- m$ X6 o1 Z  B/ A' V' Q
446.         if(ret>0)
     / W- O7 @6 I, a8 M0 C  R4 \
447.                 return 1;
     
448.         return 0;
     # }1 m& }$ j6 \6 x+ @" E
449. }
     ) Z6 @7 d5 P/ I* S& f. r8 X
450. 
     + u7 Q8 y$ A' \) e% [8 {8 M2 q0 q
451. uint8_t bmp280_get_calib_param()
     
452. {
     
453.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
454.         uint8_t data_u8[BMP280_CALIB_DATA_SIZE] = { 0x00 };
     
455.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,BMP280_TEMPERATURE_CALIB_DIG_T1_LSB_REG
     ) F# [" g' K6 X  `
456.                         ,1,data_u8,BMP280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH,1000);
     8 Y' |2 I7 o0 i5 o  S
457.         if(HAL_OK!=hi2c2_status){
     7 s* I7 H; B2 d9 I3 ]5 ~$ o+ n
458.                 printf("get bmp280_calib_param error\r\n");
     ; e+ q+ o$ b; K8 A8 L3 w
459.                 return 1;
     3 O2 u$ n4 Y5 s7 M( A; _0 l
460.         }
     
461.         g_bmp280_calib_table.dig_T1 = (uint16_t)(
     ' x( _1 _  E# p" h8 d; i: j1 y
462.                         (((uint16_t)((uint8_t)data_u8[BMP280_TEMPERATURE_CALIB_DIG_T1_MSB])) << BMP280_SHIFT_BY_08_BITS)
     
463.                         | data_u8[BMP280_TEMPERATURE_CALIB_DIG_T1_LSB]);
     
464.         g_bmp280_calib_table.dig_T2 = (int16_t)(
     / ^+ U7 o& a' X# L* z
465.               (((int16_t)((int8_t)data_u8[BMP280_TEMPERATURE_CALIB_DIG_T2_MSB])) << BMP280_SHIFT_BY_08_BITS)
     4 P" k# T) j$ ?9 y, h
466.                    | data_u8[BMP280_TEMPERATURE_CALIB_DIG_T2_LSB]);
     
467.         g_bmp280_calib_table.dig_T3 = (int16_t)(
     8 ?; e8 y  j8 q/ O& J% ^' U" R+ S
468.               (((int16_t)((int8_t)data_u8[BMP280_TEMPERATURE_CALIB_DIG_T3_MSB])) << BMP280_SHIFT_BY_08_BITS)
     
469.                   | data_u8[BMP280_TEMPERATURE_CALIB_DIG_T3_LSB]);
     
470.         g_bmp280_calib_table.dig_P1 = (uint16_t)(
     
471.               (((uint16_t)((uint8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P1_MSB])) << BMP280_SHIFT_BY_08_BITS)
     
472.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P1_LSB]);
     - U  R" q& h; ^- n7 \
473.         g_bmp280_calib_table.dig_P2 = (int16_t)(
     
474.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P2_MSB])) << BMP280_SHIFT_BY_08_BITS)
     . i( f# S/ A# g$ e% k8 b( y- G/ O
475.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P2_LSB]);
     
476.         g_bmp280_calib_table.dig_P3 = (int16_t)(
     ( }. I+ }& [$ G$ x2 O- y; f5 T' i
477.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P3_MSB])) << BMP280_SHIFT_BY_08_BITS)
     , g1 ~* J) U- {4 Z
478.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P3_LSB]);
     ( O) P) P6 X7 ]4 ]
479.         g_bmp280_calib_table.dig_P4 = (int16_t)(
     
480.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P4_MSB])) << BMP280_SHIFT_BY_08_BITS)
     $ Y! {) I  p& M) \8 }. ~
481.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P4_LSB]);
     * n; i0 a. w1 g( Z0 M
482.         g_bmp280_calib_table.dig_P5 = (int16_t)(
     7 L' g/ W6 f7 ^/ U) `
483.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P5_MSB])) << BMP280_SHIFT_BY_08_BITS)
       ^: u0 W4 X. ^7 d
484.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P5_LSB]);
     2 u( k" d7 f6 d- W+ K9 S7 J
485.         g_bmp280_calib_table.dig_P6 = (int16_t)(
     
486.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P6_MSB])) << BMP280_SHIFT_BY_08_BITS)
     
487.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P6_LSB]);
     
488.         g_bmp280_calib_table.dig_P7 = (int16_t)(
     
489.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P7_MSB])) << BMP280_SHIFT_BY_08_BITS)
     + i# o2 e& d/ W8 y, p
490.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P7_LSB]);
     * k$ S- C9 h8 Z/ k3 }9 S7 a7 w& g
491.         g_bmp280_calib_table.dig_P8 = (int16_t)(
     ' e! E( G6 z# v$ }! O4 K
492.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P8_MSB])) << BMP280_SHIFT_BY_08_BITS)
     * x, f) N, X% a% ]8 H
493.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P8_LSB]);
     2 w" y0 S, C- }9 D( T& k
494.         g_bmp280_calib_table.dig_P9 = (int16_t)(
     
495.               (((int16_t)((int8_t)data_u8[BMP280_PRESSURE_CALIB_DIG_P9_MSB])) << BMP280_SHIFT_BY_08_BITS)
     % j- W8 }) s. |0 X
496.                   | data_u8[BMP280_PRESSURE_CALIB_DIG_P9_LSB]);
     
497.         return 0;
     . J2 M$ d" _4 A' e; u6 s8 [
498. }
     8 p2 L8 V3 g* d2 g8 {3 w
499. 
     + ?+ ^' o, l: z, Y8 G7 c
500. uint8_t bmp280_set_baro_work_mode(uint8_t mode)
     0 p- r7 J' ]+ F& c- r- w0 }
501. {
     
502.     uint8_t value = 0;
     
503.     uint8_t temp  = 0;
     $ o* w5 c6 w9 |; E
504.     uint8_t baro  = 0;
     ! j6 C, Z- R9 |/ d8 Q1 Z9 z
505. 
     ( \# `0 A8 U4 `  G7 E# l* k$ p
506.     switch (mode) {
     + D% t4 B0 O9 M
507.     case BMP280_ULTRA_LOW_POWER_MODE:
     
508.         temp = BMP280_OVERSAMP_1X;
     
509.         baro = BMP280_OVERSAMP_1X;
     
510.         break;
     
511. 
     % d+ @. z) d/ W" Q% y. {
512.     case BMP280_LOW_POWER_MODE:
       [& k! L  c5 w) y
513.         temp = BMP280_OVERSAMP_2X;
     / H1 }7 D' }' K
514.         baro = BMP280_OVERSAMP_2X;
     ) f2 @+ H( `* a* [0 t5 r/ H
515.         break;
     
516. 
     
517.     case BMP280_STANDARD_RESOLUTION_MODE:
     & }8 q1 v6 d& `7 V
518.         temp = BMP280_OVERSAMP_4X;
     
519.         baro = BMP280_OVERSAMP_4X;
     
520.         break;
     
521. 
     
522.     case BMP280_HIGH_RESOLUTION_MODE:
     % f0 v  w- W9 P8 s1 S3 \
523.         temp = BMP280_OVERSAMP_8X;
     # g; \7 z3 g# _' O; X; j
524.         baro = BMP280_OVERSAMP_8X;
     
525.         break;
     ! b' w( u1 p) C0 o; W3 r! U
526. 
     
527.     case BMP280_ULTRA_HIGH_RESOLUTION_MODE:
     4 s  b0 M* g" N+ E
528.         temp = BMP280_OVERSAMP_16X;
     3 U. w! Z9 [' o* W, W8 g1 _
529.         baro = BMP280_OVERSAMP_16X;
     ' v# v. H: Y) y' a0 c6 ^2 `' K% Y
530.         break;
     ) M2 D9 @/ I5 Z$ u$ D+ E( B* A% }( X
531. 
     9 E2 e6 n9 s6 t4 r+ v: p( b
532.     default:
     ) M1 g% `* _8 K6 t8 w9 P
533.         return 1;
     
534.     }
     
535.     HAL_StatusTypeDef hi2c2_status = 0x00;
     5 E' v, ?: H0 F  a4 N; |2 D
536. 
     
537.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,BMP280_CTRL_MEAS_REG
     
538.                         ,1,&value,1,1000);
     % k6 y' `/ E* h* @: Z  t8 c: c
539.         if(HAL_OK!=hi2c2_status){
     
540.                 printf("get bmp280_calib_param error\r\n");
     
541.                 return 1;
     ! ?8 |& g* e9 T: n$ h
542.         }
     " L/ m, o& D* l
543.         value =        BMP280_SET_BITSLICE(value, BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE, baro);
     ( \- n, M. H8 s+ h9 j! u/ i
544.         value = BMP280_SET_BITSLICE(value, BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE, temp);
     . C" c; Y& w5 J! {: _; g1 c2 h
545.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c2,BMP280_I2C_ADDR,BMP280_CTRL_MEAS_REG,1,&value,1,1000);
     9 ]0 u1 @% K) T+ j- F9 X6 d
546.         if(HAL_OK!=hi2c2_status){
     
547.                 printf("bmp280_set_power_mode error\r\n");
     9 l) m% X  U5 _  X6 X
548.                 return 1;
     
549.         }
     4 b1 `' e8 Z" e6 }5 a
550.         printf("successfully BMP280 set  baro_work_mode \r\n");
     2 o* V4 T! R5 i, u: Z# @
551.         return 0;
     # @/ k* C# y) ]
552. }
     
553. 
     % b9 E9 D0 \8 j3 E& e
554. uint8_t bmp280_open(void)
     # w0 Q4 t: I$ w- i: s
555. {
     4 X& T' J  M7 v& z7 A" l
556.         uint8_t ret = bmp280_set_baro_work_mode(BMP280_ULTRA_LOW_POWER_MODE);
     
557.         if(ret>0)
     2 u$ R- d6 q3 W6 u7 I7 p1 X
558.                 return 1;
     
559.         ret = bmp280_set_power_mode(DEV_POWER_ON);
     + O/ ]! k& W( J) j  n- B$ z2 d. g: a
560.         if(ret>0)
     
561.                 return 1;
     / [$ F' ~2 ^7 f" {1 }% @
562.         return 0;
     , p9 P$ P: q' F" g3 |( |) q+ U
563. }
     & v) w9 Y8 l+ p* e' F
564. 
     
565. uint8_t bmp280_close(void)
     " [4 O' y- w$ w$ T7 _
566. {
     
567.         uint8_t ret = bmp280_set_power_mode(DEV_POWER_OFF);
     
568.         if(ret>0)
       ]" b4 i8 g. M* w. F* v, g
569.                 return 1;
     . b2 j% e! r+ w
570.         return 0;
     6 P" b- ^6 M% r, W
571. }
     
572. 
     
573. void BMP280_init()
     
574. {
     
575.         if(bmp280_id_check()>0)
     $ f' i+ H% p. }7 n. A3 J* r
576.                 return;
     
577.         if(bmp280_reset()>0)
     2 a4 m% B; ~1 b" G# P! K, U$ B
578.                 return;
     - |. ~& S* g' A$ C2 R
579.         if(bmp280_set_default_config()>0)
     
580.                 return;
     9 _3 ^6 B) j: e  T
581.         if(bmp280_get_calib_param()>0)
       ~' V) b( F- t- G8 P* b! m
582.                 return;
     
583.         printf("successfully BMP280 init\r\n");
     . L  C" f7 e' u  g; q
584. }
     3 ^8 g1 v  R0 _& J' A5 X6 b
585. 
     
586. uint8_t read_bmp280_temp(uint32_t *comp_temp)
     0 j0 _1 v0 G+ f5 q7 k3 @
587. {
     ) l* C4 v: d2 M# I
588.         *comp_temp = 0;
     : n2 D! c' ]9 h* K
589.         uint8_t data_u8[BMP280_TEMPERATURE_DATA_SIZE] = { 0 };
     
590.         int32_t temp;
     3 q- E; Y% s, Z7 `6 m$ w
591.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
592. 
     8 ]' D& z( O# p9 k7 p; F
593.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,BMP280_TEMPERATURE_MSB_REG
     8 A* e3 h1 e# G  h& m  c. l
594.                         ,1,data_u8,BMP280_TEMPERATURE_DATA_SIZE,1000);
     
595.         if(HAL_OK!=hi2c2_status){
     
596.                 printf("get bmp280_calib_param error\r\n");
     1 `6 K1 @( X1 A6 e. z. b! a
597.                 return 1;
     
598.         }
     7 a! R, g; M& T6 ?; }
599.         temp = (int)((((uint32_t)(data_u8[BMP280_TEMPERATURE_MSB_DATA]))
     
600.                         << BMP280_SHIFT_BY_12_BITS) | (((uint32_t)(data_u8[BMP280_TEMPERATURE_LSB_DATA]))
     
601.                         << BMP280_SHIFT_BY_04_BITS) | ((uint32_t)data_u8[BMP280_TEMPERATURE_XLSB_DATA]
     
602.                         >> BMP280_SHIFT_BY_04_BITS));
     
603.         //
     + r8 X& S# r; {9 b% Q  V" c$ L+ {
604.     int v_x1_u32r = 0;
     
605.     int v_x2_u32r = 0;
       T6 B+ V6 q+ J$ u
606.     v_x1_u32r = ((((temp >> BMP280_SHIFT_BY_03_BITS) -
     ( o5 o) [$ {- m; R7 U# M: V
607.                     ((int)g_bmp280_calib_table.dig_T1 << BMP280_SHIFT_BY_01_BIT))) *
     : b5 v7 i, y+ b( h2 E& X% K, E6 z) O
608.                     ((int)g_bmp280_calib_table.dig_T2)) >> BMP280_SHIFT_BY_11_BITS;
     $ E5 e& n1 N1 g# _6 N6 D# a
609. 
     
610.     v_x2_u32r = (((((temp >> BMP280_SHIFT_BY_04_BITS) -
     & g* @$ {7 I' v' O, O8 P
611.                     ((int)g_bmp280_calib_table.dig_T1)) *
     
612.                    ((temp >> BMP280_SHIFT_BY_04_BITS) -
     
613.                     ((int)g_bmp280_calib_table.dig_T1))) >>
     
614.                   BMP280_SHIFT_BY_12_BITS) *
     
615.                  ((int)g_bmp280_calib_table.dig_T3)) >>
     
616.                 BMP280_SHIFT_BY_14_BITS;
     2 `, i. P2 Z% }$ A! I
617. 
     7 A  r. l7 G8 X! I9 _
618.     g_bmp280_calib_table.t_fine = v_x1_u32r + v_x2_u32r;
     
619. 
     ; U2 m, B6 I* a
620.     temp = (g_bmp280_calib_table.t_fine * 5 + 128) >> BMP280_SHIFT_BY_08_BITS;
     
621.     printf("comp_temp: %d.%d\n", (int)temp/100, (int)(temp % 100));
     + s- P) B5 r" C  d
622.     *comp_temp = temp;
     
623.     return 0;
     % a- k7 ~- J9 ^% n  G7 `: H, G
624. }
     
625. 
     
626. uint8_t read_bmp280_baro(uint32_t *comp_baro)
     " y: B9 R2 s) O+ }$ B0 q5 o
627. {
     5 M' b3 q& M9 f$ g: [5 t6 Q4 J
628.         *comp_baro = 0;
     
629.         uint8_t data_u8[BMP280_PRESSURE_DATA_SIZE] = { 0 };
     
630.         int32_t temp;
     2 v" t4 e5 G& ^: a0 u* k7 T
631.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
632.         //BMP280_PRESSURE_MSB_REG=0XF7,BMP280_PRESSURE_DATA_SIZE=0X03
     + E, ]1 K- R$ j. r3 R5 T
633.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c2,BMP280_I2C_ADDR,BMP280_PRESSURE_MSB_REG
     
634.                                 ,1,data_u8,BMP280_PRESSURE_DATA_SIZE,1000);
     
635.         if(HAL_OK!=hi2c2_status){
     4 Q8 c& J& ~1 f4 p
636.                 printf("get bmp280_calib_param error\r\n");
     3 g1 c) K4 G$ R" l  e
637.                 return 1;
     % }9 j4 t8 Y6 F9 h! ^. \2 q
638.         }
     " a6 ^( Z/ [" Y1 a% ^
639.         temp = (int)(
     
640.                         (((uint32_t)(data_u8[BMP280_PRESSURE_MSB_DATA])) << BMP280_SHIFT_BY_12_BITS)
     0 o4 ?6 M/ w' |( C& I5 P" r
641.                         | (((uint32_t)(data_u8[BMP280_PRESSURE_LSB_DATA])) << BMP280_SHIFT_BY_04_BITS)
     
642.                         | ((uint32_t)data_u8[BMP280_PRESSURE_XLSB_DATA]        >> BMP280_SHIFT_BY_04_BITS)
     1 b* r* n5 S' O5 s( r' @, Q
643.                         );
     
644.         //
     1 Y3 _0 M+ Z5 i" U  Z
645.         int      v_x1_u32r = 0;
     
646.         int      v_x2_u32r = 0;
     ; ^- k* g# _8 O6 S; {4 u3 O$ R& C
647. 
     
648.         v_x1_u32r = (((int)g_bmp280_calib_table.t_fine) >> BMP280_SHIFT_BY_01_BIT) - (int)64000;
     ( f, B: p. f, w7 C8 t, Q
649.         v_x2_u32r = (((v_x1_u32r >> BMP280_SHIFT_BY_02_BITS) * (v_x1_u32r >> BMP280_SHIFT_BY_02_BITS)) >>
     
650.                          BMP280_SHIFT_BY_11_BITS) * ((int)g_bmp280_calib_table.dig_P6);
     & e% ^( J! ^% M& ?. t
651.         v_x2_u32r = v_x2_u32r + ((v_x1_u32r * ((int)g_bmp280_calib_table.dig_P5)) << BMP280_SHIFT_BY_01_BIT);
     
652.         v_x2_u32r = (v_x2_u32r >> BMP280_SHIFT_BY_02_BITS) + (((int)g_bmp280_calib_table.dig_P4) << BMP280_SHIFT_BY_16_BITS);
     
653.         v_x1_u32r = (((g_bmp280_calib_table.dig_P3 *  (((v_x1_u32r >> BMP280_SHIFT_BY_02_BITS) *
     & a, y0 L7 l# r) g
654.                         (v_x1_u32r >> BMP280_SHIFT_BY_02_BITS)) >> BMP280_SHIFT_BY_13_BITS)) >> BMP280_SHIFT_BY_03_BITS) +
     0 _: a/ @, z3 h! G* |5 y- E  e
655.                 ((((int)g_bmp280_calib_table.dig_P2) * v_x1_u32r) >> BMP280_SHIFT_BY_01_BIT)) >> BMP280_SHIFT_BY_18_BITS;
     ' r& f4 t/ b1 u* d! g- z2 `& ?
656.         v_x1_u32r = ((((32768 + v_x1_u32r)) * ((int)g_bmp280_calib_table.dig_P1)) >> BMP280_SHIFT_BY_15_BITS);
     8 _5 q& V2 q9 T$ {, N$ [
657.         if (v_x1_u32r == 0)
     
658.         {
     
659.                 return 1; // avoid exception caused by division by zero
     3 v. c: [) g2 P* I7 h! Z# I  g
660.         }
     
661.         //
     
662.         uint32_t val_baro = 0;
     
663.         val_baro = (((uint32_t)(((int)1048576) - temp) - (v_x2_u32r >> BMP280_SHIFT_BY_12_BITS))) * 3125;
     
664. 
     
665.         if (val_baro < 0x80000000) {
     
666.                 if (v_x1_u32r != 0) {
     ' K- x2 N  h8 i* X- W! B
667.                         val_baro =        (val_baro << BMP280_SHIFT_BY_01_BIT) / ((uint32_t)v_x1_u32r);
     / z+ |4 g) V2 [, d- r
668.                 } else {
     * K" }5 P: j5 V4 u$ f$ ~) b9 N2 f
669.                         return 1;
     9 K# N6 f. P  t
670.                 }
     - v1 M! a: v& o; k' V7 S& S$ t
671.         } else if (v_x1_u32r != 0) {
     
672.                 val_baro = (val_baro / (uint32_t)v_x1_u32r) * 2;
     7 t- Z4 b9 Y6 o1 Y! C
673.         } else {
     
674.                 return 1;
     " x# |/ E" W" l4 j7 y
675.         }
     
676.         v_x1_u32r = (((int)g_bmp280_calib_table.dig_P9) * ((int)(((val_baro >> BMP280_SHIFT_BY_03_BITS) *
     8 Q% N3 D* h3 L; X" b
677.                             (val_baro >> BMP280_SHIFT_BY_03_BITS)) >> BMP280_SHIFT_BY_13_BITS))) >> BMP280_SHIFT_BY_12_BITS;
     ! |7 p" |! P( j' y( m6 n
678. 
     
679.         v_x2_u32r = (((int)(val_baro >> BMP280_SHIFT_BY_02_BITS)) * ((int)g_bmp280_calib_table.dig_P8)) >>        BMP280_SHIFT_BY_13_BITS;
     9 F7 P. p2 k3 @  `3 Q
680. 
     / i8 m5 _, g1 ~# p
681.         val_baro = (uint32_t)((int)val_baro +
     
682.                             ((v_x1_u32r + v_x2_u32r + g_bmp280_calib_table.dig_P7) >> BMP280_SHIFT_BY_04_BITS));
     + R7 R: |; b& G0 \
683. 
     0 R1 ~/ \3 a4 u. ?% F/ s4 E
684.         printf("comp_baro:%d.%d\r\n",(int)val_baro/100, (int)(val_baro % 100));
     
685.         *comp_baro = val_baro;
       g; _/ y1 W! O0 s  u' T/ n
686.         return 0;
     , E( u. K. H2 s, H8 J" {7 x2 [- c
687. }

复制代码

! H/ t8 a  N' S4 D; R  w9 d+ t+ i  i八、LSM6DSL传感器（加速度及角速度）
在ICore源码目录下，创建LSM6DSL文件夹，再在该目录下创建LSM6DSL.h和LSM6DSL.c源文件。

# V* J) M) D" S4 ]0 P# c        在网上查找下载LSM6DSL传感器数据手册，逐步分析，该传感器的I2C通信也是采用了从机地址+寄存器地址+数据的通信方式，传感器从设备地址0XD4(0X6A（01101010）<<1)如下：
7 N9 B; e/ G3 C8 v( i+ q) L5 @( z- A

& L0 |! O1 T* K
6 J/ i3 ?( M+ G, E) R
2 h! c6 t9 h5 C& X+ D) U/ a        但中间这段文字描述翻译如下：LSM6DSL相关的从属AD地址（SAD）为110101xb。SDO/SA0引脚可用于修改设备地址的低位。如果SDO/SA0引脚连接到电源电压，LSb为“1”（地址1101011b）；否则，如果SDO/SA0引脚接地，则LSb值为“0”（地址1101010b）。该解决方案允许将两个不同的惯性模块连接并寻址到同一I2C总线，即有两个地址0X6A（1101010）、0X6B（1101011）。结合开发板的硬件原理图，在R500和R502接线下，取值不同，经测试0XD6、0XD7才能正确读取设备ID，开发板应该是R502接线，从设备地址是0XD6/0XD7。


& Y* [+ {/ ^0 {# T
" l6 K2 S5 F$ f# t
: P& W7 }# c" _2 ^* O& s7 f        1）设备ID，地址是0X0F，正确返回值是0X6A
& [' g. l0 M7 a; z9 T/ c
$ x/ F9 [% l# K/ f
$ s2 J' U, ^. f$ `0 Q4 s" F- H
8 R$ U3 _; \+ s& W6 }: Z
/ u" z8 y; P3 s) g8 L- H2 q         2）软重置设置，寄存器地址是0X12，设置mydata|0x01可重置设备
) B5 G7 J( b/ s3 M% I+ R

; I5 z# m% b0 t8 J; Q" A

$ j' C0 o4 O/ p         3）acc加速度模式设置，涉及odr(rate、power)、 刻度(scale)、频宽、是否启动。
2 _0 Q+ c, [7 Z1 ?0 K% I
! v3 Y- s# g. S2 }$ _& {

         4）Gyro角速度模式设置，涉及odr(rate)、刻度(scale)、是否启动。
& H* C/ X2 I( {# k" A# S( E6 f# V
# E( Y: s0 E0 r6 v9 x8 S
6 D" W3 n- A1 ~" p1 j5 Y4 {7 e
' s" u4 f6 C3 l+ j         5）读取数据 地址0X22~0X27为gyro数值，共6字节（16bit）.地址0X28~0X2D为acc数值，共6字节（16bit）
+ I# P  M& L1 W0 H4 r5 M
' ?$ ^7 \5 g3 @# D$ B* F4 P
  ^. t8 L1 a! s
        ACC和GYRO数值换算表如下，相关含义读者可以查找加速度及角速度相关知识了解：
) w, s% M6 m! O0 z" P% E3 B) U
& [2 }. `. d% s4 I
3 T6 r% X/ v( J% P7 G; I& `
# d$ M* C  `9 f. ?' B, d& P         6）按以上分析，给出LSM6DSl传感器的伪代码
0 r5 r& h3 ~2 X8 S0 f& F* ^  G

1. LSM6DSL从机地址是0XD6
   
2. init:
   ; N/ D; `1 Y  s3 m- }
3. read id from 从机地址是0XD6 寄存器地址0X0F
   
4. 确定id==0X6A
   % a2 \' m6 w& n* b9 J
5. write myconf|0X01 to 从机地址是0XD6 寄存器地址0X12 软重置设备
   
6. write mymode to 从机地址是0XD6 寄存器地址0X10 设置设备ACC模式
   ' `( I- }, v' K; _. u5 |
7. write mymode to 从机地址是0XD6 寄存器地址0X11 设置设备GYRO模式
   
8. 
   * s  d3 D$ ?7 d$ e, G
9. 读取数据
   
10. acc 读取数据前确保设置了相关参数，如power mode,range,频宽等，在寄存器地址0X10 设置
    
11. read acc1~6 from 从机地址是0XD6 寄存器地址0X28,0X29,0X2A,0X2B,0X2C,0X2D
    ( |6 a9 E  z- ~6 K
12. acc1~6进行换算处理得到acc数值
    
13. 
    5 ~1 a' z+ n% S. p! G% e
14. acc 读取数据前确保设置了相关参数，如power mode,range,频宽等，寄存器地址0X11设置
    ! h- A5 L+ o2 A8 y+ G; L" H
15. read gyro1~6 from 从机地址是0XD6 寄存器地址0X22,0X23,0X24,0X25,0X26,0X27
    $ W$ o5 A" B, z& j) w. Z
16. gyro1~6进行换算处理得到gyro数值

复制代码

& s0 \# }' P! Y% L         7)按以上分析及伪代码设计，LSM6DSL传感器的给出LSM6DSL.h和LSM6DSL.c源文件

        LSM6DSL.h

1. #ifndef _LSM6DSL_H_
   . e  T% f5 V  B% \" W8 k
2. #define _LSM6DSL_H_
   % z5 X0 t! D1 [3 r/ Z
3. 
   
4. #include "main.h"
   
5. 
   5 [3 z* Z7 Q; u3 b0 C, ~
6. void LSM6DSL_init();
   * }+ I$ {5 Z, Y
7. uint8_t LSM6DSL_acc_st_open(void);
   $ X* q# w7 g  T& q7 f: b- f5 y! v: U, g
8. uint8_t LSM6DSL_acc_st_close(void);
   
9. 
   
10. uint8_t LSM6DSL_gyro_st_open(void);
    + Z0 x2 x& `. M
11. uint8_t LSM6DSL_gyro_st_close(void);
    
12. 
    - _5 T* K3 ~2 l. ?- q; }
13. uint8_t LSM6DSL_acc_read(int32_t *x_data,int32_t *y_data,int32_t *z_data);
    
14. uint8_t LSM6DSL_gyro_read(int32_t *x_data,int32_t *y_data,int32_t *z_data);
    8 s9 M, O3 b! p3 l4 N9 k
15. 
    5 Y! A4 l- c5 O1 z/ v" x% d4 |
16. #endif /* LSM6DSL_LSM6DSL_H_ */

复制代码

         LSM6DSL.c

1. #include <stdio.h>
   . f# w$ S$ r7 B8 w) T( N& g
2. #include "LSM6DSL.h"
   ) O& H/ u% I$ Y
3. 
   
4. extern I2C_HandleTypeDef hi2c4;
   
5. 
   
6. #define LSM6DSL_I2C_ADDR1 (0x6A)
   
7. #define LSM6DSL_I2C_ADDR2 (0x6B)
   * o5 `( v" `/ ]0 C
8. #define LSM6DSL_I2C_ADDR_TRANS(n) ((n) << 1)
   
9. #define LSM6DSL_I2C_ADDR LSM6DSL_I2C_ADDR_TRANS(LSM6DSL_I2C_ADDR2)
   
10. 
    
11. #define LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS 0x01
    
12. #define LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME 0x04
    
13. #define LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO 0x05
    
14. #define LSM6DSL_ACC_GYRO_FIFO_CTRL1 0x06
    
15. #define LSM6DSL_ACC_GYRO_FIFO_CTRL2 0x07
    
16. #define LSM6DSL_ACC_GYRO_FIFO_CTRL3 0x08
    
17. #define LSM6DSL_ACC_GYRO_FIFO_CTRL4 0x09
    
18. #define LSM6DSL_ACC_GYRO_FIFO_CTRL5 0x0A
    
19. #define LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
    - X( C) ^9 ?& o
20. #define LSM6DSL_ACC_GYRO_INT1_CTRL 0x0D
    
21. #define LSM6DSL_ACC_GYRO_INT2_CTRL 0x0E
    
22. #define LSM6DSL_ACC_GYRO_WHO_AM_I_REG 0x0F
    4 E* c+ G- w5 B( u9 g
23. #define LSM6DSL_ACC_GYRO_CTRL1_XL 0x10
    
24. #define LSM6DSL_ACC_GYRO_CTRL2_G 0x11
    
25. #define LSM6DSL_ACC_GYRO_CTRL3_C 0x12
    
26. #define LSM6DSL_ACC_GYRO_CTRL4_C 0x13
    
27. #define LSM6DSL_ACC_GYRO_CTRL5_C 0x14
    
28. #define LSM6DSL_ACC_GYRO_CTRL6_C 0x15
    
29. #define LSM6DSL_ACC_GYRO_CTRL7_G 0x16
    
30. #define LSM6DSL_ACC_GYRO_CTRL8_XL 0x17
    $ D" e7 r8 P, _. w$ x1 @, v
31. #define LSM6DSL_ACC_GYRO_CTRL9_XL 0x18
    , U- i) G9 v3 A! q; ]! e! w6 e7 z
32. #define LSM6DSL_ACC_GYRO_CTRL10_C 0x19
    
33. 
    & k- ]" Y$ ]% o# @" A1 \
34. 
    ! |* j0 E; D  r
35. #define LSM6DSL_ACC_GYRO_MASTER_CONFIG 0x1A
    
36. #define LSM6DSL_ACC_GYRO_WAKE_UP_SRC 0x1B
    , @7 a0 }: _6 q7 b$ `  \; C
37. #define LSM6DSL_ACC_GYRO_TAP_SRC 0x1C
    
38. #define LSM6DSL_ACC_GYRO_D6D_SRC 0x1D
    
39. #define LSM6DSL_ACC_GYRO_STATUS_REG 0x1E
    : X* i5 O8 ~- k1 j: o$ _
40. 
    
41. #define LSM6DSL_ACC_GYRO_OUT_TEMP_L 0x20
    
42. #define LSM6DSL_ACC_GYRO_OUT_TEMP_H 0x21
    
43. #define LSM6DSL_ACC_GYRO_OUTX_L_G 0x22
    
44. #define LSM6DSL_ACC_GYRO_OUTX_H_G 0x23
    - v. N$ k0 o$ C" {9 U
45. #define LSM6DSL_ACC_GYRO_OUTY_L_G 0x24
    0 I0 |3 v: T! h4 [: @9 H
46. #define LSM6DSL_ACC_GYRO_OUTY_H_G 0x25
    
47. #define LSM6DSL_ACC_GYRO_OUTZ_L_G 0x26
    8 T9 f- f% {( r# |6 s& b
48. #define LSM6DSL_ACC_GYRO_OUTZ_H_G 0x27
    
49. #define LSM6DSL_ACC_GYRO_OUTX_L_XL 0x28
    
50. #define LSM6DSL_ACC_GYRO_OUTX_H_XL 0x29
    
51. #define LSM6DSL_ACC_GYRO_OUTY_L_XL 0x2A
    " j8 j, `( S( ]
52. #define LSM6DSL_ACC_GYRO_OUTY_H_XL 0x2B
    + I4 \) Z5 O+ G, A" a
53. #define LSM6DSL_ACC_GYRO_OUTZ_L_XL 0x2C
    8 [; @: P* Y2 z& K) |$ V
54. #define LSM6DSL_ACC_GYRO_OUTZ_H_XL 0x2D
    
55. #define LSM6DSL_ACC_GYRO_SENSORHUB1_REG 0x2E
    
56. #define LSM6DSL_ACC_GYRO_SENSORHUB2_REG 0x2F
    2 S9 S2 b6 W: N6 ?9 b7 H
57. #define LSM6DSL_ACC_GYRO_SENSORHUB3_REG 0x30
    
58. #define LSM6DSL_ACC_GYRO_SENSORHUB4_REG 0x31
    
59. #define LSM6DSL_ACC_GYRO_SENSORHUB5_REG 0x32
    4 U8 D/ `! O' o$ J1 Q
60. #define LSM6DSL_ACC_GYRO_SENSORHUB6_REG 0x33
    : h) ]7 h- {% v5 q
61. #define LSM6DSL_ACC_GYRO_SENSORHUB7_REG 0x34
    " y: J8 ~6 j3 A# A, O6 s* h! o
62. #define LSM6DSL_ACC_GYRO_SENSORHUB8_REG 0x35
    
63. #define LSM6DSL_ACC_GYRO_SENSORHUB9_REG 0x36
      ]% S) }5 D+ C3 k# F
64. #define LSM6DSL_ACC_GYRO_SENSORHUB10_REG 0x37
    9 W% O9 f3 M6 @; e* m: ~
65. #define LSM6DSL_ACC_GYRO_SENSORHUB11_REG 0x38
    ! j) v& k0 V) Y) a" V9 B: O' b5 H2 W
66. #define LSM6DSL_ACC_GYRO_SENSORHUB12_REG 0x39
    2 {1 H5 u  P( o) I
67. #define LSM6DSL_ACC_GYRO_FIFO_STATUS1 0x3A
    # {# l+ k4 k7 o
68. #define LSM6DSL_ACC_GYRO_FIFO_STATUS2 0x3B
    ) T# M! H$ y: v! `. f/ Y; W
69. #define LSM6DSL_ACC_GYRO_FIFO_STATUS3 0x3C
    ! \) ?/ x% f: T- I' u9 L6 A& t
70. #define LSM6DSL_ACC_GYRO_FIFO_STATUS4 0x3D
    8 h; Y/ ~* r, ~# d3 m& C! x
71. #define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
    
72. #define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
    ' K* N0 n8 H" i& v+ N, v8 ?3 X
73. #define LSM6DSL_ACC_GYRO_TIMESTAMP0_REG 0x40
      s/ \5 X" _: }% r) t) G9 Z; H, a
74. #define LSM6DSL_ACC_GYRO_TIMESTAMP1_REG 0x41
    1 T# r* E) L+ r: w4 g  G. S
75. #define LSM6DSL_ACC_GYRO_TIMESTAMP2_REG 0x42
    ) a- @+ e8 I5 l  J5 [( G7 x
76. 
    " a, [9 ^% _8 M2 F5 w5 L  S
77. #define LSM6DSL_ACC_GYRO_TIMESTAMP_L 0x49
    
78. #define LSM6DSL_ACC_GYRO_TIMESTAMP_H 0x4A
    
79. 
    4 C) T5 I* X; t# c; u) s
80. #define LSM6DSL_ACC_GYRO_STEP_COUNTER_L 0x4B
    
81. #define LSM6DSL_ACC_GYRO_STEP_COUNTER_H 0x4C
    
82. 
    
83. #define LSM6DSL_ACC_GYRO_SENSORHUB13_REG 0x4D
    
84. #define LSM6DSL_ACC_GYRO_SENSORHUB14_REG 0x4E
    1 {% \6 `: i. p+ Q9 J; C' C9 k
85. #define LSM6DSL_ACC_GYRO_SENSORHUB15_REG 0x4F
    
86. #define LSM6DSL_ACC_GYRO_SENSORHUB16_REG 0x50
    
87. #define LSM6DSL_ACC_GYRO_SENSORHUB17_REG 0x51
    2 i4 Z% v/ n  R4 y4 S
88. #define LSM6DSL_ACC_GYRO_SENSORHUB18_REG 0x52
    ! T4 g3 e' _4 \- N
89. 
    , k* P7 [7 E5 [: g3 x
90. #define LSM6DSL_ACC_GYRO_FUNC_SRC 0x53
    
91. #define LSM6DSL_ACC_GYRO_TAP_CFG1 0x58
    4 s) V, B  c+ a4 v$ K, O/ G& w6 G
92. #define LSM6DSL_ACC_GYRO_TAP_THS_6D 0x59
    5 O3 D4 ?( y. t# A( j9 {3 M
93. #define LSM6DSL_ACC_GYRO_INT_DUR2 0x5A
    $ V) f; E$ g2 P! ]' v$ ~# y  C
94. #define LSM6DSL_ACC_GYRO_WAKE_UP_THS 0x5B
    8 _4 o3 @1 o  T9 G- G5 ~( z
95. #define LSM6DSL_ACC_GYRO_WAKE_UP_DUR 0x5C
    
96. #define LSM6DSL_ACC_GYRO_FREE_FALL 0x5D
    1 S6 q* g' K1 v5 P
97. #define LSM6DSL_ACC_GYRO_MD1_CFG 0x5E
    4 b- W2 [/ v& f8 c% a% Z' I: M
98. #define LSM6DSL_ACC_GYRO_MD2_CFG 0x5F
    ! U! V: h& y/ m( o6 M
99. 
    ! f* ~+ v& E0 k" [! @' x; b
100. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
     2 U, K2 c* z. S+ a
101. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
     
102. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
     
103. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
     . B. u, r3 |- C# |) g
104. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
     9 L$ I0 [. ?5 q: }
105. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
     7 V0 R7 ^5 m6 k& E0 [; F
106. 
     ( @9 g/ ~+ S7 P. i2 y2 N
107. #define LSM6DSL_ACC_GYRO_X_OFS_USR 0x73
     6 \$ s- k# e0 c; ^$ @
108. #define LSM6DSL_ACC_GYRO_Y_OFS_USR 0x74
     
109. #define LSM6DSL_ACC_GYRO_Z_OFS_USR 0x75
     7 ~) c  [% P9 c4 Q3 X2 i& w* b) |
110. 
     
111. #define LSM6DSL_CHIP_ID_VALUE (0x6A)
     
112. 
     , r' e! Q; l6 a! O+ G
113. #define LSM6DSL_RESET_VALUE (0x1)
     
114. #define LSM6DSL_RESET_MSK (0X1)
     
115. #define LSM6DSL_RESET_POS (0)
     / _- U  J/ W: Q. I- @0 G  }0 c) F
116. 
     5 n' {! j! p* s8 j9 x" L7 }! C
117. #define LSM6DSL_ACC_ODR_POWER_DOWN (0X00)
     
118. #define LSM6DSL_ACC_ODR_1_6_HZ (0X0B)
     
119. #define LSM6DSL_ACC_ODR_12_5_HZ (0x01)
     
120. #define LSM6DSL_ACC_ODR_26_HZ (0x02)
       X! u2 ~$ W) k# P1 f5 j& _
121. #define LSM6DSL_ACC_ODR_52_HZ (0x03)
     5 d  X6 l' U6 R9 I$ L: c* Z  B3 D; s
122. #define LSM6DSL_ACC_ODR_104_HZ (0x04)
       c; u( K& Y, d! S
123. #define LSM6DSL_ACC_ODR_208_HZ (0x05)
       _5 U4 H" R) d! |
124. #define LSM6DSL_ACC_ODR_416_HZ (0x06)
     
125. #define LSM6DSL_ACC_ODR_833_HZ (0x07)
     
126. #define LSM6DSL_ACC_ODR_1_66_KHZ (0x08)
     0 X3 S. |  I% D9 z
127. #define LSM6DSL_ACC_ODR_3_33_KHZ (0x09)
     
128. #define LSM6DSL_ACC_ODR_6_66_KHZ (0x0A)
       j4 q1 x5 [' V- ?
129. #define LSM6DSL_ACC_ODR_MSK (0XF0)
     
130. #define LSM6DSL_ACC_ODR_POS (4)
     
131. 
     5 o" @' o% d  F
132. #define LSM6DSL_GYRO_ODR_POWER_DOWN (0X00)
     
133. #define LSM6DSL_GYRO_ODR_12_5_HZ (0x01)
     7 i" S4 U" t) R3 p& V2 P( e
134. #define LSM6DSL_GYRO_ODR_26_HZ (0x02)
     
135. #define LSM6DSL_GYRO_ODR_52_HZ (0x03)
     . M7 }7 d: B7 k0 O3 k) Q
136. #define LSM6DSL_GYRO_ODR_104_HZ (0x04)
     3 c& n3 z9 s  e9 ~# H5 c
137. #define LSM6DSL_GYRO_ODR_208_HZ (0x05)
     * x- ]' {- ^% o( K8 e
138. #define LSM6DSL_GYRO_ODR_416_HZ (0x06)
     $ B7 x+ a  P5 r! m
139. #define LSM6DSL_GYRO_ODR_833_HZ (0x07)
     
140. #define LSM6DSL_GYRO_ODR_1_66_KHZ (0x08)
     
141. #define LSM6DSL_GYRO_ODR_3_33_KHZ (0x09)
     
142. #define LSM6DSL_GYRO_ODR_6_66_KHZ (0x0A)
     
143. #define LSM6DSL_GYRO_ODR_MSK (0XF0)
     1 ]6 @7 m, s% o" }5 P
144. #define LSM6DSL_GYRO_ODR_POS (4)
     
145. 
     ) W( }3 v+ z, _4 S' _, s) M" i
146. #define LSM6DSL_ACC_RANGE_2G (0x0)
     " j( u7 @1 n/ {5 {
147. #define LSM6DSL_ACC_RANGE_4G (0x2)
     
148. #define LSM6DSL_ACC_RANGE_8G (0x3)
     # E, T; Z. z+ O. P0 g, Z5 K. g4 Y
149. #define LSM6DSL_ACC_RANGE_16G (0x1)
     ) X8 U' }" w' s+ T
150. #define LSM6DSL_ACC_RANGE_MSK (0X0C)
     
151. #define LSM6DSL_ACC_RANGE_POS (2)
     
152. 
     
153. #define LSM6DSL_ACC_SENSITIVITY_2G (61)
     
154. #define LSM6DSL_ACC_SENSITIVITY_4G (122)
     : W4 F' v& J8 Q% J1 @
155. #define LSM6DSL_ACC_SENSITIVITY_8G (244)
     
156. #define LSM6DSL_ACC_SENSITIVITY_16G (488)
     
157. 
     
158. #define LSM6DSL_GYRO_RANGE_245 (0x0)
     
159. #define LSM6DSL_GYRO_RANGE_500 (0x1)
     
160. #define LSM6DSL_GYRO_RANGE_1000 (0x2)
     8 {: B) X! g7 x- x2 e
161. #define LSM6DSL_GYRO_RANGE_2000 (0x3)
     
162. #define LSM6DSL_GYRO_RANGE_MSK (0X0C)
     
163. #define LSM6DSL_GYRO_RANGE_POS (2)
     
164. 
     
165. #define LSM6DSL_GYRO_SENSITIVITY_245DPS (8750)
     6 k5 K, q6 \3 O/ R& Q
166. #define LSM6DSL_GYRO_SENSITIVITY_500DPS (17500)
     
167. #define LSM6DSL_GYRO_SENSITIVITY_1000DPS (35000)
       {& t7 l  H! [# n
168. #define LSM6DSL_GYRO_SENSITIVITY_2000DPS (70000)
     
169. 
     % O' ]! F9 c0 {# l
170. #define LSM6DSL_SHIFT_EIGHT_BITS (8)
     
171. #define LSM6DSL_16_BIT_SHIFT (0xFF)
     
172. #define LSM6DSL_ACC_MUL (1000)
     
173. #define LSM6DSL_GYRO_MUL (1)
     
174. 
     
175. #define LSM6DSL_ACC_DEFAULT_ODR_100HZ (100)
     
176. #define LSM6DSL_GYRO_DEFAULT_ODR_100HZ (100)
     5 I/ S! D: j- X  L
177. 
     ; y6 p% V% _! x( Z" H$ l$ M8 {
178. #define LSM6DSL_GET_BITSLICE(regvar, bitname) \
     5 z( w, s1 B( a+ j
179.     ((regvar & bitname##_MSK) >> bitname##_POS)
     
180. 
     
181. #define LSM6DSL_SET_BITSLICE(regvar, bitname, val) \
     4 {% H. g' f" }4 o: D( T' T* A% r
182.     ((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
     $ ?$ B8 N; ?5 h3 j$ B! F2 h
183. 
     3 y! X$ V" ?. Y( Q0 {. \
184. typedef enum {
     ' j  i( b6 ^7 Z; I4 N
185.     ACC_RANGE_2G,
     
186.     ACC_RANGE_4G,
     5 L/ q& q' Z- T
187.     ACC_RANGE_8G,
     ( r& V+ {9 X7 }( C0 M9 P9 E* l# I
188.     ACC_RANGE_16G,
     ) p& z9 S: I# W' e& p
189.     ACC_RANGE_6G,
     
190.     ACC_RANGE_12G,
     + q/ r8 I1 R7 a6 \3 y, H
191.     ACC_RANGE_24G,
     
192.     ACC_RANGE_100G,
     1 O! M) f% w7 I0 i1 B3 g
193.     ACC_RANGE_200G,
     
194.     ACC_RANGE_400G,
     
195.     ACC_RANGE_MAX
     
196. } acc_range_e;
     0 f' O; u5 m0 e- w" f
197. 
     
198. typedef enum {
     
199.     GYRO_RANGE_125DPS,
     : J2 g( C- O% e
200.     GYRO_RANGE_250DPS,
     
201.     GYRO_RANGE_500DPS,
     
202.     GYRO_RANGE_1000DPS,
     6 r! p# G! D0 J2 c5 p* A% k' J3 o
203.     GYRO_RANGE_2000DPS,
     
204.     GYRO_RANGE_MAX
     
205. } gyro_range_e;
     
206. 
     ! J) D* U) z( o; z9 i7 u
207. static int32_t lsm6dsl_acc_factor[ACC_RANGE_MAX] = {
     
208.     LSM6DSL_ACC_SENSITIVITY_2G, LSM6DSL_ACC_SENSITIVITY_4G,
     
209.     LSM6DSL_ACC_SENSITIVITY_8G, LSM6DSL_ACC_SENSITIVITY_16G
     
210. };
     4 j4 H! g  j( x3 B) {
211. static int32_t lsm6dsl_gyro_factor[GYRO_RANGE_MAX] = {
     
212.     0, LSM6DSL_GYRO_SENSITIVITY_245DPS, LSM6DSL_GYRO_SENSITIVITY_500DPS,
     5 q6 {1 g4 Y5 }& |" ?% o( W. l
213.     LSM6DSL_GYRO_SENSITIVITY_1000DPS, LSM6DSL_GYRO_SENSITIVITY_2000DPS
     7 I* U2 i- I- {& U6 L
214. };
     / ^) @7 j7 W: N, B0 a) d
215. 
     
216. typedef enum {
     : \  i* ]* T% C) [
217.     DEV_POWER_OFF = 0,
     
218.     DEV_POWER_ON,
     
219.     DEV_SLEEP,
     # K% z" f. C' |
220.     DEV_SUSPEND,
     
221.     DEV_DEEP_SUSPEND,
     
222. } LSM6DSL_power_mode;
     
223. 
     1 P+ p2 r7 y7 j. K
224. static int32_t cur_acc_factor  = 0;
     
225. static int32_t cur_gyro_factor = 0;
     
226. 
     6 f, ?# T8 T- C
227. uint8_t LSM6DSL_ID_check()
     
228. {
     7 d/ I. A9 j7 C/ R
229.         HAL_StatusTypeDef hi2c2_status = 0x00;
     1 ]5 f- H" f5 [, O, g
230.         uint8_t addr_val[3] = {LSM6DSL_ACC_GYRO_WHO_AM_I_REG,0x00,LSM6DSL_CHIP_ID_VALUE};
     ; v( o9 |" V/ d4 h$ U8 p0 |
231.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
232.         if(HAL_OK!=hi2c2_status){
     4 V: G$ s/ U2 ]6 j  P
233.                 printf("get LSM6DSL ID error\r\n");
     ) T& m" u: {) R. W6 c
234.                 return 1;
     " B% v7 C4 J- M
235.         }
     2 t: x2 `; K) l8 l( X% d
236.         if(addr_val[1]!=addr_val[2]){
     8 V- A) h, h3 s* r) ?7 D0 V
237.                 printf("LSM6DSL validate_id is error\r\n");
     / h  R9 U/ G5 z% ^. D4 _
238.                 return 1;
     # j/ ~5 z! `4 T( k
239.         }
     
240.         printf("LSM6DSL_id:%02X\r\n",addr_val[1]);
     
241.         return 0;
     
242. }
     6 x0 B7 f6 X! E7 r3 r; O- m
243. 
     
244. uint8_t LSM6DSL_soft_reset()
     5 p$ S5 e- O' W- Q  S5 z
245. {
     
246.         HAL_StatusTypeDef hi2c2_status = 0x00;
     5 [/ W- z' A- r1 ]5 `6 J
247.         /*first read*/
     0 _6 V7 a2 I8 I' Z) C7 ~! Y1 X
248.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL3_C,0x00};
     * S& l( r( i, q6 C+ d7 ]
249.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
250.         if(HAL_OK!=hi2c2_status){
     
251.                 printf("get LSM6DSL ACC_GYRO_CTRL3_C error\r\n");
     
252.                 return 1;
     
253.         }
     
254.         printf("LSM6DSL ACC_GYRO_CTRL3_C old:%02X\r\n",addr_val[1]);
     
255.         addr_val[1] |= LSM6DSL_RESET_VALUE;
     3 [* J) @1 m! s( f" n9 o7 a
256.         printf("LSM6DSL ACC_GYRO_CTRL3_C new:%02X\r\n",addr_val[1]);
     $ y' g. r$ o( @2 @7 _* \' k  D
257.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     0 l$ _% C: K& M
258.         if(HAL_OK!=hi2c2_status){
     # A9 i6 x  |: p* x8 S1 `
259.                 printf("set LSM6DSL ACC_GYRO_CTRL3_C error\r\n");
     5 }# {8 o& P! b1 v9 u) @/ U$ }
260.                 return 1;
     " j& ~  K5 S+ w) U
261.         }
     
262.         printf("successfully LSM6DSL soft reset\r\n");
     
263.         return 0;
     5 H0 Z: C; K  ^7 V6 g
264. }
     
265. /*
     5 Q; _4 b  b8 p5 B% s! o% {
266. * 以正数为例，最大可到32767，如果是Accelerometer数据，量程为2g的情况下，
     6 `' Y+ Y) z! O9 D
267. * 32768个刻度，一个刻度代表：2g/32768 = 2000mg/32767 = 0.061035mg
     + A: ]! C' O5 a: K
268. * 例如：如果读出数据为16384，则加速度：16384x0.061035mg = 1000mg = 1g
     
269. */
     + [+ r7 F: [% g5 K6 p. r- `
270. uint8_t LSM6DSL_acc_set_range(uint32_t range)
       z4 x# q7 z/ x+ d* H
271. {
     " w  }' Z( ~1 U0 Y8 G' z. T
272.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
273.         /*first read*/
     
274.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL1_XL,0x00};
       _; N+ z& a1 ^% ^0 `
275.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     ! P- W- K, Q9 [- a" Z# ~. U7 x7 B0 q
276.         if(HAL_OK!=hi2c2_status){
     
277.                 printf("get LSM6DSL acc range error\r\n");
     4 S. X3 S. Y, D
278.                 return 1;
     
279.         }
     
280.         uint8_t tmp   = 0;
     + U. D! }% d3 N+ p5 d
281.     switch (range) {
     
282.             case ACC_RANGE_2G: {
     8 Q$ y8 y4 m: j$ O* F
283.             tmp = LSM6DSL_ACC_RANGE_2G;
     
284.         } break;
     
285. 
     
286.         case ACC_RANGE_4G: {
     
287.             tmp = LSM6DSL_ACC_RANGE_4G;
     
288.         } break;
     
289. 
     , i, `) t! G2 A& M
290.         case ACC_RANGE_8G: {
     
291.             tmp = LSM6DSL_ACC_RANGE_8G;
     
292.         } break;
     
293. 
     - s" ]( ~, w6 @; Z# {, j
294.         case ACC_RANGE_16G: {
     
295.             tmp = LSM6DSL_ACC_RANGE_16G;
     , e/ g1 D) S' j. J9 r! n
296.         } break;
     7 y. l0 {7 Y$ ]3 C
297. 
     
298.         default:
     9 h5 M" z1 a' v4 _
299.             break;
     
300.     }
     
301.     addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_RANGE, tmp);
     * ~. M+ w6 b. S6 n
302.     hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
303.         if(HAL_OK!=hi2c2_status){
     7 i& r0 Z; @1 e3 t6 {1 w' {
304.                 printf("set LSM6DSL acc range error\r\n");
     , H4 h3 b# ~$ F  B2 l! h; k
305.                 return 1;
     + u# a7 q) {9 B% g( h: ^
306.         }
     ' J. U7 P7 d" k0 ~+ V, A1 s
307.         if (range <= ACC_RANGE_16G) {
     
308.         cur_acc_factor = lsm6dsl_acc_factor[range];
     . D: T7 Z' V4 S- |) k
309.     }
     
310.         printf("successfully LSM6DSL set acc range\r\n");
     , H8 A! g/ t* s
311.         return 0;
     
312. }
     
313. 
     
314. static uint8_t acc_st_lsm6dsl_hz2odr(uint32_t hz)
     + d4 ?1 n. Y8 f/ K  q
315. {
       O$ r+ n9 i, U: x: d. w$ m: j
316.     if (hz > 3330)
     - _1 j& ~# T/ a* N+ R0 z) F
317.         return LSM6DSL_ACC_ODR_6_66_KHZ;
     
318.     else if (hz > 1660)
       x' j% e3 G3 f5 V$ v3 G
319.         return LSM6DSL_ACC_ODR_3_33_KHZ;
     
320.     else if (hz > 833)
     
321.         return LSM6DSL_ACC_ODR_1_66_KHZ;
     
322.     else if (hz > 416)
     
323.         return LSM6DSL_ACC_ODR_833_HZ;
     
324.     else if (hz > 208)
     
325.         return LSM6DSL_ACC_ODR_416_HZ;
     3 ~% G: k/ p: c' t
326.     else if (hz > 104)
     8 B6 u" [; _1 ]8 C! L% K, {% L2 [3 S
327.         return LSM6DSL_ACC_ODR_208_HZ;
     
328.     else if (hz > 52)
     
329.         return LSM6DSL_ACC_ODR_104_HZ;
     & B" G4 ~; L! T; Q7 C- y
330.     else if (hz > 26)
     
331.         return LSM6DSL_ACC_ODR_52_HZ;
     
332.     else if (hz > 13)
     ; ~8 r% w2 I% g; q
333.         return LSM6DSL_ACC_ODR_26_HZ;
     
334.     else if (hz >= 2)
     
335.         return LSM6DSL_ACC_ODR_12_5_HZ;
     4 g; N& x& m+ z
336.     else
     
337.         return LSM6DSL_ACC_ODR_1_6_HZ;
     
338. }
     
339. 
     ( @0 p0 w. m+ Y0 x7 g: W2 h) a& y- H
340. uint8_t LSM6DSL_acc_set_odr(uint32_t hz)
     6 ?, H8 }; G6 m$ S, M6 _2 A
341. {
     
342.         HAL_StatusTypeDef hi2c2_status = 0x00;
     - n& U& }% W! o
343.         /*first read*/
     
344.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL1_XL,0x00};
     + \' M7 t9 ?3 A" w- S
345.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
346.         if(HAL_OK!=hi2c2_status){
     
347.                 printf("get LSM6DSL acc odr error\r\n");
     
348.                 return 1;
     
349.         }
     
350.         uint8_t odr   = acc_st_lsm6dsl_hz2odr(hz);
     , Q- p( ~( W. N, V
351.         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR, odr);
     + U* ~* @$ l* S
352.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
353.         if(HAL_OK!=hi2c2_status){
     
354.                 printf("set LSM6DSL acc odr error\r\n");
     
355.                 return 1;
     % D& A' E9 ?* ?  U, I
356.         }
     
357.         printf("successfully LSM6DSL set acc odr\r\n");
     6 s$ d! B0 y* u5 m; r7 s
358.         return 0;
     $ B* M  k& u; L0 c1 o% g
359. }
     
360. 
     
361. uint8_t LSM6DSL_acc_power_mode(LSM6DSL_power_mode mode)
     
362. {
       b9 v1 d" q' q
363.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
364.         /*first read*/
     7 u& A+ k3 i  v8 ]8 P7 q' b
365.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL1_XL,0x00};
     
366.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     . F, m. }0 x9 Q, W
367.         if(HAL_OK!=hi2c2_status){
     3 b; A4 v) g9 E8 m' v4 d. N% ?
368.                 printf("get LSM6DSL acc power_mode error\r\n");
     
369.                 return 1;
     0 o% f3 v6 B0 O0 k2 P/ E
370.         }
     5 K; j% q# g1 S7 d% z' t3 V! V8 m! x& \! F
371.         switch (mode) {
     7 n* u/ a9 V% i) }& ^, [
372.                 case DEV_POWER_ON: {
     
373.                         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_12_5_HZ);
     ( \, ~- x( v6 k6 X) T: ?0 P
374.                 }
     4 R. n3 w- B+ e5 w, p! O% d
375.                 break;
     
376.                 case DEV_POWER_OFF: {
     : P$ a$ I. M7 c! Y# `. S& j
377.                         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_POWER_DOWN);
     
378.                 }
     . S9 {3 b  e) F: A7 F( n5 Y$ m
379.                 break;
     $ D1 Y$ B! p9 N; X: [9 i, j9 l( Z+ ^
380.                 case DEV_SLEEP: {
     
381.                         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_12_5_HZ);
     
382.                 }
     
383.                 break;
     5 I+ ]7 z5 u( {0 @! {
384.                 default:
     
385.                         break;
     : G, E3 f7 _2 _! d4 a
386.         }
     + @! \- m- x+ {! E
387.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
388.         if(HAL_OK!=hi2c2_status){
     3 l, [/ f$ U8 I" ^
389.                 printf("set LSM6DSL acc power_mode error\r\n");
     * @9 i3 J* n4 \2 N
390.                 return 1;
     
391.         }
     
392.         printf("successfully LSM6DSL acc power_mode\r\n");
     # Y% D$ S( ~- C6 ]$ A# Y
393.         return 0;
     
394. }
     
395. 
     . Y  M- T( \5 w3 b- R8 Y9 L0 S
396. uint8_t LSM6DSL_acc_st_open(void)
     8 p7 S, e% }5 ]/ ?! D6 z
397. {
     5 T1 ~! s' s6 j& c3 \# ?1 D
398.         uint8_t ret = 0;
     
399. 
     4 h2 x; m( x( k/ X: @; H
400.     ret = LSM6DSL_acc_power_mode( DEV_POWER_ON);
     
401.     if (ret>0) {
     2 j0 H+ |  B' A* w
402.         return ret;
     # v) G& j8 h( F
403.     }
     
404. 
     # g6 {5 I) K; W7 ^" k3 Q
405.     ret = LSM6DSL_acc_set_range(ACC_RANGE_8G);
     
406.     if (ret>0) {
     $ [6 _! a* x" a. w! C' {6 `5 B
407.         return ret;
     
408.     }
     # A. o. D- M5 ]& p
409. 
     5 y5 |8 d5 i6 d& l
410.     ret = LSM6DSL_acc_set_odr(LSM6DSL_ACC_DEFAULT_ODR_100HZ);
     
411.     if (ret>0) {
     
412.         return ret;
     , D3 R" E9 o- y
413.     }
     
414.     printf("successfully LSM6DSL acc open\r\n");
     
415.     return 0;
     
416. }
     
417. 
     
418. uint8_t LSM6DSL_acc_st_close(void)
     
419. {
     0 x5 ]4 B: t! y% u
420.         uint8_t ret = 0;
     # @8 Q. x8 v8 ~* G9 B) ^. C; |4 Q
421.     ret = LSM6DSL_acc_power_mode(DEV_POWER_OFF);
     - ], u- A( Q/ O- p$ D5 r4 N/ t
422.     if (ret>0) {
     
423.         return ret;
     6 {( \& n+ W3 L) S; M3 s
424.     }
     
425.     printf("successfully LSM6DSL acc close\r\n");
     " E1 P! D! b) Y$ ~  |; w
426.     return 0;
     1 f/ x7 {$ I9 l9 Y' F' ^8 Z8 e
427. }
     4 E& G, z4 l* o' [
428. 
     
429. uint8_t LSM6DSL_gyro_set_range(uint32_t range)
     
430. {
     ' A* a( [  B8 y; P8 K/ O" @2 C
431.         HAL_StatusTypeDef hi2c2_status = 0x00;
     $ W& m& q- `. ?$ D) P( |
432.         /*first read*/
     
433.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL2_G,0x00};
     ( b$ C2 f. N2 C" K' a
434.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
435.         if(HAL_OK!=hi2c2_status){
     2 U1 O& i, X- E+ X
436.                 printf("get LSM6DSL gyro range error\r\n");
     : r7 X# \! H" F; w  U) [7 T0 ~& }
437.                 return 1;
     
438.         }
     
439.         uint8_t tmp   = 0;
     + ~( N6 b0 }1 C" n
440.         switch (range) {
     - w- U4 l" u1 q- I# r4 M% p
441.             case GYRO_RANGE_250DPS: {
     1 G& y( L" \6 E2 \% ~3 m- F
442.             tmp = LSM6DSL_GYRO_RANGE_245;
     
443.         } break;
     3 ]1 N+ V7 u$ x$ H5 m
444. 
     
445.         case GYRO_RANGE_500DPS: {
     
446.             tmp = LSM6DSL_GYRO_RANGE_500;
     3 {) D* z8 t& P' `' B, K
447.         } break;
     
448. 
     
449.         case GYRO_RANGE_1000DPS: {
     9 P/ N' C: ~4 Q' ^- p/ e
450.             tmp = LSM6DSL_GYRO_RANGE_1000;
     . z1 T5 a+ J8 e( M8 n, }5 r0 a
451.         } break;
     4 ~: f! c, u5 ^$ m, Z
452. 
     - V# A& E& k: T4 ~1 U: E) h
453.         case GYRO_RANGE_2000DPS: {
     ) w4 b. E5 R/ w7 b
454.             tmp = LSM6DSL_GYRO_RANGE_2000;
     
455.         } break;
     , V7 P. C7 g) S% i7 n/ y! A
456. 
     ; a" Y+ H+ o" z8 G/ ^2 ]
457.         default:
     ( J2 X" w8 v6 C; p% |$ `
458.             break;
     
459.         }
     
460.         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_RANGE, tmp);
     
461.     hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
462.         if(HAL_OK!=hi2c2_status){
     $ E- T9 o0 G0 y- o9 a) b( u
463.                 printf("set LSM6DSL gyro range error\r\n");
     5 e+ j- b2 E" s9 E1 ]( h0 [
464.                 return 1;
     , i( A9 ^9 m$ s& t! c
465.         }
     6 s7 B% N# |) b. P. N
466.         if ((range >= GYRO_RANGE_250DPS) && (range <= GYRO_RANGE_2000DPS)) {
     
467.         cur_gyro_factor = lsm6dsl_gyro_factor[range];
     
468.     }
     
469.         printf("successfully LSM6DSL set gyro range\r\n");
     
470.         return 0;
     
471. }
     ! ~. T) U( Y9 Y# R/ t- I
472. 
     - m, B1 E, z) @1 X
473. static uint8_t gyro_st_lsm6dsl_hz2odr(uint32_t hz)
     , ^) T. {# k3 S0 A& p. p- r2 ^
474. {
     
475.     if (hz > 3330)
     
476.         return LSM6DSL_GYRO_ODR_6_66_KHZ;
     8 d$ {. e! ]/ V5 b5 P! l5 H3 I4 D- x
477.     else if (hz > 1660)
     ' }, v0 L) f& z. x! [- Y" r0 {7 v
478.         return LSM6DSL_GYRO_ODR_3_33_KHZ;
     
479.     else if (hz > 833)
     
480.         return LSM6DSL_GYRO_ODR_1_66_KHZ;
     
481.     else if (hz > 416)
     # Y3 |. N4 v7 j: ]
482.         return LSM6DSL_GYRO_ODR_833_HZ;
     
483.     else if (hz > 208)
     1 a4 H4 I/ @0 b0 g- g
484.         return LSM6DSL_GYRO_ODR_416_HZ;
     ! b+ _$ L/ j6 H) H1 ?+ p" z  D
485.     else if (hz > 104)
     
486.         return LSM6DSL_GYRO_ODR_208_HZ;
     / P! ]0 C7 @- c( i* q) F0 U
487.     else if (hz > 52)
     
488.         return LSM6DSL_GYRO_ODR_104_HZ;
     9 i- |! O$ D0 j8 B( d
489.     else if (hz > 26)
     2 J0 X$ x9 r- ^* x( L
490.         return LSM6DSL_GYRO_ODR_52_HZ;
     & g/ h' O, }9 \8 z0 \6 v% j
491.     else if (hz > 13)
     
492.         return LSM6DSL_GYRO_ODR_26_HZ;
     * ^1 d( ^4 R3 V0 X  B
493.     else
     
494.         return LSM6DSL_GYRO_ODR_12_5_HZ;
     " g+ j( i$ L& }8 h9 u+ {5 ]+ v, }
495. }
     6 b9 c$ M  V3 Y. r+ i% s% v
496. 
     $ H3 N0 o7 ~. R" M! _8 o
497. uint8_t LSM6DSL_gyro_set_odr(uint32_t hz)
     - P4 ?/ ]  z, w  Q$ N' z# z6 V
498. {
     
499.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
500.         /*first read*/
     
501.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL2_G,0x00};
     / X6 W9 S/ G3 N- x0 \
502.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
503.         if(HAL_OK!=hi2c2_status){
     1 A1 U% N  ^+ G
504.                 printf("get LSM6DSL gyro odr error\r\n");
     & h. }, t1 y/ e: J8 a5 _" d; G
505.                 return 1;
     
506.         }
     / \' a4 c7 i! i# O/ u
507.         uint8_t odr = gyro_st_lsm6dsl_hz2odr(hz);
     4 M- r9 V! _9 Q1 N
508.         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR, odr);
     ! |5 c1 M, K6 Z9 f
509.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     7 t4 w! _( b* q& }! Z
510.         if(HAL_OK!=hi2c2_status){
     ( }0 k: q# Y6 a( y2 E1 J
511.                 printf("set LSM6DSL gyro odr error\r\n");
     2 B4 Y( }' |" B1 ]) Z. y9 I
512.                 return 1;
     
513.         }
     5 C! \" C2 u( }5 {  f) z+ K) K
514.         printf("successfully LSM6DSL set gyro odr\r\n");
     6 D0 }( c4 ?1 R- @
515.         return 0;
     
516. }
     
517. 
     
518. uint8_t LSM6DSL_gyro_power_mode(LSM6DSL_power_mode mode)
     
519. {
     0 x9 [+ J' _  J
520.         HAL_StatusTypeDef hi2c2_status = 0x00;
     * \" ^, o( Y$ e1 R& i2 {2 J
521.         /*first read*/
     
522.         uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL2_G,0x00};
     . p4 r0 m1 ^/ t5 z+ c2 s6 k
523.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
524.         if(HAL_OK!=hi2c2_status){
     0 ?# U& ^, v: g( h
525.                 printf("get LSM6DSL gyro power_mode error\r\n");
     
526.                 return 1;
     9 ]/ E8 v$ n6 k; I# N/ I$ f
527.         }
     1 W! @8 z2 D1 o* k- J
528.         switch (mode) {
     
529.                 case DEV_POWER_ON: {
     
530.                         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_12_5_HZ);
     . T5 f+ m! v* e- m5 x
531.                         break;
     ' V: F/ i$ c, B8 z6 r
532.                 }
     
533.                 case DEV_POWER_OFF: {
     " z9 K# n  q  d* W  c7 M" I
534.                         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_POWER_DOWN);
     
535.                         break;
     
536.                 }
     
537.                 case DEV_SLEEP: {
     
538.                         addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_12_5_HZ);
     ) z. d" r- ?6 }) g' m2 ?, B: C
539.                         break;
     ' L$ J3 ?2 j$ B
540.                 }
     
541.                 default:
     * p/ y- O  q% t' a
542.                         break;
     4 F) s. s4 \; U' `
543.         }
     
544.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
545.         if(HAL_OK!=hi2c2_status){
     4 S" t, ^3 ?" y
546.                 printf("set LSM6DSL gyro power_mode error\r\n");
     
547.                 return 1;
     : B/ A0 K  u8 w/ L5 I# `
548.         }
     - B% ?$ [, s9 Q4 R& [! K1 H  I  F
549.         printf("successfully LSM6DSL gyro power_mode\r\n");
     
550.         return 0;
     # C: f2 |$ Z( Y3 k! e7 M
551. }
     3 v' D) ~8 z6 M, {! K
552. 
     ) F" @2 m) `- t; l
553. uint8_t LSM6DSL_gyro_st_open(void)
     . ^5 N$ A1 K" l( Y
554. {
     ) q2 b9 O& u  b0 h7 i2 s
555.         uint8_t ret = 0;
     - e& Z1 S! x- [% J1 {
556.     ret        = LSM6DSL_gyro_power_mode(DEV_POWER_ON);
     
557.     if (ret>0) {
     
558.         return 1;
     0 S9 {* \5 V. E6 q
559.     }
     
560. 
     : ~+ A  O0 i. t; m
561.     ret = LSM6DSL_gyro_set_range(GYRO_RANGE_1000DPS);
     ' B" u. L7 G0 h; i
562.     if (ret>0) {
     
563.         return 1;
     # Y" Z) y% w9 G1 v( g
564.     }
     . Q2 B& R; m  x) e
565. 
     5 {: \+ A8 o+ |& \* d
566.     ret = LSM6DSL_gyro_set_odr(LSM6DSL_GYRO_DEFAULT_ODR_100HZ);
     
567.     if (ret>0) {
     
568.         return 1;
     / ~. R6 g, o5 B9 J
569.     }
     
570.     printf("successfully LSM6DSL gyro open\r\n");
     # ?; p: x6 E9 i; C: b4 W
571.     return 0;
     - d& r4 W' v. V; ~
572. }
     7 N, j3 j$ ~4 Z& C1 x; f# S
573. 
     
574. uint8_t LSM6DSL_gyro_st_close(void)
     ( ?- |7 b% B$ d% e9 ]; Q/ t& B7 E! ?+ Z
575. {
     
576.         uint8_t ret = 0;
     $ L; j! X' G$ c
577.     ret        = LSM6DSL_gyro_power_mode(DEV_POWER_OFF);
     
578.     if (ret>0) {
     + t% L, Q  G9 e7 v  b. C/ S
579.         return 1;
     
580.     }
     
581.     printf("successfully LSM6DSL gyro close\r\n");
     
582.     return 0;
     1 w) |$ L  e7 p/ Q8 g# e
583. }
     
584. 
     % x9 v" L8 r  C4 Z+ K4 J: w
585. void LSM6DSL_init()
     6 Z2 j3 M4 ~" X9 z' i
586. {
     
587.         if(LSM6DSL_ID_check()>0)
     . U# f& ^1 t- d/ Z  C. m
588.                 return;
     ; Y  U0 V$ B- S, D1 q7 M! W
589.         if(LSM6DSL_soft_reset()>0)
     
590.                 return;
     ) |3 Y+ `) i; V7 w5 W2 ~# U
591.         if(LSM6DSL_acc_power_mode(DEV_POWER_OFF)>0)
     
592.                 return;
     0 ]: q. u  {5 r
593.     if(LSM6DSL_gyro_power_mode(DEV_POWER_OFF)>0)
     . k' q; m4 M% U0 G+ \4 x" A
594.                 return;
     ; L/ H( z) q$ b& _" ]7 b! D
595.         printf("successfully LSM6DSL init\r\n");
     / \* F8 ^2 G  Q3 D7 t4 z9 p8 Z
596. }
     
597. 
     
598. #define DATA_AXIS_X 0
     ) E* k8 ~* ?% C, B/ _5 u; ^
599. #define DATA_AXIS_Y 1
     
600. #define DATA_AXIS_Z 2
     
601. 
     ; o- b4 q& s, M- g$ u! n5 O* g
602. uint8_t LSM6DSL_acc_read(int32_t *x_data,int32_t *y_data,int32_t *z_data)
     
603. {
     
604.         HAL_StatusTypeDef hi2c2_status = 0x00;
     " ~( Q# E% Y$ N" K
605.         /*read 0X28,0X29,0X2A,0X2B,0X2C,0X2D*/
     
606.         uint8_t addr[6] = {LSM6DSL_ACC_GYRO_OUTX_L_XL,LSM6DSL_ACC_GYRO_OUTX_H_XL,
     6 i7 |+ u# d( @, I- o8 h5 r
607.                         LSM6DSL_ACC_GYRO_OUTY_L_XL,LSM6DSL_ACC_GYRO_OUTY_H_XL,
     
608.                         LSM6DSL_ACC_GYRO_OUTZ_L_XL,LSM6DSL_ACC_GYRO_OUTZ_H_XL};
     + G' y* G5 ^4 `; T8 {) K: Y
609.         uint8_t val[6] = {0};
     " R; t8 w4 h: Z5 X8 l
610.         for(uint8_t i=0; i<6; i++){
     4 a0 K; P0 E- k% f5 Q5 J# J' w8 M  `5 X
611.                 hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr[i],1,&val[i],1,1000);
     
612.                 if(HAL_OK!=hi2c2_status){
     
613.                         printf("get LSM6DSL acc_read[0X%02X] error\r\n",addr[i]);
     
614.                         return 1;
     " C' C, M* r5 n- I( l7 _
615.                 }
     
616.         }
     0 r! P& q$ d8 [, a8 {
617.         printf("read acc reg_data 1:%02X, 2:%02X, 3:%02X, 4:%02X, 5:%02X ,6:%02X\r\n"
     
618.                                     ,val[0],val[1],val[2],val[3],val[4],val[5]);
     2 N& ^  _+ G0 R. q! X; p$ a
619.         int32_t data[3] = {0};
     
620.         data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)val[1])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[0]));
     
621.         data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)val[3])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[2]));
     ' l- t6 V+ c! [) l+ d5 t  R
622.         data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)val[5])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[4]));
     ) r. k. B" e/ _. Z/ F+ R, s! L
623.     if (cur_acc_factor != 0)
     $ o8 `1 L: T/ Z
624.     {
     5 [! B" w2 z; ]! F& ^5 p
625.         data[DATA_AXIS_X] = (data[DATA_AXIS_X] * cur_acc_factor) / LSM6DSL_ACC_MUL;
     ' N, z' c1 }8 |& `- e" ^
626.         data[DATA_AXIS_Y] = (data[DATA_AXIS_Y] * cur_acc_factor) / LSM6DSL_ACC_MUL;
     
627.         data[DATA_AXIS_Z] = (data[DATA_AXIS_Z] * cur_acc_factor) / LSM6DSL_ACC_MUL;
     
628.     }
     $ E6 v: i  s  o- k, r/ w. W
629.     printf("read acc cur_acc_factor:%ld, X:%ld,Y:%ld,Z:%ld\r\n"
     
630.                     ,cur_acc_factor,data[0],data[1],data[2]);
     ' E1 X+ h2 l1 q
631.     *x_data = data[DATA_AXIS_X];
     
632.     *y_data = data[DATA_AXIS_Y];
     * |! |7 ?8 F: r3 P8 i0 g3 A5 k
633.     *z_data = data[DATA_AXIS_Z];
     
634.         return 0;
     
635. }
     
636. 
     % k$ p8 r4 p9 r& j2 G
637. uint8_t LSM6DSL_gyro_read(int32_t *x_data,int32_t *y_data,int32_t *z_data)
     6 n8 Q4 b3 |6 `$ p0 S" b: U
638. {
     9 C7 H! W1 W/ D3 k+ w2 G1 r% q
639.         HAL_StatusTypeDef hi2c2_status = 0x00;
     & J- X$ J5 `" X4 _9 x4 u) y
640.         /*read 0X22,0X23,0X24,0X25,0X26,0X27*/
     
641.         uint8_t addr[6] = {LSM6DSL_ACC_GYRO_OUTX_L_G,LSM6DSL_ACC_GYRO_OUTX_H_G,
     % i- l+ R7 [( ?" A* R1 `
642.                         LSM6DSL_ACC_GYRO_OUTY_L_G,LSM6DSL_ACC_GYRO_OUTY_H_G,
     . {6 F8 Z0 ^! k% n" [/ ?
643.                         LSM6DSL_ACC_GYRO_OUTZ_L_G,LSM6DSL_ACC_GYRO_OUTZ_H_G};
     + d3 [2 G4 P$ D2 `" ~
644.         uint8_t val[6] = {0};
     ) v3 U/ x( K5 m) t  S9 \
645.         for(uint8_t i=0; i<6; i++){
     
646.                 hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr[i],1,&val[i],1,1000);
       O. t/ K! A5 p9 k! d( W- k
647.                 if(HAL_OK!=hi2c2_status){
     
648.                         printf("get LSM6DSL gyro_read[0X%02X] error\r\n",addr[i]);
     ( g1 {% A4 Z1 A/ M4 m
649.                         return 1;
     % O, w/ M/ E  u- ~+ X' d
650.                 }
     7 _$ E( m" E5 l) g7 l
651.         }
     
652.         printf("read gyro reg_data 1:%02X, 2:%02X, 3:%02X, 4:%02X, 5:%02X ,6:%02X\r\n"
     
653.                             ,val[0],val[1],val[2],val[3],val[4],val[5]);
     + ?9 O6 J' W: a5 f7 c" t# |( c
654.         int32_t data[3] = {0};
     
655.         data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)val[1])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[0]));
     $ T0 G% r$ [7 C4 d4 h) k% r+ g
656.         data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)val[3])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[2]));
     
657.         data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)val[5])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[4]));
     ( _" G2 I5 O% \5 B$ l2 f" X
658. 
     & I0 z7 w. ^% `8 k& T8 `. l
659.     if (cur_gyro_factor != 0) {
     0 \- L. U- U% C6 y/ y6 }! F* ?& p+ M
660.         data[DATA_AXIS_X] = (data[DATA_AXIS_X] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
     % J6 N' @5 S: T  D" U' f
661.         data[DATA_AXIS_Y] = (data[DATA_AXIS_Y] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
     
662.         data[DATA_AXIS_Z] = (data[DATA_AXIS_Z] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
     & E, z! p5 Z) x5 s/ o
663.     }
     ; A+ }; b( b; T. K) N6 A
664.     printf("read gyro cur_gyro_factor:%ld, X:%ld,Y:%ld,Z:%ld\r\n"
     9 A" S- b- f4 T+ ~
665.                     ,cur_gyro_factor,data[0],data[1],data[2]);
     ; m( s9 U$ ]! p+ @
666.     *x_data = data[DATA_AXIS_X];
     
667.     *y_data = data[DATA_AXIS_Y];
     ; p& n" y# U* m
668.     *z_data = data[DATA_AXIS_Z];
     
669.         return 0;
     
670. }

复制代码

九、MMC3680KJ传感器（三轴磁传感器）
        在ICore源目录下，创建MMC3680KJ文件夹，并在该目录下创建MMC3680KJ.h和MMC3680KJ.c源文件。

        同样在网上查找及下载了MMC3680KJ数据手册，逐项分析，MMC3680KJ设备的I2C通信同样采用从机设备地址+寄存器地址+数据的模式，该设备的从机地址0X60（0X30(00110000)<<1）如下：
/ m8 g- W: P& s! s. m


- M, u: C6 T" j0 ?2 u8 P
" z& ?% h7 F( Y0 l4 T9 p' r         2)寄存器地址总表，设备产品ID地址是0X2F，设备状态地址是0X07，0X00~0X05共6字节，表示三个轴向数值，0X06是设备作业温度值。0X08~0X0A是三个CTRL标识。


! z" V4 w+ F) V- }- L3 i0 ~
         3）三轴向数据值每2个字节表示一个轴向，最低有效位在前。


& O( O3 a" [% a4 W. `" ?
0 O, a4 q& s; `# v; L" ?7 L& N4 k         4）作业温度，一个字节数据，给出范围及换算方法
# i: n6 `+ q6 o% l
+ L) Q3 h! ]0 s  I, b' d
9 o( Z+ t6 r8 r3 q& p" x; G/ d$ _
         5）设备状态获取，读取数据前，需要明确设备状态
" @, q7 O; v8 k
) j# f! M/ x5 @1 d; ?

         6）control01地址0X08，主要设置设备set和reset，实现设备启用。
5 B+ W' h( s/ u; }0 q8 x8 p


         7）control02地址0X09，主要设置设备ODR和OTP。
, k9 s; ^1 }. a& ?9 V, V
. s9 X5 n' G6 M) ?) R. y


$ @. C8 {+ I: B% d( J% y
         8）control03地址0X09，主要设置设备连续测量模式下频率，脉冲宽度。
* S! A* ~7 d% [2 R. @


         9）设备产品ID验证，寄存器地址是0X2F，正确返回值是0X0A（00001010）

9 F! W, K) _% u5 [* t8 s; y: Q

         10）按以上分析，伪代码设计如下：
7 _1 O* k# Z: l$ N/ @2 S7 G

1. MMC3680KJ从设备地址0x60
   / Z, S2 \! c' ~3 w- i0 @
2. init:
   1 C9 c! W( |4 [! S( a- R! J# G: x
3. read status from 从设备地址0x60 寄存器地址0X07
   
4. read p_id from 从设备地址0x60 寄存器地址0X2F
   1 S3 [4 G7 m8 _$ X' Z5 Q) Q
5. 确保p_id==0X0A
   0 f4 r8 ?9 Y5 R/ U6 O: V
6. 分别write myconf to 从设备地址0x60 寄存器地址0X08 0X09 0X0A ，完成频率、脉冲、启用等设置
   
7. 
     @7 N4 z7 }8 t+ ~* B! l' D
8. 读取数据
   8 y$ H/ G( ~: M7 Q' z  ^' s
9. 读取数据确保设备已经设置及启用，寄存器地址0X08，myconf|0X08|(0X01或 0X02)
   / i; [9 }; \7 a1 S2 M
10. read data1~6 from 从设备地址0x60 寄存器地址0X00~0X05，共六字节数据
    
11. 将data1~6 换算处理
    8 d& Y! t9 k! U
12. read temp from 从设备地址0x60 寄存器地址0X06，一个字节数据
    
13. 将temp换算处理

复制代码

3 m% L7 C; {- x         11）按以上分析及伪代码设计，得出MMC3680KJ传感器的MMC3680KJ.h和MMC3680KJ.c源码文件。

; U9 M; w$ {! n& [! W        MMC3680KJ.h
7 p1 q% a9 a( j( a& s  A

1. #ifndef _MMC3680KJ_H_
   1 s9 L* C' o4 H
2. #define _MMC3680KJ_H_
   , C9 t7 v& g, d! g- T& J+ z# y
3. 
   
4. #include "main.h"
   
5. 
   " U2 ^3 w, ^& _' `$ ]% ~. \8 N! l
6. void mmc3680kj_temp_memsic_init();
     W% P9 j2 f- f8 s# Z
7. void mmc3680kj_mag_memsic_init();
   ( b$ \, }: i( n3 L" V+ o
8. 
     n- p' M7 r  r+ f. M0 _
9. uint8_t mmc3680kj_read_temp_memsic(int32_t *temperature);
   6 K4 l% P  a7 g9 r: V9 W: z9 G
10. uint8_t mmc3680kj_read_mag_memsic(int32_t *xval, int32_t *yval, int32_t *zval);
    7 S" r3 V( i& x
11. 
    1 T0 t% S% F# b: d  q) [# r
12. #endif /* MMC3680KJ_MMC3680KJ_H_ */

复制代码

        MMC3680KJ.c

1. #include <stdio.h>
   9 c6 W# j' P$ n! y
2. #include "MMC3680KJ.h"
   ! [" l% c; Q  G
3. 
   
4. extern I2C_HandleTypeDef hi2c4;
   
5. 
   - J: T; b  L+ A- a8 d1 Y4 ^- @
6. #define MMC3680KJ_REG_DATA 0x00
   5 _* H2 i* @/ V7 j7 [+ N! n9 E
7. #define MMC3680KJ_REG_XL 0x00
   
8. #define MMC3680KJ_REG_XH 0x01
   
9. #define MMC3680KJ_REG_YL 0x02
   - v: I4 d9 z! k9 E9 D, j4 ?0 d! Z% S
10. #define MMC3680KJ_REG_YH 0x03
    
11. #define MMC3680KJ_REG_ZL 0x04
    ! B9 `0 h8 j) o: E
12. #define MMC3680KJ_REG_ZH 0x05
    # w$ X5 j+ A8 v$ \1 y3 W' \
13. #define MMC3680KJ_REG_TEMP 0x06
    / _4 I; y9 ]" T" F8 K/ L
14. #define MMC3680KJ_REG_STATUS 0x07
    2 B1 J9 t) \" v: @# `+ Z" f& ]% x
15. #define MMC3680KJ_REG_CTRL0 0x08
    
16. #define MMC3680KJ_REG_CTRL1 0x09
    
17. #define MMC3680KJ_REG_CTRL2 0x0a
    
18. #define MMC3680KJ_REG_X_THD 0x0b
    
19. #define MMC3680KJ_REG_Y_THD 0x0c
    9 [7 U9 O8 D/ x( @3 Q
20. #define MMC3680KJ_REG_Z_THD 0x0d
    
21. #define MMC3680KJ_REG_SELFTEST 0x0e
    # p* G" x2 \  @/ x6 j
22. #define MMC3680KJ_REG_PASSWORD 0x0f
    
23. #define MMC3680KJ_REG_OTPMODE 0x12
    6 J2 k/ v% p( c) K& R
24. #define MMC3680KJ_REG_TESTMODE 0x13
    
25. #define MMC3680KJ_REG_SR_PWIDTH 0x20
    
26. #define MMC3680KJ_REG_OTP 0x2a
    
27. #define MMC3680KJ_REG_PRODUCTID 0x2f
    1 z" e' P4 _& \/ J7 N+ z8 E
28. 
    
29. #define MMC3680KJ_CMD_REFILL 0x20
    , V1 S) s* _) ~  T9 Q! x$ V$ m" r
30. #define MMC3680KJ_CMD_RESET 0x10
    + v+ `. Z) p, V) j9 j* ?
31. #define MMC3680KJ_CMD_SET 0x08
    5 A% _6 K7 O3 M
32. #define MMC3680KJ_CMD_TM_M 0x01
    ! R# Z4 b7 {7 L* d+ c- Z, n% V5 o, U! ^
33. #define MMC3680KJ_CMD_TM_T 0x02
    
34. #define MMC3680KJ_CMD_START_MDT 0x04
    
35. #define MMC3680KJ_CMD_100HZ 0x00
    
36. #define MMC3680KJ_CMD_200HZ 0x01
    
37. #define MMC3680KJ_CMD_400HZ 0x02
    
38. #define MMC3680KJ_CMD_600HZ 0x03
    
39. #define MMC3680KJ_CMD_CM_14HZ 0x01
    . N* w6 v- [% K* I6 R
40. #define MMC3680KJ_CMD_CM_5HZ 0x02
    
41. #define MMC3680KJ_CMD_CM_1HZ 0x04
    
42. #define MMC3680KJ_CMD_SW_RST 0x80
    
43. #define MMC3680KJ_CMD_PASSWORD 0xe1
    
44. #define MMC3680KJ_CMD_OTP_OPER 0x11
    
45. #define MMC3680KJ_CMD_OTP_MR 0x80
    
46. #define MMC3680KJ_CMD_OTP_ACT 0x80
    
47. #define MMC3680KJ_CMD_OTP_NACT 0x00
    
48. #define MMC3680KJ_CMD_STSET_OPEN 0x02
    
49. #define MMC3680KJ_CMD_STRST_OPEN 0x04
    
50. #define MMC3680KJ_CMD_ST_CLOSE 0x00
    
51. #define MMC3680KJ_CMD_INT_MD_EN 0x40
    * ?0 E7 K. n4 O8 \) l
52. #define MMC3680KJ_CMD_INT_MDT_EN 0x20
    
53. 
    
54. #define MMC3680KJ_PRODUCT_ID 0x0a
    
55. #define MMC3680KJ_OTP_READ_DONE_BIT 0x10
    " M6 `+ R) X: \. G  ]
56. #define MMC3680KJ_PUMP_ON_BIT 0x08
    
57. #define MMC3680KJ_MDT_BIT 0x04
    ( l8 _! x  }8 k, o
58. #define MMC3680KJ_MEAS_T_DONE_BIT 0x02
    ) g- ?2 a% H3 p0 Q+ r
59. #define MMC3680KJ_MEAS_M_DONE_BIT 0x01
    
60. 
    # y# Z1 c& x7 |" V" {! q
61. #define MMC3680KJ_I2C_SLAVE_ADDR 0x30
    + ^+ X) ~2 j3 D- p" Z8 O3 |
62. #define MMC3680KJ_ADDR_TRANS(n) ((n) << 1)
    
63. #define MMC3680KJ_I2C_ADDR MMC3680KJ_ADDR_TRANS(MMC3680KJ_I2C_SLAVE_ADDR)
    
64. 
    ' u6 y& A/ f- s1 Y
65. #define MMC3680KJ_OFFSET 32768
    5 x" s8 l8 n1 h3 y$ D
66. #define MMC3680KJ_SENSITIVITY 1024000
    ' e0 p/ \$ W: ]; [+ b1 L
67. #define MMC3680KJ_T_ZERO -75
    
68. #define MMC3680KJ_T_SENSITIVITY 80
    * \9 F6 ~' h! [7 s; i
69. 
    + e5 ~. b4 t. l+ ^6 l* G; t
70. #define MMC3680KJ_MAG_DATA_SIZE 6
    
71. #define OTP_CONVERT(REG) (((REG) >= 32 ? (32 - (REG)) : (REG)) * 6)
    ' j! |; ?( o2 S- x; K
72. 
    + C  j, v6 ~/ M  s
73. typedef enum
    0 \0 ?. R- n# Z# V. ^$ g- x
74. {
    / `; ~: {8 A3 U9 b. d
75.     FLAG_INIT_MAG = 0,
    / i5 }$ v4 t! W3 M
76.     FLAG_INIT_TEMP,
    3 |) N) l7 |  j
77. } FLAG_INIT_BIT;
    
78. 
    
79. static int32_t g_otp_matrix[3] = { 1000000, 1000000, 1350000 };
    
80. 
    
81. uint8_t mmc3680kj_check_otp()
      X% ~$ w# Q- a4 o
82. {
    
83.         HAL_StatusTypeDef hi2c2_status = 0x00;
    
84.         uint8_t addr_val[3] = {MMC3680KJ_REG_STATUS,0x00,MMC3680KJ_OTP_READ_DONE_BIT};
    . q; t8 k  t. @5 D
85.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
    
86.         if(HAL_OK!=hi2c2_status){
    
87.                 printf("get mmc3680kj opt error\r\n");
    
88.                 return 1;
    4 f& F9 p0 v  A4 d  i& }
89.         }
    
90.         if ((addr_val[1] & addr_val[2]) != addr_val[2]) {
    8 w2 d8 Y- K0 I, F6 ]
91.                 printf("mmc3680kj opt is error\r\n");
    
92.         return 1;
    2 `* K; L/ X4 h0 l+ F* B' ~  g; U
93.     }
    
94.         printf("mmc3680kj opt:%02X\r\n",addr_val[1]);
    7 v% o6 o8 L3 n  X. X5 d1 ]* F
95.         return 0;
    
96. }
    $ H' o% _, G1 p" J5 ~: [* p; z) Y
97. 
    
98. uint8_t mmc3680kj_id_check()
    
99. {
    
100.         HAL_StatusTypeDef hi2c2_status = 0x00;
     $ D8 D* X1 g+ b* k& h; x: M1 X% G0 i
101.         uint8_t addr_val[3] = {MMC3680KJ_REG_PRODUCTID,0x00,MMC3680KJ_PRODUCT_ID};
     
102.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
       t/ j) e, @( E- b' z
103.         if(HAL_OK!=hi2c2_status){
     ) x0 v. m2 }" u; r" T! d
104.                 printf("get mmc3680kj ID error\r\n");
     
105.                 return 1;
     
106.         }
     
107.         if(addr_val[1]!=addr_val[2]){
     * u& J6 H) p% j0 @% ^) u- `2 o
108.                 printf("mmc3680kj validate_id is error\r\n");
     8 d* _7 l3 K) o2 z! |7 O
109.                 return 1;
     
110.         }
     : H+ ]3 e7 b+ f* B( Q" I% i
111.         printf("mmc3680kj_id:%02X\r\n",addr_val[1]);
     " I% I; l$ ?- Q
112.         return 0;
     0 n4 `0 G& V8 F$ W9 O) _
113. }
     
114. 
     9 u( T- \& x" \8 n, H! d
115. uint8_t mmc3680kj_set_comp_matrix()
     
116. {
     - _2 P9 @7 K  C
117.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
118.         /*first*/
     
119.         uint8_t addr_val[6][2] = {
     
120.                         {MMC3680KJ_REG_PASSWORD,MMC3680KJ_CMD_PASSWORD},
     # D' l) n  F/ |) R1 p
121.                         {MMC3680KJ_REG_OTPMODE,MMC3680KJ_CMD_OTP_OPER},
     
122.                         {MMC3680KJ_REG_TESTMODE,MMC3680KJ_CMD_OTP_MR},
     
123.                         {MMC3680KJ_REG_CTRL2,MMC3680KJ_CMD_OTP_ACT},
     % x) ^5 P$ v' ~& ]
124.                         {MMC3680KJ_REG_OTP,0X00},
     
125.                         {MMC3680KJ_REG_CTRL2,MMC3680KJ_CMD_OTP_NACT}
     
126.         };
     / g5 Z: N# H' h% o3 V
127.         for(uint8_t i=0; i<4; i++)
     - W  k7 {4 t. U
128.         {
     9 ~* `0 n" }) X
129.                 hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[i][0],1,&addr_val[i][1],1,1000);
     / m, f" y9 k1 x) x( E5 H; p
130.                 if(HAL_OK!=hi2c2_status){
     
131.                         printf("mmc3680kj comp_matrix addr(0X%02X) error\r\n",addr_val[i][0]);
     
132.                         return 1;
     
133.                 }
     + j5 R' E# R  g+ C
134.         }
     4 ~" R! c- ?/ W6 C6 k9 G
135.         uint8_t reg_data[2] = { 0 };
     # v3 ^% `, ?! i7 b3 f- e4 }6 }
136.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[4][0],1,reg_data,2,1000);
     
137.         if(HAL_OK!=hi2c2_status){
     
138.                 printf("mmc3680kj comp_matrix addr(0X%02X) error\r\n",addr_val[4][0]);
     
139.                 return 1;
     
140.         }
     
141.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[5][0],1,&addr_val[5][1],1,1000);
     6 d3 N1 B: d* e
142.         if(HAL_OK!=hi2c2_status){
     ' A2 t( O# ]2 r5 ]& h- m6 T
143.                 printf("mmc3680kj comp_matrix addr(0X%02X) error\r\n",addr_val[5][0]);
     
144.                 return 1;
     
145.         }
     
146.         g_otp_matrix[0] = 1000000;
     
147.         g_otp_matrix[1] = OTP_CONVERT(reg_data[0] & 0x3f) * 1000 + 1000000;
     4 g! ^4 w1 G) J$ c# @& N# M* P( g
148.         g_otp_matrix[2] = (OTP_CONVERT((reg_data[1] & 0x0f) << 2 | (reg_data[0] & 0xc0) >> 6) +        1000) * 1350;
     
149.         return 0;
     & i" _  T. n2 J; X7 I. j
150. }
     
151. 
     
152. uint8_t mmc3680kj_set_pulse_width()
     6 i4 p- G; k: Z$ a) ]2 E/ B
153. {
     0 e. |( ^0 [3 F4 ?' D
154.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
155.         /*first*/
     " t9 O. {6 h( k3 G/ j4 h
156.         uint8_t addr_val[3][2] = {
     7 g# a% R$ ?) ]( q* E( u9 j
157.                         {MMC3680KJ_REG_CTRL2,MMC3680KJ_CMD_OTP_NACT},
     
158.                         {MMC3680KJ_REG_PASSWORD,MMC3680KJ_CMD_PASSWORD},
     6 b$ W; U* O* I) @3 {! K
159.                         {MMC3680KJ_REG_SR_PWIDTH,0X00}
     # L4 J8 v  t2 d
160.                 };
     
161.         for(uint8_t i=0; i<2; i++)
     9 S8 [9 L( s; y) h
162.         {
     7 l, H# p& c$ G8 d) {2 o
163.                 hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[i][0],1,&addr_val[i][1],1,1000);
     1 r2 d9 v( s/ F/ m; l
164.                 if(HAL_OK!=hi2c2_status){
     , _$ U& I6 O- v" t* {
165.                         printf("mmc3680kj set pulse_width addr(0X%02X) error\r\n",addr_val[i][0]);
     " m1 b# ]$ c" ~  |
166.                         return 1;
     
167.                 }
     
168.         }
     4 {* p# d  _5 Y  c5 i* [
169.         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[2][0],1,&addr_val[2][1],1,1000);
     
170.         if(HAL_OK!=hi2c2_status){
     
171.                 printf("mmc3680kj set pulse_width addr(0X%02X) error\r\n",addr_val[2][0]);
     8 N/ L: p7 E" s( o
172.                 return 1;
     ' H0 I/ j! f4 N+ r# D% t: Y/ t2 t
173.         }
     
174.         addr_val[2][1] &= 0xe7;
     4 o; |: K* C+ r! H* R7 D5 v; k" u
175.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[2][0],1,&addr_val[2][1],1,1000);
     ' g: C( A$ r  ^
176.         if(HAL_OK!=hi2c2_status){
     
177.                 printf("mmc3680kj set pulse_width addr(0X%02X) error\r\n",addr_val[2][0]);
     ( |" U5 n4 M% L; Z" `
178.                 return 1;
     
179.         }
     
180.         printf("successfully mmc3680kj set pulse_width\r\n");
     
181.         return 0;
     : e6 M- J+ c4 I; i  W
182. }
     - h; G. O0 T5 n. m6 L
183. 
     
184. uint8_t mmc3680kj_set_output_resolution()
     
185. {
     
186.         //MMC3680KJ_CMD_100HZ
     
187.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
188.         uint8_t addr_val[2] = {MMC3680KJ_REG_CTRL1,MMC3680KJ_CMD_100HZ};
     
189.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
190.         if(HAL_OK!=hi2c2_status){
     
191.                 printf("mmc3680kj set output_resolution addr(0X%02X) error\r\n",addr_val[0]);
     0 ^5 c2 Q' s, Q* E# C5 v- ~" e, N5 V
192.                 return 1;
     : X/ L6 m' M3 k9 V6 d7 Z
193.         }
     6 q% |) O1 |1 g; c2 y
194.         printf("successfully mmc3680kj set pulse_width\r\n");
     
195.         return 0;
     
196. }
     
197. 
     
198. uint8_t mmc3680kj_set()
     
199. {
     
200.         HAL_StatusTypeDef hi2c2_status = 0x00;
     
201.         uint8_t addr_val[2] = {MMC3680KJ_REG_CTRL0,MMC3680KJ_CMD_SET};
     4 T* a" B# X+ v+ c
202.         hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
       Y+ L+ m3 h( q4 ?7 c+ @( ^/ ^
203.         if(HAL_OK!=hi2c2_status){
     
204.                 printf("mmc3680kj set addr(0X%02X) error\r\n",addr_val[0]);
     $ i2 z* t1 {( [
205.                 return 1;
     $ i% Q" T% F' j' j5 Y: C( D
206.         }
     ) M8 b3 Z$ c" r& R2 V( l: r: C
207.         printf("successfully mmc3680kj set\r\n");
     
208.         return 0;
     ! o, l* s/ s; ~* s+ O
209. }
     1 A0 K& }! P6 s- Y1 O6 k6 e3 n8 K
210. 
     
211. uint8_t mmc3680kj_enable(FLAG_INIT_BIT flag)
     
212. {
     
213.         HAL_StatusTypeDef hi2c2_status = 0x00;
     7 t& A& A( W' ]
214.         if (flag == FLAG_INIT_MAG) {
     , t) C. @3 P. ~' A5 N' I) A0 `6 e
215.                 uint8_t addr_val[2] = {MMC3680KJ_REG_CTRL0,MMC3680KJ_CMD_TM_M};
     / N0 a$ g+ k" [7 ^  ]2 G( W9 u
216.                 hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     - g( S5 S' F& i, E% L" _$ n5 s
217.                 if(HAL_OK!=hi2c2_status){
     9 c( C! X! S0 u) p2 f, u
218.                         printf("mmc3680kj enable addr(0X%02X) error\r\n",addr_val[0]);
     " h" K6 c7 a. s* f* `% r
219.                         return 1;
     
220.                 }
     + e) T( n1 b$ I* u# |
221.                 uint8_t value = 0;
     ; D# o# v+ m/ p# ]6 I
222.                 do{
     6 L& ?4 N1 [5 K- R+ x4 a  C
223.                         HAL_Delay(10);
     
224.                         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR,MMC3680KJ_REG_STATUS,1,&value,1,1000);
     - W7 m9 Y$ N' a, C$ p$ ?$ M
225.                         if(HAL_OK!=hi2c2_status){
     
226.                                 printf("mmc3680kj enable addr(0X%02X) error\r\n",MMC3680KJ_REG_STATUS);
     3 h2 f! w4 @0 ]/ \  N( t0 `: W5 Y7 ]! K
227.                                 return 1;
     * c7 h5 E% i! ^8 l* N
228.                         }
     
229.                 }while ((value & 0x01) != 0x01);
     / i! o' I$ K% C9 U4 c
230.         }else if(flag==FLAG_INIT_TEMP){
     
231.                 uint8_t addr_val[2] = {MMC3680KJ_REG_CTRL0,MMC3680KJ_CMD_TM_T};
     
232.                 hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,MMC3680KJ_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
     
233.                 if(HAL_OK!=hi2c2_status){
     , o* F% m* ~0 v& S# F
234.                         printf("mmc3680kj enable addr(0X%02X) error\r\n",addr_val[0]);
     
235.                         return 1;
     ) k. y) w& T/ [8 y
236.                 }
     2 z7 |- ?/ a  Y6 P' ]' C, P
237.                 uint8_t value = 0;
     
238.                 do{
     8 n$ f0 [$ {# m' L% h! M
239.                         HAL_Delay(10);
     
240.                         hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR,MMC3680KJ_REG_STATUS,1,&value,1,1000);
     
241.                         if(HAL_OK!=hi2c2_status){
     
242.                                 printf("mmc3680kj enable addr(0X%02X) error\r\n",MMC3680KJ_REG_STATUS);
     
243.                                 return 1;
     
244.                         }
     
245.                 }while ((value & 0x02) != 0x02);
     
246.         }else{
     
247.                 return 1;
     
248.         }
     
249.         printf("successfully mmc3680kj enable\r\n");
     
250.         return 0;
     9 f# X4 ^+ n( N# u* T& `( Q  y
251. }
     
252. 
     & F% R- [4 X2 ~3 s
253. static int mmc3680kj_tick()
     
254. {
     
255.     static uint32_t last_time = 0;
     
256.     uint32_t        now_time  = 0;
     ) O. N- ]. _1 ~9 }3 D4 U
257. 
     + L5 r# \: d( r' [3 x0 W
258.     now_time = HAL_GetTick();
     
259.     if (now_time - last_time > 5000) {
     # Z' p- e& k5 G2 S) `
260.         last_time = now_time;
     3 y; A& O1 |; h5 K; c; P, i
261.         return 1;
     . m, F; o9 s# P5 ]  U  e2 v; G
262.     }
     & E* c% T- r  @
263. 
     & O* E5 A, z2 b0 o/ R( e
264.     return 0;
     : w; i5 L: H  A- G9 Y  {
265. }
     : J7 H2 Z4 V1 U% ]4 j; v) a( `/ l* O. d
266. 
     + p$ n' V, O( ?, m9 u' [
267. uint8_t mmc3680kj_read_temp_memsic(int32_t *temperature)
     
268. {
     : r# @# Y6 t2 Y! o3 T
269.         uint8_t ret = mmc3680kj_enable(FLAG_INIT_TEMP);
     & g5 {3 Y. }; ?' _/ i9 C
270.         if (ret>0) {
     
271.         return ret;
     
272.     }
     
273.         uint8_t reg_raw = 0;
     # f, h& o  w3 f! U4 |
274.         HAL_StatusTypeDef hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR
     8 C1 ?# v" @, x. @: p
275.                                 ,MMC3680KJ_REG_TEMP,1,®_raw,1,1000);
     
276.         if(HAL_OK!=hi2c2_status){
     
277.                 printf("mmc3680kj read_mag_memsic addr(0X%02X) error\r\n",MMC3680KJ_REG_STATUS);
     
278.                 return 1;
     
279.         }
     6 m5 v3 c$ s8 m1 @  i6 }1 b# i& g
280.         printf("mmc3680kj_read_temp org:%02X\r\n",reg_raw);
     
281.         *temperature = ((int32_t)reg_raw) * MMC3680KJ_T_SENSITIVITY / 100 + MMC3680KJ_T_ZERO;
       ~0 s8 L8 N' m6 u. U
282.         printf("mmc3680kj_read_temp:%ld\r\n",*temperature);
     
283.         return 0;
     
284. }
     ! D' o6 S/ K, ?# P9 l8 z( q
285. 
     
286. uint8_t mmc3680kj_read_mag_memsic(int32_t *xval, int32_t *yval, int32_t *zval)
     ) `; b0 d8 P+ b
287. {
     6 Y1 T  C# Z: w" v# i! Q2 j3 w$ q
288.         uint8_t ret = 0;
     # j5 @' p! z* @4 s( C6 k5 d
289.         if (mmc3680kj_tick()) {
     $ `& f, m; a9 m- L3 }2 I  C' `
290.         ret = mmc3680kj_set();
     
291.         if (ret>0) {
     * D2 n; d5 s9 e8 P8 s' w8 Z; D* `) A) s
292.             return ret;
     % }( ~3 J0 H( `  K" x
293.         }
     
294.     }
     - e9 J# g+ ], ?" r8 l  X- N
295.         ret = mmc3680kj_enable(FLAG_INIT_MAG);
     
296.         if (ret>0) {
     ! K2 V" r& X* s" c
297.         return ret;
     
298.     }
     
299.         uint8_t reg_raw[MMC3680KJ_MAG_DATA_SIZE] = { 0 };
     
300.         HAL_StatusTypeDef hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,MMC3680KJ_I2C_ADDR
     ! |# \+ ^0 O) T  v
301.                         ,MMC3680KJ_REG_DATA,1,reg_raw,MMC3680KJ_MAG_DATA_SIZE,1000);
     8 J+ @0 {% Z+ d. |+ r% ?3 v3 ?
302.         if(HAL_OK!=hi2c2_status){
     9 y$ p' U  T' E6 U) I$ M
303.                 printf("mmc3680kj read_mag_memsic addr(0X%02X) error\r\n",MMC3680KJ_REG_STATUS);
     , w4 a* i) p7 X( U7 ]" M9 S
304.                 return 1;
     
305.         }
     
306.     uint16_t    data_raw[3] = { 0 };
       O0 f% h, C& W1 {: Z& u0 S
307.     uint32_t    mag_raw[3]  = { 0 };
     8 B3 d" c" I) X# Y
308.     data_raw[0] = (uint16_t)(reg_raw[1] << 8 | reg_raw[0]);
     
309.     data_raw[1] = (uint16_t)(reg_raw[3] << 8 | reg_raw[2]);
     5 `+ C! O2 x: a/ y  v! g
310.     data_raw[2] = (uint16_t)(reg_raw[5] << 8 | reg_raw[4]);
     
311.     mag_raw[0]  = (uint32_t)(data_raw[0]);
     
312.     mag_raw[1]  = (uint32_t)(data_raw[1] - data_raw[2] + MMC3680KJ_OFFSET);
     5 Q) X  n' V4 A
313.     mag_raw[2]  = (uint32_t)(data_raw[1] + data_raw[2] - MMC3680KJ_OFFSET);
     
314. 
     6 N: ?5 {, q0 O; g* F& h$ l
315.     *xval = (int32_t)(mag_raw[0] - MMC3680KJ_OFFSET) * g_otp_matrix[0] / MMC3680KJ_SENSITIVITY;
     7 K" x0 K! q; X4 L- M0 Y0 d
316.     *yval = (int32_t)(mag_raw[1] - MMC3680KJ_OFFSET) * g_otp_matrix[1] / MMC3680KJ_SENSITIVITY;
     4 K' @9 i2 w& \/ C1 b
317.     *zval = (int32_t)(mag_raw[2] - MMC3680KJ_OFFSET) * g_otp_matrix[2] / MMC3680KJ_SENSITIVITY;
     
318.     printf("mmc3680kj_read_mag:%ld,%ld,%ld\r\n",*xval,*yval,*zval);
     $ }  K* @. M1 r/ K, Y  E; q
319.         return 0;
     6 h4 h" m1 j, Q3 }/ @! W
320. }
     
321. 
     ) a/ [4 \  k& h) d
322. void mmc3680kj_temp_memsic_init()
     ) _4 C# W1 Q* _# ?
323. {
     3 J- t7 x+ U/ y. Q( {. E: Q
324.         if(mmc3680kj_check_otp()>0)
     ' Y' @5 Y: I  x' U, y, R  F5 D% J
325.                 return ;
     6 E9 K, ?* J" y) u
326.         if(mmc3680kj_id_check()>0)
     7 q1 c/ {! [6 \7 W" T9 i( f
327.                 return ;
     
328.         printf("successfully mmc3680kj temp_memsic_init\r\n");
     
329. }
     - n4 q$ w4 a( Y
330. 
     ! e8 W# A0 E) P- a% [
331. void mmc3680kj_mag_memsic_init()
     
332. {
     1 H* o; j) Q7 Q1 Z) z. z6 i
333.         if(mmc3680kj_check_otp()>0)
     
334.                 return ;
     7 l4 e4 h9 y& a& S' j
335.         if(mmc3680kj_id_check()>0)
     
336.                 return ;
     
337.         if(mmc3680kj_set_comp_matrix()>0)
     
338.                 return ;
     
339.         if(mmc3680kj_set_pulse_width()>0)
     
340.                 return ;
     
341.         if(mmc3680kj_set_output_resolution()>0)
     
342.                 return ;
     
343.         printf("successfully mmc3680kj mag_memsic_init\r\n");
     
344. }

复制代码

十、驱动代码调用及数据采集与展示
8 N, w% v' M1 B; x4 K/ A$ ^        在main.c函数中，调用各个传感器驱动的头文件及调试、oled显示的头文件

1. /* USER CODE BEGIN Includes */
   ; E6 N  i7 |2 M" `& Z
2. #include "../../ICore/key/key.h"
   
3. #include "../../ICore/led/led.h"
   " z2 Z0 a/ g7 y
4. #include "../../ICore/print/print.h"
   + I* u/ j+ W0 q' G/ D0 c) Q
5. #include "../../ICore/usart/usart.h"
   6 c7 \2 d: U, M' k
6. #include "../../ICore/oled/oled.h"
   
7. #include "../../ICore/SHTC1/SHTC1.h"
   - q9 @0 [+ x9 |; c/ A5 n. K
8. #include "../../ICore/LTR-553ALS-WA/LTR-553ALS-WA.h"
   ; h9 |! c, [; n! W9 o, _, N) }. P
9. #include "../../ICore/bmp280/bmp280.h"
   
10. #include "../../ICore/LSM6DSL/LSM6DSL.h"
    ! p; K1 {4 {' q
11. #include "../../ICore/MMC3680KJ/MMC3680KJ.h"
    5 X# W) \( L' X0 U6 v( m
12. /* USER CODE END Includes */

复制代码

" y! v( l* j1 e" Y3 s& X/ P        在主函数中，逐个初始化各个传感器及相关接口，并将OLED设置为蓝色背景显示。
& E# Y# ~4 }+ x* q- o& e

1. /* USER CODE BEGIN 1 */
   
2.     float humidity, temperature;
   
3.     uint32_t als_data,ps_data;
   
4.     uint32_t comp_temp,comp_baro;
   
5.     int32_t acc_x,acc_y,acc_z;
   & K! Y. O, Y) Z' S6 U; `7 N! e
6.     int32_t gyro_x,gyro_y,gyro_z;
   5 |; e6 ~' Y( [' f0 C6 N0 ]" c; P
7.     int32_t mmc_temp,mmc_aval,mmc_bval,mmc_cval;
   4 w( I3 s- d: p9 T: i0 _, Y
8.   /* USER CODE END 1 */
   
9. ...........................................
   5 W2 E* a% l( U" _
10.   /* USER CODE BEGIN 2 */
    
11.   ResetPrintInit(&hlpuart1);
    " Q" c1 y2 U4 v7 n; t! O# Z9 t7 r
12.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
    0 H" P) v4 W9 A1 H9 c0 b
13.   HLPUSART_RX_STA = 0;
      I+ l8 b5 q7 K) S# u% |+ u
14.   //oled
    3 i$ d- y9 m2 w/ d1 s
15.   OLED_init();
    
16.   //shtc1
    4 w# p0 M7 p+ r: W( Y% O& Y2 ^
17.   humidity = temperature = 0.0;
    & H; O  E3 D! D8 v4 R* Z
18.   als_data = ps_data = 0;
    
19.   shtc1_init();
    
20.   //ltr553
    
21.   LTR_ALS_init();
    8 {3 @1 Z3 r0 Y& t3 M
22.   ltr553_als_open();
    & Q$ z! n& ?, p$ E4 ^/ [: P/ w
23.   LTR_PS_init();
    
24.   ltr553_ps_open();
    9 R+ G' @' X- _2 b
25.   //bmp280
    % T: y& _# o* n; a1 J) _: F: f6 d
26.   BMP280_init();
    # d. g  ]6 @3 P. a: t( j5 J
27.   bmp280_open();
    
28.   comp_temp = comp_baro = 0;
    ' j8 F& Z0 w$ L. a0 e
29.   //mmc3680
    
30.   mmc3680kj_temp_memsic_init();
    
31.   mmc3680kj_mag_memsic_init();
    
32.   //
    
33.   LSM6DSL_init();
    
34.   LSM6DSL_acc_st_open();
    . s( ]6 r- v( }4 k6 j! k4 ~
35.   LSM6DSL_gyro_st_open();
    
36.   acc_x = acc_y = acc_z = 0;
    
37.   gyro_x = gyro_y = gyro_z = 0;
    0 O8 p, V+ m6 [& g/ ~
38.   mmc_temp = mmc_aval = mmc_bval = mmc_cval =0;
    : K5 a$ w. L& O) g  L: }1 _% H
39.   uint8_t menu = 0;
    
40.   //设置OLED蓝色背景显示
    , O9 C3 U9 s' }; {
41.   BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
    1 y+ B. q  K% B5 l9 A5 I5 B$ o% e
42.   printf("OLED_Clear_DMA\r\n");
    9 l: D- N2 y$ D9 b
43.   /* USER CODE END 2 */

复制代码

        在主函数循环中，加入对各个传感器数据读取以及显示输出，设置了一个菜单标识menu，按键可以改变它：按键KEY0清屏，按键KEY1实现I2C2接口读取（stch1、ltr553、bmp280）数据及显示；按键KEY2实现I2C4接口读取(LSM6DSL、MMC3680KJ)数据及显示。
, u- A9 q9 H, R. v3 l4 @- b0 A

1. /* USER CODE BEGIN WHILE */
   
2.   while (1)
   ! t6 ?( r/ n! w. A8 C
3.   {
   6 V  p2 t' j, s
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   
5.                     //printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   * P3 _3 g% ~. y) W0 v0 `  V3 D
6.                     OLED_printf(10,10,"%.*s",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   4 H6 u$ G& l5 \7 o7 |7 c
7.                     HLPUSART_RX_STA=0;//接收错误,重新开始
   
8.                     HAL_Delay(100);//等待
   
9.             }
   2 P/ @$ b$ C" K4 L( H* ]. s
10.           if(KEY_0())
    # u" K1 d8 B" _* v
11.           {
    : A% @9 X# R' r; m) {6 i
12.                   BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
    
13.                   printf("OLED_Clear_DMA\r\n");
    % J/ W8 i, t# C! i* k9 D# x# i8 d
14.           }
    
15.           if(KEY_1())
    
16.           {
    ( z* d  [( _' }+ V; ]% z9 T& B9 M& _
17.                   if(menu&0x02)
    , W5 c3 ]' I2 K! c# I
18.                           BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
    
19.                   if(menu&0x01)
    9 d: A0 V9 z+ x5 H7 o0 _
20.                           menu &= 0XFE;        //取消I2C2数据刷新
    ; N' U6 Z/ J4 K9 H
21.                   else
    1 _% u4 B5 O) o3 y0 s$ }+ V8 [. R
22.                           menu |= 0X01; //开启I2C2数据刷新
    
23.                   menu &= 0XFD; //取消I2C4数据刷新
    $ |8 p% m$ I7 O3 X" y' L# |
24. 
    7 W( L2 H' e0 m- Y; }
25.           }
    $ @, c' q6 p# ^
26.           if(KEY_2())
    
27.           {
    : u) U8 G+ X& l% ?: o
28.                   if(menu&0x01)
    
29.                           BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
    ! S( [9 e4 w" S$ Q
30. 
    
31.                   if(menu&0x02)
    1 d& E, B% h- H* @: i
32.                           menu &= 0XFD; //取消I2C4数据刷新
    % q) u% ^2 d1 C9 w- `. V7 _* J
33.                   else
    % R1 T4 V, @0 s" k* n* J
34.                           menu |= 0X02; //开启I2C4数据刷新
    
35.                   menu &= 0XFE;        //取消I2C2数据刷新
    
36. 
    
37.           }
    
38.           if(menu&0x01)
    , W$ p' N" q0 J- v! _
39.             {
    
40.                   /* 读取温湿度数据 */
    
41.                     read_ht(&humidity,&temperature);
    % X" K! M2 D1 P
42.                     //oled
    $ C" l% |0 a* M) \+ U3 D
43.                     OLED_printf(10,10,"humidity   : %d.%d",(int)humidity, (int)(humidity * 100) % 100);
    
44.                     if( temperature >= 0 )
    2 x( m& J/ W  f3 l$ A& C
45.                             OLED_printf(10,26,"temperature: %d.%d",(int)temperature, (int)(temperature * 100) % 100);
    
46.                     else
    ; _, }. N# b" i8 X
47.                             OLED_printf(10,26,"temperature: %d.%d",(int)temperature, (int)(-temperature * 100) % 100);
    & C# `" A$ y$ _  _  P
48.                   read_als(&als_data);
    
49.                   read_ps(&ps_data);
    
50.                   //
    
51.                   OLED_printf(10,42,"light_data : %d.%d",(int)als_data, (int)(als_data * 100) % 100);
    
52.                   OLED_printf(10,58,"proximity  : %d.%d",(int)ps_data, (int)(ps_data * 100) % 100);
    
53.                   //
    ! q: S# Q6 @" Z$ U3 U: n; X
54.                   read_bmp280_temp(&comp_temp);
    - P: W% T1 q* `. i) o/ g  j% o
55.                   read_bmp280_baro(&comp_baro);
    
56.                   OLED_printf(10,74,"comp_DegC  : %d.%d",(int)comp_temp/100,(int)comp_temp%100);
    
57.                   OLED_printf(10,90,"comp_baro  : %d.%d",(int)comp_baro/100,(int)comp_baro%100);
    1 L6 b# V: [3 M& I& _
58.             }
    
59.             if(menu&0x02)
    
60.             {
    
61.                   LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
    . ?- O) ]3 o3 @
62.                   LSM6DSL_gyro_read(&gyro_x,&gyro_y,&gyro_z);
    
63.                   if(acc_x>0)
    " G2 b+ d% E( m8 p3 C& T6 f
64.                           OLED_printf(10,10,"st_acc_x   : %d.%d    ",(acc_x*98)/10000,((acc_x*98)%10000)/100);
    
65.                   else
    
66.                           OLED_printf(10,10,"st_acc_x   : %d.%d    ",(acc_x*98)/10000,((-acc_x*98)%10000)/100);
    
67.                   if(acc_y>0)
    
68.                           OLED_printf(10,26,"st_acc_y   : %d.%d    ",(acc_y*98)/10000,((acc_y*98)%10000)/100);
    
69.                   else
    
70.                           OLED_printf(10,26,"st_acc_y   : %d.%d    ",(acc_y*98)/10000,((-acc_y*98)%10000)/100);
    9 @0 W; u  y5 m- E5 v
71.                   if(acc_z>0)
    3 O, y, u2 }+ P* Z
72.                           OLED_printf(10,42,"st_acc_z   : %d.%d    ",(acc_z*98)/10000,((acc_z*98)%10000)/100);
    
73.                   else
    
74.                           OLED_printf(10,42,"st_acc_z   : %d.%d    ",(acc_z*98)/10000,((-acc_z*98)%10000)/100);
    
75.                   if(gyro_x>0)
    
76.                           OLED_printf(10,58,"st_gyro_x  : %d.%d    ",(gyro_x)/1000,((gyro_x)%1000)/10);
    
77.                   else
    % Z4 H( q1 G) W, m' r: Y7 C! Y% L  Y
78.                           OLED_printf(10,58,"st_gyro_x  : %d.%d    ",(gyro_x)/1000,((-gyro_x)%1000)/10);
    
79.                   if(gyro_y>0)
    
80.                           OLED_printf(10,74,"st_gyro_y  : %d.%d    ",(gyro_y)/1000,((gyro_y)%1000)/10);
    
81.                   else
    
82.                           OLED_printf(10,74,"st_gyro_y  : %d.%d    ",(gyro_y)/1000,((-gyro_y)%1000)/10);
    5 x0 D: ~+ n! @9 L+ q
83.                   if(gyro_z>0)
    ' }6 d4 r0 o3 `+ E  }
84.                           OLED_printf(10,90,"st_gyro_z  : %d.%d    ",(gyro_z)/1000,((gyro_z)%1000)/10);
    2 g2 [1 u* v2 a- Y( P3 u: w* x" v
85.                   else
    5 t% f% n; R9 Q/ q6 G
86.                           OLED_printf(10,90,"st_gyro_z  : %d.%d    ",(gyro_z)/1000,((-gyro_z)%1000)/10);
    0 t) \2 D) q8 c, _0 \
87.                   mmc3680kj_read_temp_memsic(&mmc_temp);
    7 X- x0 Z1 q2 S7 T
88.                   mmc3680kj_read_mag_memsic(&mmc_aval,&mmc_bval,&mmc_cval);
    
89.                 OLED_printf(10,106,"mmc_temp   : %d.%d    ",mmc_temp,0);
    % @1 h. P: q* @5 l
90.                 OLED_printf(10,122,"mmc_aval   : %d.%d    ",mmc_aval,0);
    
91.                 OLED_printf(10,138,"mmc_bval   : %d.%d    ",mmc_bval,0);
    $ I8 e* A% j% S
92.                 OLED_printf(10,154,"mmc_cval   : %d.%d    ",mmc_cval,0);
    1 `2 V8 `2 h9 E, u; B  [: m; A
93.             }
    2 _, k9 A# W& O# k& O+ r
94.           Toggle_led0();
    
95.     /* USER CODE END WHILE */

复制代码

        程序编译及下载
* U# z! y( f9 H


9 T& o$ m! c1 J$ a9 y1 v; z  H; g         初始化打印输出
/ l2 D4 B7 R$ @3 [" u( h. ?; k
* G  p, W& O% S" q/ ?1 v

         以及oled屏幕显示I2C2读取数据，按键KEY1，将不断刷新，再按一次KEY1将停止刷新



         以及OLED屏幕显示I2C4读取数据 ，按键KEY2，将不断刷新，再按一次KEY2将停止刷新
/ O5 X  W. x8 [  f) e5 y' g* [

- u& l2 c6 }$ [, J0 O" i( @
————————————————
7 v! Q6 c) r& C/ ^2 l版权声明：py_free-物联智能
如有侵权请联系删除



+ B* G+ F3 F; z- O; \7 R, s/ C