/*==========================================================================================================
函数名称：　　设置Ｉ２Ｃ总线为标准／快速模式和占空比
函数功能：　　本函数用于设置Ｉ２Ｃ总线为标准／快速模式和占空比操作的函数。
函数入口参数：Model ----------------- 标准／快速模式和占空比， ON（快速模式）／ OFF（标准模式）。
函数返回值：　没有
调用函数：　　１．
备注：        １．
==========================================================================================================*/
void  CommI2cBusModeDuty (unsigned char Model)
{
#if   (defined(_IAR_EW_AVR_))

#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始

#else                                                     // “_USE_STM8_FWLIB_”
  I2CCR1         &= (u8)(~((1<<i2cEN   ) ));              // 禁止Ｉ２Ｃ模块，用以设置 I2CTRISER。
  if (Model == ON)                                        // 快速模式：占空比＝Tlow/Thigh＝2／1
  {
    I2CCCRH       = (u8)( ((0<<i2cDUTY )|                 // 快速模式下的占空比＝0：Tlow/Thigh＝2／1，1：Tlow/Thigh＝16／9。
                           (1<<i2cSFM  )|                 // 标准／快速模式选择位＝快速模式
                          cI2c0BrCcrF21H ));              // 置Ｉ２Ｃ比特率高位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CCCRL       = (u8)( cI2c0BrCcrF21L);                // 置Ｉ２Ｃ比特率低位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CTRISER     = (u8)( ((((cSysCpuClk / 1000000UL) * 3UL) / 10UL) + 1));
                                                          // 快速模式：最大上升时间＝300ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
  }
  else                                                    // 标准模式：占空比＝Tlow/Thigh＝1／1
  {
    I2CCCRH       = (u8)( ((0<<i2cDUTY )|                 // 快速模式下的占空比＝0：Tlow/Thigh＝2／1，1：Tlow/Thigh＝16／9。
                           (0<<i2cSFM  )|                 // 标准／快速模式选择位＝标准模式
                          cI2c0BrCcrS11H ));              // 置Ｉ２Ｃ比特率高位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CCCRL       = (u8)( cI2c0BrCcrS11L);                // 置Ｉ２Ｃ比特率低位寄存器的数值，注：只有禁用Ｉ２Ｃ模块时，才能设置。
    I2CTRISER     = (u8)( ((cSysCpuClk / 1000000UL) + 1));// 标准模式：最大上升时间＝1000ns，注：只有禁用Ｉ２Ｃ模块时，才能设置。
  }
  I2CCR1         |= (u8)( ((1<<i2cEN   ) ));              // 使能Ｉ２Ｃ模块
#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
}

#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
/*==========================================================================================================
函数名称：　　Ｉ２Ｃ总线工作于单主机方式，重新启动Ｉ２Ｃ总线前一个通讯收发作业
函数功能：　　本函数用于Ｉ２Ｃ总线工作于单主机方式，重新启动Ｉ２Ｃ总线前一个通讯收发作业操作的函数。
函数入口参数：gbitI2c.Txd ------------- “正在进行发送数据作业”标志。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志。
函数返回值：　没有
函数出口参数：gucvI2cEvent ---------- Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
              gstvI2c.TxBuf[0] ------ 每次发送数据缓冲区数组变量，出口值＝要发送的地址。
              gstvI2c.ErrNum -------- Ｉ２Ｃ总线的通讯收发作业发生错误次数值变量，出口值＝０。
              gstvI2c.RxCnt --------- 每次接收数据个数计数器变量，出口值＝０。
调用函数：　　１．
备注：        １．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
static void  CommI2cBusAgain (void)
{
#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线

  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  if (   (gbitI2c.Txd == SET)                             // 如果是先发送若干地址然后再进行发送数据作业？
      && (gbitI2c.Rxd == SET) )
  {
    pI2c->TxBuf[0]         &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  }
  pI2c->RxCnt               =  0x00;                      // Ｉ２Ｃ总线每次接收数据个数计数器清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数值清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

/*==========================================================================================================
函数名称：　　启动Ｉ２Ｃ总线应用中断方式发送数据
函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯发送数据作业操作的函数。
函数入口参数：Object ------------------ 要发送数据的的目标设备地址值。
              *pData ------------------ 指向首个要发送数据在ＳＲＡＭ中的地址指针。
              Length ------------------ 要发送数据的数据总长度。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝清位。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝Length + cI2cAddrNum。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的数据。
　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
#if cI2cTxBufSize < 256
void  CommI2cTxWithData (unsigned char Object, unsigned char *pData, unsigned char Length)
#else
void  CommI2cTxWithData (unsigned char Object, unsigned char *pData, unsigned int  Length)
#endif
{
#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  if (   (Length >= (cI2cTxBufSize - 1))
      || (Length == 0)                   )
  {
    return;
  }
#endif                                                    // “PreCommI2cWithRedundantCode”

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
  gbitI2c.Rxd               =  CLEAR;                     // 清除“正在进行接收数据作业”标志
  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
//  pI2c->Object              =  Object;                    // 复制目标设备地址到每次发送数据的目标设备地址中
//  pI2c->Object             &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
//  pUsart->pTxData           =  pData;                     // 保存要发送的数据序列的地址指针
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
  pI2c->TxBuf[0]           &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  MemCopySramToSram(pData, &pI2c->TxBuf[cI2cAddrNum], Length);
                                                          // 复制发送的数据序列到发送数据缓冲区中
  pI2c->TxSize              =  Length + cI2cAddrNum;      // 置每次发送数据个数大小值
  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

/*==========================================================================================================
函数名称：　　启动Ｉ２Ｃ总线应用中断方式接收数据
函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯接收数据作业操作的函数。
函数入口参数：Object ------------------ 要接收数据的的目标设备地址值。
              Length ------------------ 要接收数据的数据总长度。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝清位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝置位。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝cI2cAddrNum。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的数据。
　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
              gstvI2c.RxSize ---------- 每次接收数据个数大小变量，出口值＝Length。
              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝０。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
#if cI2cRxBufSize < 256
void  CommI2cRxWithData (unsigned char Object, unsigned char Length)
#else
void  CommI2cRxWithData (unsigned char Object, unsigned int  Length)
#endif
{
#if cI2cRxBufSize < 256
  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  if (   (Length > cI2cRxBufSize) )                       // 检查要接收数据的总个数是否超过缓冲区长度？
  {
    Length                  =  cI2cRxBufSize;             // 截断要接收数据的总个数
  }
#endif                                                    // “PreCommI2cWithRedundantCode”

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志
  gbitI2c.Rxd               =  SET;                       // 置“正在进行发送数据作业”标志
  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
  pI2c->TxBuf[0]           |= (u8)( BIT0);                // 设置数据传送方向为接收数据
  pI2c->TxSize              =  cI2cAddrNum;               // 置每次发送数据个数大小值
  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０

  pI2c->RxSize              =  Length;                    // 置Ｉ２Ｃ总线每次接收数据个数大小的值
  pI2c->RxCnt               =  0x00;                      // Ｉ２Ｃ总线每次接收数据个数计数器清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

/*==========================================================================================================
函数名称：　　启动Ｉ２Ｃ总线应用中断方式先发送若干地址然后再进行发送数据作业的函数。
函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯先发送若干地址然后再进行发送数据作业操作的函数。
函数入口参数：Object ------------------ 要发送数据的的目标设备地址值。
              *pAddr ------------------ 指向首个要发送地址在ＳＲＡＭ中的地址指针。
              LenAddr ----------------- 要发送地址的地址总长度。
              *pData ------------------ 指向首个要发送数据在ＳＲＡＭ中的地址指针。
              Length ------------------ 要发送数据的数据总长度。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝清位。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝LenAddr + Length + cI2cAddrNum。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的地址和数据。
　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
#if cI2cTxBufSize < 256
void  CommI2cTxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char *pData, unsigned char Length)
#else
void  CommI2cTxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char *pData, unsigned int  Length)
#endif
{
#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  if (   ((LenAddr + Length) > (cI2cTxBufSize - 1))       // 检查要接收数据的总个数是否超过缓冲区长度？
      || (LenAddr == 0)                   )
  {
    return;
  }
#endif                                                    // “PreCommI2cWithRedundantCode”

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
  gbitI2c.Rxd               =  CLEAR;                     // 清除“正在进行接收数据作业”标志
  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
//  pI2c->Object              =  Object;                    // 复制目标设备地址到每次发送数据的目标设备地址中
//  pI2c->Object             &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
//  pUsart->pTxData           =  pData;                     // 保存要发送的数据序列的地址指针
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
  pI2c->TxBuf[0]           &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  MemCopySramToSram(pAddr, &pI2c->TxBuf[cI2cAddrNum], LenAddr);
                                                          // 复制发送的地址序列到发送数据缓冲区中
  MemCopySramToSram(pData, &pI2c->TxBuf[LenAddr + cI2cAddrNum], Length);
                                                          // 复制发送的数据序列到发送数据缓冲区中
  pI2c->TxSize              =  LenAddr + Length + cI2cAddrNum;
                                                          // 置每次发送数据个数大小值
  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０

  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

/*==========================================================================================================
函数名称：　　启动Ｉ２Ｃ总线应用中断方式先发送若干地址然后再进行接收数据作业的函数。
函数功能：　　本函数用于启动Ｉ２Ｃ总线使用中断方式，进行通讯先发送若干地址然后再进行接收数据作业操作的函数。
函数入口参数：Object ------------------ 要接收数据的的目标设备地址值。
              *pAddr ------------------ 指向首个要发送地址在ＳＲＡＭ中的地址指针。
              LenAddr ----------------- 要发送地址的地址总长度。
              Length ------------------ 要接收数据的数据总长度。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝置位。
              gbitI2c.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
              gbitI2c.Rxd ------------- “正在进行接收数据作业”标志，出口值＝置位。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ cI2cAllNoState（没有相关的状态信息) 。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量，出口值＝LenAddr + cI2cAddrNum。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的地址。
　　　　　　　gstvI2c.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝0。
              gstvI2c.RxSize ---------- 每次接收数据个数大小变量，出口值＝Length。
              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝０。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定Ｉ２Ｃ总线在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommI2cBusBusy(void)”函数，来检查Ｉ２Ｃ总线的工作状态，
　　　　　　　　　　　　只有Ｉ２Ｃ总线处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将触发两线串行总线接口ＴＷＩ中断请求和向Ｉ２Ｃ总线发出 START 信号（起始条件）。
==========================================================================================================*/
#if cI2cTxBufSize < 256
#if cI2cRxBufSize < 256
void  CommI2cRxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned char Length)
#else
void  CommI2cRxWithAddr (unsigned char Object, unsigned char *pAddr, unsigned char LenAddr, unsigned int  Length)
#endif
#else
#if cI2cRxBufSize < 256
void  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
#endif
{
#if cI2cTxBufSize < 256
  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址

#ifdef PreCommI2cWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  if (   (LenAddr >= (cI2cTxBufSize - 1))
      || (LenAddr == 0)                   )
  {
    return;
  }
  if (   (Length > cI2cRxBufSize) )                       // 检查要接收数据的总个数是否超过缓冲区长度？
  {
    Length                  =  cI2cRxBufSize;             // 截断要接收数据的总个数
  }
#endif                                                    // “PreCommI2cWithRedundantCode”

  MFHI2cBusModSwRst( );                                   // 软件复位Ｉ２Ｃ模块，释放Ｉ２Ｃ总线
//  while(CommI2cBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

  gbitI2c.Busy              =  SET;                       // 置“Ｉ２Ｃ总线〖忙〗”标志
  gbitI2c.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
  gbitI2c.Rxd               =  SET;                       // 置“正在进行接收数据作业”标志
  gbitI2c.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  gucvI2cEvent              =  cI2cAllNoState;            // 置Ｉ２Ｃ总线的状态码 ＝ 没有相关的状态信息
  pI2c->OverS               =  RtcGetSecByte(cI2cOverSec);// 启动通讯任务时间计时秒表
//  pI2c->Object              =  Object;                    // 复制目标设备地址到每次发送数据的目标设备地址中
//  pI2c->Object             &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
//  pUsart->pTxData           =  pData;                     // 保存要发送的数据序列的地址指针
  MemCopySramToSram(&Object, pI2c->TxBuf, cI2cAddrNum);   // 复制目标设备地址到发送数据缓冲区中
  pI2c->TxBuf[0]           &= (u8)(~BIT0);                // 设置数据传送方向为写入数据
  MemCopySramToSram(pAddr, &pI2c->TxBuf[cI2cAddrNum], LenAddr);
                                                          // 复制发送的地址序列到发送数据缓冲区中
  pI2c->TxSize              =  LenAddr + cI2cAddrNum;     // 置每次发送数据个数大小值
  pI2c->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
  pI2c->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
  pI2c->ErrNum              =  0x00;                      // Ｉ２Ｃ总线的通讯收发作业发生错误次数清０

  pI2c->RxSize              =  Length;                    // 置Ｉ２Ｃ总线每次接收数据个数大小的值
  pI2c->RxCnt               =  0x00;                      // Ｉ２Ｃ总线每次接收数据个数计数器清０
  MFHI2cFlgEventClr( );                                   // 清０Ｉ２Ｃ总线事件中断标志位
  MFHI2cIntEventOne( );                                   // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
  MFHI2cBusNackStar( );                                   // 发出 START 信号（起始条件），没有 ACK 脉冲
}

/*==========================================================================================================
函数名称：　　Ｉ２Ｃ总线工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
函数功能：　　本函数用于Ｉ２Ｃ总线工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
函数入口参数：gbitI2c.Rxd ------------- “正在进行接收数据作业”标志。
　　　　　　　gstvI2c.TxSize ---------- 每次发送数据个数大小变量。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量。
　　　　　　　gstvI2c.TxBuf[] --------- 每次发送数据缓冲区数组变量。
              gstvI2c.RxSize ---------- 每次接收数据个数大小变量。
函数返回值：　没有
函数出口参数：gbitI2c.Busy ------------ Ｉ２Ｃ总线〖忙〗，出口值＝清位（可能）。
              gbitI2c.Error ----------- 通讯收发作业发生错误，出口值＝置位（可能）。
              gucvI2cEvent ------------ Ｉ２Ｃ总线的状态码变量，出口值＝ 不确定。
　　　　　　　gstvI2c.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝gstvI2c.TxCnt。
　　　　　　　gstvI2c.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝不确定。
              gstvI2c.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝gstvI2c.RxSize。
              gstvI2c.RxBuf[] --------- 每次接收数据缓冲区变量，出口值＝从Ｉ２Ｃ总线上接收到的数据。
调用函数：　　１．
备注：        １．注意：本函数需在Ｉ２Ｃ总线中断请求的中断向量函数中调用。
                  　　　在调用之前需对该中断向量进行初始化，使能该中断。
　　　　　　　２．全部完成通讯收发作业后，本函数将禁止Ｉ２Ｃ总线中断。
==========================================================================================================*/
#if   (   defined(_IAR_EW_AVR_)   \
       || defined(_IAR_EW_STM8_)  )
#pragma vector = int_I2C_vector
INTERRUPT_KEY void  CommI2c_isr (void)
#elif (defined(_KEIL_UV_MCS51_) )
void  CommI2c_isr (void) INTERRUPT_KEY int_I2C_vector using 0
#elif (   defined(_COSMIC_STM8_)  )
INTERRUPT_KEY void  CommI2c_isr (void)
#else
void CommI2cIsr(void);
#endif                                                    // “_IAR_EW_......”
#if   (defined(_IAR_EW_AVR_))
{
#if ((cI2cTxBufSize < 256) && (cI2cRxBufSize < 256))
  register unsigned char    cnt;                          // ＵＳＡＲＴ每次发送数据个数计数器变量
#else
  register unsigned int     cnt;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
  switch (TWSR & cI2cTwsrMask)                            // 判断已屏蔽非状态位的 TWI 状态寄存器状态位值？
  {
    case cI2cAllStart:                                    // START 信号已发送
    case cI2cAllRepStart:                                 // 重复 START 信号已发送
    {
      pI2c->TxCnt           =  0x00;                      // 每次发送数据计数器值清０
    }
    case cI2cMtxAddrAck:                                  // SLA+W 已发送，接收到 ACK
    case cI2cMtxDataAck:                                  // 数据已发送，接收到 ACK
    {
      cnt                   =  pI2c->TxCnt;               // 取Ｉ２Ｃ总线每次发送数据个数计数器变量
      if (cnt >= pI2c->TxSize)                            // 检查是否己完成发送通讯任务的全部数据？
      {                                                   // 是，在最后一个字节之后发出 STOP 信号
        if (gbitI2c.Rxd == SET)                           // 检查是否为读取Ｉ２Ｃ总线数据？
        {
          pI2c->TxBuf[0]   |= (u8)( BIT0);                // 设置数据传送方向为接收数据
          MFHI2cBusNackReps( );                           // 发出重复 START 信号（重新开始条件），没有 ACK 脉冲
        }
        else
        {
          gbitI2c.Busy      =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
          gbitI2c.OverS     =  CLEAR;                     // 清除“通讯任务时间超时”标志
          MFHI2cIntEventOff( );                           // 禁止Ｉ２Ｃ总线事件中断
          MFHI2cBusNackStop( );                           // 发出 STOP 信号（结束条件），没有 ACK 脉冲
        }
      }
      else
      {
        I2CDR               =  pI2c->TxBuf[cnt];          // 从发送缓冲区中将发送数据写入到Ｉ２Ｃ总线
        cnt++;                                            // Ｉ２Ｃ总线每次发送数据个数计数器＋１
        pI2c->TxCnt         =  cnt;                       // 返回Ｉ２Ｃ总线每次发送数据个数计数器值
        // 通过先读 I2CSR1，然后写入 I2CDR，来清０发送结束、发送数据寄存器空标志
        MFHI2cIntEventClr( );                             // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
      }
      break;
    }
    case cI2cMrxDataAck:                                  // 接收到数据，ACK 已返回
    {
      cnt                   =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
      pI2c->RxBuf[cnt]      =  I2CDR;                     // 复制Ｉ２Ｃ总线读取到的字节到接收数据缓冲区中
      cnt++;                                              // Ｉ２Ｃ总线每次接收数据个数计数器＋１
      pI2c->RxCnt           =  cnt;                       // 返回Ｉ２Ｃ总线每次接收数据个数计数器值
    }
    case cI2cMrxAddrAck:                                  // SLA+R 已发送，接收到 ACK
    {
      cnt                   =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
      if (cnt < (pI2c->RxSize - 1))                       // 检查是否完成需要读取的数据长度？
      {
        MFHI2cBusRdataAck( );                             // 在接收之后发出 ACK 脉冲
      }
      else                                                // 在最后一个字节数据接收之后发出 NOT ACK
      {
        MFHI2cBusRdatNack( );                             // 在接收之后发出 NOT ACK
      }
      break;
    }
    case cI2cMrxDataNack:                                 // 接收到数据，NOT ACK 已返回
    {
      cnt                   =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
      pI2c->RxBuf[cnt]      =  I2CDR;                     // 复制Ｉ２Ｃ总线读取到的字节到接收数据缓冲区中
      gbitI2c.Busy          =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
      gbitI2c.OverS         =  CLEAR;                     // 清除“通讯任务时间超时”标志
      MFHI2cIntEventOff( );                               // 禁止Ｉ２Ｃ总线事件中断
      MFHI2cBusNackStop( );                               // 发出 STOP 信号（结束条件），没有 ACK 脉冲
      break;
    }
    case cI2cAllArbLost:                                  // SLA+W 或数据的仲裁失败
    {
      if (pI2c->ErrNum > cI2cErrorMax)                    // 检查通讯收发作业发生错误次数是否大于最大值？
      {
        gbitI2c.Error       =  SET;                       // 置“通讯收发作业发生错误”标志
        MFHI2cInnEventMem( );                             // 存储Ｉ２Ｃ总线的事件和状态存储器值
        MFHI2cIntEventOff( );                             // 禁止Ｉ２Ｃ总线事件中断
      }
      else
      {
        pI2c->ErrNum++;                                   // Ｉ２Ｃ总线的通讯收发作业发生错误次数值＋１
        MFHI2cBusNackReps( );                             // 发出 START 或重复的 START 信号（起始条件），没有 ACK 脉冲
      }
      break;
    }
    case cI2cMtxAddrNack:                                 // SLA+W 已发送，接收到 NOT ACK
    case cI2cMrxAddrNack:                                 // SLA+R 已发送，接收到 NOT ACK
    case cI2cMtxDataNack:                                 // 数据已发送，接收到 NOT ACK
    case cI2cAllNoState:                                  // 没有相关的状态信息； TWINT = "0"
    case cI2cAllBusError:                                 // 由于非法的 START 信号或 STOP 信号引起的总线错误
    default:
    {
      gbitI2c.Error         =  SET;                       // 置“通讯收发作业发生错误”标志
      MFHI2cInnEventMem( );                               // 存储Ｉ２Ｃ总线的事件和状态存储器值
      MFHI2cIntEventOff( );                               // 禁止Ｉ２Ｃ总线事件中断
    }
  }

  INTERRUPT_RETURN( );
}

#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
{
#if ((cI2cTxBufSize < 256) && (cI2cRxBufSize < 256))
  register unsigned char    cnt;                          // ＵＳＡＲＴ每次发送数据个数计数器变量
#else
  register unsigned int     cnt;
#endif
  unsigned char             temp;                         // 临时变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  temp                      =  I2CSR2;                    // 取Ｉ２Ｃ状态寄存器２值
  if (temp & cI2cEvtSr2Mask)                              // 判断已屏蔽非状态位的Ｉ２Ｃ状态寄存器２值？
  {
    pI2c                    = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
    switch (temp & cI2cEvtSr2Mask)                        // 判断已屏蔽非状态位的 TWI 状态寄存器状态位值？
    {
      case cI2cAllArbLost:                                // 仲裁失败【I2CSR2】
      {
        if (pI2c->ErrNum > cI2cErrorMax)                  // 检查通讯收发作业发生错误次数是否大于最大值？
        {
          gbitI2c.Error     =  SET;                       // 置“通讯收发作业发生错误”标志
          MFHI2cInnEventMem( );                           // 存储Ｉ２Ｃ总线的事件和状态存储器值
          MFHI2cIntEventOff( );                           // 禁止Ｉ２Ｃ总线事件中断
          MFHI2cBusNackStop( );                           // 发出 STOP 信号（结束条件），没有 ACK 脉冲
        }
        else
        {
          pI2c->ErrNum++;                                 // Ｉ２Ｃ总线的通讯收发作业发生错误次数值＋１
          MFHI2cBusNackReps( );                           // 发出 START 或重复的 START 信号（起始条件），没有 ACK 脉冲
        }
        break;
      }
//      case cI2cMasterNack:                                // SLA 已发送，接收到 NOT ACK；或者数据已发送／接收到数据，接收到 NOT ACK／NOT ACK 已返回【I2CSR2】
//      case cI2cAllNoState:                                // 没有相关的状态信息； TWINT = "0"
//      case cI2cAllBusError:                               // 由于非法的 START 信号或 STOP 信号引起的总线错误
      default:
      {
        gbitI2c.Error       =  SET;                       // 置“通讯收发作业发生错误”标志
        MFHI2cInnEventMem( );                             // 存储Ｉ２Ｃ总线的事件和状态存储器值
        MFHI2cIntEventOff( );                             // 禁止Ｉ２Ｃ总线事件中断
        MFHI2cBusNackStop( );                             // 发出 STOP 信号（结束条件），没有 ACK 脉冲
      }
    }
  }
  else                                                    // Ｉ２Ｃ总线没有错误
  {
    // 通过先读 I2CSR1，然后再读 I2CSR3，来清０地址已被发送（主模式）／地址匹配（从模式）标志
    temp                    =  I2CSR1;                    // 取Ｉ２Ｃ状态寄存器１值
    if ((I2CSR3 & (u8)( (1<<i2cRXTX ))) == (u8)( (1<<i2cRXTX )))
    {                                                     // 检查Ｉ２Ｃ总线是否为发送数据？
      temp                 |= (u8)( BIT5);                // 是，
    }
    pI2c                    = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
    switch (temp)                                         // 判断Ｉ２Ｃ状态寄存器１＋Ｉ２Ｃ状态寄存器３值？
    {
      case cI2cAllStart:                                  // START 信号已发送
      case cI2cAllRepStart:                               // 重复 START 信号已发送
      {
        pI2c->TxCnt         =  0x00;                      // 每次发送数据计数器值清０
      }
      case cI2cMtxAddrAck:                                // SLA+W 已发送，接收到 ACK
      {
//        if (temp == cI2cMtxAddrAck)
//        {
          MFHI2cIntEventOnn( );                           // 使能缓冲中断
//        }
      }
      case cI2cMtxDataAck:                                // 数据已发送，接收到 ACK
      case cI2cMtxDataAckWait:                            // 数据已发送，接收到 ACK，且没有写新的数据到 I2CDR
      {
        cnt                 =  pI2c->TxCnt;               // 取Ｉ２Ｃ总线每次发送数据个数计数器变量
        if (cnt >= pI2c->TxSize)                          // 检查是否己完成发送通讯任务的全部数据？
        {                                                 // 是，在最后一个字节之后发出 STOP 信号
          if (gbitI2c.Rxd == SET)                         // 检查是否为读取Ｉ２Ｃ总线数据？
          {
            MFHI2cBusNackReps( );                         // 发出重复 START 信号（重新开始条件），没有 ACK 脉冲
            pI2c->TxBuf[0] |= (u8)( BIT0);                // 设置数据传送方向为接收数据
            // 通过先读 I2CSR1，然后写入 I2CDR，来清０发送数据寄存器空，字节发送结束，起始位（主模式）标志
//            MFHI2cIntEventClr( );                         // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
            I2CDR           =  pI2c->TxBuf[0];            // 从发送缓冲区中将发送数据写入到Ｉ２Ｃ总线
            MFHI2cIntEventOff( );                         // 禁止Ｉ２Ｃ总线事件中断
            MFHI2cIntEventOne( );                         // 使能Ｉ２Ｃ总线事件中断、错误中断，禁止缓冲中断
          }
          else
          {
            gbitI2c.Busy    =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
            gbitI2c.OverS   =  CLEAR;                     // 清除“通讯任务时间超时”标志
            MFHI2cIntEventOff( );                         // 禁止Ｉ２Ｃ总线事件中断
            MFHI2cBusNackStop( );                         // 发出 STOP 信号（结束条件），没有 ACK 脉冲
          }
        }
        else
        {
          // 通过先读 I2CSR1，然后写入 I2CDR，来清０发送数据寄存器空，字节发送结束，起始位（主模式）标志
//          MFHI2cIntEventClr( );                           // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
          I2CDR             =  pI2c->TxBuf[cnt];          // 从发送缓冲区中将发送数据写入到Ｉ２Ｃ总线
          cnt++;                                          // Ｉ２Ｃ总线每次发送数据个数计数器＋１
          pI2c->TxCnt       =  cnt;                       // 返回Ｉ２Ｃ总线每次发送数据个数计数器值
        }
        break;
      }
      case cI2cMrxDataAck:                                // 接收到数据，ACK 已返回
      case cI2cMrxDataAckWait:                            // 接收到数据，ACK 已返回，且 I2CDR 中的数据没有被读取
      {
        cnt                 =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
        // 通过先读 I2CSR1，然后读取 I2CDR，来清０接收数据寄存器非空标志
//        MFHI2cIntEventClr( );                             // 进入中断后，在中断句柄中，清０Ｉ２Ｃ总线事件中断标志位（在中断服务程序中）
        pI2c->RxBuf[cnt]    =  I2CDR;                     // 复制Ｉ２Ｃ总线读取到的字节到接收数据缓冲区中
        cnt++;                                            // Ｉ２Ｃ总线每次接收数据个数计数器＋１
        pI2c->RxCnt         =  cnt;                       // 返回Ｉ２Ｃ总线每次接收数据个数计数器值
        cnt                 =  pI2c->RxCnt;               // 取Ｉ２Ｃ总线每次接收数据个数计数器变量
        if      (cnt >= pI2c->RxSize)                     // 检查是否完成需要读取的数据长度？
        {
          gbitI2c.Busy      =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
          gbitI2c.OverS     =  CLEAR;                     // 清除“通讯任务时间超时”标志
          MFHI2cIntEventOff( );                           // 禁止Ｉ２Ｃ总线事件中断
        }
        else if (cnt >= (pI2c->RxSize - 1))               // 在最后一个字节数据接收之后发出 NOT ACK
        {
          MFHI2cBusRdatNack( );                           // 在接收之后发出 NOT ACK
          MFHI2cBusNackStop( );                           // 发出 STOP 信号（结束条件），没有 ACK 脉冲
        }
        else
        {
          MFHI2cBusRdataAck( );                           // 在接收之后发出 ACK 脉冲
        }
        break;
      }
      case cI2cMrxAddrAck:                                // SLA+R 已发送，接收到 ACK
      {
        MFHI2cBusRdataAck( );                             // 在接收之后发出 ACK 脉冲
        MFHI2cIntEventOnn( );                             // 使能缓冲中断
        break;
      }
      default:
      {
        gbitI2c.Error       =  SET;                       // 置“通讯收发作业发生错误”标志
        MFHI2cInnEventMem( );                             // 存储Ｉ２Ｃ总线的事件和状态存储器值
        MFHI2cIntEventOff( );                             // 禁止Ｉ２Ｃ总线事件中断
        MFHI2cBusNackStop( );                             // 发出 STOP 信号（结束条件），没有 ACK 脉冲
      }
    }
  }

  (void)temp;                                             // 用以阻止编译器产生［temp］未使用的警告消息
  INTERRUPT_RETURN( );
}
#else
#error 错误：
#endif                                                    // “PreMcuIs__......”





#endif                                                    // “Ｉ２Ｃ总线工作于单主机方式”条件编译结束

/*==========================================================================================================
函数功能：    本函数是Ｉ２Ｃ总线通信接收和发送作业不间断循环调用运行函数。
备注：        ▲．注意：本函数为消息任务队列函数，要在主函数中不间断循环调用运行。
              ▲．当Ｉ２Ｃ总线工作于从机方式时，Ｉ２Ｃ总线中断总是处于使能状态，以便
                  Ｉ２Ｃ总线处于随时接收数据状态。
==========================================================================================================*/
void  CommI2cCircleFunc (void)
{
#ifdef DEBUG
  unsigned char i;                           // 循环计数器变量
  unsigned char j;
  unsigned char hex_data[2];
  unsigned char *ptr;
#endif
  unsigned char              i;                           // 循环计数器变量
  CommI2cDataStru           *pI2c;                        // 指向Ｉ２Ｃ总线通讯收发数据处理变量的指针

  pI2c                      = &gstvI2c;                   // 取Ｉ２Ｃ总线通讯收发数据处理变量的首个地址
#ifdef PreCommI2cUseSingleMasterMode                      // “Ｉ２Ｃ总线工作于单主机方式”的条件编译
  if (   (gbitI2c.Error == SET)                           // 如果Ｉ２Ｃ总线通讯收发作业发生错误，
      && ( ! CommI2cBusBusy( )) )                         // 且Ｉ２Ｃ总线收发器处于空闲状态？
  {
    if (pI2c->Cycle > cI2cErrorMax)                       // 检查重新启动收发作业错误次数是否大于最大值？
    {
      pI2c->Cycle           =  0x00;                      // Ｉ２Ｃ总线的重新启动收发作业发生错误次数清０
      gbitI2c.Error         =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
      gbitI2c.Busy          =  CLEAR;                     // 清除“Ｉ２Ｃ总线〖忙〗”标志
#ifdef _SYSTEM_ERROR_MANAGE_H_
      sys_error_type       |=  SYS_ERROR_TYPE_IS_GENERAL; // 置【普通】错误类型消息任务标志位
      sys_error_value       =  SYS_ERROR_COMM_I2CBUS    ; // 置“Ｉ２Ｃ总线通信收发作业”错误代码值
#endif
    }
    else
    {
      pI2c->Cycle++;                                      // Ｉ２Ｃ的重新启动收发作业发生错误次数值＋１
      gbitI2c.Error         =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
      CommI2cBusAgain( );                                 // 重新启动Ｉ２Ｃ总线前一个通讯收发作业操作
    }
  }
  // 通讯任务时间超时计时处理，用以处理Ｉ２Ｃ总线直处于“BUSY”状态。
  if (gbitI2c.OverS == SET)
  {
    if (RtcSecByteOverflow(pI2c->OverS))                  // 如果通讯任务时间计时秒表时间已溢出？
    {
      I2CCR2      = (u8)( ((0<<i2cSTART)|                 // 禁止 START 信号（起始条件）
                           (0<<i2cSTOP )|(0<<i2cACKEN)|   // 禁止 STOP 信号（停止条件），使能 ACK 应答
                           (0<<i2cPOS  )|(1<<i2cRST  ) ));// 应答的位置＝当前字节，复位Ｉ２Ｃ模块
      CLKPECR1   &= (u8)(~((1<<clkI2C  )));               // 禁止Ｉ２Ｃ外设时钟
      I2CCR1      = (u8)( ((0<<i2cEN   )|(0<<i2cGCEN )|   // 禁止Ｉ２Ｃ模块，禁止广播呼叫
                           (0<<i2cCKTEN) ));              // 禁止时钟延展
      MFH_PIN_CFG_OUTH_I2cScl;                            // 设置Ｉ２Ｃ时钟引脚为推挽输出，并为Ｈ电平（释放 SCL）
      MFH_PIN_CFG_OUTH_I2cSda;                            // 设置Ｉ２Ｃ数据引脚为推挽输出，并为Ｈ电平（释放 SDA）
      for (i=0; i<9; i++)                                 // 发送 9 个 SCL 时钟脉冲；在此过程中，SDA 为高电平，以复位从设备
      {
        DelayUs(1);
        MFH_PIN_OUT_CLRL_I2cScl;
        DelayUs(1);
        MFH_PIN_OUT_SETH_I2cScl;
      }
      CLKPECR1   |= (u8)( ((1<<clkI2C  )));               // 使能Ｉ２Ｃ外设时钟
      CommI2cInit( );                                     // 重新初始化Ｉ２Ｃ总线
    }
  }
#endif                                                    // “PreCommI2cUseSingleMasterMode”

}





#ifdef __cplusplus
}                                                         // extern "C" 链接指示符作用域结束
#endif


/*
************************************************************************************************************
　　　　　　　　　　　　　　　　　　　　 本Ｃ语言源程序文件到此结束
************************************************************************************************************
*/

/*------------------------------------------------------------------------------------------------
　　　　　　　　　两线串行总线接口（I2C）
------------------------------------------------------------------------------------------------*/
// I2CCR1（I2C_CR1）——— Ｉ２Ｃ控制寄存器１
#define i2cEN                 0                           // Ｉ２Ｃ启动／停止使能位
#define i2cGCEN               6                           // 广播呼叫使能位
#define i2cCKTEN              7                           // 时钟延展禁止位

// I2CCR2（I2C_CR2）——— Ｉ２Ｃ控制寄存器２
#define i2cSTART              0                           // 起始位状态
#define i2cSTOP               1                           // 结束位状态
#define i2cACKEN              2                           // 应答使能位
#define i2cPOS                3                           // 应答的位置
#define i2cRST                7                           // 软件复位

// I2CARL（I2C_OARL）——— Ｉ２Ｃ（从机）地址低位寄存器
#define i2cADD0               0                           // Ｉ２Ｃ从机地址位０
#define i2cADD1               1                           // Ｉ２Ｃ从机地址位１
#define i2cADD2               2                           // Ｉ２Ｃ从机地址位２
#define i2cADD3               3                           // Ｉ２Ｃ从机地址位３
#define i2cADD4               4                           // Ｉ２Ｃ从机地址位４
#define i2cADD5               5                           // Ｉ２Ｃ从机地址位５
#define i2cADD6               6                           // Ｉ２Ｃ从机地址位６
#define i2cADD7               7                           // Ｉ２Ｃ从机地址位７
#define i2cADD17              1                           // Ｉ２Ｃ从机地址位１～７

// I2CARH（I2C_OARH）——— Ｉ２Ｃ（从机）地址高位寄存器
#define i2cADD8               1                           // Ｉ２Ｃ从机地址位８
#define i2cADD9               2                           // Ｉ２Ｃ从机地址位９
#define i2cCFG                6                           // 地址模式配置
#define i2cMODE               7                           // 寻址模式
#define i2cADD89              1                           // Ｉ２Ｃ从机地址位８～９

// I2CSR1（I2C_SR1）——— Ｉ２Ｃ状态寄存器１
#define i2cSTAF               0                           // 起始位（主模式）
#define i2cADDTR              1                           // 地址已被发送（主模式）／地址匹配（从模式）
#define i2cTXC                2                           // 字节发送结束
#define i2cADD10              3                           // １０位头序列已发送（主模式）
#define i2cSTODF              4                           // 停止条件检测位（从模式）
#define i2cRXNE               6                           // 接收数据寄存器非空
#define i2cDRE                7                           // 发送数据寄存器空

// I2CSR2（I2C_SR2）——— Ｉ２Ｃ状态寄存器２
#define i2cBERR               0                           // 总线错误
#define i2cARLO               1                           // 仲裁失败（主模式）
#define i2cACKF               2                           // 应答失败
#define i2cOVF                3                           // 溢出标志位
#define i2cWUF                5                           // 从停机(Halt)模式唤醒标志

// I2CSR3（I2C_SR3）——— Ｉ２Ｃ状态寄存器３
#define i2cMSF                0                           // 主／从机模式标志位
#define i2cBSY                1                           // 总线忙标志
#define i2cRXTX               2                           // 接收器／发送器，０：接收，１：发送
#define i2cGCF                4                           // 广播呼叫头序列（从模式）

// I2CICR（I2C_ITR）——— Ｉ２Ｃ中断控制寄存器
#define i2cERRIE              0                           // 错误中断使能位
#define i2cEVTIE              1                           // 事件中断使能位
#define i2cBUFIE              2                           // 缓冲中断使能位

// I2CCCRL（I2C_CCRL）——— Ｉ２Ｃ时钟控制低位寄存器
#define i2cCS0                0                           // 预分频器时钟选择位０
#define i2cCS1                1                           // 预分频器时钟选择位１
#define i2cCS2                2                           // 预分频器时钟选择位２
#define i2cCS3                3                           // 预分频器时钟选择位３
#define i2cCS4                4                           // 预分频器时钟选择位４
#define i2cCS5                5                           // 预分频器时钟选择位５
#define i2cCS6                6                           // 预分频器时钟选择位６
#define i2cCS7                7                           // 预分频器时钟选择位７

// I2CCCRH （I2C_CCRH）——— Ｉ２Ｃ时钟控制高位寄存器
#define i2cCS8                0                           // 预分频器选择控制位８
#define i2cCS9                1                           // 预分频器选择控制位９
#define i2cCSA                2                           // 预分频器选择控制位１０
#define i2cCSB                3                           // 预分频器选择控制位１１
#define i2cDUTY               6                           // 快速模式下的占空比
#define i2cSFM                7                           // 标准／快速模式选择位

__IO_REG8_BIT(I2CCR1    , 0x5210, __READ_WRITE, __BITS_I2C_CR1      );// Ｉ２Ｃ控制寄存器１
__IO_REG8_BIT(I2CCR2    , 0x5211, __READ_WRITE, __BITS_I2C_CR2      );// Ｉ２Ｃ控制寄存器２
__IO_REG8_BIT(I2CFR     , 0x5212, __READ_WRITE, __BITS_I2C_FREQR    );// Ｉ２Ｃ频率寄存器
__IO_REG8_BIT(I2CARL    , 0x5213, __READ_WRITE, __BITS_I2C_OARL     );// Ｉ２Ｃ（从机）地址低位寄存器
__IO_REG8_BIT(I2CARH    , 0x5214, __READ_WRITE, __BITS_I2C_OARH     );// Ｉ２Ｃ（从机）地址高位寄存器
__IO_REG8    (I2CDR     , 0x5216, __READ_WRITE                      );// Ｉ２Ｃ数据寄存器
__IO_REG8_BIT(I2CSR1    , 0x5217, __READ,       __BITS_I2C_SR1      );// Ｉ２Ｃ状态寄存器１
__IO_REG8_BIT(I2CSR2    , 0x5218, __READ_WRITE, __BITS_I2C_SR2      );// Ｉ２Ｃ状态寄存器２
__IO_REG8_BIT(I2CSR3    , 0x5219, __READ,       __BITS_I2C_SR3      );// Ｉ２Ｃ状态寄存器３
__IO_REG8_BIT(I2CICR    , 0x521A, __READ_WRITE, __BITS_I2C_ITR      );// Ｉ２Ｃ中断控制寄存器
__IO_REG8    (I2CCCRL   , 0x521B, __READ_WRITE                      );// Ｉ２Ｃ比特率低位寄存器
__IO_REG8_BIT(I2CCCRH   , 0x521C, __READ_WRITE, __BITS_I2C_CCRH     );// Ｉ２Ｃ比特率高位寄存器
__IO_REG8_BIT(I2CTRISER , 0x521D, __READ_WRITE, __BITS_I2C_TRISER   );// Ｉ２ＣＴＲＩＳＥ寄存器
__IO_REG8    (I2CPECR   , 0x521E, __READ_WRITE                      );// Ｉ２Ｃ包错误检查寄存器

感谢分享～一大串

这是干什么呢，求关注吗