一、基本情况

       LC709203F是一款适用于单节锂离子/聚合物电池应用的电量计，通过HG-CVR算法来测量电池的RSOC(相对电荷状态)。精确的RSOC数据有助于改善便携式设备的运行时间和合理使用。利用单片机的I2C口与LC709203F通讯，实现对其电池温度、电池电压、电池剩余电量(RSOC)等锂电池重要数据的采集。单片机管脚PB10(I2C2_SCL)连接LC709203F的第8脚SCL,单片机管脚PB11(I2C2_SDA)）连接LC709203F的第7脚SDA。

* H  ?( @* C; F; U" C

二、LC709203F的I2C通讯协议

三、程序

' Y: z  D( p8 p; F5 o

lc709203f.c中程序：

1 d/ M" ~" f9 A" u5 t% c

1. #include "lc709203f.h"  
   
2. #include "delay.h"                                  
   8 i5 ~/ h/ V8 A: W2 B$ e
3. 
   
4. //初始化IIC接口
   
5. void lc709203f_Init(void)
   
6. {
   
7.         u16 Buffer_data0=0x0001;//设置电源模式
   
8.         u16 Buffer_data1=0x0010;//设置适合您电池的APA参数
   
9.         u16 Buffer_data2=0x0001;//设置适合您电池的配置文件
   
10.         u16 Buffer_data3=0xAA55;//初始化RSOC
    
11.         u16 Buffer_data4=0x0001;//设置热敏电阻模式
    - [5 p, B# d/ R: f) q$ W. u
12.        
    & V2 V0 B& E: B9 D7 D
13.         IIC2_Init();//IIC初始化
    , n9 d4 S, q' |8 {& I
14.         lc709203f_WriteOneWord(LC709203F_IC_Power_Mode,Buffer_data0);
    
15.         lc709203f_WriteOneWord(LC709203F_Adjustment_Pack_Appli,Buffer_data1);
    4 r* i' P# \$ F% y
16.         lc709203f_WriteOneWord(LC709203F_Change_Parameter,Buffer_data2);
    , K& B& I1 y8 q6 l- A& \6 s
17.         lc709203f_WriteOneWord(LC709203F_Initial_RSOC,Buffer_data3);
    
18.         lc709203f_WriteOneWord(LC709203F_Status_Bit,Buffer_data4);
    
19.        
    1 A* t3 a( |/ v% E' t
20. 
    + P# ]2 n8 C& B9 i6 Y
21. }

复制代码

- y0 K5 O0 d; t) M! G

2）读一个字函数：u16 lc709203f_ReadOneWord(u8 ReadAddr)，严格按照上述协议中的时许写代码

3 q# q: D! E+ ?% c$ }

1. 
   : P* t2 n$ k5 K; G. y6 @/ K( J
2. u16 lc709203f_ReadOneWord(u8 ReadAddr)
   ; K" Y  P3 Z5 i3 ~1 [( g# {: U9 ]
3. {                                  
   
4.         u16 data=0;       
   9 E) S, [; w6 i" x
5.     u8 data_l=0;       
   . p: Y5 [& l( P# [# Z. O$ }! \
6.         u8 data_h=0;
   , j* W* H6 I+ M* b$ p
7.         u8 crc_8=0;
   + G+ T4 ^* l5 m/ X
8.         u8 readcrc[5];
   
9.     IIC2_Start();                              //第一步：第一次启动
   
10.         delay_us(100);
    
11.         IIC2_Send_Byte(LC709203F_ADDR_wr); //第二步：写入从机地址和写入指令
    0 y0 O2 ?. e3 k8 `+ H" ~
12.         delay_us(100);
    ! R! k1 Y* g; L! Z# L- I; `" c8 H
13.         IIC2_Wait_Ack();                           //第三步：等待从机确认
    ( j8 J4 b7 _: Q" t3 F1 y
14.         delay_us(100);
    5 v7 v0 n- D! `- K7 s% p" v
15.     IIC2_Send_Byte(ReadAddr);                  //第四步：发送寄存器地址（字节最高位为虚拟位）
    
16.         delay_us(100);
    
17.         IIC2_Wait_Ack();                                  //第五步：等待从机确认
    0 m& ]. }9 B, \* q* w
18.         delay_us(100);
    2 ?4 B0 ~6 |  w& K# o
19.         IIC2_Start();                                         //第六步：第二次启动
    
20.         delay_us(100);
    
21.     IIC2_Send_Byte(LC709203F_ADDR_rd); //第七步：写入从机地址和读取指令       
    % F( n9 V; \+ s5 O) H. }  K
22.     delay_us(100);        
    
23.         IIC2_Wait_Ack();                                  //第八步：等待从机确认
    
24.         delay_us(100);
    5 x, ?0 G# e* \/ P
25.     data_l=IIC2_Read_Byte(1);                              //第九步：接收低字节数据
    
26.         delay_us(100);
    
27.         //IIC2_Ack();                                   //产生应答1
    
28.         data_h=IIC2_Read_Byte(1);                              //第十步：接收高字节数据
    
29.         delay_us(100);
    
30.         //IIC2_Ack();                                   //产生应答2
    
31.         crc_8=IIC2_Read_Byte(0);                              //第十一步：接收CRC-8数据
    . u, I2 V/ c* x, ~
32.         delay_us(100);
    
33.         //IIC2_NAck();                                  //不产生应答
    
34.     IIC2_Stop();                                      //第十二步：停止
    8 t1 a( l3 l2 ]: ^8 I! H
35.         readcrc[0]=LC709203F_ADDR_wr;
    
36.         readcrc[1]=ReadAddr;
    
37.         readcrc[2]=LC709203F_ADDR_rd;
    ' F* u& |+ o8 j  S, s
38.         readcrc[3]=data_l;
      `% y+ n8 c$ D) q" A% V" X
39.         readcrc[4]=data_h;
    / y+ L- |4 z$ r5 _3 {2 G
40.         if(gh_crc8(readcrc,5)==crc_8)
    
41.                 data=data_h*256+data_l;
    
42.        
    
43.         return data;
    
44. }

复制代码

  ~" t8 ?% t4 c/ U

3）写一个字函数：void lc709203f_WriteOneWord(u8 WriteAddr,u16 DataToWrite)

1. void lc709203f_WriteOneWord(u8 WriteAddr,u16 DataToWrite)
   
2. {                                                                                                  
   
3.     u8 data[4];
   
4.     IIC2_Start();                              //第一步：启动
   
5.     IIC2_Send_Byte(LC709203F_ADDR_wr); //第二步：写入从机地址和写入指令
   9 P9 n, {6 h( L! p1 C$ Z/ K
6.     IIC2_Wait_Ack();                              //第三步：等待从机确认
   6 j: V% O0 l2 `& r6 o( o: }# y
7.     IIC2_Send_Byte(WriteAddr);                 //第四步：发送寄存器地址（字节最高位为虚拟位）
   
8.     IIC2_Wait_Ack();                            //第五步：等待从机确认                                 
   $ @% N9 U5 b- u
9.     IIC2_Send_Byte((u8)(DataToWrite&0x00FF));               //第六步：发送低字节数据                              
   
10.     IIC2_Wait_Ack();                            //第七步：等待从机确认
    
11.     IIC2_Send_Byte((u8)(DataToWrite>>8));      //第八步：发送高字节数据   
    ) y+ d& g6 t% S  k. O
12.     IIC2_Wait_Ack();                            //第九步：等待从机确认
    
13.     data[0]=LC709203F_ADDR_wr;
    , ^! x( A" \& ]# P! w! v! w
14.     data[1]=WriteAddr;
    ! r: @( M; i& t( S% Z9 B. g
15.     data[2]=(u8)(DataToWrite&0x00FF);
    1 ]# p( \2 [4 w: b' i
16.     data[3]=(u8)(DataToWrite>>8);
    
17.     IIC2_Send_Byte(gh_crc8(data,4));      //第十步：发送CRC-8数据   
    
18.     IIC2_Wait_Ack();                            //第十一步：等待从机确认
    
19.     IIC2_Stop();                               //第十二步：停止
    
20.     delay_ms(10);     
    8 T, h: @/ J  ^5 G9 W3 U& z1 n
21. }

复制代码

/ [* s7 @) [; k7 g

4）获取数据函数：void getLC709203FOutput(s16* LC709203FData)

* \- _2 ]  c5 U- B: g$ H9 {4 U

1. void getLC709203FOutput(s16* LC709203FData)
   
2. {
   
3.       
   4 \( C3 ~* o( e) d- D: {) H) C' Y
4.     u16 data0,data1,data2;
   7 Q" d& s. a  K6 |6 ^3 o1 M; K- b
5.        
   6 n; ]. v& V4 S* h2 H
6.     data0=lc709203f_ReadOneWord(LC709203F_Cell_Temperature);//电池温度
   
7.         data1=lc709203f_ReadOneWord(LC709203F_RSOC);//电池剩余电量
   * G3 @+ z% w- C: O' w* a8 ?. H
8.         data2=lc709203f_ReadOneWord(LC709203F_Cell_Voltage); //电池电压
   
9.    
   0 [" r5 K) j5 W* n, j
10.     if((data0>=0x0AAC)&&(data0<=0x7FFF)) //读取的数据处理
    
11.         LC709203FData[0]=data0-0x0AAC;
    
12.         if(data1<=0x0064)
    
13.         LC709203FData[1]=data1;
    
14.     if((data2<=0x0FA0)&&(data2>=0x07D0))
    
15.         LC709203FData[2]=data2;
    
16. }

复制代码

四、调试中遇到的问题处理总结

2 X0 ]' l% n* C5 I& t

1、起初，未严格按照协议，读取到的数据均是0XABAB等，以为是I2C读写函数信号延时函数设置不合适的问题，后来多次测试还是不行，再后来仔细阅读协议，发现此协议还需要CRC8校验，比其他一些芯片的I2C通讯协议要复杂，于是按照通讯协议写lc709203f_ReadOneWord()和lc709203f_WriteOneWord()函数；

/ \3 b! ^5 h* H5 Z- Z: z

( o9 g3 L3 ?! V+ l& o

2、之后下载程序运行，仍然读不到正确数据，检查程序，发现lc709203f_ReadOneWord()中第九步、第十步、第十一步都是IIC2_Read_Byte(1),函数的形参都为1，而该函数1表示为产生应答ACK，0为不产生应答NACK，根据I2C通讯协议,应该为上面程序所写的，不产生应答的改为IIC2_Read_Byte(0),并且此函数里面已经有ACK和NACK函数，如上述程序所写的需要注释掉产生应答1、产生应答2和不产生应答。

5 I/ l4 w  P) I' l: y" B

IIC2_Read_Byte()如下：

1. 
   - w: a" d# X' |: K  ?* Q/ d
2. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
   9 c% W  @/ h% m8 v( C# F
3. u8 IIC2_Read_Byte(unsigned char ack)
   
4. {
   
5.         unsigned char i,receive=0;
   1 [4 d) W: O" ?/ B8 r! a7 @
6.         SDA2_IN();//SDA设置为输入
   
7.     for(i=0;i<8;i++ )
   ! A) C; l# g' k! {0 y" w: K
8.         {
   
9.         IIC2_SCL=0;
   
10.         delay_us(4);                   //LC709203F时钟频率400Khz=2.5us
    
11.                 IIC2_SCL=1;
    ' F: Y9 U1 W2 C3 ?. g7 z
12.         receive<<=1;  //receive=receive<<1;
    & R( H" D/ g; E/ F
13.         if(READ2_SDA)receive++;   // 根据READ_SDA的值（SDA），从高到低顺序依次写入一个字节，
    
14.                 delay_us(4);             //i=0时，SDA=1则receive=0B00000001,i=1,SDA=1则receive=0B00000011
    
15.     }                                         
    - D/ _: l% F( ~$ K% Z
16.     if (!ack)
    ! m0 x  f) n2 _  o& f9 i
17.         IIC2_NAck();//发送nACK
    - u1 f( h. L+ m3 U
18.     else
    
19.         IIC2_Ack(); //发送ACK   
    ( j- M; g/ S- G: \3 N" X& `
20.     return receive;
    ( r3 S4 w" P7 H5 `, w# M
21. }

复制代码

: H7 E- A7 n; {7 D$ |# [! G

• 
  
  * g6 z$ ]  r6 Y4 w( N# p
  4 C( f/ x2 z4 x; ~: `

3、修改上述后，下载程序运行仍然读不到正确数据，但是通过单步调试都能正确读到数据，原因在哪里呢？单步调试发现写的数据均已写入进去了，于是在读字节函数lc709203f_ReadOneWord()中，在每一步之间增加delay_us(100);//延时100us，此时运行，都能正确读到数据。

8 T( K/ m! m" a