弄了好几天，才弄好。

& M3 R0 u9 c1 N4 w$ T# p2 d/*
************************************************************************************************************
; k! t2 ]( Y" a6 U" C0 d/ ~( N/ a版权所有 (C)，2010－2012，磊元科技有限公司
--------------------------------------------------------------------------------------------------
头文件名：      　　CommI2c.h
! |0 J/ V+ i6 O头文件名称：        两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线）的头文件
/ F. b! u# O+ {程序版本：　　      1.0
文件功能：
　　　　本文件是对两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线）的源程序文件的编译控制声明、字符化常数和输入／输出引脚
　　定义、全局常量声明、全局数据结构类型定义、全局变量声明和函数原型声明的头文件。
文件说明：
  x$ ?& q7 X1 a7 [3 @! r; I  t* `　　　　１．本文件中的所有标识符定义前缀字母表示意义如下：
! }1 q7 t2 |& n3 s0 R$ Z　　　　　　c  ---------- 常量
　　　　　　v  ---------- 变量
　　　　　　g  ---------- 全局变量（Global）
　　　　　　l  ---------- 局部变量（Local）
　　　　　　uc ---------- 数据类型（Unsigned Char）
' p  \& Q: ^. c! e3 f  q* u　　　　　　ui ---------- 数据类型（Unsigned Word）
4 I* Z, w, p' P　　　　　　p  ---------- 指针
　　　　　　st ---------- 数据体
　　　　　　pt ---------- 指向数据体的指针
" M' Q9 B0 _( i& i            Pre --------- 条件编译预定义
            MFH --------- 宏定义硬件操作函数
) p6 ~; f( O7 ~# W! l  V( |            MFS --------- 宏定义软件操作和条件编译函数
            MFO --------- 宏定义其他函数
- B/ m/ J7 t# i5 Y# ~. ?; K7 ?# `0 U6 ]　　　　２．注意：使用源程序的Ｉ２Ｃ总线接收和发送数据的函数之前，必须使能全局中断。
　　　　３．注意：使用Ｉ２Ｃ总线作为主、从机进行通信，主机在接收数据时，须连续接收２次才可正确接收到
                  从机发送的数据；因为主机第一次接收数据的第１个数据为Ｉ２Ｃ总线上出现的最后一个字节。
                  但在与外围器件通信正常，只须接收１次即可。
主要函数列表：　　　
; R9 I; g, }' C　　　　▲．在主函数中运行的函数：
4 O/ }% b3 n7 W　　　　　　１．void UsartsInit(void)（ＵＳＡＲＴｓ端口和查询式串行通讯协议的初始化）
　　　　　　２．void Rs422UsartsAskManage(void)（查询式ＲＳ４２２的通讯协议处理）
　　　　▲．中断请求服务函数：
8 R8 m% U. v9 [; t  w4 O. p0 k　　　　　　１．void usart1_txc_isr(void)（发送结束中断方式发送数据的中断服务程序）
/ N/ w8 F: v1 `　　　　　　２．void usart1_rxc_isr(void)（接收结束中断方式接收数据的中断服务程序）
编译工具软件：      IAR Embedded Workbench for Atmel AVR 版本：5.20A 以上
9 F" Q, K6 S. k链接文件：          １．SysCfg.h ------------ 系统运行结构定义配置的头文件。
编作者：            磊元
) E6 m( q, _/ I. r! R: `! o3 g4 [' g编制日期：          2009年4月8日
) e; I/ o# a  B' _) B; C6 W; w1 a--------------------------------------------------------------------------------------------------
+ E3 [$ w( ]. l! x: L) }) L头文件版本历史：
6 \5 u5 C6 z4 z1 X" a6 R4 t; _2 `' a2006年07月26日  〖磊元〗 -------- 版本 1.0 ：原始版本（AVR）
1 N" l- p; A- _3 ?2016年09月20日  〖磊元〗 -------- 版本 2.0 ：扩增版本（STM8S）
************************************************************************************************************
*/
#ifndef _COMMI2C_H_                                       // “_COMMI2C_H_”条件编译开始
#define _COMMI2C_H_
9 {2 @/ O( Y/ U7 x5 F* m5 n
/*==========================================================================================================
" i' D" d/ N( A9 D2 \  k* f7 N　　　　　　　　　　　　　　　　　　　　　本头文件包括的其他头文件
% k% _: ^% F* _& W) E, `建议：包含本项目的文件使用 #include "文件名.扩展名" ，
( j+ [7 q2 @6 B1 N" z1 C( q　　　包含系统库的文件使用 #include <文件名.扩展名> 。
- I' x6 u! g9 D+ L& ?2 Q==========================================================================================================*/
( W* e4 m9 W' n% S7 [' F#include "SysCfg.h"                                       // 系统运行结构定义配置的头文件

2 f, W& m5 M5 g1 E. Z#ifdef __cplusplus
extern "C" {                                              // 声明接在下面的指令为Ｃ程序编译系统
#endif
  x/ f' u* b( b! {
# ^1 \4 ]0 E+ q7 W; }/*==========================================================================================================
3 ]" Q; T* b0 n; K; D; v　　　　　　　　　　　　　　　　　　　　　　　条件编译控制声明
! \* M4 N6 D1 f7 {) A==========================================================================================================*/
#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
6 Z3 A% ]) l/ p9 r% o' ~#if defined(PreGlobalWithRedundantCode)
/*------------------------------------------------------------------------------------------------
声明程序指令使用冗余代码的条件定义：
------------------------------------------------------------------------------------------------*/
+ w2 O2 e1 C5 r2 Q$ I  _#define PreCommI2cWithRedundantCode                       // “使用冗余程序代码”条件定义
#endif
#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
! w4 j$ L  N: p7 {2 b#endif                                                    // “PreCommI2cWithRedundantCode”
/*------------------------------------------------------------------------------------------------
* O! r3 K& A" E, F6 v声明ＴＷＩ接口的Ｉ２Ｃ总线工作于哪种方式的条件定义：
注意：只能使用下面几个条件定义中的１个条件定义，不允许使用２个以上条件定义！！！
% U6 y8 c- w# J9 m# ?8 w& r! G警告：此处的声明定义对于本源程序文件和其他源程序文件的编译有决定性作用，应慎重！
------------------------------------------------------------------------------------------------*/
# U6 W) Q1 I0 x/ Y#define PreCommI2cUseSingleMasterMode                          // “Ｉ２Ｃ总线工作于单主机方式”条件定义
9 n% f0 U9 n1 r& r# x# p4 ^4 ?//#define PreCommI2cUseSingleSlaveMode                      // “Ｉ２Ｃ总线工作于单从机方式”条件定义
* q2 J/ @/ [1 c  U) W& v- P//#define PreCommI2cUseMultiSlaveMode                            // “Ｉ２Ｃ总线工作于多从机方式”条件定义
$ B5 _6 a# B# v% {. [4 x8 X#if   (   (defined(PreCommI2cUseSingleMasterMode) || defined(PreCommI2cUseSingleSlaveMode)) \
       && (defined(PreCommI2cUseSingleMasterMode) || defined(PreCommI2cUseMultiSlaveMode )) \
       && (defined(PreCommI2cUseSingleSlaveMode ) || defined(PreCommI2cUseMultiSlaveMode )) )
7 ^; m+ |) p- n#error 错误：＜声明ＴＷＩ接口的Ｉ２Ｃ总线工作于哪种方式的条件定义＞不允许使用２个以上条件定义！！！
, v) Q) X, L# N- j  e+ A1 v0 j#endif
/*------------------------------------------------------------------------------------------------
声明在应用中对于具有多个Ｉ２Ｃ接口的目标器件芯片，具体指定使用哪一个Ｉ２Ｃ端口的条件定义：
8 n4 i( _+ u6 B7 w% _' i------------------------------------------------------------------------------------------------*/
) Z" S* R8 X8 l! {" X9 Y#define PreCommI2cMultipleI2cEnable0                      // 使用Ｉ２Ｃ０接口的声明定义
#endif                                                    // “PreGlobalCompilerHardware”
/ l  v% H( i% V: t3 i

. }! s; J) R9 E5 I+ m/*==========================================================================================================
2 v8 E" z6 ^- M　　　　　　　　　　　　　　　　 本源程序文件内部使用的一些操作指令的宏定义
0 g) l( t5 ^0 q; A+ e  }' D; A==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
9 _/ q! [, S) P输入／输出端口和引脚宏定义：（注：下列这些定义用以简化宏函数参数字符。）
3 x+ ?+ Q+ ]. r5 w7 w* J! I, U------------------------------------------------------------------------------------------------*/
1 \( p$ C! f, v5 Z( t% E#define MFH_PIN_CFG_INPU_I2cScl                           MFH_PIN_CFG_INPU(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
#define MFH_PIN_CFG_INHZ_I2cScl                           MFH_PIN_CFG_INHZ(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
#define MFH_PIN_CFG_OOUT_I2cScl                           MFH_PIN_CFG_OOUT(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
5 o# V3 W5 }" M0 K/ O/ O) f- N#define MFH_PIN_CFG_OUTH_I2cScl                           MFH_PIN_CFG_OUTH(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
5 g  v( t* F7 f; y9 T6 B! q3 o. U#define MFH_PIN_CFG_OUTL_I2cScl                           MFH_PIN_CFG_OUTL(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
2 n# C' m# w, W2 y3 F#define MFH_PIN_OUT_SETH_I2cScl                           MFH_PIN_OUT_SETH(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
: k% O" S9 H! |2 h7 j1 N4 C6 q) n#define MFH_PIN_OUT_CLRL_I2cScl                           MFH_PIN_OUT_CLRL(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
#define MFH_PIN_IN_STATE_I2cScl                           MFH_PIN_IN_STATE(cDdrI2cScl, cPurI2cScl, cCirI2cScl, cOdrI2cScl, cIdrI2cScl, cBitI2cScl)
' t9 L( o8 h6 f: {
# |7 \0 D. J3 u- U% k6 R' a#define MFH_PIN_CFG_INPU_I2cSda                           MFH_PIN_CFG_INPU(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
; `& P; ^0 F& Y1 y8 j1 R#define MFH_PIN_CFG_INHZ_I2cSda                           MFH_PIN_CFG_INHZ(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
8 Z" M; I. A, J' S- h( ?) S" P#define MFH_PIN_CFG_OOUT_I2cSda                           MFH_PIN_CFG_OOUT(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
#define MFH_PIN_CFG_OUTH_I2cSda                           MFH_PIN_CFG_OUTH(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
#define MFH_PIN_CFG_OUTL_I2cSda                           MFH_PIN_CFG_OUTL(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
3 m% o, k, r" l# w/ ?#define MFH_PIN_OUT_SETH_I2cSda                           MFH_PIN_OUT_SETH(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
#define MFH_PIN_OUT_CLRL_I2cSda                           MFH_PIN_OUT_CLRL(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)
6 G' Z" o8 I2 _#define MFH_PIN_IN_STATE_I2cSda                           MFH_PIN_IN_STATE(cDdrI2cSda, cPurI2cSda, cCirI2cSda, cOdrI2cSda, cIdrI2cSda, cBitI2cSda)

/*------------------------------------------------------------------------------------------------
" r+ s) m% e7 wMFHI2cInnEventReg( ) --------- 输入Ｉ２Ｃ总线的事件和状态寄存器值
4 O7 W& T$ T; ~9 xMFHI2cChkEventReg( ) --------- 检查Ｉ２Ｃ总线事件状态寄存器中的事件状态值
- o9 V( j0 P+ HMFHI2cInnEventMem( ) --------- 输入Ｉ２Ｃ总线的事件和状态存储器值
MFHI2cChkEventMem( ) --------- 检查Ｉ２Ｃ总线事件状态存储器中的事件状态值
------------------------------------------------------------------------------------------------*/
#if   (defined(_IAR_EW_AVR_))
2 X* y0 L0 ~' l1 x2 L#define MFHI2cInnEventMem( )          gucvI2cEvent                  =  TWSR
5 O8 R6 T7 c/ t#define MFHI2cChkEventMem( )          (gucvI2cEvent & cI2cTwsrMask)
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

#elif (   defined(_IAR_EW_STM8_) \
4 Q& v$ x2 }3 b& t! I5 v8 L8 l0 ^3 o       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
1 E0 P* a/ S7 m) g- y* ^! m#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
* D8 D5 x* Z8 l9 R7 c5 N2 M
#else                                                     // “_USE_STM8_FWLIB_”
+ S5 ?; r+ w! R# E/ I) K#define MFHI2cInnEventMem( )          NOTHING
//#define MFHI2cInnEventMem( )          gucvI2cEvent                  =  temp
#define MFHI2cChkEventMem( )          (gucvI2cEvent & cI2cEvtSr2Mask)
#endif                                                    // “_USE_STM8_FWLIB_”
: ]0 @% f$ ]* G! S# E#else
4 T( z1 V1 t5 h8 y8 U" m2 `#error 错误：
3 ?- t7 p3 A* _+ ^7 E#endif                                                    // “PreMcuIs__......”

) R. @$ z. C! l0 x0 f2 C6 c/ m/*------------------------------------------------------------------------------------------------
MFHI2cBusModSwRst( ) --------- 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
/ F8 X5 X; \/ U6 h2 }- J2 q5 xMFHI2cFlgEventClr( ) --------- 清０Ｉ２Ｃ总线事件中断标志位
MFHI2cIntEventClr( ) --------- 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
MFHI2cIntEventChk( ) --------- 检查Ｉ２Ｃ总线事件中断状态值
MFHI2cIntEventOnn( ) --------- 使能Ｉ２Ｃ总线事件全部中断
MFHI2cIntEventOne( ) --------- 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
2 ]3 B* v$ w. o2 F/ P- Z- Z1 X" b  sMFHI2cIntEventOff( ) --------- 禁止Ｉ２Ｃ总线事件全部中断
- @0 l% r) W( `6 oMFHI2cBusErrorChk( ) --------- 检查Ｉ２Ｃ总线在收发过程中存在的全部错误状态值
$ n) x: Z6 m9 M9 ]MFHI2cBusErrorClr( ) --------- 清０Ｉ２Ｃ总线在收发过程中存在的全部错误标记
$ O# |# P7 g$ BMFHI2cBusNackStar( ) --------- 发出 START 信号（起始条件），没有 ACK 脉冲
/ }# ]3 B2 i5 C) X9 I2 ~MFHI2cBusNackReps( ) --------- 发出重复 START 信号（重新开始条件），没有 ACK 脉冲
MFHI2cBusNackStop( ) --------- 发出 STOP 信号（结束条件），没有 ACK 脉冲
MFHI2cBusRdataAck( ) --------- 在接收之后发出 ACK 脉冲
MFHI2cBusRdatNack( ) --------- 在接收之后发出 NOT ACK
- v8 g3 F+ t" j' {" F* y+ n% c------------------------------------------------------------------------------------------------*/
#if   (defined(_IAR_EW_AVR_))
# c' ]. ~& [: {#define MFHI2cBusModSwRst( )          NOTHING
1 i# a) H( ?# a2 z# w! {#define MFHI2cFlgEventClr( )          NOTHING
#define MFHI2cIntEventClr( )          TWCR                          =  (1<<TWEN )|                \
: f9 s! \$ b' }/ ]: j6 U: g                                                                       (1<<TWIE )|(1<<TWINT)|     \
# g: M2 H) W. @$ ], i                                                                       (0<<TWEA )|                \
; L- _3 s' @) [5 V+ n" a  R                                                                       (0<<TWSTA)|(0<<TWSTO)|     \
2 I) u0 ]. P2 O+ o, ?, o7 r3 w                                                                       (0<<TWWC);
#define MFHI2cIntEventChk( )          NOTHING
  F; @9 `: S, B, `/ `8 ]#define MFHI2cIntEventOnn( )          NOTHING
1 J, P* S$ w! A. ]#define MFHI2cIntEventOne( )          NOTHING
#define MFHI2cIntEventOff( )          NOTHING
: W' w, o' a7 T( t#define MFHI2cBusErrorChk( )          NOTHING
#define MFHI2cBusErrorClr( )          NOTHING
#define MFHI2cBusNackStar( )          TWCR                          =  (1<<TWEN )|                \
/ V' l3 [3 l6 y; n- Q7 q0 w                                                                       (1<<TWIE )|(1<<TWINT)|     \
                                                                       (0<<TWEA )|                \
                                                                       (1<<TWSTA)|(0<<TWSTO)|     \
0 ?1 j) r8 w5 m! ]6 {3 g: c/ R/ }8 g                                                                       (0<<TWWC);
2 o' G0 C9 p( A#define MFHI2cBusNackReps( )          TWCR                          =  (1<<TWEN )|                \
% p4 {" }: r2 t6 Z: W$ Q7 l1 p2 W                                                                       (1<<TWIE )|(1<<TWINT)|     \
                                                                       (0<<TWEA )|                \
" m1 v! b1 r! M% }3 F. t$ j6 |                                                                       (1<<TWSTA)|(0<<TWSTO)|     \
                                                                       (0<<TWWC);
#define MFHI2cBusNackStop( )          TWCR                          =  (1<<TWEN )|                \
                                                                       (0<<TWIE )|(1<<TWINT)|     \
                                                                       (0<<TWEA )|                \
% m/ m$ b2 Q$ h# i: s6 a" K! z                                                                       (0<<TWSTA)|(1<<TWSTO)|     \
1 o; o( f. j8 \2 W1 J- ?                                                                       (0<<TWWC);
#define MFHI2cBusRdataAck( )          TWCR                          =  (1<<TWEN )|                \
                                                                       (1<<TWIE )|(1<<TWINT)|     \
) v8 L9 l; v" r, |8 {) _                                                                       (1<<TWEA )|                \
. O' V7 |/ h6 M. j6 x0 L                                                                       (0<<TWSTA)|(0<<TWSTO)|     \
                                                                       (0<<TWWC);
2 h3 e" Q5 Q8 B4 ^' J$ @' G% D#define MFHI2cBusRdatNack( )          TWCR                          =  (1<<TWEN )|                \
/ G7 L6 O1 n+ r$ L7 F, ~, ~                                                                       (1<<TWIE )|(1<<TWINT)|     \
                                                                       (0<<TWEA )|                \
                                                                       (0<<TWSTA)|(0<<TWSTO)|     \
                                                                       (0<<TWWC);
; _1 m; B; H% U0 }. J#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

! g8 H' ?9 C, [6 W) T2 B4 m#elif (   defined(_IAR_EW_STM8_) \
6 S" Z$ d$ t2 w: N& k       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
% a% d- y  l' I! X/ S
( F: U( G# l- I5 q$ P( U; v#else                                                     // “_USE_STM8_FWLIB_”
#define MFHI2cBusModSwRst( )          I2CCR1                        = (u8)( ((0<<i2cEN   )|       \
                                                                             (0<<i2cGCEN )|       \
/ D/ w& H1 \% a# x. E3 f                                                                             (0<<i2cCKTEN) ));    \
                                      I2CCR1                        = (u8)( ((1<<i2cEN   )|       \
# u# F2 k, B, m9 P% {                                                                             (0<<i2cGCEN )|       \
( j! q7 h3 c, [; G! t                                                                             (0<<i2cCKTEN) ));
#define MFHI2cFlgEventClr( )          NOTHING
! k: y8 ?4 M' e# X( _& @, D- n#define MFHI2cIntEventClr( )          temp                          =  I2CSR1;
0 L0 A7 ?3 `0 k5 F' T: L# x#define MFHI2cIntEventChk( )          NOTHING
#define MFHI2cIntEventOnn( )          I2CICR                        = (u8)( ((1<<i2cERRIE)|       \
                                                                             (1<<i2cEVTIE)|       \
/ F1 a$ {, `( F% Z+ L                                                                             (1<<i2cBUFIE) ));
* O2 q$ U3 z7 i9 T/ U#define MFHI2cIntEventOne( )          I2CICR                        = (u8)( ((1<<i2cERRIE)|       \
& P* G. r+ x9 B5 v' t* U                                                                             (1<<i2cEVTIE)|       \
                                                                             (0<<i2cBUFIE) ));
# x4 O4 X8 I! E( X* ^0 B#define MFHI2cIntEventOff( )          I2CICR                        = (u8)( ((0<<i2cERRIE)|       \
  z# D4 S; Q) b                                                                             (0<<i2cEVTIE)|       \
                                                                             (0<<i2cBUFIE) ));
#define MFHI2cBusErrorChk( )          NOTHING
#define MFHI2cBusErrorClr( )          NOTHING
/ _1 ?7 a, e3 G1 g! ]% p3 W' Q#define MFHI2cBusNackStar( )          I2CCR2                        = (u8)( ((1<<i2cSTART)|       \
                                                                             (0<<i2cSTOP )|       \
                                                                             (0<<i2cACKEN)|       \
                                                                             (0<<i2cPOS  )|       \
4 l& Z0 M/ c. {                                                                             (0<<i2cRST  ) ));
. c* l, G! c4 V" h! Y#define MFHI2cBusNackReps( )          I2CCR2                        = (u8)( ((1<<i2cSTART)|       \
! g+ [7 i# m2 S3 M& O. G                                                                             (0<<i2cSTOP )|       \
                                                                             (0<<i2cACKEN)|       \
& |& q6 H: B4 C+ f, d                                                                             (0<<i2cPOS  )|       \
+ H4 O( l/ E- v( i; k% O1 l& b) U                                                                             (0<<i2cRST  ) ));
#define MFHI2cBusNackStop( )          I2CCR2                        = (u8)( ((0<<i2cSTART)|       \
                                                                             (1<<i2cSTOP )|       \
                                                                             (0<<i2cACKEN)|       \
                                                                             (0<<i2cPOS  )|       \
                                                                             (0<<i2cRST  ) ));
$ K, A. J' y/ l' g#define MFHI2cBusRdataAck( )          I2CCR2                        = (u8)( ((0<<i2cSTART)|       \
( S' _- X; d2 q, m                                                                             (0<<i2cSTOP )|       \
, Z( I' z4 `" O" `% r( c                                                                             (1<<i2cACKEN)|       \
                                                                             (0<<i2cPOS  )|       \
                                                                             (0<<i2cRST  ) ));
. o1 ^& I# k( u#define MFHI2cBusRdatNack( )          I2CCR2                        = (u8)( ((0<<i2cSTART)|       \
                                                                             (0<<i2cSTOP )|       \
                                                                             (0<<i2cACKEN)|       \
                                                                             (0<<i2cPOS  )|       \
% _3 I- {( h  \+ t                                                                             (0<<i2cRST  ) ));
#endif                                                    // “_USE_STM8_FWLIB_”
#else
9 l8 X* i/ q# d- E. m- `#error 错误：
#endif                                                    // “PreMcuIs__......”
+ \" J+ p, H, q

% u8 I; g: M! C2 z+ q
/*
, `, r/ r0 I9 Z$ |************************************************************************************************************
　　　　　　　　　　　　　　　　　　　　　　　程序指令代码清单
: D# d) d( t* ?1 H( v: t************************************************************************************************************
*/
4 Q8 @1 |: v5 y+ d/ Z. l" X/*==========================================================================================================
函数名称：　　两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线），使用中断方式接收和发送数据通信的初始化
" o- F# f8 }; X5 S- u函数功能：　　本函数用于两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线），使用中断方式接收和发送数据通信的初始化操作。
函数入口参数：没有
函数返回值：　没有
, `. u- q% w4 c/ z9 q0 m; G调用函数：　　１．
备注：        １．本函数仅在主函数中调用一次即可。
==========================================================================================================*/
; R& \: H) S3 }3 Y1 avoid  CommI2cInit (void)
{
& E5 @5 Z, R# e" U' z" u+ `5 o% _. x  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

! B$ s' u# _( h2 R& {& I  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
, I$ c& g; @, {0 U2 `#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
/*------------------------------------------------------------------------------------------------
! W3 ^* S: j( \; @9 }“Ｉ２Ｃ总线工作于主机方式”的初始化操作。
------------------------------------------------------------------------------------------------*/
#if   (defined(_IAR_EW_AVR_))
  TWBR    =  cI2c0BrBr;                                   // 置 TWI 比特率寄存器的数值
  TWSR    =  cI2c0BrSr;                                   // 置 TWI 预分频位（TWPS）的数值
! M4 V8 c% F, F, a( Q  TWDR    =  0xFF;                                        // 默认数据字节内容 ＝ SDA 释放
3 h& `1 }  y7 _5 v! D8 H- \! o  TWCR    =  (1<<TWEN)|                                   // 使能ＴＷＩ接口为Ｉ２Ｃ总线和释放ＴＷＩ引脚
             (0<<TWIE)|(0<<TWINT)|                        // 禁止ＴＷＩ中断
  _' A3 G1 l9 S/ o) M) M7 S" R             (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|             // 没有请求信号
9 a  k* ^7 \+ {# @5 L& t: W             (0<<TWWC);                                   // 清零ＴＷＩ写冲突标志
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
( F3 l) D2 C. X' [, D7 d' n' R, |
4 `: F% z4 e, a2 a+ T3 M& `+ e#elif (   defined(_IAR_EW_STM8_) \
  I9 T% o; G% B2 P. k       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
% \, L+ @+ i  ?, ]; E% w$ n#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
* a/ ^7 ]8 N& S2 d- j  I2C_Cmd(ENABLE);
  I2C_Init(cI2c0BaudRate, cI2cOwnAddr, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, (cSysCpuClk / 1000000UL));
  I2C_ITConfig((I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
0 u/ {0 `  v/ l5 q7 h#else                                                     // “_USE_STM8_FWLIB_”
  I2cDeInit( );
( a( x" E% V: [: T& X* ~' m- l3 ]  I2CFR           = (u8)( (cSysCpuClk / 1000000UL));      // 置Ｉ２Ｃ频率寄存器的数值
# y4 _+ z! {  F( N' N  I2CCCRH         = (u8)( ((0<<i2cDUTY )|                 // 快速模式下的占空比＝0：Tlow/Thigh＝2／1，1：Tlow/Thigh＝16／9。
                           (0<<i2cSFM  )|                 // 标准／快速模式选择位＝标准模式
! T# b9 v5 R9 L6 b) V                          cI2c0BrCcrS11H ));              // 置Ｉ２Ｃ比特率高位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
  I2CCCRL         = (u8)( cI2c0BrCcrS11L);                // 置Ｉ２Ｃ比特率低位寄存器的数值
//  I2CCR1         &= (u8)(~((1<<i2cEN   ) ));              // 禁止Ｉ２Ｃ模块，用以设置 I2CTRISER。注：只有禁用Ｉ２Ｃ模块时，才能设置。
& i) p7 S* ^7 H- m) N, B& z% S3 d; D  I2CTRISER       = (u8)( ((cSysCpuClk / 1000000UL) + 1));// 标准模式：最大上升时间＝1000ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
//  I2CTRISER       = (u8)( ((((cSysCpuClk / 1000000UL) * 3UL) / 10UL) + 1));
  Z0 M3 X$ M( p//                                                          // 快速模式：最大上升时间＝300ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
  I2CDR           = (u8)( 0xFF);                          // 默认数据字节内容 ＝ SDA 释放
  I2CCR1          = (u8)( ((1<<i2cEN   )|(0<<i2cGCEN )|   // 使能Ｉ２Ｃ模块，禁止广播呼叫
2 o+ [8 K- c/ `  W, j( {, U. Y                           (0<<i2cCKTEN) ));              // 禁止时钟延展
  I2CCR2          = (u8)( ((0<<i2cSTART)|                 // 禁止 START 信号（起始条件）
                           (0<<i2cSTOP )|(1<<i2cACKEN)|   // 禁止 STOP 信号（停止条件），使能 ACK 应答
) _  P0 a) b& h5 X' S; v                           (0<<i2cPOS  )|(0<<i2cRST  ) ));// 应答的位置＝当前字节，Ｉ２Ｃ模块不处于复位状态
& A* X7 {6 x: l9 A  I2CARH          = (u8)( ((1<<i2cCFG  )|                 // 地址模式配置＝软件必须配置该位（只能配置成 1）
0 K  s# r6 o4 D* L" ]) ]5 m                           (0<<i2cMODE )|                 // 寻址模式＝7 位从地址（对 10 位地址不响应）
: n) c! s- }, R) F4 f3 k9 U% ~                          cI2cOwnAddrH   ));              // 置Ｉ２Ｃ（从机）地址高位寄存器的数值
% {* z: }) w6 x2 Z/ L6 i//  I2CARL          = (u8)( cI2cOwnAddrL);                  // 置Ｉ２Ｃ（从机）地址低位寄存器的数值
  V% R/ j5 E$ v1 q. S  I2CICR          = (u8)( ((0<<i2cERRIE)|(0<<i2cEVTIE)|   // 禁止错误中断，禁止事件中断
4 U0 m( k* w4 Q9 f                           (0<<i2cBUFIE) ));              // 禁止缓冲中断
# q7 q, A% s( x0 T* F' i! ]: n, B#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
#endif                                                    // “PreCommI2cUseSingleMasterMode”
) X, h6 X3 X5 }* G, U7 _1 a- \( O#if defined(PreCommI2cUseSingleSlaveMode) || defined(PreCommI2cUseMultiSlaveMode)
0 v! U( |/ g0 K0 m2 a* _1 j. w                                                          // “Ｉ２Ｃ总线工作于从机方式”的条件编译
/*------------------------------------------------------------------------------------------------
: @* I, l4 ?* k( X  ], f“Ｉ２Ｃ总线工作于从机方式”的初始化操作。
------------------------------------------------------------------------------------------------*/
#if   (defined(_IAR_EW_AVR_))
  TWAR    =  cI2c0OwnAddr;                                // 置本器件的从机地址值
#if   (defined(PreMcuIs__AtMega48)  || defined(PreMcuIs__AtMega48A)  || \
2 t' r6 m, O+ }. N: C! B& z" {       defined(PreMcuIs__AtMega88)  || defined(PreMcuIs__AtMega88A)  || \
       defined(PreMcuIs__AtMega168) || defined(PreMcuIs__AtMega168A)    )
+ I! @& a- N0 M: H6 a: c  TWAMR   =  cI2c0OwnAddrMask;                            // 置本器件的从机地址屏蔽位值
#endif
  TWDR    =  0xFF;                                        // 默认数据字节内容 ＝ SDA 释放
5 _7 c& c6 D' ?- w- s2 G$ }  TWCR    =  (1<<TWEN)|                                   // 使能ＴＷＩ接口为Ｉ２Ｃ总线和释放ＴＷＩ引脚
& I2 o8 z: \: I4 X; b7 i) e$ W2 |6 Q             (0<<TWIE)|(0<<TWINT)|                        // 禁止ＴＷＩ中断
             (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|             // 目前对任何请求不发出 ACK 应答脉冲
             (0<<TWWC);                                   // 清零ＴＷＩ写冲突标志
8 ?2 K. k' Y5 g; S  D( M! h#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
" Q" S2 i" V8 I! f
& ^$ Y/ s9 S/ Y) Y' m$ s#elif (   defined(_IAR_EW_STM8_) \
2 q# c, {) @, T0 @$ {# b! f       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
% t) Q& ^+ j+ T3 Y/ v! `$ {#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
. e- h6 Q5 L+ a& P( y  I2C_Cmd(ENABLE);
6 }$ G/ {7 g' C9 G- |  I2C_Init(cI2c0BaudRate, cI2cOwnAddr, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, (cSysCpuClk / 1000000UL));
, d' {, u' Y6 n  I2C_ITConfig((I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
/ b: ?7 C% O$ c9 P6 h#else                                                     // “_USE_STM8_FWLIB_”
& [+ m$ X' J" v2 ^' U  I2cDeInit( );
. r3 l. j7 w, B! W; j/ C  I2CFR           = (u8)( (cSysCpuClk / 1000000UL));      // 置Ｉ２Ｃ频率寄存器的数值
* [2 a& m5 D4 q; b  I2CCCRH         = (u8)( ((0<<i2cDUTY )|                 // 快速模式下的占空比＝0：Tlow/Thigh＝2／1，1：Tlow/Thigh＝16／9。
                           (0<<i2cSFM  )|                 // 标准／快速模式选择位＝标准模式
+ u/ O: ^9 T5 U/ V                          cI2c0BrCcrS11H ));              // 置Ｉ２Ｃ比特率高位寄存器的数值
0 e) @$ r$ y0 Z% L* M3 [* `  I2CCCRL         = (u8)( cI2c0BrCcrS11L);                // 置Ｉ２Ｃ比特率低位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
. U, \8 W, x% [" @) f1 X//  I2CCR1         &= (u8)(~((1<<i2cEN   ) ));              // 禁止Ｉ２Ｃ模块，用以设置 I2CTRISER。注：只有禁用Ｉ２Ｃ模块时，才能设置。
# Q3 E+ Q* Z4 H- w  I2CTRISER       = (u8)( ((cSysCpuClk / 1000000UL) + 1));// 标准模式：最大上升时间＝1000ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
//  I2CTRISER       = (u8)( ((((cSysCpuClk / 1000000UL) * 3UL) / 10UL) + 1));
4 l3 g7 Q) i9 H" Z! R! B* \2 f. A//                                                          // 快速模式：最大上升时间＝300ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
0 i2 y% y6 `  Y5 a1 D, l1 X  I2CDR           = (u8)( 0xFF);                          // 默认数据字节内容 ＝ SDA 释放
5 r7 l' l0 E8 S  I2CCR1          = (u8)( ((1<<i2cEN   )|(1<<i2cGCEN )|   // 使能Ｉ２Ｃ模块，使能广播呼叫
+ m# s: z$ d* m0 j                           (0<<i2cCKTEN) ));              // 禁止时钟延展
3 ~5 x$ ?* \  [$ z8 R  `- i  I2CCR2          = (u8)( ((0<<i2cSTART)|                 // 禁止 START 信号（起始条件）
                           (0<<i2cSTOP )|(1<<i2cACKEN)|   // 禁止 STOP 信号（停止条件），使能 ACK 应答
                           (0<<i2cPOS  )|(0<<i2cRST  ) ));// 应答的位置＝当前字节，Ｉ２Ｃ模块不处于复位状态
  I2CARH          = (u8)( ((1<<i2cCFG  )|                 // 地址模式配置＝软件必须配置该位（只能配置成 1）
                           (0<<i2cMODE )|                 // 寻址模式＝7 位从地址（对 10 位地址不响应）
                          cI2cOwnAddrH   ));              // 置Ｉ２Ｃ（从机）地址高位寄存器的数值
9 [/ _7 }3 m; P  p. m  S! T- o  I2CARL          = (u8)( cI2cOwnAddrL);                  // 置Ｉ２Ｃ（从机）地址低位寄存器的数值
  I2CICR          = (u8)( ((0<<i2cERRIE)|(0<<i2cEVTIE)|   // 禁止错误中断，禁止事件中断
                           (0<<i2cBUFIE) ));              // 禁止缓冲中断
- s8 b1 }& k8 @#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
2 a! Y, ?% q4 ^9 d4 m. ]#endif                                                    // “PreMcuIs__......”
#endif                                                    // “PreCommI2cUse......SlaveMode”
5 G0 C3 m- ]3 a/*------------------------------------------------------------------------------------------------
; i. F4 x! w# T" i- ]6 w9 Q初始化各个标志位
------------------------------------------------------------------------------------------------*/
0 r3 ~) u4 g- Z  gbitI2c.Busy              =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
2 L8 m4 }+ L/ f  gbitI2c.RxOk              =  CLEAR;                     // 清除“接收数据缓冲区己更新”标志
4 U7 b+ t1 O% r/ N. |* a  gbitI2c.RxOvf             =  CLEAR;                     // 清除“接收数据缓冲区溢出”标志
1 l% E3 C1 _$ S, \  gbitI2c.Error             =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
: D8 [/ t$ Y4 `3 |$ L1 P5 {& W# u  gbitI2c.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志
0 ?* w3 e4 E( v: ^: I  gbitI2c.Rxd               =  CLEAR;                     // 清除“正在进行接收数据作业”标志
) E+ S* v5 I+ k$ l/ H7 _  gbitI2c.CallG             =  CLEAR;                     // 清除“响应广播地址”标志
  gbitI2c.OverS             =  CLEAR;                     // 清除“通讯任务时间超时”标志
6 q& J2 l+ |) f# H+ w( f* E- \#if defined(PreCommI2cUseSingleSlaveMode) || defined(PreCommI2cUseMultiSlaveMode)
: L; c& ]* X* t% M& M: i  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
0 p% N0 F6 ^, i$ W' _: e9 v, d#endif

  // 初始化Ｉ２Ｃ总线通讯收发数据处理变量
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
9 f# x2 a1 X4 z. T; `! R$ @  MemClearSram(pI2c, sizeof(CommI2cDataStru));
0 r% x2 U& i/ }: [6 f: p# j4 x9 h* o- g}
) u$ h' u: Z5 V$ [+ |
/*==========================================================================================================
+ V2 D# A9 Y, G5 ?3 o- ^函数名称：　　查询Ｉ２Ｃ总线通讯发送数据作业工作状态
函数功能：　　本函数用于检查Ｉ２Ｃ总线通讯发送数据作业工作状态的函数。
函数入口参数：没有
$ Q0 c* ^1 i* t! e9 ]函数返回值：　Ｉ２Ｃ总线收发器的工作状态，０（空闲状态）。
1 H! A9 ^8 n8 L" f6 M调用函数：　　１．
备注：        １．
==========================================================================================================*/
$ k6 ~9 x3 ^5 uunsigned char  CommI2cBusBusy (void)
{
#if   (defined(_IAR_EW_AVR_))
  O1 u% f$ r/ V& w( V  return (TWCR & (1<<TWIE));                              // 如果ＴＷＩ中断使能则收发器处于忙碌状态　
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

#elif (   defined(_IAR_EW_STM8_) \
2 j( }9 j9 C) ~# f2 |# c4 l       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
- D; d) v- y$ j( D3 Z#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始

4 S+ S$ n/ ?, G' S& g9 e+ [#else                                                     // “_USE_STM8_FWLIB_”
* s2 j1 Y' F/ V# H/ W: W: f0 w  return (I2CSR3 & (1<<i2cBSY  ));                        // 如果Ｉ２Ｃ总线忙则总线处于忙碌状态
#endif                                                    // “_USE_STM8_FWLIB_”
#else
" v  N. q  S8 N9 B! R. C2 \#error 错误：
#endif                                                    // “PreMcuIs__......”
& {  n3 }& i* i}
- S% G$ i# [- b3 I$ Y

#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
6 Y- Z: b6 b3 o
#elif (   defined(_IAR_EW_STM8_) \
& g. W/ X7 j3 D) {0 D+ U0 C& M( B. Q       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
: T! A( |9 |4 `" g& k; k% B{
#if ((cI2cTxBufSize < 256) && (cI2cRxBufSize < 256))
0 T! J6 q# [' E* i- l& n  register unsigned char    cnt;                          // ＵＳＡＲＴ每次发送数据个数计数器变量
/ O$ O9 y7 ]$ G#else
  register unsigned int     cnt;
#endif
  unsigned char             temp;                         // 临时变量
; M' v1 X% u! w  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  temp                      =  I2CSR2;                    // 取Ｉ２Ｃ状态寄存器２值
  if (temp & cI2cEvtSr2Mask)                              // 判断已屏蔽非状态位的Ｉ２Ｃ状态寄存器２值？
  {
* |* \. q' U. ]* {4 C( q    pI2c                    = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
0 ]! A% Z6 L+ ~/ z  b( X% {    switch (temp & cI2cEvtSr2Mask)                        // 判断已屏蔽非状态位的 TWI 状态寄存器状态位值？
* P! a# q8 P4 `$ e5 s9 T    {
      case cI2cAllArbLost:                                // 仲裁失败【I2CSR2】
, n8 `5 ]1 X( b; m4 E      {
        if (pI2c->ErrNum > cI2cErrorMax)                  // 检查通讯收发作业发生错误次数是否大于最大值？
) e# n  M- n7 n$ W7 v5 ^$ h" j5 _: L+ i        {
          gbitI2c.Error     =  SET;                       // 置“通讯收发作业发生错误”标志
          MFHI2cInnEventMem( );                           // 存储Ｉ２Ｃ总线的事件和状态存储器值
! I- Y4 a" ?* K  q8 u& W          MFHI2cIntEventOff( );                           // 禁止Ｉ２Ｃ总线事件中断
          MFHI2cBusNackStop( );                           // 发出 STOP 信号（结束条件），没有 ACK 脉冲
        }
. y0 m0 q; `) ~4 r5 P        else
        {
          pI2c->ErrNum++;                                 // Ｉ２Ｃ总线的通讯收发作业发生错误次数值＋１
          MFHI2cBusNackReps( );                           // 发出 START 或重复的 START 信号（起始条件），没有 ACK 脉冲
& u0 @( y3 C7 j, B2 W  g        }
        break;
( N& ?3 B3 L) X' [7 _      }
* W6 H+ r8 I8 A% r. N. G3 R$ l- a//      case cI2cMasterNack:                                // SLA 已发送，接收到 NOT ACK；或者数据已发送／接收到数据，接收到 NOT ACK／NOT ACK 已返回【I2CSR2】
( T& W3 i+ I4 K1 _! C//      case cI2cAllNoState:                                // 没有相关的状态信息； TWINT = "0"
//      case cI2cAllBusError:                               // 由于非法的 START 信号或 STOP 信号引起的总线错误
      default:
      {
- O' u8 \( r" V7 f  z9 T& l        gbitI2c.Error       =  SET;                       // 置“通讯收发作业发生错误”标志
3 b) ?  I, B$ h  I! ]+ X& e        MFHI2cInnEventMem( );                             // 存储Ｉ２Ｃ总线的事件和状态存储器值
        MFHI2cIntEventOff( );                             // 禁止Ｉ２Ｃ总线事件中断
' s, W' h; n9 K6 U        MFHI2cBusNackStop( );                             // 发出 STOP 信号（结束条件），没有 ACK 脉冲
8 z! f! u" C' f0 P/ g. D( X4 l      }
5 F5 [9 C5 Q$ h4 a" _    }
  }
  else                                                    // Ｉ２Ｃ总线没有错误
6 `& O) A( ^2 O* M+ g5 G+ M  {
    // 通过先读 I2CSR1，然后再读 I2CSR3，来清０地址已被发送（主模式）／地址匹配（从模式）标志
; C) V' v# d$ V: }/ ?, ~, t7 N4 f    temp                    =  I2CSR1;                    // 取Ｉ２Ｃ状态寄存器１值
; I+ i1 y; b' u' w7 e    if ((I2CSR3 & (u8)( (1<<i2cRXTX ))) == (u8)( (1<<i2cRXTX )))
* e' r8 N; l5 S! x% ]% f5 L; Y' o$ e5 |    {                                                     // 检查Ｉ２Ｃ总线是否为发送数据？
3 ~! w1 F0 d7 h# e  Q+ q      temp                 |= (u8)( BIT5);                // 是，
    }
& U* v, p4 P: S- j/ h- O+ h! Z    pI2c                    = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
    switch (temp)                                         // 判断Ｉ２Ｃ状态寄存器１＋Ｉ２Ｃ状态寄存器３值？
    {
      case cI2cAllStart:                                  // START 信号已发送
. C9 b) y8 ^1 v1 ]) s5 a- d      case cI2cAllRepStart:                               // 重复 START 信号已发送
7 ?7 r" `4 L, C* Q      {
        pI2c->TxCnt         =  0x00;                      // 每次发送数据计数器值清０
      }
2 h, ]- l3 u1 S7 ^/ O      case cI2cMtxAddrAck:                                // SLA+W 已发送，接收到 ACK
      {
//        if (temp == cI2cMtxAddrAck)
//        {
* n" ^) d$ a2 O8 \0 Q& n& d          MFHI2cIntEventOnn( );                           // 使能缓冲中断
//        }
4 _2 p) g8 S) P      }
5 n6 i' p9 t( ?      case cI2cMtxDataAck:                                // 数据已发送，接收到 ACK
& Q* E5 D: _8 ~      case cI2cMtxDataAckWait:                            // 数据已发送，接收到 ACK，且没有写新的数据到 I2CDR
      {
0 X' o$ u- G. U" F0 W$ t1 w6 w: s) e        cnt                 =  pI2c->TxCnt;               // 取Ｉ２Ｃ总线每次发送数据个数计数器变量
        if (cnt >= pI2c->TxSize)                          // 检查是否己完成发送通讯任务的全部数据？
        {                                                 // 是，在最后一个字节之后发出 STOP 信号
+ L) R8 C# A* A4 a+ w          if (gbitI2c.Rxd == SET)                         // 检查是否为读取Ｉ２Ｃ总线数据？
! z; q: _% k# e* E- G/ P2 Y          {
7 d1 V8 d5 U0 e6 Z6 A8 {6 [            MFHI2cBusNackReps( );                         // 发出重复 START 信号（重新开始条件），没有 ACK 脉冲
            pI2c->TxBuf[0] |= (u8)( BIT0);                // 设置数据传送方向为接收数据
0 m/ T% j' z+ r2 U5 T            // 通过先读 I2CSR1，然后写入 I2CDR，来清０发送数据寄存器空，字节发送结束，起始位（主模式）标志
//            MFHI2cIntEventClr( );                         // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
            I2CDR           =  pI2c->TxBuf[0];            // 从发送缓冲区中将发送数据写入到Ｉ２Ｃ总线
            MFHI2cIntEventOff( );                         // 禁止Ｉ２Ｃ总线事件中断
            MFHI2cIntEventOne( );                         // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
2 H$ \" ?. E" B/ V7 ?' n) b          }
9 ?; k+ E9 F& g          else
) R3 s8 {9 m3 E' l1 C& I          {
( P5 O+ H3 M6 ~/ c            gbitI2c.Busy    =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
            gbitI2c.OverS   =  CLEAR;                     // 清除“通讯任务时间超时”标志
            MFHI2cIntEventOff( );                         // 禁止Ｉ２Ｃ总线事件中断
( Q, `) e0 y/ S1 g+ p' g$ L            MFHI2cBusNackStop( );                         // 发出 STOP 信号（结束条件），没有 ACK 脉冲
6 b1 Q7 I$ o4 Q6 H$ I, \          }
        }
        else
" _! `" s+ w3 w6 t  c" H        {
          // 通过先读 I2CSR1，然后写入 I2CDR，来清０发送数据寄存器空，字节发送结束，起始位（主模式）标志
+ b( U4 @( y  {9 }, d//          MFHI2cIntEventClr( );                           // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
          I2CDR             =  pI2c->TxBuf[cnt];          // 从发送缓冲区中将发送数据写入到Ｉ２Ｃ总线
          cnt++;                                          // Ｉ２Ｃ总线每次发送数据个数计数器＋１
: Q$ J$ [( f1 L0 T: [% M- n: N          pI2c->TxCnt       =  cnt;                       // 返回Ｉ２Ｃ总线每次发送数据个数计数器值
        }
4 P6 e4 K4 j8 M3 @1 E        break;
      }
      case cI2cMrxDataAck:                                // 接收到数据，ACK 已返回
      case cI2cMrxDataAckWait:                            // 接收到数据，ACK 已返回，且 I2CDR 中的数据没有被读取
4 \: G) q% k4 ]      {
& Y0 H6 w5 Z! f+ [  V$ _% G' w% d        cnt                 =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
: S$ A0 a, k( Y; J- n        // 通过先读 I2CSR1，然后读取 I2CDR，来清０接收数据寄存器非空标志
//        MFHI2cIntEventClr( );                             // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
        pI2c->RxBuf[cnt]    =  I2CDR;                     // 复制Ｉ２Ｃ总线读取到的字节到接收数据缓冲区中
1 e, D0 y! b. F1 a        cnt++;                                            // Ｉ２Ｃ总线每次接收数据个数计数器＋１
        pI2c->RxCnt         =  cnt;                       // 返回Ｉ２Ｃ总线每次接收数据个数计数器值
        cnt                 =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
9 Y: F; I% z0 D, N        if      (cnt >= pI2c->RxSize)                     // 检查是否完成需要读取的数据长度？
0 l$ s, u7 D( x        {
          gbitI2c.Busy      =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
# m' e. a) x3 K/ U5 A* `          gbitI2c.OverS     =  CLEAR;                     // 清除“通讯任务时间超时”标志
# |) {7 V7 t# p: I          MFHI2cIntEventOff( );                           // 禁止Ｉ２Ｃ总线事件中断
) u* y" O8 @2 L  f/ h6 _8 K( C        }
& R& H9 I5 B. M        else if (cnt >= (pI2c->RxSize - 1))               // 在最后一个字节数据接收之后发出 NOT ACK
        {
+ \2 m! g& A3 n- M. T5 y          MFHI2cBusRdatNack( );                           // 在接收之后发出 NOT ACK
          MFHI2cBusNackStop( );                           // 发出 STOP 信号（结束条件），没有 ACK 脉冲
* C" |, [; @9 l7 y9 |! H        }
        else
        {
2 N1 Y0 i" c6 ^  b! L5 Z          MFHI2cBusRdataAck( );                           // 在接收之后发出 ACK 脉冲
7 O( I7 ^1 ]9 t# T        }
0 m8 e! W* Q5 i5 U9 _0 n: p        break;
0 ]# {* E' B- l; M, {! D1 h/ x      }
9 q+ ]* Y: {! i4 C% J( V      case cI2cMrxAddrAck:                                // SLA+R 已发送，接收到 ACK
      {
        MFHI2cBusRdataAck( );                             // 在接收之后发出 ACK 脉冲
, K& s: L3 @# `4 S. Y% U        MFHI2cIntEventOnn( );                             // 使能缓冲中断
        break;
      }
; h) ?8 Q, b% r, r$ _! r$ ~      default:
% y* ^9 b  E' s" \% z: x* V" e$ S      {
        gbitI2c.Error       =  SET;                       // 置“通讯收发作业发生错误”标志
        MFHI2cInnEventMem( );                             // 存储Ｉ２Ｃ总线的事件和状态存储器值
1 e: B7 @2 Z  x; A        MFHI2cIntEventOff( );                             // 禁止Ｉ２Ｃ总线事件中断
        MFHI2cBusNackStop( );                             // 发出 STOP 信号（结束条件），没有 ACK 脉冲
      }
( J3 Y' F2 m' _' z) X, n    }
$ ?3 y1 b8 n1 K* f$ p  }

  (void)temp;                                             // 用以阻止编译器产生［temp］未使用的警告消息
+ k7 U3 ]( Q) ]  T2 l) H  INTERRUPT_RETURN( );
}
! c1 t! M5 [' m0 g. T9 M9 N) \( K#else
#error 错误：
$ n9 {6 x) I/ Y: x#endif                                                    // “PreMcuIs__......”
9 `) X7 B8 p/ ?- \8 V) C




  V8 h& C8 `% e/ q7 v: l#endif                                                    // “Ｉ２Ｃ总线工作于单主机方式”条件编译结束

/*==========================================================================================================
　　　　　　　　　　　　　　　各类字符化常数和硬件设计相关的输入／输出引脚定义
1 a. v; s; w- E; v- r, V- k% K==========================================================================================================*/
#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ接口的输入／输出引脚定义：
注：下列这些定义与硬件设计相关，如需改变控制的输入／输出引脚仅在此重新定义即可。
& `2 y$ v/ m" E: }$ q0－－A，1－－B，2－－C，3－－D，4－－E，5－－F，6－－G，7－－H，8－－I，9－－J。
------------------------------------------------------------------------------------------------*/
, `9 h' d7 d1 X8 r+ R9 ^! h#if   (defined(PreMcuIs__AtMega64)  || defined(PreMcuIs__AtMega64A)  || \
       defined(PreMcuIs__AtMega128) || defined(PreMcuIs__AtMega128A) || \
       defined(PreMcuIs__AtMega162) || defined(PreMcuIs__AtMega162A)    )
" o5 |/ n  Q; x+ y" Y
#elif (defined(PreMcuIs__STM8S207R6) || defined(PreMcuIs__STM8S208R6)  || \
       defined(PreMcuIs__STM8S207R8) || defined(PreMcuIs__STM8S208R8)  || \
" m* M6 {6 P4 u       defined(PreMcuIs__STM8S207RB) || defined(PreMcuIs__STM8S208RB)     )
9 Q) ~+ r0 q" u) B* x3 p#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
2 d5 V' P5 K' g" O- l#define cI2c0Gpio             GPIOE
#define cI2c0SclPinBit        GPIO_PIN_1
#define cI2c0SdaPinBit        GPIO_PIN_2
#else                                                     // “_USE_STM8_FWLIB_”
$ D8 m# }8 X7 L6 L#define cDdrI2c0Scl           P4DDR                       // Ｉ２Ｃ０时钟引脚的数据方向寄存器
& c  S$ }9 n" d* U#define cPurI2c0Scl           P4PUR                       // Ｉ２Ｃ０时钟引脚的上拉电阻寄存器（控制寄存器１）
5 |3 ]7 E# M6 j) Q" s( X#define cCirI2c0Scl           P4CIR                       // Ｉ２Ｃ０时钟引脚的控制中断寄存器（控制寄存器２）
" L. f: x# u1 w5 ?: M# M; b! _#define cOdrI2c0Scl           P4ODR                       // Ｉ２Ｃ０时钟引脚的输出数据寄存器
#define cIdrI2c0Scl           P4IDR                       // Ｉ２Ｃ０时钟引脚的输入数据寄存器
#define cPidI2c0Scl           PI41                        // Ｉ２Ｃ０时钟引脚的引脚输入
#define cPodI2c0Scl           PO41                        // Ｉ２Ｃ０时钟引脚的引脚输出
#define cBitI2c0Scl           BIT1                        // Ｉ２Ｃ０时钟引脚的引脚数字索引
& U- L5 ]* R6 w, o#define cDdrI2c0Sda           P4DDR                       // Ｉ２Ｃ０数据引脚的数据方向寄存器
2 u8 [4 U' m) V7 V" R3 h5 O#define cPurI2c0Sda           P4PUR                       // Ｉ２Ｃ０数据引脚的上拉电阻寄存器（控制寄存器１）
- Q, E3 _  H% ?0 \" P#define cCirI2c0Sda           P4CIR                       // Ｉ２Ｃ０数据引脚的控制中断寄存器（控制寄存器２）
. N' M8 M3 F! e8 C#define cOdrI2c0Sda           P4ODR                       // Ｉ２Ｃ０数据引脚的输出数据寄存器
, u2 L- D6 n( H#define cIdrI2c0Sda           P4IDR                       // Ｉ２Ｃ０数据引脚的输入数据寄存器
#define cPidI2c0Sda           PI42                        // Ｉ２Ｃ０数据引脚的引脚输入
* N: g1 c, `1 d7 {+ u#define cPodI2c0Sda           PO42                        // Ｉ２Ｃ０数据引脚的引脚输出
' L1 s/ E/ @, g+ l9 c#define cBitI2c0Sda           BIT2                        // Ｉ２Ｃ０数据引脚的引脚数字索引
#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：没有定义Ｉ２Ｃ接口的输入引脚端口！！！
#endif                                                    // “PreMcuIs__......”

/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线收发数据缓冲区大小字符化定义:
------------------------------------------------------------------------------------------------*/
, A* s0 h/ v1 e; c& l#define cI2c0BufSize          0x22                        // Ｉ２Ｃ总线接收和发送数据缓冲区大小
#endif                                                    // “PreGlobalCompilerHardware”

5 ]4 M" h/ Q4 t5 O#ifdef PreCommI2cUseMultiSlaveMode                        // “Ｉ２Ｃ总线工作于多从机方式”条件编译结束
#define cI2c0RxBufSize        (cI2c0BufSize + 1)          // Ｉ２Ｃ总线接收数据缓冲区大小
#define cI2c0TxBufSize        (cI2c0BufSize + 2)          // Ｉ２Ｃ总线发送数据缓冲区大小
#else
#define cI2c0RxBufSize        (cI2c0BufSize + 0)          // Ｉ２Ｃ总线接收数据缓冲区大小
#define cI2c0TxBufSize        (cI2c0BufSize + 1)          // Ｉ２Ｃ总线发送数据缓冲区大小
#endif
, @3 k9 f# O# W, U' u1 Q$ Z
7 f2 ~( v" [0 S7 r3 M#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
#define cI2cErrorMax          0x10                        // Ｉ２Ｃ总线通讯收发作业最大发生错误次数值
4 x1 Z! l4 {" c  j, h' y% D#define cI2cOverSec           0x08                        // 通讯任务超时时间的最大秒数值（８ｓ）
; ?2 s" U  M/ t- Y" N
#define cI2c0AddrNum          1                           // Ｉ２Ｃ总线目标设备地址的字节数
# `; o) P: ?6 {. w" }#endif                                                    // “PreGlobalCompilerHardware”
. d2 e2 s8 S: P- ?/ \5 x4 H/ a
8 _4 c! F/ Z" p, M! V$ D( }, \! E#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
! A  n/ A9 w& l/*------------------------------------------------------------------------------------------------
ＴＷＩ接口的Ｉ２Ｃ总线的比特率常数定义：
+ o. G0 k) j# v8 w) X7 I下面以单片机的时钟＝ 11.0592 MHz，Ｉ２Ｃ总线的比特率≈307K(Bit)为依据进行定义。
# c( U2 ~; s1 s6 {2 g' S+ Z                          单片机的时钟
比特率计算公式 = ─────────────────
                                             TWPS
8 H7 x1 w7 L, `9 X2 @- @. E                 １６＋2×（I2CTWI_BR_BR）×４
& r+ A4 C" ^3 G. |5 f0 a------------------------------------------------------------------------------------------------*/
& }0 ]5 ^: U( V0 Q- r. {#define cI2c0BaudRate         10000UL                     // Ｉ２Ｃ０波特率(bps)【标准模式】
; s: z; T; ~6 U+ ?#define cI2c0FsmMul           80UL                        // 快速模式／标准模式的倍数
#if   (defined(PreMcuIs__AtMega64)  || defined(PreMcuIs__AtMega64A)  || \
" |% D% S; }& I% `4 K       defined(PreMcuIs__AtMega128) || defined(PreMcuIs__AtMega128A) || \
0 A$ Y# o* Z/ J0 }6 ]9 ^! W7 Y# Y       defined(PreMcuIs__AtMega162) || defined(PreMcuIs__AtMega162A)    )
#define cI2c0BrBr             0x0A                        // TWI 比特率寄存器值（TWI 在主机模式时，TWBR 值应该不小于10）
  V" j" A+ f5 R) u+ A#define cI2c0BrSr             0x00                        // TWI 状态寄存器中（TWI 预分频位（TWPS）的数值）
#elif (defined(PreMcuIs__STM8S207R6) || defined(PreMcuIs__STM8S208R6)  || \
( f3 g0 X3 L# Y5 D8 ~5 o2 F       defined(PreMcuIs__STM8S207R8) || defined(PreMcuIs__STM8S208R8)  || \
* n. y! ?. U4 q3 v; r" Q       defined(PreMcuIs__STM8S207RB) || defined(PreMcuIs__STM8S208RB)     )
// 标准模式：占空比＝Tlow/Thigh＝1／1
: J% i6 Z  ]# ]% o3 X#define cI2c0BrCcrS11         (cSysCpuClk / ( 2UL * cI2c0BaudRate))
#define cI2c0BrCcrS11L        ((cI2c0BrCcrS11     ) & 0x00FF)
#define cI2c0BrCcrS11H        ((cI2c0BrCcrS11 >> 8) & 0x00FF)
: a2 T/ |- E0 L$ b) T6 \// 快速模式：占空比＝Tlow/Thigh＝2／1
" t5 l8 Y3 z2 e#define cI2c0BrCcrF21         (cSysCpuClk / ( 3UL * cI2c0BaudRate * cI2c0FsmMul))
#define cI2c0BrCcrF21L        ((cI2c0BrCcrF21     ) & 0x00FF)
+ s5 R$ P: g: M! |" H: A9 x! V4 E#define cI2c0BrCcrF21H        ((cI2c0BrCcrF21 >> 8) & 0x00FF)
// 快速模式：占空比＝Tlow/Thigh＝16／9
#define cI2c0BrCcrF69         (cSysCpuClk / (25UL * cI2c0BaudRate * cI2c0FsmMul))
#define cI2c0BrCcrF69L        ((cI2c0BrCcrF69     ) & 0x00FF)
#define cI2c0BrCcrF69H        ((cI2c0BrCcrF69 >> 8) & 0x00FF)
6 H+ s7 K* m: K1 Q#else
#error 错误：没有定义Ｉ２Ｃ接口的比特率常数！！！
1 c2 O) ]2 L1 }6 Z#endif                                                    // “PreMcuIs__......”
#endif                                                    // “Ｉ２Ｃ总线工作于单主机方式”条件编译结束

/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线工作于从机方式时，本器件的从机地址定义:
------------------------------------------------------------------------------------------------*/
9 [" _3 O% s& `+ Q#define cI2cOwnAddr           ((u8)( 0x10))               // 本器件的从机自身地址值
#define cI2cOwnAddrL          ((u8)( ((cI2cOwnAddr     ) & 0x00FF)))
#define cI2cOwnAddrH          ((u8)( ((cI2cOwnAddr >> 8) & 0x00FF)))
#if   (defined(PreMcuIs__AtMega48)  || defined(PreMcuIs__AtMega48A)  || \
       defined(PreMcuIs__AtMega88)  || defined(PreMcuIs__AtMega88A)  || \
# L! L" o' n0 c       defined(PreMcuIs__AtMega168) || defined(PreMcuIs__AtMega168A)    )
#define cI2cOwnAddrMask       ((u8)( 0x00))               // 本器件的从机自身地址屏蔽位值
#endif

9 R5 O, a% E4 D4 Q0 T#define cI2cGenAddr           ((u8)( 0x00))               // 广播方式地址值
; J9 K, @/ ^6 b$ T3 n  N1 [# F, z
/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线的状态码定义：
------------------------------------------------------------------------------------------------*/
#if   (defined(_IAR_EW_AVR_))
# l0 ?* F# D# ]#define cI2cTwsrMask          ((u8)( 0xF8))               // TWI 状态寄存器的状态位屏蔽值
; G' E, \( c* t  y4 a* \3 ]& [
#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
  K: Q' P" I6 X& x// Ｉ２Ｃ总线主机所有模式的通用状态码
#define cI2cAllStart          ((u8)( 0x08))               // START 信号已发送
#define cI2cAllRepStart       ((u8)( 0x10))               // 重复 START 信号已发送
3 U0 Y8 P3 s" q* c' d! M# m#define cI2cAllArbLost        ((u8)( 0x38))               // SLA+W 或数据的仲裁失败
6 ?" \4 K4 z" ^4 v4 ^
  @! @& {4 g" R; s. a; H5 J; N// Ｉ２Ｃ总线主机发送模式的状态码
#define cI2cMtxAddrAck        ((u8)( 0x18))               // SLA+W 已发送，接收到 ACK
#define cI2cMtxAddrNack       ((u8)( 0x20))               // SLA+W 已发送，接收到 NOT ACK
$ s/ g% H, {- F2 c; \5 }. t( O#define cI2cMtxDataAck        ((u8)( 0x28))               // 数据已发送，接收到 ACK
#define cI2cMtxDataNack       ((u8)( 0x30))               // 数据已发送，接收到 NOT ACK
6 U$ u- ]0 t" W2 q) ^# s( \% m
3 i0 Z: g! I# S6 t$ P// Ｉ２Ｃ总线主机接收模式的状态码
#define cI2cMrxAddrAck        ((u8)( 0x40))               // SLA+R 已发送，接收到 ACK
#define cI2cMrxAddrNack       ((u8)( 0x48))               // SLA+R 已发送，接收到 NOT ACK
#define cI2cMrxDataAck        ((u8)( 0x50))               // 接收到数据，ACK 已返回
5 x: m0 r, k3 Q) Z7 O; q#define cI2cMrxDataNack       ((u8)( 0x58))               // 接收到数据，NOT ACK 已返回
3 x; o9 s, Y/ h3 ]9 f#endif                                                    // “PreCommI2cUseSingleMasterMode”

#if defined(PreCommI2cUseSingleSlaveMode) || defined(PreCommI2cUseMultiSlaveMode)
                                                          // “Ｉ２Ｃ总线工作于从机方式”的条件编译
// Ｉ２Ｃ总线从机发送模式的状态码
#define cI2cStxAddrAck        ((u8)( 0xA8))               // 自己的 SLA+R 已经被接收，ACK 已返回
#define cI2cStxAddrAckLost    ((u8)( 0xB0))               // SLA+R/W 作为主机的仲裁失败；自己的 SLA+R 已经被接收，ACK 已返回
#define cI2cStxDataAck        ((u8)( 0xB8))               // TWDR 里的数据字节已经发送，接收到 ACK
#define cI2cStxDataNack       ((u8)( 0xC0))               // TWDR 里的数据字节已经发送，接收到 NOT ACK
4 b/ I5 Q6 m/ U5 L, }. |9 M/ P! O#define cI2cStxDataAckLast    ((u8)( 0xC8))               // TWDR 的最后一字节数据已经发送(TWEA = "0")，接收到 ACK
) y1 r; {4 b4 b/ h- _! j( u9 U! j% f
#define cI2cStxAddrAck        ((u8)( 0xA8))               // 自己的 SLA+R 已经被接收，ACK 已返回
) U7 X  a8 n9 ?4 S2 X# y  N  ?! [  c! G#define cI2cStxAddrAckLost    ((u8)( 0xB0))               // SLA+R/W 作为主机的仲裁失败；自己的 SLA+R 已经被接收，ACK 已返回
#define cI2cStxDataAck        ((u8)( 0xB8))               // TWDR 里的数据字节已经发送，接收到 ACK
#define cI2cStxDataNack       ((u8)( 0xC0))               // TWDR 里的数据字节已经发送，接收到 NOT ACK
#define cI2cStxDataAckLast    ((u8)( 0xC8))               // TWDR 的最后一字节数据已经发送(TWEA = "0")，接收到 ACK

' d* ]/ ]) A1 ~% U# ~// Ｉ２Ｃ总线从机接收模式的状态码
; ]2 w, y7 K3 L* Z' U$ c6 G( k3 I0 S#define IcI2cSrxAddrAck       ((u8)( 0x60))               // 自己的 SLA+W 已经被接收，ACK 已返回
#define cI2cSrxAddrAckLost    ((u8)( 0x68))               // SLA+R/W 作为主机的仲裁失败；自己的 SLA+W 已经被接收，ACK 已返回
" |' R6 ?+ L3 D' ~( I. c#define cI2cSrxGenaAck        ((u8)( 0x70))               // 接收到广播地址，ACK 已返回
#define cI2cSrxGenaAckLost    ((u8)( 0x78))               // SLA+R/W 作为主机的仲裁失败；接收到广播地址，ACK 已返回
#define cI2cSrxDataAck        ((u8)( 0x80))               // 以前以自己的 SLA+W 被寻址；数据已经被接收，ACK 已返回
5 A# A- e0 G- O#define cI2cSrxDataNack       ((u8)( 0x88))               // 以前以自己的 SLA+W 被寻址；数据已经被接收，NOT ACK 已返回
' Y' I$ s" }2 V#define cI2cSrxGendAck        ((u8)( 0x90))               // 以前以广播方式被寻址；数据已经被接收，ACK 已返回
#define cI2cSrxGendNack       ((u8)( 0x98))               // 以前以广播方式被寻址；数据已经被接收，NOT ACK 已返回
#define cI2cSrxStopRestart    ((u8)( 0xA0))               // 在以从机方式工作时接收到 STOP 信号或重复 START 信号
#endif                                                    // “PreCommI2cUse......SlaveMode”
9 A0 E- p4 P8 x0 r5 N
// Ｉ２Ｃ总线其它的状态码
! n" e1 Y' l5 h2 k#define cI2cAllNoState        ((u8)( 0xF8))               // 没有相关的状态信息； TWINT = "0"
3 t2 ^! F) m- e#define cI2cAllBusError       ((u8)( 0x00))               // 由于非法的 START 信号或 STOP 信号引起的总线错误
/ d' Y8 h6 x, H) Y#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

#elif (   defined(_IAR_EW_STM8_) \
+ m- O: i3 y0 _" f/ f       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
# M9 t/ M6 V0 r, b7 p#define cI2cEventMask         ((u8)( b11111111))          // Ｉ２Ｃ总线状态寄存器的状态位屏蔽值【I2CSR3(i2cRXTX) | I2CSR1】
#define cI2cEvtSr1Mask        ((u8)( b11011111))          // Ｉ２Ｃ状态寄存器１的状态位屏蔽值
#define cI2cEvtSr2Mask        ((u8)( b00101111))          // Ｉ２Ｃ状态寄存器２的状态位屏蔽值

6 c% R. b) @# g0 ]3 R' X+ T& J#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
$ @' w( O2 }% p# [" {6 [- s// Ｉ２Ｃ总线主机所有模式的通用状态码
1 \6 w0 b) _( c& I#define cI2cAllStart          ((u8)( b00000001))          // START 信号已发送【I2CSR1】
  O( L! X. ?' O4 k' G7 P4 f#define cI2cAllRepStart       ((u8)( b00000101))          // 重复 START 信号已发送【I2CSR1】
#define cI2cAllArbLost        ((u8)( b00000010))          // 仲裁失败【I2CSR2】

// Ｉ２Ｃ总线主机发送模式的状态码
9 O& L' j! _: r4 {; L( d& u#define cI2cMtxAddrAck        ((u8)( b10100010))          // SLA+W 已发送，接收到 ACK【I2CSR1】
#define cI2cMtxAddrNack       ((u8)( b10100010))          // SLA+W 已发送，接收到 NOT ACK
#define cI2cMtxDataAck        ((u8)( b10100000))          // 数据已发送，接收到 ACK（只有当收到 ACK ，i2cDRE 才会置 1）【I2CSR1】
9 A* e; s& J/ |* }#define cI2cMtxDataAckWait    ((u8)( b10100100))          // 数据已发送，接收到 ACK，且没有写入新的数据到 I2CDR 【I2CSR1】
+ M' Q9 P" [3 P2 c' R) f( H& W#define cI2cMtxDataNack       ((u8)( b10100000))          // 数据已发送，接收到 NOT ACK

. V+ Z+ e# r, G/ P5 K* F" o0 V: W; ^5 Y// Ｉ２Ｃ总线主机接收模式的状态码
#define cI2cMrxAddrAck        ((u8)( b00000010))          // SLA+R 已发送，接收到 ACK【I2CSR1】
#define cI2cMrxAddrNack       ((u8)( b00000010))          // SLA+R 已发送，接收到 NOT ACK
#define cI2cMrxDataAck        ((u8)( b01000000))          // 接收到数据，ACK 已返回【I2CSR1】
2 W0 r8 N; Y% A#define cI2cMrxDataAckWait    ((u8)( b01000100))          // 接收到数据，ACK 已返回，且 I2CDR 中的数据没有被读取【I2CSR1】
8 o) ]4 P+ |1 x+ |, S#define cI2cMrxDataNack       ((u8)( b01000000))          // 接收到数据，NOT ACK 已返回
+ P" }, |0 j# Q7 q& s
#define cI2cMasterNack        ((u8)( b00000100))          // SLA 已发送，接收到 NOT ACK；或者数据已发送／接收到数据，接收到 NOT ACK／NOT ACK 已返回【I2CSR2】
#endif                                                    // “PreCommI2cUseSingleMasterMode”
& k/ T8 j, T2 y! x! \  V* W
- R+ S8 q: z* t) a# w) l#if defined(PreCommI2cUseSingleSlaveMode) || defined(PreCommI2cUseMultiSlaveMode)
                                                          // “Ｉ２Ｃ总线工作于从机方式”的条件编译
// Ｉ２Ｃ总线从机发送模式的状态码
, y/ o: ?- G) u& L8 o#define cI2cStxAddrAck        ((u16)( 0xA8))              // 自己的 SLA+R 已经被接收，ACK 已返回
. M) o7 N" \* p2 |- a  y#define cI2cStxAddrAckLost    ((u16)( 0xB0))              // SLA+R/W 作为主机的仲裁失败；自己的 SLA+R 已经被接收，ACK 已返回
* }6 `% a1 C  c$ h#define cI2cStxDataAck        ((u16)( 0xB8))              // TWDR 里的数据字节已经发送，接收到 ACK
8 Z0 P6 e  ]6 C. N2 G; y- T#define cI2cStxDataNack       ((u16)( 0xC0))              // TWDR 里的数据字节已经发送，接收到 NOT ACK
$ J1 A- `6 j! O) J- N& y# K! U, I! P#define cI2cStxDataAckLast    ((u16)( 0xC8))              // TWDR 的最后一字节数据已经发送(TWEA = "0")，接收到 ACK
: a+ q+ [8 e! w0 O# x( B. p" U7 L
9 A# `7 i& H) h: K#define cI2cStxAddrAck        ((u16)( 0xA8))              // 自己的 SLA+R 已经被接收，ACK 已返回
#define cI2cStxAddrAckLost    ((u16)( 0xB0))              // SLA+R/W 作为主机的仲裁失败；自己的 SLA+R 已经被接收，ACK 已返回
#define cI2cStxDataAck        ((u16)( 0xB8))              // TWDR 里的数据字节已经发送，接收到 ACK
#define cI2cStxDataNack       ((u16)( 0xC0))              // TWDR 里的数据字节已经发送，接收到 NOT ACK
4 Y: G. D* E: o" m- ]* W#define cI2cStxDataAckLast    ((u16)( 0xC8))              // TWDR 的最后一字节数据已经发送(TWEA = "0")，接收到 ACK

8 x- D4 @4 z2 u4 H// Ｉ２Ｃ总线从机接收模式的状态码
#define IcI2cSrxAddrAck       ((u16)( 0x60))              // 自己的 SLA+W 已经被接收，ACK 已返回
#define cI2cSrxAddrAckLost    ((u16)( 0x68))              // SLA+R/W 作为主机的仲裁失败；自己的 SLA+W 已经被接收，ACK 已返回
#define cI2cSrxGenaAck        ((u16)( 0x70))              // 接收到广播地址，ACK 已返回
3 l6 b4 s: T, |8 f2 t( I' n3 y#define cI2cSrxGenaAckLost    ((u16)( 0x78))              // SLA+R/W 作为主机的仲裁失败；接收到广播地址，ACK 已返回
# R, J; {. Y# I+ I- r#define cI2cSrxDataAck        ((u16)( 0x80))              // 以前以自己的 SLA+W 被寻址；数据已经被接收，ACK 已返回
" ]4 p5 R2 u% ^+ K2 B2 K! F6 V#define cI2cSrxDataNack       ((u16)( 0x88))              // 以前以自己的 SLA+W 被寻址；数据已经被接收，NOT ACK 已返回
#define cI2cSrxGendAck        ((u16)( 0x90))              // 以前以广播方式被寻址；数据已经被接收，ACK 已返回
/ f9 r9 J2 ]  C# ~4 Z2 g, {9 ^6 e#define cI2cSrxGendNack       ((u16)( 0x98))              // 以前以广播方式被寻址；数据已经被接收，NOT ACK 已返回
#define cI2cSrxStopRestart    ((u16)( 0xA0))              // 在以从机方式工作时接收到 STOP 信号或重复 START 信号
#endif                                                    // “PreCommI2cUse......SlaveMode”
8 e( O( n2 H! W2 B/ b; Z! t  @. h
// Ｉ２Ｃ总线其它的状态码
#define cI2cAllNoState        ((u8)( b00000000))          // 没有相关的状态信息； TWINT = "0"
#define cI2cAllBusError       ((u8)( b00000001))          // 由于非法的 START 信号或 STOP 信号引起的总线错误【I2CSR2】
! F) G  C& V& t# `, O) @#else
7 {& b7 E& S, b" T#error 错误：
#endif                                                    // “PreMcuIs__......”
2 m. d! D* P+ M$ @  j

. v4 o, |8 O3 y, W7 x3 f% b; W
/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　全局变量数据结构类型定义
) n# v( E& K; I: n==========================================================================================================*/
/ y$ H2 i) ~6 M) e3 L* P" i/*------------------------------------------------------------------------------------------------
6 e1 O/ G, i! N; Y; Z: ?: \; s/ XＩ２Ｃ总线通讯处理消息任务标志的全局数据结构类型定义：
------------------------------------------------------------------------------------------------*/
#define CommI2c0FlagDefaults                              \
! `* F6 ~) g( m3 R+ M                           {  CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
" L8 r  n- X: P$ k* ]3 R                              0  }                        // Ｉ２Ｃ０消息任务标志变量的默认初始化值
typedef struct
{
! A' f) J# y6 u  unsigned char Busy        : 1;                          // Ｉ２Ｃ总线〖忙〗
  unsigned char RxOk        : 1;                          // 接收数据缓冲区己更新
  unsigned char RxOvf       : 1;                          // 接收数据缓冲区溢出
  unsigned char Error       : 1;                          // 通讯收发作业发生错误
. Z9 V) ^3 s2 Y4 q: P  D1 N  unsigned char Txd         : 1;                          // 正在进行发送数据作业
  unsigned char Rxd         : 1;                          // 正在进行接收数据作业
  unsigned char CallG       : 1;                          // 响应广播地址
  unsigned char OverS       : 1;                          // 通讯任务时间超时
$ u; `0 k$ K4 X( H} CommI2c0FlagBits;

% \4 K- O' i" W* p, s/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ通讯收发数据处理的全局数据结构类型定义：
------------------------------------------------------------------------------------------------*/
# V9 d. p4 t$ a# F# ~typedef struct
5 E$ O2 v8 j, D; i6 L* M{
  unsigned char             TxSize                      ; // 每次发送数据个数大小
. o* E2 R+ T# |7 \  unsigned char             TxCnt                       ; // 每次发送数据个数计数器
//  unsigned char             Object                      ; // 每次发送数据的目标设备地址
//  const unsigned char       *pTxData                    ; // 每次发送数据的地址指针
  unsigned char             TxBuf[cI2c0RxBufSize]       ; // 每次发送数据缓冲区
; i5 D9 i- _2 W+ `4 x6 ]5 f& @  E1 K
  unsigned char             RxSize                      ; // 每次接收数据个数大小
4 H- l* n) w; J' ~$ P& a  unsigned char             RxCnt                       ; // 每次接收数据个数计数器
& u: r9 \. f6 `* t' x  unsigned char             RxBuf[cI2c0TxBufSize]       ; // 每次接收数据缓冲区

  unsigned char             OverS                       ; // 通讯任务时间超时的计时秒变量
: ~+ l) E7 G$ s6 f( L4 v9 l  unsigned char             Cycle                       ; // 重新启动通讯收发作业圈数
#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
- r* k1 o) ]+ `5 ~9 \$ s  unsigned char             ErrNum                      ; // 通讯收发作业发生错误次数
2 R1 s3 Q2 b; K* ^/ H/ h) G7 p#endif                                                    // “PreCommI2cUseSingleMasterMode”
3 L" Z% U. A; v} CommI2c0DataStru;


4 V# K* a0 f( Q; R
/*==========================================================================================================
7 |, D. T7 g" a+ J　　　　　　　　　　　　　　　　　　　　　　　　全局常量声明
==========================================================================================================*/

3 C% O1 p  j! _9 w# s6 Z; u

/*==========================================================================================================
* b9 w5 O8 x8 [! k6 H9 y　　　　　　　　　　　　　　　　　　　　　　　　全局变量声明
4 A  {5 ?/ \9 U: W7 M- b1 q; Y& L==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线通讯处理消息任务标志的全局变量声明：
------------------------------------------------------------------------------------------------*/
/ Q, x4 |; Q1 ^2 Qextern bdata CommI2c0FlagBits      gbitI2c0;

5 s7 ~0 N4 G2 b" Z/*------------------------------------------------------------------------------------------------
+ W: Z' {6 x9 C  |$ m2 r  iＩ２Ｃ总线的事件和状态码的全局变量声明：
* _# p% e5 t# j5 d. v7 w9 Q0 Q------------------------------------------------------------------------------------------------*/
# B9 _/ C: y8 n) z0 _; `extern data  unsigned char         gucvI2c0Event;
5 q' K- _7 ^6 n# m/ s. ^
6 M9 m' ]+ m$ R6 B* x9 j
; _! M) `( S; P
3 r& x8 i& p0 k. v" l/*------------------------------------------------------------------------------------------------
, R7 c' G5 R1 Q- q5 [- |3 MＩ２Ｃ总线通讯收发数据处理的全局变量声明：
------------------------------------------------------------------------------------------------*/
( X. `7 A( Z  mextern xdata CommI2c0DataStru      gstvI2c0;

/ `' F5 X3 A6 ^; U" y( {% ~& e( N
( Z$ @4 b* o+ J; s6 X

/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　 源程序文件中的函数原型声明
==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
函数名称：　　两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线），使用中断方式接收和发送数据通信的初始化
. r) H* g& I. D3 D% r函数功能：　　本函数用于两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线），使用中断方式接收和发送数据通信的初始化操作。
函数入口参数：没有
9 {$ p; }% s- a$ E/ O8 k7 a函数返回值：　没有
调用函数：　　１．
备注：        １．本函数仅在主函数中调用一次即可。
------------------------------------------------------------------------------------------------*/
void CommI2cInit(void);
' o  o. w6 w4 l  N7 X& A
/*------------------------------------------------------------------------------------------------
函数名称：　　查询Ｉ２Ｃ总线通讯发送数据作业工作状态
函数功能：　　本函数用于检查Ｉ２Ｃ总线通讯发送数据作业工作状态的函数。
' Z2 `) S/ n: A1 L& L3 |函数入口参数：没有
  y  n$ l% w- l$ ]9 [函数返回值：　Ｉ２Ｃ总线收发器的工作状态，０（空闲状态）。
8 r7 ]6 g6 E7 X& [0 v# X, Q调用函数：　　１．
$ T2 I0 A+ U( ~9 b4 @备注：        １．
------------------------------------------------------------------------------------------------*/
; I1 e0 K( p9 }, a* b$ m, Sunsigned char CommI2cBusBusy(void);

/*------------------------------------------------------------------------------------------------
函数名称：　　设置Ｉ２Ｃ总线为标准／快速模式和占空比
函数功能：　　本函数用于设置Ｉ２Ｃ总线为标准／快速模式和占空比操作的函数。
! u9 }0 M1 }" z函数入口参数：Model ----------------- 标准／快速模式和占空比， ON（快速模式）／ OFF（标准模式）。
" e6 x4 ~: T! \) v函数返回值：　没有
) Q9 g% f8 Q5 h9 O' g- K5 T" j/ P1 {调用函数：　　１．
备注：        １．
------------------------------------------------------------------------------------------------*/
void CommI2cBusModeDuty(unsigned char Model);
# p& |( \6 G% {) h# I
0 w& T: x8 T; |$ E+ _0 j' R8 I#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
  l1 W# S1 w  c& F4 M( v/*------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------*/
+ H6 c' @+ H6 i6 k1 Y, n" e. f#if cI2cTxBufSize < 256
void CommI2cTxWithData(unsigned char Object, unsigned char *pData, unsigned char Length);
#else
1 d) l7 m; t7 `2 qvoid CommI2cTxWithData(unsigned char Object, unsigned char *pData, unsigned int  Length);
#endif

/*------------------------------------------------------------------------------------------------

4 P' ]4 M' I( f. Z& Q$ k7 v------------------------------------------------------------------------------------------------*/
( t2 k% U, K6 B9 u0 s#if cI2cRxBufSize < 256
void CommI2cRxWithData(unsigned char Object, unsigned char Length);
' s+ R* M+ {8 J1 i4 A. U+ V  W#else
9 A! g! m/ v+ Jvoid CommI2cRxWithData(unsigned char Object, unsigned int  Length);
( r) O6 W+ J3 f% S#endif
) N7 q3 D# b% B# X
/*------------------------------------------------------------------------------------------------
0 J0 D  u7 l' ^1 k9 |/ H7 @
------------------------------------------------------------------------------------------------*/
#if cI2cTxBufSize < 256
4 }$ @* L( _) Z3 N% Kvoid CommI2cTxWithAddr(unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char *pData, unsigned char Length);
#else
8 A1 i9 L1 m5 nvoid CommI2cTxWithAddr(unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char *pData, unsigned int  Length);
#endif
6 f6 X7 H0 T! P( Y" t  |
/*------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------*/
#if cI2cTxBufSize < 256
#if cI2cRxBufSize < 256
' I5 D/ A4 y4 ^9 K/ Svoid CommI2cRxWithAddr(unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char Length);
#else
. t0 h# b- ^) R# lvoid CommI2cRxWithAddr(unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned int  Length);
#endif
8 S  Z0 f! ~  t# e. |4 Z& X0 d#else
" N$ L! B* ]9 W4 z9 m) E! B4 b  A. v#if cI2cRxBufSize < 256
! [& A. }+ H* c2 {7 K( Nvoid CommI2cRxWithAddr(unsigned char Object, unsigned char *pAddr, unsigned int  LenAddr, unsigned char Length);
#else
, z7 e: _6 Y2 Vvoid CommI2cRxWithAddr(unsigned char Object, unsigned char *pAddr, unsigned int  LenAddr, unsigned int  Length);
, V% v7 n1 s. D#endif
#endif
; {- K( e# ?5 U+ t( T2 @/ |

- m( V* h3 G/ R8 G

6 X' [2 L. l) @! N  p  z, p



9 ]: ~* N6 e) a( D" `
# p( d4 S$ W# O2 Z/ b, W


! A+ y0 K/ a; M6 S# z

) j+ l& G  Y' i( r




* ?& x' X6 P3 G5 j% d
' @3 y+ d/ [! f# j+ y+ v/*------------------------------------------------------------------------------------------------
函数名称：　　Ｉ２Ｃ总线工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
4 l) x- v& W" [, Z! L- S* O. P, Q函数功能：　　本函数用于Ｉ２Ｃ总线工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
7 O& w' t. G$ O. H, u* }函数入口参数：gbitI2c.Rxd ------------- “正在进行接收数据作业”标志。
9 n0 \! ~  E7 p- C- ~  f- ~　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量。
. d% {# h8 L- q5 r& g　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量。
              gstvI2c.RxSize ---------- 每次接收数据个数大小变量。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝清位（可能）。
              gbitI2c.Error ----------- 通讯收发作业发生错误，出口值＝置位（可能）。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ 不确定。
6 e9 C) Y- r- P" ~$ O0 X; g　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝gstvI2c.TxCnt。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝不确定。
  u( u/ s3 x2 t0 W( V  ]              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝gstvI2c.RxSize。
              gstvI2c.RxBuf[] --------- 每次接收数据缓冲区变量，出口值＝从Ｉ２Ｃ总线上接收到的数据。
调用函数：　　１．
备注：        １．注意：本函数需在Ｉ２Ｃ总线中断请求的中断向量函数中调用。
                  　　　在调用之前需对该中断向量进行初始化，使能该中断。
) N& w3 t5 H( L( N5 d6 W( y　　　　　　　２．全部完成通讯收发作业后，本函数将禁止Ｉ２Ｃ总线中断。
7 u6 b. ~, W3 S1 M& `. }6 |  n( s------------------------------------------------------------------------------------------------*/
8 f& q+ A. q0 [1 I& L7 S#if   (   defined(_IAR_EW_AVR_)   \
9 I& ]( K! k4 Q1 Q/ N  `0 v       || defined(_IAR_EW_MCS51_) \
) Q. o) B% D( j' c7 u6 w* |       || defined(_IAR_EW_STM8_)  )
#pragma vector = int_I2C_vector
INTERRUPT_KEY void CommI2c_isr(void);
" V; @9 \: e) @% L) r) y1 d#elif (defined(_KEIL_UV_MCS51_) )
5 t6 [: U9 {/ K8 N  v, w% g0 R
% J; f5 `/ r" `$ g( N. N#elif (   defined(_COSMIC_STM8_)  )
  J9 S( n+ ], LINTERRUPT_KEY void CommI2c_isr(void);
#else
void CommI2cIsr(void);
" D8 O# a& \( U+ C+ b; A2 H#endif                                                    // “_IAR_EW_......”
#endif                                                    // “Ｉ２Ｃ总线工作于单主机方式”条件编译结束
7 {# {! x, g0 A4 N4 d# Y3 ~
  P! |0 ]: }1 G# a! P2 }. G



! _8 e9 ~6 \/ r% b
/*------------------------------------------------------------------------------------------------
函数功能：    本函数是Ｉ２Ｃ总线通信接收和发送作业不间断循环调用运行函数。
" A. f$ e, l+ S2 ~; L备注：        ▲．注意：本函数为消息任务队列函数，要在主函数中不间断循环调用运行。
              ▲．当Ｉ２Ｃ总线工作于从机方式时，Ｉ２Ｃ总线中断总是处于使能状态，以便
% r! B) }) I/ R9 K6 @                  Ｉ２Ｃ总线处于随时接收数据状态。
------------------------------------------------------------------------------------------------*/
5 t2 `5 F4 G1 @( n- C& k' ~void CommI2cCircleFunc(void);
+ k% G2 `: M1 F3 l


#ifdef __cplusplus
* w) z* _  G* l}                                                         // extern "C" 链接指示符作用域结束
8 B$ A2 X) a+ d( {2 g#endif
) u& a0 x  C6 A& T
5 O, f7 {2 q$ h5 R#endif                                                    // “_COMMI2C_H_”条件编译结束
& B# J$ h/ ^& q0 S8 g8 e: o
1 P8 B* T* U' @  n$ D
' I" v& O6 Y+ {! z- e/ r/*
************************************************************************************************************
　　　　　　　　　　　　　　　　　　　　　　　本头文件到此结束
************************************************************************************************************
, F" G5 s6 m2 Z/ R) t0 I*/

, V, i5 H2 O* i: j! T# {4 T4 r6 q/*
************************************************************************************************************
版权所有 (C)，2010－2012，磊元科技有限公司
--------------------------------------------------------------------------------------------------
源程序文件名：　　　CommI2c.c
源程序名称：　　　　两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线）的源程序文件
程序版本：　　      1.0
& b7 I" f9 E6 s8 H7 O2 f) `) R3 D程序功能：
8 M; H- q  M3 N3 e　　　　本文件是两线串行总线接口ＴＷＩ（Ｉ２Ｃ总线）使用中断方式接收和发送数据通信的源程序文件。
4 j- o+ s' V% X程序说明：
; a7 @( U% S9 m5 p0 v) k1 T; q2 e　　　　１．注意：使用源程序的Ｉ２Ｃ总线接收和发送数据的函数之前，必须使能全局中断。
$ P, s. y7 W+ w! V6 ^, `1 z, J. K　　　　２．注意：使用Ｉ２Ｃ总线作为主、从机进行通信，主机在接收数据时，须连续接收２次才可正确接收到
                  从机发送的数据；因为主机第一次接收数据的第１个数据为Ｉ２Ｃ总线上出现的最后一个字节。
3 Y) C) y) j3 d" P& G4 }" I                  但在与外围器件通信正常，只须接收１次即可。

主要函数列表：　　　
　　　　▲．在主函数中运行的函数：
) N2 _* j/ i1 K6 v　　　　　　１．void Drv74595Init(void)
2 t% i% f: k; K# _& ^$ |4 N# q                （串行输出端口初始化）
4 \/ a6 D9 q2 R) K　　　　▲．芯片７４ＨＣ５９５输出驱动函数：
0 q" a6 e& r$ G0 c# ]6 W, i& H% t　　　　　　１．void Drv74595Drive(const unsigned char *pParallel)
                （串入并出芯片７４ＨＣ５９５输出驱动）
- }, N0 S; H6 b. L- {( w) U9 r　　　　　　２．void Drv74595Single(unsigned char Parallel, unsigned char Series)
' G6 A* r  ?% b3 c+ Y3 T                （串入并出芯片７４ＨＣ５９５单个驱动）

! `$ R: J9 ^2 P/ S) x( ^- D: r3 a9 o链接子程序文件：　　
1 t1 Q2 U8 M2 D' o  R" U　　　　１．
5 E- I# |  e4 v' z
编译工具软件：      IAR Embedded Workbench for Atmel AVR 版本：5.20A 以上
. m1 ~' [5 e( Y: {4 k. q( `. H
************************************************************************************************************
*/
4 n( Z% y5 r8 V) e5 |



: C1 G* z1 Z2 k/*==========================================================================================================
$ k# T. O% d5 I& O8 }" H7 w　　　　　　　　　　　　　　　　　　　　　　　　调试开关声明
==========================================================================================================*/
$ h" S9 F; I/ \1 {5 K' ]3 N2 A//#define DEBUG
; U' o: J  z6 q' d' S
7 C7 z# j  i$ R8 d& @
% V0 k" u+ O! ^1 T) C4 L/*==========================================================================================================
' b% S! F: A+ H- u' ]) Q/ r- E　　　　　　　　　　　　　　　　　　　　　　本源程序包括的头文件
建议：包含本项目的文件使用 #include "文件名.扩展名" ，
　　　包含系统库的文件使用 #include <文件名.扩展名> 。
==========================================================================================================*/
8 R, F# u3 F+ `" I$ P# `( V#include "CommI2c.h"                                      // 本源程序的头文件
#include "DataMath.h"                                     // 算术运算及数制转换等数学算法的头文件
#include "RtcTimer.h"                                     // 应用内部定时器计时的实时时钟的头文件
2 K3 _3 s6 z/ s1 G' g#ifdef DEBUG
#include "LcdHt1621.h"                                    // HT1621 字符液晶模块显示接口驱动的头文件
) v! J$ n) T$ F  s//#include "LcdSed1520.h"                                   // SED1520 图形液晶模块显示接口驱动的头文件件
//#include "LcdHd61202.h"                                   // HD61202／3 图形液晶模块显示接口驱动的头文件
/ }1 C+ M* K3 Y/ t  a" a  E//#include "LedDigital.h"                                   // 发光数码管驱动显示接口的头文件
# _" r" P  A9 {  s8 b# G+ e) a//#include "LcdTftBus.h"                                    // ＴＦＴ液晶模块总线驱动显示接口的头文件
. b4 t! ~# h$ Y" g#endif

#ifdef __cplusplus
extern "C" {                                              // 声明接在下面的指令为Ｃ程序编译系统
/ q" q7 u, e# o8 H3 A) v#endif


" B9 {9 f# r8 A, P- ~
/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　　　　全局常量定义
==========================================================================================================*/
#if   (defined(_IAR_EW_AVR_))
7 x0 n8 W* M0 h; n% O8 J$ o* b
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

- E. a$ g( z/ L8 F7 a* h/ R2 D#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
3 V7 Y# z  {1 c1 o; M
" J. J3 l; S2 l% @  T/ [; T3 K#else                                                     // “_USE_STM8_FWLIB_”

#endif                                                    // “_USE_STM8_FWLIB_”
#else
: J3 g* j7 s& o& m' y#error 错误：
$ i: O8 d3 p& K7 ^6 i$ \#endif                                                    // “PreMcuIs__......”
5 U' @* }( f6 [; t9 Q! }

/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　　　　全局变量定义
$ s7 W, \# x- ^! d==========================================================================================================*/
+ H. \! k$ U: b2 y. Z  Y) y1 B/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线通讯处理消息任务标志的全局变量定义：
------------------------------------------------------------------------------------------------*/
bdata CommI2c0FlagBits      gbitI2c0;
  A$ z1 h' D# ?# I0 q
' l! j6 W5 u. g+ v& Z) m/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线的事件和状态码的全局变量定义：
8 w: G: g9 D: M------------------------------------------------------------------------------------------------*/
0 o+ g9 p/ j. i( A9 N6 ddata  unsigned char         gucvI2c0Event;
6 k) d+ Y$ K' t/ H0 F, O
1 y$ y% K+ s! k' P1 o3 N1 M/ x/*------------------------------------------------------------------------------------------------
Ｉ２Ｃ总线通讯收发数据处理的全局变量定义：
' N5 B6 h) f4 n! z, k; y------------------------------------------------------------------------------------------------*/
1 ~: V5 \) X7 r4 {' N' m! Y3 U0 \xdata CommI2c0DataStru      gstvI2c0;

+ G8 }9 [8 L) b7 j
/*==========================================================================================================
2 m# b1 e3 R: t' _& X  [; Z% d6 v* Z　　　　　　　　　　　　　　　　　　本源程序文件内部使用的字符化常数定义
==========================================================================================================*/
#if   defined(PreCommI2cMultipleI2cEnable0)               // “使用Ｉ２Ｃ０”条件编译开始
8 [" N' @, J# M; G& i; z#define cDdrI2cScl            cDdrI2c0Scl
4 Z- l! g+ `/ d( J+ ?$ b7 E: U( w#define cPurI2cScl            cPurI2c0Scl
#define cCirI2cScl            cCirI2c0Scl
#define cOdrI2cScl            cOdrI2c0Scl
) b  j& i  Y% U3 a/ m#define cIdrI2cScl            cIdrI2c0Scl
: I1 u( t! H* b1 J2 |7 f#define cPidI2cScl            cPidI2c0Scl
#define cPodI2cScl            cPodI2c0Scl
#define cBitI2cScl            cBitI2c0Scl
#define cDdrI2cSda            cDdrI2c0Sda
8 I- ^4 Q! Z0 z+ `+ ]1 w5 a0 ~9 M#define cPurI2cSda            cPurI2c0Sda
2 |% \, q6 f2 ?( r5 @#define cCirI2cSda            cCirI2c0Sda
#define cOdrI2cSda            cOdrI2c0Sda
5 b* f% I! `6 j- Q9 |8 j#define cIdrI2cSda            cIdrI2c0Sda
#define cPidI2cSda            cPidI2c0Sda
4 q& H6 D" s% _: `. e#define cPodI2cSda            cPodI2c0Sda
( W- m, F; J% ^# M) e6 N8 ~#define cBitI2cSda            cBitI2c0Sda
% m- N# A+ B- i0 H8 ?0 E5 S2 t7 B#define cI2cRxBufSize         cI2c0RxBufSize
#define cI2cTxBufSize         cI2c0TxBufSize
#define CommI2cDataStru       CommI2c0DataStru
#define cI2cAddrNum           cI2c0AddrNum
#define gbitI2c               gbitI2c0
#define gstvI2c               gstvI2c0
#define gucvI2cEvent          gucvI2c0Event
# h5 E' P; V! y' D) m#elif defined(PreCommI2cMultipleI2cEnableS)               // “使用Ｉ２Ｃｓ”条件编译开始
' F3 k4 j7 n$ {9 H& I) k! t! ?
8 @/ F1 S8 J3 U) s#endif                                                    // “使用Ｉ２Ｃ......”

1 z7 p7 j, b6 t4 s

/*==========================================================================================================
　　　　　　　　　　　　　　　　　 本源程序文件内部使用的数据结构类型定义
==========================================================================================================*/



4 h3 C# d  z: e1 {5 i* H; I/*==========================================================================================================
　　　　　　　　　　　　　　　　　　 本源程序文件内部使用的局部常量定义
==========================================================================================================*/
# k% Z- e. {3 J& u& u


/*==========================================================================================================
" V6 q. c6 u/ j0 p& d& r. k/ H　　　　　　　　　　　　　　　　　　 本源程序文件内部使用的局部变量定义
8 \, v. _7 A: l+ A==========================================================================================================*/
# v/ a. y( p8 c) b$ c#ifdef DEBUG
9 r0 T6 @6 S. nstatic unsigned char display_y_cnt = 0;
#endif
5 I) @: B, g* N, E- E; J1 U/ J* E

0 j7 ~' y8 R( D  c
1 j+ P  d, r; ]6 u1 q/*==========================================================================================================
　　　　　　　　　　　　　　　　　　 本源程序文件内部使用的函数原型声明
==========================================================================================================*/
static void CommI2cBusAgain(void);

" C3 B3 `: o8 \" d5 v: y0 k4 o- c% Y
8 b: s* D2 I- C

  ?0 C( {! x2 P) l+ ~/*==========================================================================================================
2 b' v6 t% `# I1 K3 {函数名称：　　设置Ｉ２Ｃ总线为标准／快速模式和占空比
函数功能：　　本函数用于设置Ｉ２Ｃ总线为标准／快速模式和占空比操作的函数。
函数入口参数：Model ----------------- 标准／快速模式和占空比， ON（快速模式）／ OFF（标准模式）。
4 O- o2 h& {; }9 L6 [4 R2 i函数返回值：　没有
/ K! {" U7 ?4 g9 s8 }, N调用函数：　　１．
: l3 u" i% q9 F) `7 e' l备注：        １．
7 E; K  S2 v% r0 B7 x1 l==========================================================================================================*/
% D" E& o' Q/ J* [+ d, mvoid  CommI2cBusModeDuty (unsigned char Model)
2 r+ T4 ]. A& s5 y) v% l! Q3 y{
# _4 |- R' A( H4 T) z0 d, G#if   (defined(_IAR_EW_AVR_))
$ ?# g# M. z% u. R, I  }
9 y3 D' j6 _4 w#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
, u3 z, s+ }5 L5 z
#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
: R, l: d4 P& s; `# K
#else                                                     // “_USE_STM8_FWLIB_”
  I2CCR1         &= (u8)(~((1<<i2cEN   ) ));              // 禁止Ｉ２Ｃ模块，用以设置 I2CTRISER。
3 ?. j* z) O/ o( ^, a! {  if (Model == ON)                                        // 快速模式：占空比＝Tlow/Thigh＝2／1
  {
# l( k5 F5 b1 O    I2CCCRH       = (u8)( ((0<<i2cDUTY )|                 // 快速模式下的占空比＝0：Tlow/Thigh＝2／1，1：Tlow/Thigh＝16／9。
1 I3 j' v5 v* n+ e                           (1<<i2cSFM  )|                 // 标准／快速模式选择位＝快速模式
! v1 h3 q. t$ m0 E                          cI2c0BrCcrF21H ));              // 置Ｉ２Ｃ比特率高位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CCCRL       = (u8)( cI2c0BrCcrF21L);                // 置Ｉ２Ｃ比特率低位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
# {+ N( D. w: b" y0 j    I2CTRISER     = (u8)( ((((cSysCpuClk / 1000000UL) * 3UL) / 10UL) + 1));
                                                          // 快速模式：最大上升时间＝300ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
  }
  else                                                    // 标准模式：占空比＝Tlow/Thigh＝1／1
+ T9 R' W3 i2 Z% ~  q  {
    I2CCCRH       = (u8)( ((0<<i2cDUTY )|                 // 快速模式下的占空比＝0：Tlow/Thigh＝2／1，1：Tlow/Thigh＝16／9。
5 ]$ f) G. X8 w$ f! d                           (0<<i2cSFM  )|                 // 标准／快速模式选择位＝标准模式
1 s8 b* k5 C6 g* V9 ^                          cI2c0BrCcrS11H ));              // 置Ｉ２Ｃ比特率高位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CCCRL       = (u8)( cI2c0BrCcrS11L);                // 置Ｉ２Ｃ比特率低位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CTRISER     = (u8)( ((cSysCpuClk / 1000000UL) + 1));// 标准模式：最大上升时间＝1000ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
  }
  I2CCR1         |= (u8)( ((1<<i2cEN   ) ));              // 使能Ｉ２Ｃ模块
#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
0 U9 h8 p  l6 s& }6 @}
  j* Y& u9 S2 O
: T% ^( @! d1 @% |5 ?#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
9 U' H0 b  R3 I8 W( @2 F. q) ?3 {0 Y/*==========================================================================================================
函数名称：　　Ｉ２Ｃ总线工作于单主机方式，重新启动Ｉ２Ｃ总线前一个通讯收发作业
函数功能：　　本函数用于Ｉ２Ｃ总线工作于单主机方式，重新启动Ｉ２Ｃ总线前一个通讯收发作业操作的函数。
函数入口参数：gbitI2c.Txd ------------- “正在进行发送数据作业”标志。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志。
, ]5 _: l6 j% s3 `. Z+ m+ L; }函数返回值：　没有
3 L! E! R% O6 F. S/ n' |函数出口参数：gucvI2cEvent ---------- Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
4 G& w- |8 b+ v. W              gstvI2c.TxBuf[0] ------ 每次发送数据缓冲区数组变量，出口值＝要发送的地址。
9 X$ w  W6 \( v. T: A              gstvI2c.ErrNum -------- Ｉ２Ｃ总线的通讯收发作业发生错误次数值变量，出口值＝０。
              gstvI2c.RxCnt --------- 每次接收数据个数计数器变量，出口值＝０。
4 j- P$ q2 K9 |3 M/ t4 X调用函数：　　１．
备注：        １．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
- S2 a2 o( w4 A9 e==========================================================================================================*/
static void  CommI2cBusAgain (void)
{
#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
. U, m3 a# |7 _& }5 y- v#else
/ l' r& [- i/ G2 R  register unsigned int     i;
#endif
( L, H; U8 i; [5 g  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针
( U" W) M6 W0 Z- k- [  g2 j
4 w& I  R1 O& b+ `. V+ }( A0 Z2 b  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
) t$ ~8 O0 H6 }7 H1 h) f& b/ C. R
  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线

! a+ K1 `* l% G* T0 y3 @1 Y) o% P0 o  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
* q7 M+ h, w6 h. d. e  if (   (gbitI2c.Txd == SET)                             // 如果是先发送若干地址然后再进行发送数据作业？
      && (gbitI2c.Rxd == SET) )
  {
2 e8 Z2 I3 G3 H    pI2c->TxBuf[0]         &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  }
: x+ T& W4 ?' Y7 M7 [  pI2c->RxCnt               =  0x00;                      // Ｉ２Ｃ总线每次接收数据个数计数器清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数值清０
$ E# [$ Q1 ]3 T+ S& P' H  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

6 d! R# E5 b$ s/*==========================================================================================================
函数名称：　　启动Ｉ２Ｃ总线应用中断方式发送数据
函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯发送数据作业操作的函数。
1 e% h$ ]5 H, ^函数入口参数：Object ------------------ 要发送数据的的目标设备地址值。
8 g' {2 {; {$ _" M  @. L* H0 ?- J              *pData ------------------ 指向首个要发送数据在ＳＲＡＭ中的地址指针。
; q7 A* Z( M) o/ g7 n, C              Length ------------------ 要发送数据的数据总长度。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝清位。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝Length + cI2cAddrNum。
# a" f# @5 q- z, q) F0 J: Q　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
* {- J: T7 a- K4 D　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的数据。
　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
; J1 e0 B8 W% a0 G; |( h0 F4 O　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
: _) f" k- X  G7 P# t调用函数：　　１．
) k5 d; D; i% e! W备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
# ]0 o/ _: x) g4 M* T　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
* H* I( W5 b* z; Y2 o* N#if cI2cTxBufSize < 256
void  CommI2cTxWithData (unsigned char Object, unsigned char *pData, unsigned char Length)
#else
  `  x- {! J& dvoid  CommI2cTxWithData (unsigned char Object, unsigned char *pData, unsigned int  Length)
#endif
% F2 M& ]6 O" ]2 r) J4 I/ R{
#if cI2cTxBufSize < 256
+ A; O, L) x+ _( D  register unsigned char    i;                            // 循环变量
$ r' ]2 o; T: a4 i4 g#else
  register unsigned int     i;
6 ~% i* W5 g6 ?0 r, L#endif
  unsigned char             temp;                         // 临时变量
! k" f6 u" u0 ?+ k+ k. X  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针
+ s" F  c) e, D: d. K6 @: v- E
  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  if (   (Length >= (cI2cTxBufSize - 1))
      || (Length == 0)                   )
  {
    return;
" B2 s+ ]4 W/ ~' C+ J; w) h" H3 u  }
#endif                                                    // “PreCommI2cWithRedundantCode”

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
, L( x; R! X- K" a//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止
/ n, J/ |9 f' r- R
  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
* i/ [+ o/ M4 |& O1 q2 p& I  gbitI2c.Rxd               =  CLEAR;                     // 清除“正在进行接收数据作业”标志
  \# C3 Q2 s4 q% z  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
% @4 z, l8 M1 K% L' L) s  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
! v: `7 Y! X( y0 ]% c//  pI2c->Object              =  Object;                    // 复制目标设备地址到每次发送数据的目标设备地址中
//  pI2c->Object             &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
//  pUsart->pTxData           =  pData;                     // 保存要发送的数据序列的地址指针
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
  pI2c->TxBuf[0]           &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
8 Q. [  ~, R% A- w1 H) a. l  MemCopySramToSram(pData, &pI2c->TxBuf[cI2cAddrNum], Length);
# {7 r4 ]( y8 ?4 r5 @& A7 g                                                          // 复制发送的数据序列到发送数据缓冲区中
! M- ?$ p& G9 l0 Y0 P4 e  ?& c  pI2c->TxSize              =  Length + cI2cAddrNum;      // 置每次发送数据个数大小值
9 j! Q4 Z7 d  [7 R6 F  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
3 E$ I/ O$ b4 A  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}
+ n1 }% B' U; y3 i6 w' b. l$ I

: n9 L5 o+ ^6 @5 ?5 _/*==========================================================================================================
函数名称：　　启动Ｉ２Ｃ总线应用中断方式接收数据
- B" i# {" w7 `! T函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯接收数据作业操作的函数。
( E! q) z+ y! R3 n  o函数入口参数：Object ------------------ 要接收数据的的目标设备地址值。
5 w0 R1 t" u9 h  ?; m" F! H* L              Length ------------------ 要接收数据的数据总长度。
5 {/ o# d0 G) h+ P7 M4 J函数返回值：　没有
8 X( h) F4 {- K! M( v1 [函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝清位。
1 V; \( y- y, K/ h              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝置位。
6 [9 y  h6 G3 n( z# h' J- G  U/ {( b              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝cI2cAddrNum。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的数据。
% Q9 ~+ w2 l5 E2 j1 N5 Q* X: ~; m　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
) l0 i/ h" V8 E( l- h% b              gstvI2c.RxSize ---------- 每次接收数据个数大小变量，出口值＝Length。
9 w) M0 X8 N1 ]# ?4 w4 }              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝０。
调用函数：　　１．
% F# J+ E" b+ u! P" H3 K" b7 Q0 @备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
) y, h8 |1 L( u6 `　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
. z9 U# o; p  Q, w& d8 i' F3 L==========================================================================================================*/
& T) p7 q3 O7 C8 [- T1 e- g0 g7 `#if cI2cRxBufSize < 256
( P7 ~$ Q3 ~2 B* Avoid  CommI2cRxWithData (unsigned char Object, unsigned char Length)
#else
" o: y. t7 q# f; b) pvoid  CommI2cRxWithData (unsigned char Object, unsigned int  Length)
#endif
8 ^' G2 v4 O0 |& @{
3 \# X- Q) M4 K( ?#if cI2cRxBufSize < 256
* w  w* P) V& o3 j  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针
, I( A( r4 ^: X. }0 ~2 j
4 Q3 K5 ^( f4 B3 p' t& b9 S  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
' N. h2 ^, C! G! x0 \8 Z#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
, h  }4 {& Q! Y5 q" Q: l5 j  if (   (Length > cI2cRxBufSize) )                       // 检查要接收数据的总个数是否超过缓冲区长度？
  {
    Length                  =  cI2cRxBufSize;             // 截断要接收数据的总个数
  }
#endif                                                    // “PreCommI2cWithRedundantCode”
/ Q3 N3 ~' F  L( v1 K
  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
$ U" o* \' J( E, I//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  x! S9 @. m7 n% o: g  gbitI2c.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志
& a0 ^/ b3 D( m1 x: `. m" M  gbitI2c.Rxd               =  SET;                       // 置“正在进行发送数据作业”标志
! V" S! N) \) k' `9 j  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
! ^! c4 l; S6 \6 x7 e  pI2c->TxBuf[0]           |= (u8)( BIT0);                // 设置数据传送方向为接收数据
  pI2c->TxSize              =  cI2cAddrNum;               // 置每次发送数据个数大小值
2 `( o+ }5 p* \( u( X* H; z  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
3 O% h. |8 P. ^/ d) n  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
6 i1 Q, }1 P: @# D" P: g  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０

  pI2c->RxSize              =  Length;                    // 置Ｉ２Ｃ总线每次接收数据个数大小的值
  pI2c->RxCnt               =  0x00;                      // Ｉ２Ｃ总线每次接收数据个数计数器清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
* N1 Z8 {  S* L  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
% j1 x7 o2 R$ P! U# M! L  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}
3 w  B& \( W, n0 I. ~
/*==========================================================================================================
( n$ t& ?5 t# F- u函数名称：　　启动Ｉ２Ｃ总线应用中断方式先发送若干地址然后再进行发送数据作业的函数。
$ ~9 F" H  E6 R函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯先发送若干地址然后再进行发送数据作业操作的函数。
% k, M# Q/ h  v* X' W2 E" K# q9 l函数入口参数：Object ------------------ 要发送数据的的目标设备地址值。
              *pAddr ------------------ 指向首个要发送地址在ＳＲＡＭ中的地址指针。
              LenAddr ----------------- 要发送地址的地址总长度。
              *pData ------------------ 指向首个要发送数据在ＳＲＡＭ中的地址指针。
3 [9 x$ B% ]; n& V+ l              Length ------------------ 要发送数据的数据总长度。
+ W' `/ V) U( C% [, Z# B; w函数返回值：　没有
9 L/ u! I! c" {3 z函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝清位。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
# f: D" @7 e0 E. D0 W( d! s- C! N　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝LenAddr + Length + cI2cAddrNum。
! l* b( D$ j- e4 V　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
9 `; o9 I% C# X) S, I( n　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的地址和数据。
　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
2 S1 I! I; [) ~& s/ ?' O/ h调用函数：　　１．
$ x; F& M# D! z4 w* ^备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
+ q; R$ |9 p8 Y0 l　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
#if cI2cTxBufSize < 256
void  CommI2cTxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char *pData, unsigned char Length)
% e. P& e; ^0 U#else
void  CommI2cTxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char *pData, unsigned int  Length)
% T$ t# k2 A& F- R, P' O#endif
{
& s7 m4 C' m# v, K#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
) B/ i! i. G- M+ V' @6 A#else
- G6 s; E& S' u" o  register unsigned int     i;
" ]3 z* V% ~- h; i8 Q5 K#endif
  unsigned char             temp;                         // 临时变量
* p/ T. R3 z" i- m  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

& u& o+ q0 R& `; l  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

/ Q; }$ P0 A# e) e* L( t#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  if (   ((LenAddr + Length) > (cI2cTxBufSize - 1))       // 检查要接收数据的总个数是否超过缓冲区长度？
      || (LenAddr == 0)                   )
  {
    return;
; n+ Z6 c# Z1 q1 i- o  }
#endif                                                    // “PreCommI2cWithRedundantCode”

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
' T& c- ~5 L& a+ y4 ]" S$ Q//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

# v4 d( ^, b* V/ A# U0 D/ [* H" B  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
0 H6 x6 d" z* g7 j2 W  gbitI2c.Rxd               =  CLEAR;                     // 清除“正在进行接收数据作业”标志
  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
//  pI2c->Object              =  Object;                    // 复制目标设备地址到每次发送数据的目标设备地址中
, ^* }$ J# Y& I: j9 k//  pI2c->Object             &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
2 f; L, [' [1 o% E( C9 n0 b5 O//  pUsart->pTxData           =  pData;                     // 保存要发送的数据序列的地址指针
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
3 W1 {: W' V4 h  pI2c->TxBuf[0]           &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  MemCopySramToSram(pAddr, &pI2c->TxBuf[cI2cAddrNum], LenAddr);
8 B. m9 n1 a0 `) D7 H5 |8 b                                                          // 复制发送的地址序列到发送数据缓冲区中
  MemCopySramToSram(pData, &pI2c->TxBuf[LenAddr + cI2cAddrNum], Length);
                                                          // 复制发送的数据序列到发送数据缓冲区中
/ P$ L% O6 t- y6 ^/ O0 x  pI2c->TxSize              =  LenAddr + Length + cI2cAddrNum;
+ g0 J0 k. o3 ~: y' o' a* Y3 s                                                          // 置每次发送数据个数大小值
$ f# M3 C4 f' x# L$ g" N  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
6 e4 ^- ~. ^: y* N. @' i$ w  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０
0 F3 n9 [+ s( O$ W9 n9 v, @
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
3 o6 C6 T1 r" g+ E+ ]1 X+ [  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

1 m' @, ~. w5 P. a& A% ]8 r/*==========================================================================================================
- r0 o  ~! ?% J函数名称：　　启动Ｉ２Ｃ总线应用中断方式先发送若干地址然后再进行接收数据作业的函数。
函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯先发送若干地址然后再进行接收数据作业操作的函数。
函数入口参数：Object ------------------ 要接收数据的的目标设备地址值。
% y4 L9 i- |1 @0 I' c6 s0 x' M5 M( c              *pAddr ------------------ 指向首个要发送地址在ＳＲＡＭ中的地址指针。
              LenAddr ----------------- 要发送地址的地址总长度。
' P+ a, S/ f4 p              Length ------------------ 要接收数据的数据总长度。
) ]0 Q& f" A' P函数返回值：　没有
. @+ x5 L  o1 T$ P. x; I: L函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝置位。
& T! M/ `0 i% k. W6 B0 Y              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝LenAddr + cI2cAddrNum。
% g4 u% f+ A6 J' Q4 J) i　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的地址。
) k7 j4 H9 D) `. [　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
              gstvI2c.RxSize ---------- 每次接收数据个数大小变量，出口值＝Length。
9 E; z. B: i% w+ N. m6 C0 A              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝０。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
7 O0 B! p# w; i3 g. t  W+ K　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
: s) q$ h4 e8 A==========================================================================================================*/
) V4 z" V9 M4 e, j5 H1 v/ t9 y& ]#if cI2cTxBufSize < 256
7 j6 R; a$ U/ h6 `( S; g6 W#if cI2cRxBufSize < 256
0 O- A" f/ l3 `/ d9 S+ hvoid  CommI2cRxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char Length)
#else
$ _7 i" |# m. lvoid  CommI2cRxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned int  Length)
#endif
#else
, u3 q2 s0 {' Y* |#if cI2cRxBufSize < 256
: p' ?4 j% h* ^" N: _2 G6 `( ~5 Zvoid  CommI2cRxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned int  LenAddr, unsigned char Length)
#else
void  CommI2cRxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned int  LenAddr, unsigned int  Length)
#endif
- C; y8 a8 }9 U% ~#endif
{
) ]9 E7 X! B  P# s/ \; `1 A#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
#else
' r. o7 i5 P: h; U; w# i  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
+ s) t5 B! h/ |8 I7 y  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针
' Y& x1 ~7 A: C* K
  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

' n: a2 j) w; I+ D  c" i" i- l2 v) O#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
+ \+ \' j  v; g8 B; v/ ?3 f, n  if (   (LenAddr >= (cI2cTxBufSize - 1))
      || (LenAddr == 0)                   )
  {
* i! j, i5 K/ \$ @0 b9 h& N    return;
  }
  if (   (Length > cI2cRxBufSize) )                       // 检查要接收数据的总个数是否超过缓冲区长度？
5 H- C$ i( B9 t1 T" K  {
% ~( x; }7 |6 _0 h% h8 S+ G' P    Length                  =  cI2cRxBufSize;             // 截断要接收数据的总个数
  }
#endif                                                    // “PreCommI2cWithRedundantCode”
' D. G3 G9 C, U  |7 w
' {6 X1 L$ L/ h" V4 p" C  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
, Y! f9 ]* Y+ F: ^  ^# ~//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

. F8 T. Z- ?9 L: ~+ I  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
' f. F# D1 z( s8 r  gbitI2c.Rxd               =  SET;                       // 置“正在进行接收数据作业”标志
  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
8 [; A6 n+ ]# z4 _% d  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
//  pI2c->Object              =  Object;                    // 复制目标设备地址到每次发送数据的目标设备地址中
//  pI2c->Object             &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
//  pUsart->pTxData           =  pData;                     // 保存要发送的数据序列的地址指针
- D- K) z, P3 U. D  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
  R* X) a) g1 [$ ]; }" N3 B* u& l  pI2c->TxBuf[0]           &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  MemCopySramToSram(pAddr, &pI2c->TxBuf[cI2cAddrNum], LenAddr);
                                                          // 复制发送的地址序列到发送数据缓冲区中
  pI2c->TxSize              =  LenAddr + cI2cAddrNum;     // 置每次发送数据个数大小值
  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
5 Z& P  C9 e& T; a  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０
2 S5 r+ f4 ?5 y$ Q8 k0 S
  pI2c->RxSize              =  Length;                    // 置Ｉ２Ｃ总线每次接收数据个数大小的值
6 c- Y2 C& s  T, q2 u  z! Q  pI2c->RxCnt               =  0x00;                      // Ｉ２Ｃ总线每次接收数据个数计数器清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
6 \$ ~/ H2 e* ~3 x* b  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
' l4 B+ T. L" `% C  D8 ?- r}
8 _( |6 Y) y& H

/*==========================================================================================================
5 v) h- x4 U2 a  R% s函数名称：　　Ｉ２Ｃ总线工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
函数功能：　　本函数用于Ｉ２Ｃ总线工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
函数入口参数：gbitI2c.Rxd ------------- “正在进行接收数据作业”标志。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量。
* z" S% b, r' l) K( P　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量。
* f0 V1 `8 v) ?- J1 c　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量。
. I8 Y2 Q& j' x- q# V7 ]0 o              gstvI2c.RxSize ---------- 每次接收数据个数大小变量。
  ^; R$ o( B1 ^, {: x函数返回值：　没有
8 U" v8 }$ m; f. O+ l函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝清位（可能）。
              gbitI2c.Error ----------- 通讯收发作业发生错误，出口值＝置位（可能）。
3 x* Y) }' T  Z5 h& ^) w              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ 不确定。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝gstvI2c.TxCnt。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝不确定。
              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝gstvI2c.RxSize。
              gstvI2c.RxBuf[] --------- 每次接收数据缓冲区变量，出口值＝从Ｉ２Ｃ总线上接收到的数据。
5 V, u, C* U6 b! A) y, L% o调用函数：　　１．
备注：        １．注意：本函数需在Ｉ２Ｃ总线中断请求的中断向量函数中调用。
3 t& Y' a7 c1 v4 r                  　　　在调用之前需对该中断向量进行初始化，使能该中断。
' N) X; Y" P) N, k　　　　　　　２．全部完成通讯收发作业后，本函数将禁止Ｉ２Ｃ总线中断。
==========================================================================================================*/
1 Z6 X& M/ T/ b#if   (   defined(_IAR_EW_AVR_)   \
       || defined(_IAR_EW_STM8_)  )
9 e. ?9 Z* v( }# C" @, z& I#pragma vector = int_I2C_vector
INTERRUPT_KEY void  CommI2c_isr (void)
% ~9 e& E3 g% t8 e#elif (defined(_KEIL_UV_MCS51_) )
4 |4 G9 n$ C: J8 p% S/ K4 Uvoid  CommI2c_isr (void) INTERRUPT_KEY int_I2C_vector using 0
#elif (   defined(_COSMIC_STM8_)  )
INTERRUPT_KEY void  CommI2c_isr (void)
! q' e! O$ v/ l  a* M. `) O#else
void CommI2cIsr(void);
#endif                                                    // “_IAR_EW_......”
% [+ A% P& a7 |8 R3 W#if   (defined(_IAR_EW_AVR_))
0 h. V2 \0 J: F{
& x3 b( a: ~% i, m$ D#if ((cI2cTxBufSize < 256) && (cI2cRxBufSize < 256))
  register unsigned char    cnt;                          // ＵＳＡＲＴ每次发送数据个数计数器变量
#else
9 y# b; U4 ~' }* L5 K7 W  register unsigned int     cnt;
#endif
: h- o7 Y( N6 R$ |. q! G% u" j4 c  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针
# j/ v2 g3 G! n: x% p& u( `, Z" n
  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
" c6 w: @6 }, n  F3 a2 e1 b* Z  switch (TWSR & cI2cTwsrMask)                            // 判断已屏蔽非状态位的 TWI 状态寄存器状态位值？
  {
    case cI2cAllStart:                                    // START 信号已发送
    case cI2cAllRepStart:                                 // 重复 START 信号已发送
    {
      pI2c->TxCnt           =  0x00;                      // 每次发送数据计数器值清０
    }
    case cI2cMtxAddrAck:                                  // SLA+W 已发送，接收到 ACK
    case cI2cMtxDataAck:                                  // 数据已发送，接收到 ACK
3 h8 H( I  s# w+ ^% {2 x  N1 U    {
* c& S6 F, V- f) m8 b, n( r; b      cnt                   =  pI2c->TxCnt;               // 取Ｉ２Ｃ总线每次发送数据个数计数器变量
      if (cnt >= pI2c->TxSize)                            // 检查是否己完成发送通讯任务的全部数据？
* R% ~5 |8 k/ g( v: U      {                                                   // 是，在最后一个字节之后发出 STOP 信号
        if (gbitI2c.Rxd == SET)                           // 检查是否为读取Ｉ２Ｃ总线数据？
        {
& T2 F/ V& j' j; z          pI2c->TxBuf[0]   |= (u8)( BIT0);                // 设置数据传送方向为接收数据
' N+ J' S, W4 P7 ^* V- U0 D* ^          MFHI2cBusNackReps( );                           // 发出重复 START 信号（重新开始条件），没有 ACK 脉冲
: l5 ?  n1 Q1 x7 L+ I        }
4 q/ J* j( v& }2 m! ^* a. _6 x7 b8 |        else
% Y) @& M) }: @: L+ a0 v) X( {4 u2 j        {
& q# f1 r& f1 ~' x7 u  W" @' s, W          gbitI2c.Busy      =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
          gbitI2c.OverS     =  CLEAR;                     // 清除“通讯任务时间超时”标志
1 b; h. j( z9 V1 V/ b8 X5 m8 w          MFHI2cIntEventOff( );                           // 禁止Ｉ２Ｃ总线事件中断
          MFHI2cBusNackStop( );                           // 发出 STOP 信号（结束条件），没有 ACK 脉冲
# [1 t& @( X) W6 A        }
7 b7 g- o0 E1 M" [' p. X. ?      }
      else
( N, ^8 T7 i, @& o  ^      {
        I2CDR               =  pI2c->TxBuf[cnt];          // 从发送缓冲区中将发送数据写入到Ｉ２Ｃ总线
        cnt++;                                            // Ｉ２Ｃ总线每次发送数据个数计数器＋１
% g+ B. L% A$ W) s. R        pI2c->TxCnt         =  cnt;                       // 返回Ｉ２Ｃ总线每次发送数据个数计数器值
        // 通过先读 I2CSR1，然后写入 I2CDR，来清０发送结束、发送数据寄存器空标志
        MFHI2cIntEventClr( );                             // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
      }
      break;
+ n# K+ m6 M+ ?    }
    case cI2cMrxDataAck:                                  // 接收到数据，ACK 已返回
) R1 G5 K+ S8 z: c6 S3 a    {
      cnt                   =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
5 _# \; x" }7 o/ v      pI2c->RxBuf[cnt]      =  I2CDR;                     // 复制Ｉ２Ｃ总线读取到的字节到接收数据缓冲区中
5 u- F; O& z- l# S+ t      cnt++;                                              // Ｉ２Ｃ总线每次接收数据个数计数器＋１
      pI2c->RxCnt           =  cnt;                       // 返回Ｉ２Ｃ总线每次接收数据个数计数器值
2 ^$ l& R' ]+ a, n; ]& }" f    }
8 n- t8 E0 @$ f& f% `7 j0 L    case cI2cMrxAddrAck:                                  // SLA+R 已发送，接收到 ACK
4 J2 d8 }( F! ?' I; E    {
      cnt                   =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
1 T9 I! e  m& k& E6 s9 P      if (cnt < (pI2c->RxSize - 1))                       // 检查是否完成需要读取的数据长度？
      {
. _% l9 ~1 c) l2 K+ L* e4 {8 t        MFHI2cBusRdataAck( );                             // 在接收之后发出 ACK 脉冲
; L, b+ ?8 x' Z2 t& P      }
      else                                                // 在最后一个字节数据接收之后发出 NOT ACK
. I& u/ ^, V! ^      {
" p* X7 p( r2 l8 F        MFHI2cBusRdatNack( );                             // 在接收之后发出 NOT ACK
0 i1 |/ h- e$ X8 ?      }
      break;
    }
5 U$ Z, N# m5 S* B    case cI2cMrxDataNack:                                 // 接收到数据，NOT ACK 已返回
    {
3 V$ _3 f  H) i; H% O      cnt                   =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
  q9 k3 d$ ?  `" Z% R      pI2c->RxBuf[cnt]      =  I2CDR;                     // 复制Ｉ２Ｃ总线读取到的字节到接收数据缓冲区中
      gbitI2c.Busy          =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
. M; L5 f; I# g" e      gbitI2c.OverS         =  CLEAR;                     // 清除“通讯任务时间超时”标志
      MFHI2cIntEventOff( );                               // 禁止Ｉ２Ｃ总线事件中断
      MFHI2cBusNackStop( );                               // 发出 STOP 信号（结束条件），没有 ACK 脉冲
. p! p- `2 e$ b! A+ b2 c      break;
    }
* T( Q7 _" z5 B  D7 p, n    case cI2cAllArbLost:                                  // SLA+W 或数据的仲裁失败
    {
      if (pI2c->ErrNum > cI2cErrorMax)                    // 检查通讯收发作业发生错误次数是否大于最大值？
7 z0 t6 g! _  w, ^5 X$ d: S      {
  R) z4 e; q+ ~% p. P3 t$ d        gbitI2c.Error       =  SET;                       // 置“通讯收发作业发生错误”标志
/ V  h1 S- E- V: y- e( B        MFHI2cInnEventMem( );                             // 存储Ｉ２Ｃ总线的事件和状态存储器值
# y' _/ C5 J& B  C        MFHI2cIntEventOff( );                             // 禁止Ｉ２Ｃ总线事件中断
      }
      else
      {
        pI2c->ErrNum++;                                   // Ｉ２Ｃ总线的通讯收发作业发生错误次数值＋１
        MFHI2cBusNackReps( );                             // 发出 START 或重复的 START 信号（起始条件），没有 ACK 脉冲
7 m  P- o& w- e; e      }
      break;
; p+ c1 T( B# s2 ?    }
" u4 a% l% P9 t2 H; {3 j    case cI2cMtxAddrNack:                                 // SLA+W 已发送，接收到 NOT ACK
    case cI2cMrxAddrNack:                                 // SLA+R 已发送，接收到 NOT ACK
    case cI2cMtxDataNack:                                 // 数据已发送，接收到 NOT ACK
    case cI2cAllNoState:                                  // 没有相关的状态信息； TWINT = "0"
, _* h. n) m+ s    case cI2cAllBusError:                                 // 由于非法的 START 信号或 STOP 信号引起的总线错误
    default:
+ Q9 D/ o. r2 o    {
      gbitI2c.Error         =  SET;                       // 置“通讯收发作业发生错误”标志
      MFHI2cInnEventMem( );                               // 存储Ｉ２Ｃ总线的事件和状态存储器值
; N/ u/ `9 w. Z: z. o) b0 G      MFHI2cIntEventOff( );                               // 禁止Ｉ２Ｃ总线事件中断
1 E) }5 D4 p* F- M: L  X    }
% N$ T6 b! Z3 f" W7 J; u  }

% [- U2 C8 ]' b+ l* V2 n  INTERRUPT_RETURN( );
}