git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M23_Nuvoton_NuMaker_PFM_M2351_IAR_GCC/Nuvoton_Code/StdDriver/src/usci_i2c.c

   1 /****************************************************************************//**\r
   2  * @file     usci_i2c.c\r
   3  * @version  V3.00\r
   4  * $Revision: 1 $\r
   5  * $Date: 16/07/07 7:50p $\r
   6  * @brief    M2351 series USCI I2C(UI2C) driver source file\r
   7  *\r
   8  * @note\r
   9  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.\r
  10 *****************************************************************************/\r
  11 #include "NuMicro.h"\r
  12 \r
  13 /** @addtogroup Standard_Driver Standard Driver\r
  14   @{\r
  15 */\r
  16 \r
  17 /** @addtogroup USCI_I2C_Driver USCI_I2C Driver\r
  18   @{\r
  19 */\r
  20 \r
  21 \r
  22 /** @addtogroup USCI_I2C_EXPORTED_FUNCTIONS USCI_I2C Exported Functions\r
  23   @{\r
  24 */\r
  25 \r
  26 /**\r
  27  *    @brief        This function makes USCI_I2C module be ready and set the wanted bus clock\r
  28  *\r
  29  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
  30  *    @param[in]    u32BusClock     The target bus speed of USCI_I2C module.\r
  31  *\r
  32  *    @return       Actual USCI_I2C bus clock frequency.\r
  33  *\r
  34  *    @details      Enable USCI_I2C module and configure USCI_I2C module(bus clock, data format).\r
  35  */\r
  36 uint32_t UI2C_Open(UI2C_T *ui2c, uint32_t u32BusClock)\r
  37 {\r
  38     uint32_t u32ClkDiv;\r
  39     uint32_t u32Pclk;\r
  40 \r
  41     if((ui2c == UI2C1) || (ui2c == UI2C1_NS))\r
  42     {\r
  43         u32Pclk = CLK_GetPCLK1Freq();\r
  44     }\r
  45     else\r
  46     {\r
  47         u32Pclk = CLK_GetPCLK0Freq();\r
  48     }\r
  49 \r
  50     u32ClkDiv = (uint32_t)((((((u32Pclk / 2u) * 10u) / (u32BusClock)) + 5u) / 10u) - 1u); /* Compute proper divider for USCI_I2C clock */\r
  51 \r
  52     /* Enable USCI_I2C protocol */\r
  53     ui2c->CTL &= ~UI2C_CTL_FUNMODE_Msk;\r
  54     ui2c->CTL = 4u << UI2C_CTL_FUNMODE_Pos;\r
  55 \r
  56     /* Data format configuration */\r
  57     /* 8 bit data length */\r
  58     ui2c->LINECTL &= ~UI2C_LINECTL_DWIDTH_Msk;\r
  59     ui2c->LINECTL |= 8u << UI2C_LINECTL_DWIDTH_Pos;\r
  60 \r
  61     /* MSB data format */\r
  62     ui2c->LINECTL &= ~UI2C_LINECTL_LSB_Msk;\r
  63 \r
  64     /* Set USCI_I2C bus clock */\r
  65     ui2c->BRGEN &= ~UI2C_BRGEN_CLKDIV_Msk;\r
  66     ui2c->BRGEN |= (u32ClkDiv << UI2C_BRGEN_CLKDIV_Pos);\r
  67     ui2c->PROTCTL |=  UI2C_PROTCTL_PROTEN_Msk;\r
  68 \r
  69     return (u32Pclk / ((u32ClkDiv + 1u) << 1u));\r
  70 }\r
  71 \r
  72 /**\r
  73  *    @brief        This function closes the USCI_I2C module\r
  74  *\r
  75  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
  76  *\r
  77  *    @return       None\r
  78  *\r
  79  *    @details      Close USCI_I2C protocol function.\r
  80  */\r
  81 void UI2C_Close(UI2C_T *ui2c)\r
  82 {\r
  83     /* Disable USCI_I2C function */\r
  84     ui2c->CTL &= ~UI2C_CTL_FUNMODE_Msk;\r
  85 }\r
  86 \r
  87 /**\r
  88  *    @brief        This function clears the time-out flag\r
  89  *\r
  90  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
  91  *\r
  92  *    @return       None\r
  93  *\r
  94  *    @details      Clear time-out flag when time-out flag is set.\r
  95  */\r
  96 void UI2C_ClearTimeoutFlag(UI2C_T *ui2c)\r
  97 {\r
  98     ui2c->PROTSTS = UI2C_PROTSTS_TOIF_Msk;\r
  99 }\r
 100 \r
 101 /**\r
 102  *    @brief        This function sets the control bit of the USCI_I2C module.\r
 103  *\r
 104  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 105  *    @param[in]    u8Start         Set START bit to USCI_I2C module.\r
 106  *    @param[in]    u8Stop Set      STOP bit to USCI_I2C module.\r
 107  *    @param[in]    u8Ptrg Set      PTRG bit to USCI_I2C module.\r
 108  *    @param[in]    u8Ack Set       ACK bit to USCI_I2C module.\r
 109  *\r
 110  *    @return       None\r
 111  *\r
 112  *    @details      The function set USCI_I2C control bit of USCI_I2C bus protocol.\r
 113  */\r
 114 void UI2C_Trigger(UI2C_T *ui2c, uint8_t u8Start, uint8_t u8Stop, uint8_t u8Ptrg, uint8_t u8Ack)\r
 115 {\r
 116     uint32_t u32Reg = 0u;\r
 117     uint32_t u32Val = ui2c->PROTCTL & ~(UI2C_PROTCTL_STA_Msk | UI2C_PROTCTL_STO_Msk | UI2C_PROTCTL_AA_Msk);\r
 118 \r
 119     if(u8Start)\r
 120     {\r
 121         u32Reg |= UI2C_PROTCTL_STA_Msk;\r
 122     }\r
 123     if(u8Stop)\r
 124     {\r
 125         u32Reg |= UI2C_PROTCTL_STO_Msk;\r
 126     }\r
 127     if(u8Ptrg)\r
 128     {\r
 129         u32Reg |= UI2C_PROTCTL_PTRG_Msk;\r
 130     }\r
 131     if(u8Ack)\r
 132     {\r
 133         u32Reg |= UI2C_PROTCTL_AA_Msk;\r
 134     }\r
 135     ui2c->PROTCTL = u32Val | u32Reg;\r
 136 }\r
 137 \r
 138 /**\r
 139  *    @brief        This function disables the interrupt of USCI_I2C module\r
 140  *\r
 141  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 142  *    @param[in]    u32Mask         The combination of all related interrupt enable bits.\r
 143  *                                  Each bit corresponds to an interrupt enable bit.\r
 144  *                                  This parameter decides which interrupts will be disabled. It is combination of:\r
 145  *                                  - \ref UI2C_TO_INT_MASK\r
 146  *                                  - \ref UI2C_STAR_INT_MASK\r
 147  *                                  - \ref UI2C_STOR_INT_MASK\r
 148  *                                  - \ref UI2C_NACK_INT_MASK\r
 149  *                                  - \ref UI2C_ARBLO_INT_MASK\r
 150  *                                  - \ref UI2C_ERR_INT_MASK\r
 151  *                                  - \ref UI2C_ACK_INT_MASK\r
 152  *\r
 153  *    @return       None\r
 154  *\r
 155  *    @details      The function is used to disable USCI_I2C bus interrupt events.\r
 156  */\r
 157 void UI2C_DisableInt(UI2C_T *ui2c, uint32_t u32Mask)\r
 158 {\r
 159     /* Disable time-out interrupt flag */\r
 160     if((u32Mask & UI2C_TO_INT_MASK) == UI2C_TO_INT_MASK)\r
 161     {\r
 162         ui2c->PROTIEN &= ~UI2C_PROTIEN_TOIEN_Msk;\r
 163     }\r
 164     /* Disable start condition received interrupt flag */\r
 165     if((u32Mask & UI2C_STAR_INT_MASK) == UI2C_STAR_INT_MASK)\r
 166     {\r
 167         ui2c->PROTIEN &= ~UI2C_PROTIEN_STARIEN_Msk;\r
 168     }\r
 169     /* Disable stop condition received interrupt flag */\r
 170     if((u32Mask & UI2C_STOR_INT_MASK) == UI2C_STOR_INT_MASK)\r
 171     {\r
 172         ui2c->PROTIEN &= ~UI2C_PROTIEN_STORIEN_Msk;\r
 173     }\r
 174     /* Disable non-acknowledge interrupt flag */\r
 175     if((u32Mask & UI2C_NACK_INT_MASK) == UI2C_NACK_INT_MASK)\r
 176     {\r
 177         ui2c->PROTIEN &= ~UI2C_PROTIEN_NACKIEN_Msk;\r
 178     }\r
 179     /* Disable arbitration lost interrupt flag */\r
 180     if((u32Mask & UI2C_ARBLO_INT_MASK) == UI2C_ARBLO_INT_MASK)\r
 181     {\r
 182         ui2c->PROTIEN &= ~UI2C_PROTIEN_ARBLOIEN_Msk;\r
 183     }\r
 184 \r
 185     /* Disable error interrupt flag */\r
 186     if((u32Mask & UI2C_ERR_INT_MASK) == UI2C_ERR_INT_MASK)\r
 187     {\r
 188         ui2c->PROTIEN &= ~UI2C_PROTIEN_ERRIEN_Msk;\r
 189     }\r
 190     /* Disable acknowledge interrupt flag */\r
 191     if((u32Mask & UI2C_ACK_INT_MASK) == UI2C_ACK_INT_MASK)\r
 192     {\r
 193         ui2c->PROTIEN &= ~UI2C_PROTIEN_ACKIEN_Msk;\r
 194     }\r
 195 }\r
 196 \r
 197 /**\r
 198  *    @brief        This function enables the interrupt of USCI_I2C module.\r
 199  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 200  *    @param[in]    u32Mask         The combination of all related interrupt enable bits.\r
 201  *                                  Each bit corresponds to a interrupt enable bit.\r
 202  *                                  This parameter decides which interrupts will be enabled. It is combination of:\r
 203  *                                  - \ref UI2C_TO_INT_MASK\r
 204  *                                  - \ref UI2C_STAR_INT_MASK\r
 205  *                                  - \ref UI2C_STOR_INT_MASK\r
 206  *                                  - \ref UI2C_NACK_INT_MASK\r
 207  *                                  - \ref UI2C_ARBLO_INT_MASK\r
 208  *                                  - \ref UI2C_ERR_INT_MASK\r
 209  *                                  - \ref UI2C_ACK_INT_MASK\r
 210  *    @return None\r
 211  *\r
 212  *    @details      The function is used to enable USCI_I2C bus interrupt events.\r
 213  */\r
 214 void UI2C_EnableInt(UI2C_T *ui2c, uint32_t u32Mask)\r
 215 {\r
 216     /* Enable time-out interrupt flag */\r
 217     if((u32Mask & UI2C_TO_INT_MASK) == UI2C_TO_INT_MASK)\r
 218     {\r
 219         ui2c->PROTIEN |= UI2C_PROTIEN_TOIEN_Msk;\r
 220     }\r
 221     /* Enable start condition received interrupt flag */\r
 222     if((u32Mask & UI2C_STAR_INT_MASK) == UI2C_STAR_INT_MASK)\r
 223     {\r
 224         ui2c->PROTIEN |= UI2C_PROTIEN_STARIEN_Msk;\r
 225     }\r
 226     /* Enable stop condition received interrupt flag */\r
 227     if((u32Mask & UI2C_STOR_INT_MASK) == UI2C_STOR_INT_MASK)\r
 228     {\r
 229         ui2c->PROTIEN |= UI2C_PROTIEN_STORIEN_Msk;\r
 230     }\r
 231     /* Enable non-acknowledge interrupt flag */\r
 232     if((u32Mask & UI2C_NACK_INT_MASK) == UI2C_NACK_INT_MASK)\r
 233     {\r
 234         ui2c->PROTIEN |= UI2C_PROTIEN_NACKIEN_Msk;\r
 235     }\r
 236     /* Enable arbitration lost interrupt flag */\r
 237     if((u32Mask & UI2C_ARBLO_INT_MASK) == UI2C_ARBLO_INT_MASK)\r
 238     {\r
 239         ui2c->PROTIEN |= UI2C_PROTIEN_ARBLOIEN_Msk;\r
 240     }\r
 241     /* Enable error interrupt flag */\r
 242     if((u32Mask & UI2C_ERR_INT_MASK) == UI2C_ERR_INT_MASK)\r
 243     {\r
 244         ui2c->PROTIEN |= UI2C_PROTIEN_ERRIEN_Msk;\r
 245     }\r
 246     /* Enable acknowledge interrupt flag */\r
 247     if((u32Mask & UI2C_ACK_INT_MASK) == UI2C_ACK_INT_MASK)\r
 248     {\r
 249         ui2c->PROTIEN |= UI2C_PROTIEN_ACKIEN_Msk;\r
 250     }\r
 251 }\r
 252 \r
 253 /**\r
 254  *    @brief        This function returns the real bus clock of USCI_I2C module\r
 255  *\r
 256  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 257  *\r
 258  *    @return       Actual USCI_I2C bus clock frequency.\r
 259  *\r
 260  *    @details      The function returns the actual USCI_I2C module bus clock.\r
 261  */\r
 262 uint32_t UI2C_GetBusClockFreq(UI2C_T *ui2c)\r
 263 {\r
 264     uint32_t u32Divider;\r
 265     uint32_t u32Pclk;\r
 266 \r
 267     if((ui2c == UI2C1) || (ui2c == UI2C1_NS))\r
 268     {\r
 269         u32Pclk = CLK_GetPCLK1Freq();\r
 270     }\r
 271     else\r
 272     {\r
 273         u32Pclk = CLK_GetPCLK0Freq();\r
 274     }\r
 275     u32Divider = (ui2c->BRGEN & UI2C_BRGEN_CLKDIV_Msk) >> UI2C_BRGEN_CLKDIV_Pos;\r
 276 \r
 277     return (u32Pclk / ((u32Divider + 1u) << 1u));\r
 278 }\r
 279 \r
 280 /**\r
 281  *    @brief        This function sets bus clock frequency of USCI_I2C module\r
 282  *\r
 283  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 284  *    @param[in]    u32BusClock     The target bus speed of USCI_I2C module.\r
 285  *\r
 286  *    @return Actual USCI_I2C bus clock frequency.\r
 287  *\r
 288  *    @details      Use this function set USCI_I2C bus clock frequency and return actual bus clock.\r
 289  */\r
 290 uint32_t UI2C_SetBusClockFreq(UI2C_T *ui2c, uint32_t u32BusClock)\r
 291 {\r
 292     uint32_t u32ClkDiv;\r
 293     uint32_t u32Pclk;\r
 294 \r
 295     if((ui2c == UI2C1) || (ui2c == UI2C1_NS))\r
 296     {\r
 297         u32Pclk = CLK_GetPCLK1Freq();\r
 298     }\r
 299     else\r
 300     {\r
 301         u32Pclk = CLK_GetPCLK0Freq();\r
 302     }\r
 303     u32ClkDiv = (uint32_t)((((((u32Pclk / 2u) * 10u) / (u32BusClock)) + 5u) / 10u) - 1u); /* Compute proper divider for USCI_I2C clock */\r
 304 \r
 305     /* Set USCI_I2C bus clock */\r
 306     ui2c->BRGEN &= ~UI2C_BRGEN_CLKDIV_Msk;\r
 307     ui2c->BRGEN |= (u32ClkDiv << UI2C_BRGEN_CLKDIV_Pos);\r
 308 \r
 309     return (u32Pclk / ((u32ClkDiv + 1u) << 1u));\r
 310 }\r
 311 \r
 312 /**\r
 313  *    @brief        This function gets the interrupt flag of USCI_I2C module\r
 314  *\r
 315  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 316  *    @param[in]    u32Mask         The combination of all related interrupt sources.\r
 317  *                                  Each bit corresponds to a interrupt source.\r
 318  *                                  This parameter decides which interrupt flags will be read. It is combination of:\r
 319  *                                  - \ref UI2C_TO_INT_MASK\r
 320  *                                  - \ref UI2C_STAR_INT_MASK\r
 321  *                                  - \ref UI2C_STOR_INT_MASK\r
 322  *                                  - \ref UI2C_NACK_INT_MASK\r
 323  *                                  - \ref UI2C_ARBLO_INT_MASK\r
 324  *                                  - \ref UI2C_ERR_INT_MASK\r
 325  *                                  - \ref UI2C_ACK_INT_MASK\r
 326  *\r
 327  *    @return       Interrupt flags of selected sources.\r
 328  *\r
 329  *    @details      Use this function to get USCI_I2C interrupt flag when module occurs interrupt event.\r
 330  */\r
 331 uint32_t UI2C_GetIntFlag(UI2C_T *ui2c, uint32_t u32Mask)\r
 332 {\r
 333     uint32_t u32IntFlag = 0U;\r
 334     uint32_t u32TmpValue;\r
 335 \r
 336     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_TOIF_Msk;\r
 337     /* Check Time-out Interrupt Flag */\r
 338     if((u32Mask & UI2C_TO_INT_MASK) && (u32TmpValue))\r
 339     {\r
 340         u32IntFlag |= UI2C_TO_INT_MASK;\r
 341     }\r
 342 \r
 343     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_STARIF_Msk;\r
 344     /* Check Start Condition Received Interrupt Flag */\r
 345     if((u32Mask & UI2C_STAR_INT_MASK) && (u32TmpValue))\r
 346     {\r
 347         u32IntFlag |= UI2C_STAR_INT_MASK;\r
 348     }\r
 349 \r
 350     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_STORIF_Msk;\r
 351     /* Check Stop Condition Received Interrupt Flag */\r
 352     if((u32Mask & UI2C_STOR_INT_MASK) && (u32TmpValue))\r
 353     {\r
 354         u32IntFlag |= UI2C_STOR_INT_MASK;\r
 355     }\r
 356 \r
 357     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_NACKIF_Msk;\r
 358     /* Check Non-Acknowledge Interrupt Flag */\r
 359     if((u32Mask & UI2C_NACK_INT_MASK) && (u32TmpValue))\r
 360     {\r
 361         u32IntFlag |= UI2C_NACK_INT_MASK;\r
 362     }\r
 363 \r
 364     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_ARBLOIF_Msk;\r
 365     /* Check Arbitration Lost Interrupt Flag */\r
 366     if((u32Mask & UI2C_ARBLO_INT_MASK) && (u32TmpValue))\r
 367     {\r
 368         u32IntFlag |= UI2C_ARBLO_INT_MASK;\r
 369     }\r
 370 \r
 371     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_ERRIF_Msk;\r
 372     /* Check Error Interrupt Flag */\r
 373     if((u32Mask & UI2C_ERR_INT_MASK) && (u32TmpValue))\r
 374     {\r
 375         u32IntFlag |= UI2C_ERR_INT_MASK;\r
 376     }\r
 377 \r
 378     u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_ACKIF_Msk;\r
 379     /* Check Acknowledge Interrupt Flag */\r
 380     if((u32Mask & UI2C_ACK_INT_MASK) && (u32TmpValue))\r
 381     {\r
 382         u32IntFlag |= UI2C_ACK_INT_MASK;\r
 383     }\r
 384 \r
 385     return u32IntFlag;\r
 386 }\r
 387 \r
 388 /**\r
 389  *    @brief        This function clears the interrupt flag of USCI_I2C module.\r
 390  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 391  *    @param[in]    u32Mask         The combination of all related interrupt sources.\r
 392  *                                  Each bit corresponds to a interrupt source.\r
 393  *                                  This parameter decides which interrupt flags will be cleared. It is combination of:\r
 394  *                                  - \ref UI2C_TO_INT_MASK\r
 395  *                                  - \ref UI2C_STAR_INT_MASK\r
 396  *                                  - \ref UI2C_STOR_INT_MASK\r
 397  *                                  - \ref UI2C_NACK_INT_MASK\r
 398  *                                  - \ref UI2C_ARBLO_INT_MASK\r
 399  *                                  - \ref UI2C_ERR_INT_MASK\r
 400  *                                  - \ref UI2C_ACK_INT_MASK\r
 401  *\r
 402  *    @return       None\r
 403  *\r
 404  *    @details      Use this function to clear USCI_I2C interrupt flag when module occurs interrupt event and set flag.\r
 405  */\r
 406 void UI2C_ClearIntFlag(UI2C_T *ui2c, uint32_t u32Mask)\r
 407 {\r
 408     /* Clear Time-out Interrupt Flag */\r
 409     if(u32Mask & UI2C_TO_INT_MASK)\r
 410     {\r
 411         ui2c->PROTSTS = UI2C_PROTSTS_TOIF_Msk;\r
 412     }\r
 413     /* Clear Start Condition Received Interrupt Flag */\r
 414     if(u32Mask & UI2C_STAR_INT_MASK)\r
 415     {\r
 416         ui2c->PROTSTS = UI2C_PROTSTS_STARIF_Msk;\r
 417     }\r
 418     /* Clear Stop Condition Received Interrupt Flag */\r
 419     if(u32Mask & UI2C_STOR_INT_MASK)\r
 420     {\r
 421         ui2c->PROTSTS = UI2C_PROTSTS_STORIF_Msk;\r
 422     }\r
 423     /* Clear Non-Acknowledge Interrupt Flag */\r
 424     if(u32Mask & UI2C_NACK_INT_MASK)\r
 425     {\r
 426         ui2c->PROTSTS = UI2C_PROTSTS_NACKIF_Msk;\r
 427     }\r
 428     /* Clear Arbitration Lost Interrupt Flag */\r
 429     if(u32Mask & UI2C_ARBLO_INT_MASK)\r
 430     {\r
 431         ui2c->PROTSTS = UI2C_PROTSTS_ARBLOIF_Msk;\r
 432     }\r
 433     /* Clear Error Interrupt Flag */\r
 434     if(u32Mask & UI2C_ERR_INT_MASK)\r
 435     {\r
 436         ui2c->PROTSTS = UI2C_PROTSTS_ERRIF_Msk;\r
 437     }\r
 438     /* Clear Acknowledge Interrupt Flag */\r
 439     if(u32Mask & UI2C_ACK_INT_MASK)\r
 440     {\r
 441         ui2c->PROTSTS = UI2C_PROTSTS_ACKIF_Msk;\r
 442     }\r
 443 }\r
 444 \r
 445 /**\r
 446  *    @brief        This function returns the data stored in data register of USCI_I2C module.\r
 447  *\r
 448  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 449  *\r
 450  *    @return       USCI_I2C data.\r
 451  *\r
 452  *    @details      To read a byte data from USCI_I2C module receive data register.\r
 453  */\r
 454 uint32_t UI2C_GetData(UI2C_T *ui2c)\r
 455 {\r
 456     return (ui2c->RXDAT);\r
 457 }\r
 458 \r
 459 /**\r
 460  *    @brief        This function writes a byte data to data register of USCI_I2C module\r
 461  *\r
 462  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 463  *    @param[in]    u8Data          The data which will be written to data register of USCI_I2C module.\r
 464  *\r
 465  *    @return       None\r
 466  *\r
 467  *    @details      To write a byte data to transmit data register to transmit data.\r
 468  */\r
 469 void UI2C_SetData(UI2C_T *ui2c, uint8_t u8Data)\r
 470 {\r
 471     ui2c->TXDAT = u8Data;\r
 472 }\r
 473 \r
 474 /**\r
 475  *    @brief        Configure slave address and enable GC mode\r
 476  *\r
 477  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 478  *    @param[in]    u8SlaveNo       Slave channel number [0/1]\r
 479  *    @param[in]    u16SlaveAddr    The slave address.\r
 480  *    @param[in]    u8GCMode        GC mode enable or not. Valid values are:\r
 481  *                                  - \ref UI2C_GCMODE_ENABLE\r
 482  *                                  - \ref UI2C_GCMODE_DISABLE\r
 483  *\r
 484  *    @return None\r
 485  *\r
 486  *    @details      To configure USCI_I2C module slave address and GC mode.\r
 487  */\r
 488 void UI2C_SetSlaveAddr(UI2C_T *ui2c, uint8_t u8SlaveNo, uint16_t u16SlaveAddr, uint8_t u8GCMode)\r
 489 {\r
 490     if(u8SlaveNo)\r
 491     {\r
 492         ui2c->DEVADDR1  = u16SlaveAddr;\r
 493     }\r
 494     else\r
 495     {\r
 496         ui2c->DEVADDR0  = u16SlaveAddr;\r
 497     }\r
 498     ui2c->PROTCTL  = (ui2c->PROTCTL & ~UI2C_PROTCTL_GCFUNC_Msk) | u8GCMode;\r
 499 }\r
 500 \r
 501 /**\r
 502  *    @brief        Configure the mask bit of slave address.\r
 503  *\r
 504  *    @param[in]    ui2c             The pointer of the specified USCI_I2C module.\r
 505  *    @param[in]    u8SlaveNo        Slave channle number [0/1]\r
 506  *    @param[in]    u16SlaveAddrMask The slave address mask.\r
 507  *\r
 508  *    @return None\r
 509  *\r
 510  *    @details      To configure USCI_I2C module slave  address mask bit.\r
 511  *    @note         The corresponding address bit is "Don't Care".\r
 512  */\r
 513 void UI2C_SetSlaveAddrMask(UI2C_T *ui2c, uint8_t u8SlaveNo, uint16_t u16SlaveAddrMask)\r
 514 {\r
 515     if(u8SlaveNo)\r
 516     {\r
 517         ui2c->ADDRMSK1  = u16SlaveAddrMask;\r
 518     }\r
 519     else\r
 520     {\r
 521         ui2c->ADDRMSK0  = u16SlaveAddrMask;\r
 522     }\r
 523 }\r
 524 \r
 525 /**\r
 526  *    @brief        This function enables time-out function and configures timeout counter\r
 527  *\r
 528  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 529  *    @param[in]    u32TimeoutCnt   Timeout counter. Valid values are between 0~0x3FF.\r
 530  *\r
 531  *    @return       None\r
 532  *\r
 533  *    @details      To enable USCI_I2C bus time-out function and set time-out counter.\r
 534  */\r
 535 void UI2C_EnableTimeout(UI2C_T *ui2c, uint32_t u32TimeoutCnt)\r
 536 {\r
 537     ui2c->PROTCTL = (ui2c->PROTCTL & ~UI2C_PROTCTL_TOCNT_Msk) | (u32TimeoutCnt << UI2C_PROTCTL_TOCNT_Pos);\r
 538     ui2c->BRGEN = (ui2c->BRGEN & ~UI2C_BRGEN_TMCNTSRC_Msk) | UI2C_BRGEN_TMCNTEN_Msk;\r
 539 }\r
 540 \r
 541 /**\r
 542  *    @brief        This function disables time-out function\r
 543  *\r
 544  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 545  *\r
 546  *    @return       None\r
 547  *\r
 548  *    @details      To disable USCI_I2C bus time-out function.\r
 549  */\r
 550 void UI2C_DisableTimeout(UI2C_T *ui2c)\r
 551 {\r
 552     ui2c->PROTCTL &= ~UI2C_PROTCTL_TOCNT_Msk;\r
 553     ui2c->BRGEN &= ~UI2C_BRGEN_TMCNTEN_Msk;\r
 554 }\r
 555 \r
 556 /**\r
 557  *    @brief        This function enables the wakeup function of USCI_I2C module\r
 558  *\r
 559  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 560  *    @param[in]    u8WakeupMode    The wake-up mode selection. Valid values are:\r
 561  *                                  - \ref UI2C_DATA_TOGGLE_WK\r
 562  *                                  - \ref UI2C_ADDR_MATCH_WK\r
 563  *\r
 564  *    @return       None\r
 565  *\r
 566  *    @details      To enable USCI_I2C module wake-up function.\r
 567  */\r
 568 void UI2C_EnableWakeup(UI2C_T *ui2c, uint8_t u8WakeupMode)\r
 569 {\r
 570     ui2c->WKCTL = (ui2c->WKCTL & ~UI2C_WKCTL_WKADDREN_Msk) | (u8WakeupMode | UI2C_WKCTL_WKEN_Msk);\r
 571 }\r
 572 \r
 573 /**\r
 574  *    @brief        This function disables the wakeup function of USCI_I2C module\r
 575  *\r
 576  *    @param[in]    ui2c            The pointer of the specified USCI_I2C module.\r
 577  *\r
 578  *    @return       None\r
 579  *\r
 580  *    @details      To disable USCI_I2C module wake-up function.\r
 581  */\r
 582 void UI2C_DisableWakeup(UI2C_T *ui2c)\r
 583 {\r
 584     ui2c->WKCTL &= ~UI2C_WKCTL_WKEN_Msk;\r
 585 }\r
 586 \r
 587 /**\r
 588   * @brief      Write a byte to Slave\r
 589   *\r
 590   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
 591   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
 592   * @param[in]  data            Write a byte data to Slave\r
 593   *\r
 594   * @retval     0               Write data success\r
 595   * @retval     1               Write data fail, or bus occurs error events\r
 596   *\r
 597   * @details    The function is used for USCI_I2C Master write a byte data to Slave.\r
 598   *\r
 599   */\r
 600 \r
 601 uint8_t UI2C_WriteByte(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t data)\r
 602 {\r
 603     uint8_t u8Xfering = 1U, u8Err = 0U, u8Ctrl = 0U;\r
 604     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
 605 \r
 606     UI2C_START(ui2c);                                                       /* Send START */\r
 607 \r
 608     while(u8Xfering)\r
 609     {\r
 610         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
 611 \r
 612         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
 613         {\r
 614             case UI2C_PROTSTS_STARIF_Msk:\r
 615                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
 616                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);             /* Write SLA+W to Register UI2C_TXDAT */\r
 617                 eEvent = MASTER_SEND_ADDRESS;\r
 618                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 619                 break;\r
 620 \r
 621             case UI2C_PROTSTS_ACKIF_Msk:\r
 622                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
 623 \r
 624                 if(eEvent == MASTER_SEND_ADDRESS)\r
 625                 {\r
 626                     UI2C_SET_DATA(ui2c, data);                              /* Write data to UI2C_TXDAT */\r
 627                     eEvent = MASTER_SEND_DATA;\r
 628                 }\r
 629                 else\r
 630                 {\r
 631                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                /* Clear SI and send STOP */\r
 632                 }\r
 633 \r
 634                 break;\r
 635 \r
 636             case UI2C_PROTSTS_NACKIF_Msk:\r
 637                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
 638                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 639                 u8Err = 1U;\r
 640                 break;\r
 641 \r
 642             case UI2C_PROTSTS_STORIF_Msk:\r
 643                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
 644                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 645                 u8Xfering = 0U;\r
 646                 break;\r
 647 \r
 648             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
 649             default:                                                        /* Unknow status */\r
 650                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 651                 u8Err = 1U;\r
 652                 break;\r
 653         }\r
 654 \r
 655         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
 656     }\r
 657 \r
 658     return (u8Err | u8Xfering);                                             /* return (Success)/(Fail) status */\r
 659 }\r
 660 \r
 661 /**\r
 662   * @brief      Write multi bytes to Slave\r
 663   *\r
 664   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
 665   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
 666   * @param[in]  *data           Pointer to array to write data to Slave\r
 667   * @param[in]  u32wLen         How many bytes need to write to Slave\r
 668   *\r
 669   * @return     A length of how many bytes have been transmitted.\r
 670   *\r
 671   * @details    The function is used for USCI_I2C Master write multi bytes data to Slave.\r
 672   *\r
 673   */\r
 674 \r
 675 uint32_t UI2C_WriteMultiBytes(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t *data, uint32_t u32wLen)\r
 676 {\r
 677     uint8_t u8Xfering = 1U, u8Ctrl = 0U;\r
 678     uint32_t u32txLen = 0U;\r
 679 \r
 680     UI2C_START(ui2c);                                                       /* Send START */\r
 681 \r
 682     while(u8Xfering)\r
 683     {\r
 684         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
 685 \r
 686         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
 687         {\r
 688             case UI2C_PROTSTS_STARIF_Msk:\r
 689                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
 690                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);             /* Write SLA+W to Register UI2C_TXDAT */\r
 691                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 692                 break;\r
 693 \r
 694             case UI2C_PROTSTS_ACKIF_Msk:\r
 695                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
 696 \r
 697                 if(u32txLen < u32wLen)\r
 698                     UI2C_SET_DATA(ui2c, data[u32txLen++]);                  /* Write data to UI2C_TXDAT */\r
 699                 else\r
 700                 {\r
 701                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                /* Clear SI and send STOP */\r
 702                 }\r
 703 \r
 704                 break;\r
 705 \r
 706             case UI2C_PROTSTS_NACKIF_Msk:\r
 707                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
 708                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 709                 break;\r
 710 \r
 711             case UI2C_PROTSTS_STORIF_Msk:\r
 712                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
 713                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 714                 u8Xfering = 0U;\r
 715                 break;\r
 716 \r
 717             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
 718             default:                                                        /* Unknow status */\r
 719                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 720                 break;\r
 721         }\r
 722 \r
 723         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_CTL register */\r
 724     }\r
 725 \r
 726     return u32txLen;                                                        /* Return bytes length that have been transmitted */\r
 727 }\r
 728 \r
 729 /**\r
 730   * @brief      Specify a byte register address and write a byte to Slave\r
 731   *\r
 732   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
 733   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
 734   * @param[in]  u8DataAddr      Specify a address (1 byte) of data write to\r
 735   * @param[in]  data            A byte data to write it to Slave\r
 736   *\r
 737   * @retval     0               Write data success\r
 738   * @retval     1               Write data fail, or bus occurs error events\r
 739   *\r
 740   * @details    The function is used for USCI_I2C Master specify a address that data write to in Slave.\r
 741   *\r
 742   */\r
 743 \r
 744 uint8_t UI2C_WriteByteOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t data)\r
 745 {\r
 746     uint8_t u8Xfering = 1U, u8Err = 0U, u8Ctrl = 0U;\r
 747     uint32_t u32txLen = 0U;\r
 748 \r
 749     UI2C_START(ui2c);                                                       /* Send START */\r
 750 \r
 751     while(u8Xfering)\r
 752     {\r
 753         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
 754 \r
 755         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
 756         {\r
 757             case UI2C_PROTSTS_STARIF_Msk:\r
 758                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
 759                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);             /* Write SLA+W to Register UI2C_TXDAT */\r
 760                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 761                 break;\r
 762 \r
 763             case UI2C_PROTSTS_ACKIF_Msk:\r
 764                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
 765 \r
 766                 if(u32txLen == 0U)\r
 767                 {\r
 768                     UI2C_SET_DATA(ui2c, u8DataAddr);                        /* Write data address to UI2C_TXDAT */\r
 769                     u32txLen++;\r
 770                 }\r
 771                 else if(u32txLen == 1U)\r
 772                 {\r
 773                     UI2C_SET_DATA(ui2c, data);                              /* Write data to UI2C_TXDAT */\r
 774                     u32txLen++;\r
 775                 }\r
 776                 else\r
 777                 {\r
 778                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                /* Clear SI and send STOP */\r
 779                 }\r
 780 \r
 781                 break;\r
 782 \r
 783             case UI2C_PROTSTS_NACKIF_Msk:\r
 784                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
 785                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 786                 u8Err = 1U;\r
 787                 break;\r
 788 \r
 789             case UI2C_PROTSTS_STORIF_Msk:\r
 790                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
 791                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 792                 u8Xfering = 0U;\r
 793                 break;\r
 794 \r
 795             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
 796             default:                                                        /* Unknow status */\r
 797                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 798                 u8Err = 1U;\r
 799                 break;\r
 800         }\r
 801 \r
 802         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_CTL register */\r
 803     }\r
 804 \r
 805     return (u8Err | u8Xfering);                                             /* return (Success)/(Fail) status */\r
 806 }\r
 807 \r
 808 \r
 809 /**\r
 810   * @brief      Specify a byte register address and write multi bytes to Slave\r
 811   *\r
 812   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
 813   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
 814   * @param[in]  u8DataAddr      Specify a address (1 byte) of data write to\r
 815   * @param[in]  *data           Pointer to array to write data to Slave\r
 816   * @param[in]  u32wLen         How many bytes need to write to Slave\r
 817   *\r
 818   * @return     A length of how many bytes have been transmitted.\r
 819   *\r
 820   * @details    The function is used for USCI_I2C Master specify a byte address that multi data bytes write to in Slave.\r
 821   *\r
 822   */\r
 823 \r
 824 uint32_t UI2C_WriteMultiBytesOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t *data, uint32_t u32wLen)\r
 825 {\r
 826     uint8_t u8Xfering = 1U, u8Ctrl = 0U;\r
 827     uint32_t u32txLen = 0U;\r
 828     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
 829 \r
 830     UI2C_START(ui2c);                                                       /* Send START */\r
 831 \r
 832     while(u8Xfering)\r
 833     {\r
 834         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
 835 \r
 836         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
 837         {\r
 838             case UI2C_PROTSTS_STARIF_Msk:\r
 839                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
 840                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);             /* Write SLA+W to Register UI2C_TXDAT */\r
 841                 eEvent = MASTER_SEND_ADDRESS;\r
 842                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 843                 break;\r
 844 \r
 845             case UI2C_PROTSTS_ACKIF_Msk:\r
 846                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
 847 \r
 848                 if(eEvent == MASTER_SEND_ADDRESS)\r
 849                 {\r
 850                     UI2C_SET_DATA(ui2c, u8DataAddr);                        /* Write data address to UI2C_TXDAT */\r
 851                     eEvent = MASTER_SEND_DATA;\r
 852                 }\r
 853                 else\r
 854                 {\r
 855                     if(u32txLen < u32wLen)\r
 856                         UI2C_SET_DATA(ui2c, data[u32txLen++]);              /* Write data to UI2C_TXDAT */\r
 857                     else\r
 858                     {\r
 859                         u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);            /* Clear SI and send STOP */\r
 860                     }\r
 861                 }\r
 862 \r
 863                 break;\r
 864 \r
 865             case UI2C_PROTSTS_NACKIF_Msk:\r
 866                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
 867                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 868                 break;\r
 869 \r
 870             case UI2C_PROTSTS_STORIF_Msk:\r
 871                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
 872                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 873                 u8Xfering = 0U;\r
 874                 break;\r
 875 \r
 876             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
 877             default:                                                        /* Unknow status */\r
 878                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
 879                 break;\r
 880         }\r
 881 \r
 882         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_CTL register */\r
 883     }\r
 884 \r
 885     return u32txLen;                                                        /* Return bytes length that have been transmitted */\r
 886 }\r
 887 \r
 888 /**\r
 889   * @brief      Specify two bytes register address and Write a byte to Slave\r
 890   *\r
 891   * @param[in]  *ui2c            The pointer of the specified USCI_I2C module.\r
 892   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
 893   * @param[in]  u16DataAddr     Specify a address (2 byte) of data write to\r
 894   * @param[in]  data            Write a byte data to Slave\r
 895   *\r
 896   * @retval     0               Write data success\r
 897   * @retval     1               Write data fail, or bus occurs error events\r
 898   *\r
 899   * @details    The function is used for USCI_I2C Master specify two bytes address that data write to in Slave.\r
 900   *\r
 901   */\r
 902 \r
 903 uint8_t UI2C_WriteByteTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t data)\r
 904 {\r
 905     uint8_t u8Xfering = 1U, u8Err = 0U, u8Ctrl = 0U;\r
 906     uint32_t u32txLen = 0U;\r
 907 \r
 908     UI2C_START(ui2c);                                                           /* Send START */\r
 909 \r
 910     while(u8Xfering)\r
 911     {\r
 912         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
 913 \r
 914         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
 915         {\r
 916             case UI2C_PROTSTS_STARIF_Msk:\r
 917                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);         /* Clear START INT Flag */\r
 918                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);                 /* Write SLA+W to Register UI2C_TXDAT */\r
 919                 u8Ctrl = UI2C_CTL_PTRG;                                         /* Clear SI */\r
 920                 break;\r
 921 \r
 922             case UI2C_PROTSTS_ACKIF_Msk:\r
 923                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);          /* Clear ACK INT Flag */\r
 924 \r
 925                 if(u32txLen == 0U)\r
 926                 {\r
 927                     UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFF00U) >> 8U);  /* Write Hi byte data address to UI2C_TXDAT */\r
 928                     u32txLen++;\r
 929                 }\r
 930                 else if(u32txLen == 1U)\r
 931                 {\r
 932                     UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU));         /* Write Lo byte data address to UI2C_TXDAT */\r
 933                     u32txLen++;\r
 934                 }\r
 935                 else if(u32txLen == 2U)\r
 936                 {\r
 937                     UI2C_SET_DATA(ui2c, data);                                  /* Write data to UI2C_TXDAT */\r
 938                     u32txLen++;\r
 939                 }\r
 940                 else\r
 941                 {\r
 942                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                /* Clear SI and send STOP */\r
 943                 }\r
 944 \r
 945                 break;\r
 946 \r
 947             case UI2C_PROTSTS_NACKIF_Msk:\r
 948                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);         /* Clear NACK INT Flag */\r
 949                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
 950                 u8Err = 1U;\r
 951                 break;\r
 952 \r
 953             case UI2C_PROTSTS_STORIF_Msk:\r
 954                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
 955                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
 956                 u8Xfering = 0U;\r
 957                 break;\r
 958 \r
 959             case UI2C_PROTSTS_ARBLOIF_Msk:                                      /* Arbitration Lost */\r
 960             default:                                                            /* Unknow status */\r
 961                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
 962                 u8Err = 1U;\r
 963                 break;\r
 964         }\r
 965 \r
 966         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                     /* Write controlbit to UI2C_CTL register */\r
 967     }\r
 968 \r
 969     return (u8Err | u8Xfering);\r
 970 }\r
 971 \r
 972 \r
 973 /**\r
 974   * @brief      Specify two bytes register address and write multi bytes to Slave\r
 975   *\r
 976   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
 977   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
 978   * @param[in]  u16DataAddr     Specify a address (2 bytes) of data write to\r
 979   * @param[in]  *data           Pointer to array to write data to Slave\r
 980   * @param[in]  u32wLen         How many bytes need to write to Slave\r
 981   *\r
 982   * @return     A length of how many bytes have been transmitted.\r
 983   *\r
 984   * @details    The function is used for USCI_I2C Master specify a byte address that multi data write to in Slave.\r
 985   *\r
 986   */\r
 987 \r
 988 uint32_t UI2C_WriteMultiBytesTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t *data, uint32_t u32wLen)\r
 989 {\r
 990     uint8_t u8Xfering = 1U, u8Addr = 1U, u8Ctrl = 0U;\r
 991     uint32_t u32txLen = 0U;\r
 992     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
 993 \r
 994     UI2C_START(ui2c);                                                           /* Send START */\r
 995 \r
 996     while(u8Xfering)\r
 997     {\r
 998         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
 999 \r
1000         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1001         {\r
1002             case UI2C_PROTSTS_STARIF_Msk:\r
1003                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);         /* Clear START INT Flag */\r
1004                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);                 /* Write SLA+W to Register UI2C_TXDAT */\r
1005                 eEvent = MASTER_SEND_ADDRESS;\r
1006                 u8Ctrl = UI2C_CTL_PTRG;                                         /* Clear SI */\r
1007                 break;\r
1008 \r
1009             case UI2C_PROTSTS_ACKIF_Msk:\r
1010                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);          /* Clear ACK INT Flag */\r
1011 \r
1012                 if(eEvent == MASTER_SEND_ADDRESS)\r
1013                 {\r
1014                     UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFF00U) >> 8U);  /* Write Hi byte data address to UI2C_TXDAT */\r
1015                     eEvent = MASTER_SEND_DATA;\r
1016                 }\r
1017                 else if(eEvent == MASTER_SEND_DATA)\r
1018                 {\r
1019                     if(u8Addr)\r
1020                     {\r
1021                         UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU));         /* Write Lo byte data address to UI2C_TXDAT */\r
1022                         u8Addr = 0;\r
1023                     }\r
1024                     else\r
1025                     {\r
1026                         if(u32txLen < u32wLen)\r
1027                         {\r
1028                             UI2C_SET_DATA(ui2c, data[u32txLen++]);                  /* Write data to UI2C_TXDAT */\r
1029                         }\r
1030                         else\r
1031                         {\r
1032                             u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                /* Clear SI and send STOP */\r
1033                         }\r
1034                     }\r
1035                 }\r
1036 \r
1037                 break;\r
1038 \r
1039             case UI2C_PROTSTS_NACKIF_Msk:\r
1040                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);         /* Clear NACK INT Flag */\r
1041                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1042                 break;\r
1043 \r
1044             case UI2C_PROTSTS_STORIF_Msk:\r
1045                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1046                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1047                 u8Xfering = 0U;\r
1048                 break;\r
1049 \r
1050             case UI2C_PROTSTS_ARBLOIF_Msk:                                      /* Arbitration Lost */\r
1051             default:                                                            /* Unknow status */\r
1052                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1053                 break;\r
1054         }\r
1055 \r
1056         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                     /* Write controlbit to UI2C_CTL register */\r
1057     }\r
1058 \r
1059     return u32txLen;                                                            /* Return bytes length that have been transmitted */\r
1060 }\r
1061 \r
1062 /**\r
1063   * @brief      Read a byte from Slave\r
1064   *\r
1065   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
1066   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
1067   *\r
1068   * @return     Read a byte data from Slave\r
1069   *\r
1070   * @details    The function is used for USCI_I2C Master to read a byte data from Slave.\r
1071   *\r
1072   */\r
1073 uint8_t UI2C_ReadByte(UI2C_T *ui2c, uint8_t u8SlaveAddr)\r
1074 {\r
1075     uint8_t u8Xfering = 1U, u8Err = 0U, rdata = 0U, u8Ctrl = 0U;\r
1076     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
1077 \r
1078     UI2C_START(ui2c);                                                       /* Send START */\r
1079 \r
1080     while(u8Xfering)\r
1081     {\r
1082         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
1083 \r
1084         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1085         {\r
1086             case UI2C_PROTSTS_STARIF_Msk:\r
1087                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
1088                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U);             /* Write SLA+R to Register UI2C_TXDAT */\r
1089                 eEvent = MASTER_SEND_H_RD_ADDRESS;\r
1090                 u8Ctrl = UI2C_CTL_PTRG;\r
1091                 break;\r
1092 \r
1093             case UI2C_PROTSTS_ACKIF_Msk:\r
1094                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
1095                 eEvent = MASTER_READ_DATA;\r
1096                 break;\r
1097 \r
1098             case UI2C_PROTSTS_NACKIF_Msk:\r
1099                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
1100 \r
1101                 if(eEvent == MASTER_SEND_H_RD_ADDRESS)\r
1102                 {\r
1103                     u8Err = 1U;\r
1104                 }\r
1105                 else\r
1106                 {\r
1107                     rdata = (unsigned char) UI2C_GET_DATA(ui2c);            /* Receive Data */\r
1108                 }\r
1109 \r
1110                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1111 \r
1112                 break;\r
1113 \r
1114             case UI2C_PROTSTS_STORIF_Msk:\r
1115                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1116                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1117                 u8Xfering = 0U;\r
1118                 break;\r
1119 \r
1120             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
1121             default:                                                        /* Unknow status */\r
1122                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
1123                 u8Err = 1U;\r
1124                 break;\r
1125         }\r
1126 \r
1127         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
1128     }\r
1129 \r
1130     if(u8Err)\r
1131         rdata = 0U;\r
1132 \r
1133     return rdata;                                                           /* Return read data */\r
1134 }\r
1135 \r
1136 \r
1137 /**\r
1138   * @brief      Read multi bytes from Slave\r
1139   *\r
1140   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
1141   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
1142   * @param[out] *rdata          Point to array to store data from Slave\r
1143   * @param[in]  u32rLen         How many bytes need to read from Slave\r
1144   *\r
1145   * @return     A length of how many bytes have been received\r
1146   *\r
1147   * @details    The function is used for USCI_I2C Master to read multi data bytes from Slave.\r
1148   *\r
1149   *\r
1150   */\r
1151 uint32_t UI2C_ReadMultiBytes(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t *rdata, uint32_t u32rLen)\r
1152 {\r
1153     uint8_t u8Xfering = 1U, u8Ctrl = 0U;\r
1154     uint32_t u32rxLen = 0U;\r
1155     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
1156 \r
1157     UI2C_START(ui2c);                                                       /* Send START */\r
1158 \r
1159     while(u8Xfering)\r
1160     {\r
1161         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
1162 \r
1163         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1164         {\r
1165             case UI2C_PROTSTS_STARIF_Msk:\r
1166                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
1167                 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U);             /* Write SLA+R to Register UI2C_TXDAT */\r
1168                 eEvent = MASTER_SEND_H_RD_ADDRESS;\r
1169                 u8Ctrl = UI2C_CTL_PTRG;\r
1170                 break;\r
1171 \r
1172             case UI2C_PROTSTS_ACKIF_Msk:\r
1173                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
1174 \r
1175                 if(eEvent == MASTER_SEND_H_RD_ADDRESS)\r
1176                 {\r
1177                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);\r
1178                     eEvent = MASTER_READ_DATA;\r
1179                 }\r
1180                 else\r
1181                 {\r
1182                     rdata[u32rxLen++] = (unsigned char) UI2C_GET_DATA(ui2c);    /* Receive Data */\r
1183 \r
1184                     if(u32rxLen < (u32rLen - 1U))\r
1185                         u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);\r
1186                     else\r
1187                         u8Ctrl = UI2C_CTL_PTRG;\r
1188                 }\r
1189 \r
1190                 break;\r
1191 \r
1192             case UI2C_PROTSTS_NACKIF_Msk:\r
1193                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
1194 \r
1195                 if(eEvent == MASTER_READ_DATA)\r
1196                     rdata[u32rxLen++] = (unsigned char) UI2C_GET_DATA(ui2c);    /* Receive Data */\r
1197 \r
1198                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1199 \r
1200                 break;\r
1201 \r
1202             case UI2C_PROTSTS_STORIF_Msk:\r
1203                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1204                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1205                 u8Xfering = 0U;\r
1206                 break;\r
1207 \r
1208             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
1209             default:                                                        /* Unknow status */\r
1210                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
1211                 break;\r
1212         }\r
1213 \r
1214         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
1215     }\r
1216 \r
1217     return u32rxLen;                                                        /* Return bytes length that have been received */\r
1218 }\r
1219 \r
1220 \r
1221 /**\r
1222   * @brief      Specify a byte register address and read a byte from Slave\r
1223   *\r
1224   * @param[in]  *ui2c            The pointer of the specified USCI_I2C module.\r
1225   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
1226   * @param[in]  u8DataAddr      Specify a address(1 byte) of data read from\r
1227   *\r
1228   * @return     Read a byte data from Slave\r
1229   *\r
1230   * @details    The function is used for USCI_I2C Master specify a byte address that a data byte read from Slave.\r
1231   *\r
1232   *\r
1233   */\r
1234 uint8_t UI2C_ReadByteOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr)\r
1235 {\r
1236     uint8_t u8Xfering = 1U, u8Err = 0U, rdata = 0U, u8Ctrl = 0U;\r
1237     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
1238 \r
1239     UI2C_START(ui2c);                                                       /* Send START */\r
1240 \r
1241     while(u8Xfering)\r
1242     {\r
1243         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
1244 \r
1245         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1246         {\r
1247             case UI2C_PROTSTS_STARIF_Msk:\r
1248                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
1249 \r
1250                 if(eEvent == MASTER_SEND_START)\r
1251                 {\r
1252                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);         /* Write SLA+W to Register UI2C_TXDAT */\r
1253                     eEvent = MASTER_SEND_ADDRESS;\r
1254                 }\r
1255                 else if(eEvent == MASTER_SEND_REPEAT_START)\r
1256                 {\r
1257                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U);        /* Write SLA+R to Register TXDAT */\r
1258                     eEvent = MASTER_SEND_H_RD_ADDRESS;\r
1259                 }\r
1260 \r
1261                 u8Ctrl = UI2C_CTL_PTRG;\r
1262                 break;\r
1263 \r
1264             case UI2C_PROTSTS_ACKIF_Msk:\r
1265                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
1266 \r
1267                 if(eEvent == MASTER_SEND_ADDRESS)\r
1268                 {\r
1269                     UI2C_SET_DATA(ui2c, u8DataAddr);                        /* Write data address of register */\r
1270                     u8Ctrl = UI2C_CTL_PTRG;\r
1271                     eEvent = MASTER_SEND_DATA;\r
1272                 }\r
1273                 else if(eEvent == MASTER_SEND_DATA)\r
1274                 {\r
1275                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA);                /* Send repeat START signal */\r
1276                     eEvent = MASTER_SEND_REPEAT_START;\r
1277                 }\r
1278                 else\r
1279                 {\r
1280                     /* SLA+R ACK */\r
1281                     u8Ctrl = UI2C_CTL_PTRG;\r
1282                     eEvent = MASTER_READ_DATA;\r
1283                 }\r
1284 \r
1285                 break;\r
1286 \r
1287             case UI2C_PROTSTS_NACKIF_Msk:\r
1288                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
1289 \r
1290                 if(eEvent == MASTER_READ_DATA)\r
1291                 {\r
1292                     rdata = (uint8_t) UI2C_GET_DATA(ui2c);                  /* Receive Data */\r
1293                 }\r
1294                 else\r
1295                 {\r
1296                     u8Err = 1U;\r
1297                 }\r
1298 \r
1299                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1300 \r
1301                 break;\r
1302 \r
1303             case UI2C_PROTSTS_STORIF_Msk:\r
1304                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1305                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1306                 u8Xfering = 0U;\r
1307                 break;\r
1308 \r
1309             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
1310             default:                                                        /* Unknow status */\r
1311                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
1312                 u8Err = 1U;\r
1313                 break;\r
1314         }\r
1315 \r
1316         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
1317     }\r
1318 \r
1319     if(u8Err)\r
1320         rdata = 0U;                                                 /* If occurs error, return 0 */\r
1321 \r
1322     return rdata;                                                  /* Return read data */\r
1323 }\r
1324 \r
1325 /**\r
1326   * @brief      Specify a byte register address and read multi bytes from Slave\r
1327   *\r
1328   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
1329   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
1330   * @param[in]  u8DataAddr      Specify a address (1 bytes) of data read from\r
1331   * @param[out] *rdata          Point to array to store data from Slave\r
1332   * @param[in]  u32rLen         How many bytes need to read from Slave\r
1333   *\r
1334   * @return     A length of how many bytes have been received\r
1335   *\r
1336   * @details    The function is used for USCI_I2C Master specify a byte address that multi data bytes read from Slave.\r
1337   *\r
1338   *\r
1339   */\r
1340 uint32_t UI2C_ReadMultiBytesOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t *rdata, uint32_t u32rLen)\r
1341 {\r
1342     uint8_t u8Xfering = 1U, u8Ctrl = 0U;\r
1343     uint32_t u32rxLen = 0U;\r
1344     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
1345 \r
1346     UI2C_START(ui2c);                                                       /* Send START */\r
1347 \r
1348     while(u8Xfering)\r
1349     {\r
1350         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
1351 \r
1352         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1353         {\r
1354             case UI2C_PROTSTS_STARIF_Msk:\r
1355                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
1356 \r
1357                 if(eEvent == MASTER_SEND_START)\r
1358                 {\r
1359                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);         /* Write SLA+W to Register UI2C_TXDAT */\r
1360                     eEvent = MASTER_SEND_ADDRESS;\r
1361                 }\r
1362                 else if(eEvent == MASTER_SEND_REPEAT_START)\r
1363                 {\r
1364                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U);        /* Write SLA+R to Register TXDAT */\r
1365                     eEvent = MASTER_SEND_H_RD_ADDRESS;\r
1366                 }\r
1367 \r
1368                 u8Ctrl = UI2C_CTL_PTRG;\r
1369                 break;\r
1370 \r
1371             case UI2C_PROTSTS_ACKIF_Msk:\r
1372                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
1373 \r
1374                 if(eEvent == MASTER_SEND_ADDRESS)\r
1375                 {\r
1376                     UI2C_SET_DATA(ui2c, u8DataAddr);                        /* Write data address of register */\r
1377                     u8Ctrl = UI2C_CTL_PTRG;\r
1378                     eEvent = MASTER_SEND_DATA;\r
1379                 }\r
1380                 else if(eEvent == MASTER_SEND_DATA)\r
1381                 {\r
1382                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA);                /* Send repeat START signal */\r
1383                     eEvent = MASTER_SEND_REPEAT_START;\r
1384                 }\r
1385                 else if(eEvent == MASTER_SEND_H_RD_ADDRESS)\r
1386                 {\r
1387                     /* SLA+R ACK */\r
1388                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);\r
1389                     eEvent = MASTER_READ_DATA;\r
1390                 }\r
1391                 else\r
1392                 {\r
1393                     rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c);      /* Receive Data */\r
1394 \r
1395                     if(u32rxLen < u32rLen - 1U)\r
1396                         u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);\r
1397                     else\r
1398                         u8Ctrl = UI2C_CTL_PTRG;\r
1399                 }\r
1400 \r
1401                 break;\r
1402 \r
1403             case UI2C_PROTSTS_NACKIF_Msk:\r
1404                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
1405 \r
1406                 if(eEvent == MASTER_READ_DATA)\r
1407                     rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c);                  /* Receive Data */\r
1408 \r
1409                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1410 \r
1411                 break;\r
1412 \r
1413             case UI2C_PROTSTS_STORIF_Msk:\r
1414                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1415                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1416                 u8Xfering = 0U;\r
1417                 break;\r
1418 \r
1419             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
1420             default:                                                        /* Unknow status */\r
1421                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
1422                 break;\r
1423         }\r
1424 \r
1425         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
1426     }\r
1427 \r
1428     return u32rxLen;                                               /* Return bytes length that have been received */\r
1429 }\r
1430 \r
1431 /**\r
1432   * @brief      Specify two bytes register address and read a byte from Slave\r
1433   *\r
1434   * @param[in]  *ui2c           The pointer of the specified USCI_I2C module.\r
1435   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
1436   * @param[in]  u16DataAddr     Specify a address(2 byte) of data read from\r
1437   *\r
1438   * @return     Read a byte data from Slave\r
1439   *\r
1440   * @details    The function is used for USCI_I2C Master specify two bytes address that a data byte read from Slave.\r
1441   *\r
1442   *\r
1443   */\r
1444 uint8_t UI2C_ReadByteTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr)\r
1445 {\r
1446     uint8_t u8Xfering = 1U, u8Err = 0U, rdata = 0U, u8Addr = 1U, u8Ctrl = 0U;\r
1447     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
1448 \r
1449     UI2C_START(ui2c);                                                       /* Send START */\r
1450 \r
1451     while(u8Xfering)\r
1452     {\r
1453         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
1454 \r
1455         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1456         {\r
1457             case UI2C_PROTSTS_STARIF_Msk:\r
1458                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
1459 \r
1460                 if(eEvent == MASTER_SEND_START)\r
1461                 {\r
1462                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);        /* Write SLA+W to Register UI2C_TXDAT */\r
1463                     eEvent = MASTER_SEND_ADDRESS;\r
1464                 }\r
1465                 else if(eEvent == MASTER_SEND_REPEAT_START)\r
1466                 {\r
1467                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U);        /* Write SLA+R to Register TXDAT */\r
1468                     eEvent = MASTER_SEND_H_RD_ADDRESS;\r
1469                 }\r
1470 \r
1471                 u8Ctrl = UI2C_CTL_PTRG;\r
1472                 break;\r
1473 \r
1474             case UI2C_PROTSTS_ACKIF_Msk:\r
1475                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
1476 \r
1477                 if(eEvent == MASTER_SEND_ADDRESS)\r
1478                 {\r
1479                     UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFF00U) >> 8U);  /* Write Hi byte address of register */\r
1480                     eEvent = MASTER_SEND_DATA;\r
1481                 }\r
1482                 else if(eEvent == MASTER_SEND_DATA)\r
1483                 {\r
1484                     if(u8Addr)\r
1485                     {\r
1486                         UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU));       /* Write Lo byte address of register */\r
1487                         u8Addr = 0;\r
1488                     }\r
1489                     else\r
1490                     {\r
1491                         u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA);                /* Send repeat START signal */\r
1492                         eEvent = MASTER_SEND_REPEAT_START;\r
1493                     }\r
1494                 }\r
1495                 else\r
1496                 {\r
1497                     /* SLA+R ACK */\r
1498                     u8Ctrl = UI2C_CTL_PTRG;\r
1499                     eEvent = MASTER_READ_DATA;\r
1500                 }\r
1501 \r
1502                 break;\r
1503 \r
1504             case UI2C_PROTSTS_NACKIF_Msk:\r
1505                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
1506 \r
1507                 if(eEvent == MASTER_READ_DATA)\r
1508                 {\r
1509                     rdata = (uint8_t) UI2C_GET_DATA(ui2c);                  /* Receive Data */\r
1510                 }\r
1511                 else\r
1512                 {\r
1513                     u8Err = 1U;\r
1514                 }\r
1515 \r
1516                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1517 \r
1518                 break;\r
1519 \r
1520             case UI2C_PROTSTS_STORIF_Msk:\r
1521                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1522                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1523                 u8Xfering = 0U;\r
1524                 break;\r
1525 \r
1526             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
1527             default:                                                        /* Unknow status */\r
1528                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
1529                 u8Err = 1U;\r
1530                 break;\r
1531         }\r
1532 \r
1533         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
1534     }\r
1535 \r
1536     if(u8Err)\r
1537         rdata = 0U;                                                 /* If occurs error, return 0 */\r
1538 \r
1539     return rdata;                                                  /* Return read data */\r
1540 }\r
1541 \r
1542 /**\r
1543   * @brief      Specify two bytes register address and read multi bytes from Slave\r
1544   *\r
1545   * @param[in]  *ui2c            The pointer of the specified USCI_I2C module.\r
1546   * @param[in]  u8SlaveAddr     Access Slave address(7-bit)\r
1547   * @param[in]  u16DataAddr     Specify a address (2 bytes) of data read from\r
1548   * @param[out] *rdata          Point to array to store data from Slave\r
1549   * @param[in]  u32rLen         How many bytes need to read from Slave\r
1550   *\r
1551   * @return     A length of how many bytes have been received\r
1552   *\r
1553   * @details    The function is used for USCI_I2C Master specify two bytes address that multi data bytes read from Slave.\r
1554   *\r
1555   *\r
1556   */\r
1557 uint32_t UI2C_ReadMultiBytesTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t *rdata, uint32_t u32rLen)\r
1558 {\r
1559     uint8_t u8Xfering = 1U, u8Addr = 1U, u8Ctrl = 0U;\r
1560     uint32_t u32rxLen = 0U;\r
1561     enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;\r
1562 \r
1563     UI2C_START(ui2c);                                                       /* Send START */\r
1564 \r
1565     while(u8Xfering)\r
1566     {\r
1567         while(!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U));                      /* Wait UI2C new status occur */\r
1568 \r
1569         switch(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)\r
1570         {\r
1571             case UI2C_PROTSTS_STARIF_Msk:\r
1572                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk);     /* Clear START INT Flag */\r
1573 \r
1574                 if(eEvent == MASTER_SEND_START)\r
1575                 {\r
1576                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U);         /* Write SLA+W to Register UI2C_TXDAT */\r
1577                     eEvent = MASTER_SEND_ADDRESS;\r
1578                 }\r
1579                 else if(eEvent == MASTER_SEND_REPEAT_START)\r
1580                 {\r
1581                     UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U);        /* Write SLA+R to Register TXDAT */\r
1582                     eEvent = MASTER_SEND_H_RD_ADDRESS;\r
1583                 }\r
1584 \r
1585                 u8Ctrl = UI2C_CTL_PTRG;\r
1586                 break;\r
1587 \r
1588             case UI2C_PROTSTS_ACKIF_Msk:\r
1589                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk);      /* Clear ACK INT Flag */\r
1590 \r
1591                 if(eEvent == MASTER_SEND_ADDRESS)\r
1592                 {\r
1593                     UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFF00U) >> 8U);  /* Write Hi byte address of register */\r
1594                     eEvent = MASTER_SEND_DATA;\r
1595                 }\r
1596                 else if(eEvent == MASTER_SEND_DATA)\r
1597                 {\r
1598                     if(u8Addr)\r
1599                     {\r
1600                         UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU));       /* Write Lo byte address of register */\r
1601                         u8Addr = 0;\r
1602                     }\r
1603                     else\r
1604                     {\r
1605                         u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA);                /* Send repeat START signal */\r
1606                         eEvent = MASTER_SEND_REPEAT_START;\r
1607                     }\r
1608                 }\r
1609                 else if(eEvent == MASTER_SEND_H_RD_ADDRESS)\r
1610                 {\r
1611                     u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);\r
1612                     eEvent = MASTER_READ_DATA;\r
1613                 }\r
1614                 else\r
1615                 {\r
1616                     rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c);      /* Receive Data */\r
1617 \r
1618                     if(u32rxLen < u32rLen - 1U)\r
1619                         u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);\r
1620                     else\r
1621                         u8Ctrl = UI2C_CTL_PTRG;\r
1622                 }\r
1623 \r
1624                 break;\r
1625 \r
1626             case UI2C_PROTSTS_NACKIF_Msk:\r
1627                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk);     /* Clear NACK INT Flag */\r
1628 \r
1629                 if(eEvent == MASTER_READ_DATA)\r
1630                     rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c);                  /* Receive Data */\r
1631 \r
1632                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                        /* Clear SI and send STOP */\r
1633 \r
1634                 break;\r
1635 \r
1636             case UI2C_PROTSTS_STORIF_Msk:\r
1637                 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk);     /* Clear STOP INT Flag */\r
1638                 u8Ctrl = UI2C_CTL_PTRG;                                     /* Clear SI */\r
1639                 u8Xfering = 0U;\r
1640                 break;\r
1641 \r
1642             case UI2C_PROTSTS_ARBLOIF_Msk:                                  /* Arbitration Lost */\r
1643             default:                                                        /* Unknow status */\r
1644                 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO);                    /* Clear SI and send STOP */\r
1645                 break;\r
1646         }\r
1647 \r
1648         UI2C_SET_CONTROL_REG(ui2c, u8Ctrl);                                 /* Write controlbit to UI2C_PROTCTL register */\r
1649     }\r
1650 \r
1651     return u32rxLen;                                                        /* Return bytes length that have been received */\r
1652 }\r
1653 \r
1654 /*@}*/ /* end of group USCI_I2C_EXPORTED_FUNCTIONS */\r
1655 \r
1656 /*@}*/ /* end of group USCI_I2C_Driver */\r
1657 \r
1658 /*@}*/ /* end of group Standard_Driver */\r
1659 \r
1660 /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/\r