| M480 BSP V3.05.001 The Board Support Package for M480 Series

usci_i2c.c
Go to the documentation of this file.
1 /****************************************************************************/
9 #include "NuMicro.h"
10
34 uint32_t UI2C_Open(UI2C_T *ui2c, uint32_t u32BusClock)
35 {
36 uint32_t u32ClkDiv;
37 uint32_t u32Pclk;
38
39 if( ui2c == UI2C0 )
40 {
41 u32Pclk = CLK_GetPCLK0Freq();
42 }
43 else
44 {
45 u32Pclk = CLK_GetPCLK1Freq();
46 }
47
48 u32ClkDiv = (uint32_t) ((((((u32Pclk/2U)*10U)/(u32BusClock))+5U)/10U)-1U); /* Compute proper divider for USCI_I2C clock */
49
50 /* Enable USCI_I2C protocol */
51 ui2c->CTL &= ~UI2C_CTL_FUNMODE_Msk;
52 ui2c->CTL = 4U << UI2C_CTL_FUNMODE_Pos;
53
54 /* Data format configuration */
55 /* 8 bit data length */
56 ui2c->LINECTL &= ~UI2C_LINECTL_DWIDTH_Msk;
57 ui2c->LINECTL |= 8U << UI2C_LINECTL_DWIDTH_Pos;
58
59 /* MSB data format */
60 ui2c->LINECTL &= ~UI2C_LINECTL_LSB_Msk;
61
62 /* Set USCI_I2C bus clock */
63 ui2c->BRGEN &= ~UI2C_BRGEN_CLKDIV_Msk;
64 ui2c->BRGEN |= (u32ClkDiv << UI2C_BRGEN_CLKDIV_Pos);
65 ui2c->PROTCTL |= UI2C_PROTCTL_PROTEN_Msk;
66
67 return ( u32Pclk / ((u32ClkDiv+1U)<<1U) );
68 }
69
79 void UI2C_Close(UI2C_T *ui2c)
80 {
81 /* Disable USCI_I2C function */
82 ui2c->CTL &= ~UI2C_CTL_FUNMODE_Msk;
83 }
84
94 void UI2C_ClearTimeoutFlag(UI2C_T *ui2c)
95 {
96 ui2c->PROTSTS = UI2C_PROTSTS_TOIF_Msk;
97 }
98
112 void UI2C_Trigger(UI2C_T *ui2c, uint8_t u8Start, uint8_t u8Stop, uint8_t u8Ptrg, uint8_t u8Ack)
113 {
114 uint32_t u32Reg = 0U;
115 uint32_t u32Val = ui2c->PROTCTL & ~(UI2C_PROTCTL_STA_Msk | UI2C_PROTCTL_STO_Msk | UI2C_PROTCTL_AA_Msk);
116
117 if (u8Start)
118 {
119 u32Reg |= UI2C_PROTCTL_STA_Msk;
120 }
121 if (u8Stop)
122 {
123 u32Reg |= UI2C_PROTCTL_STO_Msk;
124 }
125 if (u8Ptrg)
126 {
127 u32Reg |= UI2C_PROTCTL_PTRG_Msk;
128 }
129 if (u8Ack)
130 {
131 u32Reg |= UI2C_PROTCTL_AA_Msk;
132 }
133
134 ui2c->PROTCTL = u32Val | u32Reg;
135 }
136
156 void UI2C_DisableInt(UI2C_T *ui2c, uint32_t u32Mask)
157 {
158 /* Disable time-out interrupt flag */
159 if((u32Mask & UI2C_TO_INT_MASK) == UI2C_TO_INT_MASK)
160 {
161 ui2c->PROTIEN &= ~UI2C_PROTIEN_TOIEN_Msk;
162 }
163
164 /* Disable start condition received interrupt flag */
165 if((u32Mask & UI2C_STAR_INT_MASK) == UI2C_STAR_INT_MASK)
166 {
167 ui2c->PROTIEN &= ~UI2C_PROTIEN_STARIEN_Msk;
168 }
169
170 /* Disable stop condition received interrupt flag */
171 if((u32Mask & UI2C_STOR_INT_MASK) == UI2C_STOR_INT_MASK)
172 {
173 ui2c->PROTIEN &= ~UI2C_PROTIEN_STORIEN_Msk;
174 }
175
176 /* Disable non-acknowledge interrupt flag */
177 if((u32Mask & UI2C_NACK_INT_MASK) == UI2C_NACK_INT_MASK)
178 {
179 ui2c->PROTIEN &= ~UI2C_PROTIEN_NACKIEN_Msk;
180 }
181
182 /* Disable arbitration lost interrupt flag */
183 if((u32Mask & UI2C_ARBLO_INT_MASK) == UI2C_ARBLO_INT_MASK)
184 {
185 ui2c->PROTIEN &= ~UI2C_PROTIEN_ARBLOIEN_Msk;
186 }
187
188 /* Disable error interrupt flag */
189 if((u32Mask & UI2C_ERR_INT_MASK) == UI2C_ERR_INT_MASK)
190 {
191 ui2c->PROTIEN &= ~UI2C_PROTIEN_ERRIEN_Msk;
192 }
193
194 /* Disable acknowledge interrupt flag */
195 if((u32Mask & UI2C_ACK_INT_MASK) == UI2C_ACK_INT_MASK)
196 {
197 ui2c->PROTIEN &= ~UI2C_PROTIEN_ACKIEN_Msk;
198 }
199 }
200
218 void UI2C_EnableInt(UI2C_T *ui2c, uint32_t u32Mask)
219 {
220 /* Enable time-out interrupt flag */
221 if((u32Mask & UI2C_TO_INT_MASK) == UI2C_TO_INT_MASK)
222 {
223 ui2c->PROTIEN |= UI2C_PROTIEN_TOIEN_Msk;
224 }
225
226 /* Enable start condition received interrupt flag */
227 if((u32Mask & UI2C_STAR_INT_MASK) == UI2C_STAR_INT_MASK)
228 {
229 ui2c->PROTIEN |= UI2C_PROTIEN_STARIEN_Msk;
230 }
231
232 /* Enable stop condition received interrupt flag */
233 if((u32Mask & UI2C_STOR_INT_MASK) == UI2C_STOR_INT_MASK)
234 {
235 ui2c->PROTIEN |= UI2C_PROTIEN_STORIEN_Msk;
236 }
237
238 /* Enable non-acknowledge interrupt flag */
239 if((u32Mask & UI2C_NACK_INT_MASK) == UI2C_NACK_INT_MASK)
240 {
241 ui2c->PROTIEN |= UI2C_PROTIEN_NACKIEN_Msk;
242 }
243
244 /* Enable arbitration lost interrupt flag */
245 if((u32Mask & UI2C_ARBLO_INT_MASK) == UI2C_ARBLO_INT_MASK)
246 {
247 ui2c->PROTIEN |= UI2C_PROTIEN_ARBLOIEN_Msk;
248 }
249
250 /* Enable error interrupt flag */
251 if((u32Mask & UI2C_ERR_INT_MASK) == UI2C_ERR_INT_MASK)
252 {
253 ui2c->PROTIEN |= UI2C_PROTIEN_ERRIEN_Msk;
254 }
255
256 /* Enable acknowledge interrupt flag */
257 if((u32Mask & UI2C_ACK_INT_MASK) == UI2C_ACK_INT_MASK)
258 {
259 ui2c->PROTIEN |= UI2C_PROTIEN_ACKIEN_Msk;
260 }
261 }
262
272 uint32_t UI2C_GetBusClockFreq(UI2C_T *ui2c)
273 {
274 uint32_t u32Divider;
275 uint32_t u32Pclk;
276
277 if (ui2c == UI2C0)
278 {
279 u32Pclk = CLK_GetPCLK0Freq();
280 }
281 else
282 {
283 u32Pclk = CLK_GetPCLK1Freq();
284 }
285
286 u32Divider = (ui2c->BRGEN & UI2C_BRGEN_CLKDIV_Msk) >> UI2C_BRGEN_CLKDIV_Pos;
287
288 return ( u32Pclk / ((u32Divider+1U)<<1U) );
289 }
290
301 uint32_t UI2C_SetBusClockFreq(UI2C_T *ui2c, uint32_t u32BusClock)
302 {
303 uint32_t u32ClkDiv;
304 uint32_t u32Pclk;
305
306 if( ui2c == UI2C0 )
307 {
308 u32Pclk = CLK_GetPCLK0Freq();
309 }
310 else
311 {
312 u32Pclk = CLK_GetPCLK1Freq();
313 }
314
315 u32ClkDiv = (uint32_t) ((((((u32Pclk/2U)*10U)/(u32BusClock))+5U)/10U)-1U); /* Compute proper divider for USCI_I2C clock */
316
317 /* Set USCI_I2C bus clock */
318 ui2c->BRGEN &= ~UI2C_BRGEN_CLKDIV_Msk;
319 ui2c->BRGEN |= (u32ClkDiv << UI2C_BRGEN_CLKDIV_Pos);
320
321 return ( u32Pclk / ((u32ClkDiv+1U)<<1U) );
322 }
323
343 uint32_t UI2C_GetIntFlag(UI2C_T *ui2c, uint32_t u32Mask)
344 {
345 uint32_t u32IntFlag = 0U;
346 uint32_t u32TmpValue;
347
348 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_TOIF_Msk;
349 /* Check Time-out Interrupt Flag */
350 if((u32Mask & UI2C_TO_INT_MASK) && (u32TmpValue))
351 {
352 u32IntFlag |= UI2C_TO_INT_MASK;
353 }
354
355 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_STARIF_Msk;
356 /* Check Start Condition Received Interrupt Flag */
357 if((u32Mask & UI2C_STAR_INT_MASK) && (u32TmpValue))
358 {
359 u32IntFlag |= UI2C_STAR_INT_MASK;
360 }
361
362 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_STORIF_Msk;
363 /* Check Stop Condition Received Interrupt Flag */
364 if((u32Mask & UI2C_STOR_INT_MASK) && (u32TmpValue))
365 {
366 u32IntFlag |= UI2C_STOR_INT_MASK;
367 }
368
369 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_NACKIF_Msk;
370 /* Check Non-Acknowledge Interrupt Flag */
371 if((u32Mask & UI2C_NACK_INT_MASK) && (u32TmpValue))
372 {
373 u32IntFlag |= UI2C_NACK_INT_MASK;
374 }
375
376 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_ARBLOIF_Msk;
377 /* Check Arbitration Lost Interrupt Flag */
378 if((u32Mask & UI2C_ARBLO_INT_MASK) && (u32TmpValue))
379 {
380 u32IntFlag |= UI2C_ARBLO_INT_MASK;
381 }
382
383 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_ERRIF_Msk;
384 /* Check Error Interrupt Flag */
385 if((u32Mask & UI2C_ERR_INT_MASK) && (u32TmpValue))
386 {
387 u32IntFlag |= UI2C_ERR_INT_MASK;
388 }
389
390 u32TmpValue = ui2c->PROTSTS & UI2C_PROTSTS_ACKIF_Msk;
391 /* Check Acknowledge Interrupt Flag */
392 if((u32Mask & UI2C_ACK_INT_MASK) && (u32TmpValue))
393 {
394 u32IntFlag |= UI2C_ACK_INT_MASK;
395 }
396
397 return u32IntFlag;
398 }
399
418 void UI2C_ClearIntFlag(UI2C_T *ui2c, uint32_t u32Mask)
419 {
420 /* Clear Time-out Interrupt Flag */
421 if(u32Mask & UI2C_TO_INT_MASK)
422 {
423 ui2c->PROTSTS = UI2C_PROTSTS_TOIF_Msk;
424 }
425
426 /* Clear Start Condition Received Interrupt Flag */
427 if(u32Mask & UI2C_STAR_INT_MASK)
428 {
429 ui2c->PROTSTS = UI2C_PROTSTS_STARIF_Msk;
430 }
431
432 /* Clear Stop Condition Received Interrupt Flag */
433 if(u32Mask & UI2C_STOR_INT_MASK)
434 {
435 ui2c->PROTSTS = UI2C_PROTSTS_STORIF_Msk;
436 }
437
438 /* Clear Non-Acknowledge Interrupt Flag */
439 if(u32Mask & UI2C_NACK_INT_MASK)
440 {
441 ui2c->PROTSTS = UI2C_PROTSTS_NACKIF_Msk;
442 }
443
444 /* Clear Arbitration Lost Interrupt Flag */
445 if(u32Mask & UI2C_ARBLO_INT_MASK)
446 {
447 ui2c->PROTSTS = UI2C_PROTSTS_ARBLOIF_Msk;
448 }
449
450 /* Clear Error Interrupt Flag */
451 if(u32Mask & UI2C_ERR_INT_MASK)
452 {
453 ui2c->PROTSTS = UI2C_PROTSTS_ERRIF_Msk;
454 }
455
456 /* Clear Acknowledge Interrupt Flag */
457 if(u32Mask & UI2C_ACK_INT_MASK)
458 {
459 ui2c->PROTSTS = UI2C_PROTSTS_ACKIF_Msk;
460 }
461 }
462
472 uint32_t UI2C_GetData(UI2C_T *ui2c)
473 {
474 return ( ui2c->RXDAT );
475 }
476
487 void UI2C_SetData(UI2C_T *ui2c, uint8_t u8Data)
488 {
489 ui2c->TXDAT = u8Data;
490 }
491
506 void UI2C_SetSlaveAddr(UI2C_T *ui2c, uint8_t u8SlaveNo, uint16_t u16SlaveAddr, uint8_t u8GCMode)
507 {
508 if(u8SlaveNo)
509 {
510 ui2c->DEVADDR1 = u16SlaveAddr;
511 }
512 else
513 {
514 ui2c->DEVADDR0 = u16SlaveAddr;
515 }
516
517 ui2c->PROTCTL = (ui2c->PROTCTL & ~UI2C_PROTCTL_GCFUNC_Msk) |u8GCMode;
518 }
519
532 void UI2C_SetSlaveAddrMask(UI2C_T *ui2c, uint8_t u8SlaveNo, uint16_t u16SlaveAddrMask)
533 {
534 if(u8SlaveNo)
535 {
536 ui2c->ADDRMSK1 = u16SlaveAddrMask;
537 }
538 else
539 {
540 ui2c->ADDRMSK0 = u16SlaveAddrMask;
541 }
542 }
543
554 void UI2C_EnableTimeout(UI2C_T *ui2c, uint32_t u32TimeoutCnt)
555 {
556 ui2c->PROTCTL = (ui2c->PROTCTL & ~UI2C_PROTCTL_TOCNT_Msk) | (u32TimeoutCnt << UI2C_PROTCTL_TOCNT_Pos);
557 ui2c->BRGEN = (ui2c->BRGEN & ~UI2C_BRGEN_TMCNTSRC_Msk) | UI2C_BRGEN_TMCNTEN_Msk;
558 }
559
569 void UI2C_DisableTimeout(UI2C_T *ui2c)
570 {
571 ui2c->PROTCTL &= ~UI2C_PROTCTL_TOCNT_Msk;
572 ui2c->BRGEN &= ~UI2C_BRGEN_TMCNTEN_Msk;
573 }
574
587 void UI2C_EnableWakeup(UI2C_T *ui2c, uint8_t u8WakeupMode)
588 {
589 ui2c->WKCTL = (ui2c->WKCTL & ~UI2C_WKCTL_WKADDREN_Msk) | (u8WakeupMode | UI2C_WKCTL_WKEN_Msk);
590 }
591
601 void UI2C_DisableWakeup(UI2C_T *ui2c)
602 {
603 ui2c->WKCTL &= ~UI2C_WKCTL_WKEN_Msk;
604 }
605
620 uint8_t UI2C_WriteByte(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t data)
621 {
622 uint8_t u8Xfering = 1U, u8Err = 0U, u8Ctrl = 0U;
623 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
624
625 UI2C_START(ui2c); /* Send START */
626
627 while (u8Xfering)
628 {
629 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
630
631 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
632 {
633 case UI2C_PROTSTS_STARIF_Msk:
634 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
635 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
636 eEvent = MASTER_SEND_ADDRESS;
637 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
638 break;
639
640 case UI2C_PROTSTS_ACKIF_Msk:
641 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
642
643 if (eEvent == MASTER_SEND_ADDRESS)
644 {
645 UI2C_SET_DATA(ui2c, data); /* Write data to UI2C_TXDAT */
646 eEvent = MASTER_SEND_DATA;
647 }
648 else
649 {
650 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
651 }
652
653 break;
654
655 case UI2C_PROTSTS_NACKIF_Msk:
656 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
657 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
658 u8Err = 1U;
659 break;
660
661 case UI2C_PROTSTS_STORIF_Msk:
662 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
663 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
664 u8Xfering = 0U;
665 break;
666
667 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
668 default: /* Unknow status */
669 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
670 u8Err = 1U;
671 break;
672 }
673
674 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
675 }
676
677 return (u8Err | u8Xfering); /* return (Success)/(Fail) status */
678 }
679
694 uint32_t UI2C_WriteMultiBytes(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t *data, uint32_t u32wLen)
695 {
696 uint8_t u8Xfering = 1U, u8Ctrl = 0U;
697 uint32_t u32txLen = 0U;
698
699 UI2C_START(ui2c); /* Send START */
700
701 while (u8Xfering)
702 {
703 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
704
705 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
706 {
707 case UI2C_PROTSTS_STARIF_Msk:
708 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
709 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
710 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
711 break;
712
713 case UI2C_PROTSTS_ACKIF_Msk:
714 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
715
716 if (u32txLen < u32wLen)
717 UI2C_SET_DATA(ui2c, data[u32txLen++]); /* Write data to UI2C_TXDAT */
718 else
719 {
720 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
721 }
722
723 break;
724
725 case UI2C_PROTSTS_NACKIF_Msk:
726 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
727 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
728 break;
729
730 case UI2C_PROTSTS_STORIF_Msk:
731 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
732 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
733 u8Xfering = 0U;
734 break;
735
736 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
737 default: /* Unknow status */
738 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
739 break;
740 }
741
742 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_CTL register */
743 }
744
745 return u32txLen; /* Return bytes length that have been transmitted */
746 }
747
763 uint8_t UI2C_WriteByteOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t data)
764 {
765 uint8_t u8Xfering = 1U, u8Err = 0U, u8Ctrl = 0U;
766 uint32_t u32txLen = 0U;
767
768 UI2C_START(ui2c); /* Send START */
769
770 while (u8Xfering)
771 {
772 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
773
774 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
775 {
776 case UI2C_PROTSTS_STARIF_Msk:
777 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
778 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
779 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
780 break;
781
782 case UI2C_PROTSTS_ACKIF_Msk:
783 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
784
785 if (u32txLen == 0U)
786 {
787 UI2C_SET_DATA(ui2c, u8DataAddr); /* Write data address to UI2C_TXDAT */
788 u32txLen++;
789 }
790 else if (u32txLen == 1U)
791 {
792 UI2C_SET_DATA(ui2c, data); /* Write data to UI2C_TXDAT */
793 u32txLen++;
794 }
795 else
796 {
797 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
798 }
799
800 break;
801
802 case UI2C_PROTSTS_NACKIF_Msk:
803 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
804 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
805 u8Err = 1U;
806 break;
807
808 case UI2C_PROTSTS_STORIF_Msk:
809 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
810 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
811 u8Xfering = 0U;
812 break;
813
814 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
815 default: /* Unknow status */
816 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
817 u8Err = 1U;
818 break;
819 }
820
821 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_CTL register */
822 }
823
824 return (u8Err | u8Xfering); /* return (Success)/(Fail) status */
825 }
826
827
843 uint32_t UI2C_WriteMultiBytesOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t *data, uint32_t u32wLen)
844 {
845 uint8_t u8Xfering = 1U, u8Ctrl = 0U;
846 uint32_t u32txLen = 0U;
847 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
848
849 UI2C_START(ui2c); /* Send START */
850
851 while (u8Xfering)
852 {
853 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
854
855 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
856 {
857 case UI2C_PROTSTS_STARIF_Msk:
858 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
859 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
860 eEvent = MASTER_SEND_ADDRESS;
861 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
862 break;
863
864 case UI2C_PROTSTS_ACKIF_Msk:
865 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
866
867 if (eEvent == MASTER_SEND_ADDRESS)
868 {
869 UI2C_SET_DATA(ui2c, u8DataAddr); /* Write data address to UI2C_TXDAT */
870 eEvent = MASTER_SEND_DATA;
871 }
872 else
873 {
874 if (u32txLen < u32wLen)
875 UI2C_SET_DATA(ui2c, data[u32txLen++]); /* Write data to UI2C_TXDAT */
876 else
877 {
878 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
879 }
880 }
881
882 break;
883
884 case UI2C_PROTSTS_NACKIF_Msk:
885 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
886 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
887 break;
888
889 case UI2C_PROTSTS_STORIF_Msk:
890 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
891 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
892 u8Xfering = 0U;
893 break;
894
895 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
896 default: /* Unknow status */
897 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
898 break;
899 }
900
901 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_CTL register */
902 }
903
904 return u32txLen; /* Return bytes length that have been transmitted */
905 }
906
922 uint8_t UI2C_WriteByteTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t data)
923 {
924 uint8_t u8Xfering = 1U, u8Err = 0U, u8Ctrl = 0U;
925 uint32_t u32txLen = 0U;
926
927 UI2C_START(ui2c); /* Send START */
928
929 while (u8Xfering)
930 {
931 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
932
933 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
934 {
935 case UI2C_PROTSTS_STARIF_Msk:
936 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
937 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
938 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
939 break;
940
941 case UI2C_PROTSTS_ACKIF_Msk:
942 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
943
944 if (u32txLen == 0U)
945 {
946 UI2C_SET_DATA(ui2c, (uint8_t)((u16DataAddr & 0xFF00U) >> 8U)); /* Write Hi byte data address to UI2C_TXDAT */
947 u32txLen++;
948 }
949 else if (u32txLen == 1U)
950 {
951 UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU)); /* Write Lo byte data address to UI2C_TXDAT */
952 u32txLen++;
953 }
954 else if (u32txLen == 2U)
955 {
956 UI2C_SET_DATA(ui2c, data); /* Write data to UI2C_TXDAT */
957 u32txLen++;
958 }
959 else
960 {
961 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
962 }
963
964 break;
965
966 case UI2C_PROTSTS_NACKIF_Msk:
967 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
968 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
969 u8Err = 1U;
970 break;
971
972 case UI2C_PROTSTS_STORIF_Msk:
973 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
974 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
975 u8Xfering = 0U;
976 break;
977
978 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
979 default: /* Unknow status */
980 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
981 u8Err = 1U;
982 break;
983 }
984
985 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_CTL register */
986 }
987
988 return (u8Err | u8Xfering);
989 }
990
991
1007 uint32_t UI2C_WriteMultiBytesTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t *data, uint32_t u32wLen)
1008 {
1009 uint8_t u8Xfering = 1U, u8Addr = 1U, u8Ctrl = 0U;
1010 uint32_t u32txLen = 0U;
1011 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1012
1013 UI2C_START(ui2c); /* Send START */
1014
1015 while (u8Xfering)
1016 {
1017 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1018
1019 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1020 {
1021 case UI2C_PROTSTS_STARIF_Msk:
1022 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1023 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
1024 eEvent = MASTER_SEND_ADDRESS;
1025 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1026 break;
1027
1028 case UI2C_PROTSTS_ACKIF_Msk:
1029 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1030
1031 if (eEvent == MASTER_SEND_ADDRESS)
1032 {
1033 UI2C_SET_DATA(ui2c, (uint8_t)((u16DataAddr & 0xFF00U) >> 8U)); /* Write Hi byte data address to UI2C_TXDAT */
1034 eEvent = MASTER_SEND_DATA;
1035 }
1036 else if (eEvent == MASTER_SEND_DATA)
1037 {
1038 if (u8Addr)
1039 {
1040 UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU)); /* Write Lo byte data address to UI2C_TXDAT */
1041 u8Addr = 0;
1042 }
1043 else
1044 {
1045 if (u32txLen < u32wLen)
1046 {
1047 UI2C_SET_DATA(ui2c, data[u32txLen++]); /* Write data to UI2C_TXDAT */
1048 }
1049 else
1050 {
1051 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1052 }
1053 }
1054 }
1055
1056 break;
1057
1058 case UI2C_PROTSTS_NACKIF_Msk:
1059 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1060 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1061 break;
1062
1063 case UI2C_PROTSTS_STORIF_Msk:
1064 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1065 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1066 u8Xfering = 0U;
1067 break;
1068
1069 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1070 default: /* Unknow status */
1071 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1072 break;
1073 }
1074
1075 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_CTL register */
1076 }
1077
1078 return u32txLen; /* Return bytes length that have been transmitted */
1079 }
1080
1092 uint8_t UI2C_ReadByte(UI2C_T *ui2c, uint8_t u8SlaveAddr)
1093 {
1094 uint8_t u8Xfering = 1U, u8Err = 0U, rdata = 0U, u8Ctrl = 0U;
1095 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1096
1097 UI2C_START(ui2c); /* Send START */
1098
1099 while (u8Xfering)
1100 {
1101 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1102
1103 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1104 {
1105 case UI2C_PROTSTS_STARIF_Msk:
1106 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1107 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U); /* Write SLA+R to Register UI2C_TXDAT */
1108 eEvent = MASTER_SEND_H_RD_ADDRESS;
1109 u8Ctrl = UI2C_CTL_PTRG;
1110 break;
1111
1112 case UI2C_PROTSTS_ACKIF_Msk:
1113 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1114 eEvent = MASTER_READ_DATA;
1115 break;
1116
1117 case UI2C_PROTSTS_NACKIF_Msk:
1118 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1119
1120 if (eEvent == MASTER_SEND_H_RD_ADDRESS)
1121 {
1122 u8Err = 1U;
1123 }
1124 else
1125 {
1126 rdata = (unsigned char) UI2C_GET_DATA(ui2c); /* Receive Data */
1127 }
1128
1129 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1130
1131 break;
1132
1133 case UI2C_PROTSTS_STORIF_Msk:
1134 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1135 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1136 u8Xfering = 0U;
1137 break;
1138
1139 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1140 default: /* Unknow status */
1141 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1142 u8Err = 1U;
1143 break;
1144 }
1145
1146 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
1147 }
1148
1149 if (u8Err)
1150 rdata = 0U;
1151
1152 return rdata; /* Return read data */
1153 }
1154
1155
1170 uint32_t UI2C_ReadMultiBytes(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t *rdata, uint32_t u32rLen)
1171 {
1172 uint8_t u8Xfering = 1U, u8Ctrl = 0U;
1173 uint32_t u32rxLen = 0U;
1174 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1175
1176 UI2C_START(ui2c); /* Send START */
1177
1178 while (u8Xfering)
1179 {
1180 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1181
1182 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1183 {
1184 case UI2C_PROTSTS_STARIF_Msk:
1185 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1186 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U); /* Write SLA+R to Register UI2C_TXDAT */
1187 eEvent = MASTER_SEND_H_RD_ADDRESS;
1188 u8Ctrl = UI2C_CTL_PTRG;
1189 break;
1190
1191 case UI2C_PROTSTS_ACKIF_Msk:
1192 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1193
1194 if (eEvent == MASTER_SEND_H_RD_ADDRESS)
1195 {
1196 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);
1197 eEvent = MASTER_READ_DATA;
1198 }
1199 else
1200 {
1201 rdata[u32rxLen++] = (unsigned char) UI2C_GET_DATA(ui2c); /* Receive Data */
1202
1203 if (u32rxLen < (u32rLen - 1U))
1204 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);
1205 else
1206 u8Ctrl = UI2C_CTL_PTRG;
1207 }
1208
1209 break;
1210
1211 case UI2C_PROTSTS_NACKIF_Msk:
1212 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1213
1214 if (eEvent == MASTER_READ_DATA)
1215 rdata[u32rxLen++] = (unsigned char) UI2C_GET_DATA(ui2c); /* Receive Data */
1216
1217 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1218
1219 break;
1220
1221 case UI2C_PROTSTS_STORIF_Msk:
1222 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1223 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1224 u8Xfering = 0U;
1225 break;
1226
1227 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1228 default: /* Unknow status */
1229 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1230 break;
1231 }
1232
1233 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
1234 }
1235
1236 return u32rxLen; /* Return bytes length that have been received */
1237 }
1238
1239
1253 uint8_t UI2C_ReadByteOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr)
1254 {
1255 uint8_t u8Xfering = 1U, u8Err = 0U, rdata = 0U, u8Ctrl = 0U;
1256 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1257
1258 UI2C_START(ui2c); /* Send START */
1259
1260 while (u8Xfering)
1261 {
1262 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1263
1264 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1265 {
1266 case UI2C_PROTSTS_STARIF_Msk:
1267 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1268
1269 if (eEvent == MASTER_SEND_START)
1270 {
1271 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
1272 eEvent = MASTER_SEND_ADDRESS;
1273 }
1274 else if (eEvent == MASTER_SEND_REPEAT_START)
1275 {
1276 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U); /* Write SLA+R to Register TXDAT */
1277 eEvent = MASTER_SEND_H_RD_ADDRESS;
1278 }
1279
1280 u8Ctrl = UI2C_CTL_PTRG;
1281 break;
1282
1283 case UI2C_PROTSTS_ACKIF_Msk:
1284 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1285
1286 if (eEvent == MASTER_SEND_ADDRESS)
1287 {
1288 UI2C_SET_DATA(ui2c, u8DataAddr); /* Write data address of register */
1289 u8Ctrl = UI2C_CTL_PTRG;
1290 eEvent = MASTER_SEND_DATA;
1291 }
1292 else if (eEvent == MASTER_SEND_DATA)
1293 {
1294 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA); /* Send repeat START signal */
1295 eEvent = MASTER_SEND_REPEAT_START;
1296 }
1297 else
1298 {
1299 /* SLA+R ACK */
1300 u8Ctrl = UI2C_CTL_PTRG;
1301 eEvent = MASTER_READ_DATA;
1302 }
1303
1304 break;
1305
1306 case UI2C_PROTSTS_NACKIF_Msk:
1307 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1308
1309 if (eEvent == MASTER_READ_DATA)
1310 {
1311 rdata = (uint8_t) UI2C_GET_DATA(ui2c); /* Receive Data */
1312 }
1313 else
1314 {
1315 u8Err = 1U;
1316 }
1317
1318 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1319
1320 break;
1321
1322 case UI2C_PROTSTS_STORIF_Msk:
1323 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1324 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1325 u8Xfering = 0U;
1326 break;
1327
1328 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1329 default: /* Unknow status */
1330 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1331 u8Err = 1U;
1332 break;
1333 }
1334
1335 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
1336 }
1337
1338 if (u8Err)
1339 rdata = 0U; /* If occurs error, return 0 */
1340
1341 return rdata; /* Return read data */
1342 }
1343
1359 uint32_t UI2C_ReadMultiBytesOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t *rdata, uint32_t u32rLen)
1360 {
1361 uint8_t u8Xfering = 1U, u8Ctrl = 0U;
1362 uint32_t u32rxLen = 0U;
1363 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1364
1365 UI2C_START(ui2c); /* Send START */
1366
1367 while (u8Xfering)
1368 {
1369 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1370
1371 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1372 {
1373 case UI2C_PROTSTS_STARIF_Msk:
1374 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1375
1376 if (eEvent == MASTER_SEND_START)
1377 {
1378 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
1379 eEvent = MASTER_SEND_ADDRESS;
1380 }
1381 else if (eEvent == MASTER_SEND_REPEAT_START)
1382 {
1383 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U); /* Write SLA+R to Register TXDAT */
1384 eEvent = MASTER_SEND_H_RD_ADDRESS;
1385 }
1386
1387 u8Ctrl = UI2C_CTL_PTRG;
1388 break;
1389
1390 case UI2C_PROTSTS_ACKIF_Msk:
1391 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1392
1393 if (eEvent == MASTER_SEND_ADDRESS)
1394 {
1395 UI2C_SET_DATA(ui2c, u8DataAddr); /* Write data address of register */
1396 u8Ctrl = UI2C_CTL_PTRG;
1397 eEvent = MASTER_SEND_DATA;
1398 }
1399 else if (eEvent == MASTER_SEND_DATA)
1400 {
1401 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA); /* Send repeat START signal */
1402 eEvent = MASTER_SEND_REPEAT_START;
1403 }
1404 else if (eEvent == MASTER_SEND_H_RD_ADDRESS)
1405 {
1406 /* SLA+R ACK */
1407 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);
1408 eEvent = MASTER_READ_DATA;
1409 }
1410 else
1411 {
1412 rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c); /* Receive Data */
1413
1414 if (u32rxLen < u32rLen - 1U)
1415 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);
1416 else
1417 u8Ctrl = UI2C_CTL_PTRG;
1418 }
1419
1420 break;
1421
1422 case UI2C_PROTSTS_NACKIF_Msk:
1423 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1424
1425 if (eEvent == MASTER_READ_DATA)
1426 rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c); /* Receive Data */
1427
1428 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1429
1430 break;
1431
1432 case UI2C_PROTSTS_STORIF_Msk:
1433 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1434 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1435 u8Xfering = 0U;
1436 break;
1437
1438 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1439 default: /* Unknow status */
1440 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1441 break;
1442 }
1443
1444 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
1445 }
1446
1447 return u32rxLen; /* Return bytes length that have been received */
1448 }
1449
1463 uint8_t UI2C_ReadByteTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr)
1464 {
1465 uint8_t u8Xfering = 1U, u8Err = 0U, rdata = 0U, u8Addr = 1U, u8Ctrl = 0U;
1466 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1467
1468 UI2C_START(ui2c); /* Send START */
1469
1470 while (u8Xfering)
1471 {
1472 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1473
1474 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1475 {
1476 case UI2C_PROTSTS_STARIF_Msk:
1477 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1478
1479 if (eEvent == MASTER_SEND_START)
1480 {
1481 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
1482 eEvent = MASTER_SEND_ADDRESS;
1483 }
1484 else if (eEvent == MASTER_SEND_REPEAT_START)
1485 {
1486 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U); /* Write SLA+R to Register TXDAT */
1487 eEvent = MASTER_SEND_H_RD_ADDRESS;
1488 }
1489
1490 u8Ctrl = UI2C_CTL_PTRG;
1491 break;
1492
1493 case UI2C_PROTSTS_ACKIF_Msk:
1494 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1495
1496 if (eEvent == MASTER_SEND_ADDRESS)
1497 {
1498 UI2C_SET_DATA(ui2c, (uint8_t)((u16DataAddr & 0xFF00U) >> 8U)); /* Write Hi byte address of register */
1499 eEvent = MASTER_SEND_DATA;
1500 }
1501 else if (eEvent == MASTER_SEND_DATA)
1502 {
1503 if (u8Addr)
1504 {
1505 UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU)); /* Write Lo byte address of register */
1506 u8Addr = 0;
1507 }
1508 else
1509 {
1510 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA); /* Send repeat START signal */
1511 eEvent = MASTER_SEND_REPEAT_START;
1512 }
1513 }
1514 else
1515 {
1516 /* SLA+R ACK */
1517 u8Ctrl = UI2C_CTL_PTRG;
1518 eEvent = MASTER_READ_DATA;
1519 }
1520
1521 break;
1522
1523 case UI2C_PROTSTS_NACKIF_Msk:
1524 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1525
1526 if (eEvent == MASTER_READ_DATA)
1527 {
1528 rdata = (uint8_t) UI2C_GET_DATA(ui2c); /* Receive Data */
1529 }
1530 else
1531 {
1532 u8Err = 1U;
1533 }
1534
1535 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1536
1537 break;
1538
1539 case UI2C_PROTSTS_STORIF_Msk:
1540 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1541 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1542 u8Xfering = 0U;
1543 break;
1544
1545 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1546 default: /* Unknow status */
1547 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1548 u8Err = 1U;
1549 break;
1550 }
1551
1552 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
1553 }
1554
1555 if (u8Err)
1556 rdata = 0U; /* If occurs error, return 0 */
1557
1558 return rdata; /* Return read data */
1559 }
1560
1576 uint32_t UI2C_ReadMultiBytesTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t *rdata, uint32_t u32rLen)
1577 {
1578 uint8_t u8Xfering = 1U, u8Addr = 1U, u8Ctrl = 0U;
1579 uint32_t u32rxLen = 0U;
1580 enum UI2C_MASTER_EVENT eEvent = MASTER_SEND_START;
1581
1582 UI2C_START(ui2c); /* Send START */
1583
1584 while (u8Xfering)
1585 {
1586 while (!(UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)); /* Wait UI2C new status occur */
1587
1588 switch (UI2C_GET_PROT_STATUS(ui2c) & 0x3F00U)
1589 {
1590 case UI2C_PROTSTS_STARIF_Msk:
1591 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STARIF_Msk); /* Clear START INT Flag */
1592
1593 if (eEvent == MASTER_SEND_START)
1594 {
1595 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x00U); /* Write SLA+W to Register UI2C_TXDAT */
1596 eEvent = MASTER_SEND_ADDRESS;
1597 }
1598 else if (eEvent == MASTER_SEND_REPEAT_START)
1599 {
1600 UI2C_SET_DATA(ui2c, (u8SlaveAddr << 1U) | 0x01U); /* Write SLA+R to Register TXDAT */
1601 eEvent = MASTER_SEND_H_RD_ADDRESS;
1602 }
1603
1604 u8Ctrl = UI2C_CTL_PTRG;
1605 break;
1606
1607 case UI2C_PROTSTS_ACKIF_Msk:
1608 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_ACKIF_Msk); /* Clear ACK INT Flag */
1609
1610 if (eEvent == MASTER_SEND_ADDRESS)
1611 {
1612 UI2C_SET_DATA(ui2c, (uint8_t)((u16DataAddr & 0xFF00U) >> 8U)); /* Write Hi byte address of register */
1613 eEvent = MASTER_SEND_DATA;
1614 }
1615 else if (eEvent == MASTER_SEND_DATA)
1616 {
1617 if (u8Addr)
1618 {
1619 UI2C_SET_DATA(ui2c, (uint8_t)(u16DataAddr & 0xFFU)); /* Write Lo byte address of register */
1620 u8Addr = 0;
1621 }
1622 else
1623 {
1624 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STA); /* Send repeat START signal */
1625 eEvent = MASTER_SEND_REPEAT_START;
1626 }
1627 }
1628 else if (eEvent == MASTER_SEND_H_RD_ADDRESS)
1629 {
1630 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);
1631 eEvent = MASTER_READ_DATA;
1632 }
1633 else
1634 {
1635 rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c); /* Receive Data */
1636
1637 if (u32rxLen < u32rLen - 1U)
1638 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_AA);
1639 else
1640 u8Ctrl = UI2C_CTL_PTRG;
1641 }
1642
1643 break;
1644
1645 case UI2C_PROTSTS_NACKIF_Msk:
1646 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_NACKIF_Msk); /* Clear NACK INT Flag */
1647
1648 if (eEvent == MASTER_READ_DATA)
1649 rdata[u32rxLen++] = (uint8_t) UI2C_GET_DATA(ui2c); /* Receive Data */
1650
1651 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1652
1653 break;
1654
1655 case UI2C_PROTSTS_STORIF_Msk:
1656 UI2C_CLR_PROT_INT_FLAG(ui2c, UI2C_PROTSTS_STORIF_Msk); /* Clear STOP INT Flag */
1657 u8Ctrl = UI2C_CTL_PTRG; /* Clear SI */
1658 u8Xfering = 0U;
1659 break;
1660
1661 case UI2C_PROTSTS_ARBLOIF_Msk: /* Arbitration Lost */
1662 default: /* Unknow status */
1663 u8Ctrl = (UI2C_CTL_PTRG | UI2C_CTL_STO); /* Clear SI and send STOP */
1664 break;
1665 }
1666
1667 UI2C_SET_CONTROL_REG(ui2c, u8Ctrl); /* Write controlbit to UI2C_PROTCTL register */
1668 }
1669
1670 return u32rxLen; /* Return bytes length that have been received */
1671 }
1672 /* end of group USCI_I2C_EXPORTED_FUNCTIONS */
1674 /* end of group USCI_I2C_Driver */
1676 /* end of group Standard_Driver */
1678
1679 /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
UI2C_T::CTL
__IO uint32_t CTL
Definition: ui2c_reg.h:820
MASTER_SEND_DATA
Definition: usci_i2c.h:39
UI2C_T::TXDAT
__O uint32_t TXDAT
Definition: ui2c_reg.h:829
UI2C_SetSlaveAddrMask
void UI2C_SetSlaveAddrMask(UI2C_T *ui2c, uint8_t u8SlaveNo, uint16_t u16SlaveAddrMask)
Configure the mask bit of slave address.
Definition: usci_i2c.c:532
UI2C_T::BRGEN
__IO uint32_t BRGEN
Definition: ui2c_reg.h:824
UI2C_LINECTL_LSB_Msk
#define UI2C_LINECTL_LSB_Msk
Definition: ui2c_reg.h:884
UI2C_PROTCTL_STO_Msk
#define UI2C_PROTCTL_STO_Msk
Definition: ui2c_reg.h:923
MASTER_SEND_ADDRESS
Definition: usci_i2c.h:35
UI2C_ACK_INT_MASK
#define UI2C_ACK_INT_MASK
Definition: usci_i2c.h:89
UI2C_PROTIEN_ACKIEN_Msk
#define UI2C_PROTIEN_ACKIEN_Msk
Definition: ui2c_reg.h:965
UI2C_SetData
void UI2C_SetData(UI2C_T *ui2c, uint8_t u8Data)
This function writes a byte data to data register of USCI_I2C module.
Definition: usci_i2c.c:487
UI2C_PROTCTL_STA_Msk
#define UI2C_PROTCTL_STA_Msk
Definition: ui2c_reg.h:926
UI2C_EnableWakeup
void UI2C_EnableWakeup(UI2C_T *ui2c, uint8_t u8WakeupMode)
This function enables the wakeup function of USCI_I2C module.
Definition: usci_i2c.c:587
UI2C_EnableInt
void UI2C_EnableInt(UI2C_T *ui2c, uint32_t u32Mask)
This function enables the interrupt of USCI_I2C module.
Definition: usci_i2c.c:218
UI2C_PROTCTL_TOCNT_Msk
#define UI2C_PROTCTL_TOCNT_Msk
Definition: ui2c_reg.h:941
UI2C_WKCTL_WKADDREN_Msk
#define UI2C_WKCTL_WKADDREN_Msk
Definition: ui2c_reg.h:911
UI2C_DisableWakeup
void UI2C_DisableWakeup(UI2C_T *ui2c)
This function disables the wakeup function of USCI_I2C module.
Definition: usci_i2c.c:601
UI2C_PROTSTS_TOIF_Msk
#define UI2C_PROTSTS_TOIF_Msk
Definition: ui2c_reg.h:968
UI2C_BRGEN_TMCNTEN_Msk
#define UI2C_BRGEN_TMCNTEN_Msk
Definition: ui2c_reg.h:869
UI2C_Trigger
void UI2C_Trigger(UI2C_T *ui2c, uint8_t u8Start, uint8_t u8Stop, uint8_t u8Ptrg, uint8_t u8Ack)
This function sets the control bit of the USCI_I2C module.
Definition: usci_i2c.c:112
UI2C_ReadMultiBytesTwoRegs
uint32_t UI2C_ReadMultiBytesTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t *rdata, uint32_t u32rLen)
Specify two bytes register address and read multi bytes from Slave.
Definition: usci_i2c.c:1576
UI2C_WriteByteOneReg
uint8_t UI2C_WriteByteOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t data)
Specify a byte register address and write a byte to Slave.
Definition: usci_i2c.c:763
UI2C_PROTCTL_GCFUNC_Msk
#define UI2C_PROTCTL_GCFUNC_Msk
Definition: ui2c_reg.h:917
UI2C_SET_DATA
#define UI2C_SET_DATA(ui2c, u8Data)
This macro writes the data to data register of USCI_I2C module.
Definition: usci_i2c.h:158
UI2C_WriteMultiBytes
uint32_t UI2C_WriteMultiBytes(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t *data, uint32_t u32wLen)
Write multi bytes to Slave.
Definition: usci_i2c.c:694
UI2C_PROTSTS_STORIF_Msk
#define UI2C_PROTSTS_STORIF_Msk
Definition: ui2c_reg.h:977
UI2C_WriteMultiBytesOneReg
uint32_t UI2C_WriteMultiBytesOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t *data, uint32_t u32wLen)
Specify a byte register address and write multi bytes to Slave.
Definition: usci_i2c.c:843
NuMicro.h
NuMicro peripheral access layer header file.
UI2C_ARBLO_INT_MASK
#define UI2C_ARBLO_INT_MASK
Definition: usci_i2c.h:87
UI2C_SET_CONTROL_REG
#define UI2C_SET_CONTROL_REG(ui2c, u8Ctrl)
This macro sets the USCI_I2C protocol control register at one time.
Definition: usci_i2c.h:109
UI2C_GetBusClockFreq
uint32_t UI2C_GetBusClockFreq(UI2C_T *ui2c)
This function returns the real bus clock of USCI_I2C module.
Definition: usci_i2c.c:272
UI2C_T::LINECTL
__IO uint32_t LINECTL
Definition: ui2c_reg.h:828
UI2C_ERR_INT_MASK
#define UI2C_ERR_INT_MASK
Definition: usci_i2c.h:88
UI2C_PROTSTS_STARIF_Msk
#define UI2C_PROTSTS_STARIF_Msk
Definition: ui2c_reg.h:974
UI2C_EnableTimeout
void UI2C_EnableTimeout(UI2C_T *ui2c, uint32_t u32TimeoutCnt)
This function enables time-out function and configures timeout counter.
Definition: usci_i2c.c:554
UI2C_CLR_PROT_INT_FLAG
#define UI2C_CLR_PROT_INT_FLAG(ui2c, u32IntTypeFlag)
This macro clears specified protocol interrupt flag.
Definition: usci_i2c.h:250
UI2C_T::WKCTL
__IO uint32_t WKCTL
Definition: ui2c_reg.h:838
UI2C_SetSlaveAddr
void UI2C_SetSlaveAddr(UI2C_T *ui2c, uint8_t u8SlaveNo, uint16_t u16SlaveAddr, uint8_t u8GCMode)
Configure slave address and enable GC mode.
Definition: usci_i2c.c:506
UI2C_CTL_STA
#define UI2C_CTL_STA
Definition: usci_i2c.h:64
CLK_GetPCLK1Freq
uint32_t CLK_GetPCLK1Freq(void)
Get PCLK1 frequency.
Definition: clk.c:204
UI2C_ReadByteTwoRegs
uint8_t UI2C_ReadByteTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr)
Specify two bytes register address and read a byte from Slave.
Definition: usci_i2c.c:1463
UI2C_ReadByte
uint8_t UI2C_ReadByte(UI2C_T *ui2c, uint8_t u8SlaveAddr)
Read a byte from Slave.
Definition: usci_i2c.c:1092
CLK_GetPCLK0Freq
uint32_t CLK_GetPCLK0Freq(void)
Get PCLK0 frequency.
Definition: clk.c:164
UI2C_TO_INT_MASK
#define UI2C_TO_INT_MASK
Definition: usci_i2c.h:83
UI2C_GetIntFlag
uint32_t UI2C_GetIntFlag(UI2C_T *ui2c, uint32_t u32Mask)
This function gets the interrupt flag of USCI_I2C module.
Definition: usci_i2c.c:343
UI2C_ClearIntFlag
void UI2C_ClearIntFlag(UI2C_T *ui2c, uint32_t u32Mask)
This function clears the interrupt flag of USCI_I2C module.
Definition: usci_i2c.c:418
UI2C_LINECTL_DWIDTH_Pos
#define UI2C_LINECTL_DWIDTH_Pos
Definition: ui2c_reg.h:886
UI2C_Close
void UI2C_Close(UI2C_T *ui2c)
This function closes the USCI_I2C module.
Definition: usci_i2c.c:79
UI2C_DisableTimeout
void UI2C_DisableTimeout(UI2C_T *ui2c)
This function disables time-out function.
Definition: usci_i2c.c:569
UI2C_T
Definition: ui2c_reg.h:26
UI2C_STOR_INT_MASK
#define UI2C_STOR_INT_MASK
Definition: usci_i2c.h:85
UI2C_CTL_PTRG
#define UI2C_CTL_PTRG
Definition: usci_i2c.h:63
MASTER_SEND_REPEAT_START
Definition: usci_i2c.h:40
UI2C_PROTSTS_ACKIF_Msk
#define UI2C_PROTSTS_ACKIF_Msk
Definition: ui2c_reg.h:989
UI2C_T::RXDAT
__I uint32_t RXDAT
Definition: ui2c_reg.h:830
UI2C_START
#define UI2C_START(ui2c)
This macro only set START bit to protocol control register of USCI_I2C module.
Definition: usci_i2c.h:121
UI2C_T::PROTCTL
__IO uint32_t PROTCTL
Definition: ui2c_reg.h:840
UI2C_CTL_STO
#define UI2C_CTL_STO
Definition: usci_i2c.h:65
UI2C_PROTCTL_PTRG_Msk
#define UI2C_PROTCTL_PTRG_Msk
Definition: ui2c_reg.h:932
UI2C_GetData
uint32_t UI2C_GetData(UI2C_T *ui2c)
This function returns the data stored in data register of USCI_I2C module.
Definition: usci_i2c.c:472
UI2C_T::DEVADDR1
__IO uint32_t DEVADDR1
Definition: ui2c_reg.h:835
UI2C_T::PROTSTS
__IO uint32_t PROTSTS
Definition: ui2c_reg.h:842
UI2C_ReadMultiBytes
uint32_t UI2C_ReadMultiBytes(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t *rdata, uint32_t u32rLen)
Read multi bytes from Slave.
Definition: usci_i2c.c:1170
UI2C_Open
uint32_t UI2C_Open(UI2C_T *ui2c, uint32_t u32BusClock)
This function makes USCI_I2C module be ready and set the wanted bus clock.
Definition: usci_i2c.c:34
UI2C_PROTCTL_TOCNT_Pos
#define UI2C_PROTCTL_TOCNT_Pos
Definition: ui2c_reg.h:940
UI2C_T::ADDRMSK0
__IO uint32_t ADDRMSK0
Definition: ui2c_reg.h:836
UI2C_MASTER_EVENT
UI2C_MASTER_EVENT
Definition: usci_i2c.h:33
UI2C0
#define UI2C0
Definition: M480.h:454
UI2C_NACK_INT_MASK
#define UI2C_NACK_INT_MASK
Definition: usci_i2c.h:86
UI2C_PROTSTS_NACKIF_Msk
#define UI2C_PROTSTS_NACKIF_Msk
Definition: ui2c_reg.h:980
UI2C_WKCTL_WKEN_Msk
#define UI2C_WKCTL_WKEN_Msk
Definition: ui2c_reg.h:908
UI2C_T::PROTIEN
__IO uint32_t PROTIEN
Definition: ui2c_reg.h:841
UI2C_PROTCTL_PROTEN_Msk
#define UI2C_PROTCTL_PROTEN_Msk
Definition: ui2c_reg.h:944
UI2C_CTL_FUNMODE_Pos
#define UI2C_CTL_FUNMODE_Pos
Definition: ui2c_reg.h:856
UI2C_PROTIEN_STORIEN_Msk
#define UI2C_PROTIEN_STORIEN_Msk
Definition: ui2c_reg.h:953
UI2C_BRGEN_TMCNTSRC_Msk
#define UI2C_BRGEN_TMCNTSRC_Msk
Definition: ui2c_reg.h:872
UI2C_GET_DATA
#define UI2C_GET_DATA(ui2c)
This macro returns the data stored in data register of USCI_I2C module.
Definition: usci_i2c.h:145
UI2C_ReadMultiBytesOneReg
uint32_t UI2C_ReadMultiBytesOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t *rdata, uint32_t u32rLen)
Specify a byte register address and read multi bytes from Slave.
Definition: usci_i2c.c:1359
UI2C_PROTIEN_ERRIEN_Msk
#define UI2C_PROTIEN_ERRIEN_Msk
Definition: ui2c_reg.h:962
UI2C_ClearTimeoutFlag
void UI2C_ClearTimeoutFlag(UI2C_T *ui2c)
This function clears the time-out flag.
Definition: usci_i2c.c:94
MASTER_READ_DATA
Definition: usci_i2c.h:41
UI2C_PROTIEN_STARIEN_Msk
#define UI2C_PROTIEN_STARIEN_Msk
Definition: ui2c_reg.h:950
UI2C_DisableInt
void UI2C_DisableInt(UI2C_T *ui2c, uint32_t u32Mask)
This function disables the interrupt of USCI_I2C module.
Definition: usci_i2c.c:156
UI2C_WriteMultiBytesTwoRegs
uint32_t UI2C_WriteMultiBytesTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t *data, uint32_t u32wLen)
Specify two bytes register address and write multi bytes to Slave.
Definition: usci_i2c.c:1007
UI2C_T::DEVADDR0
__IO uint32_t DEVADDR0
Definition: ui2c_reg.h:834
UI2C_LINECTL_DWIDTH_Msk
#define UI2C_LINECTL_DWIDTH_Msk
Definition: ui2c_reg.h:887
UI2C_PROTIEN_TOIEN_Msk
#define UI2C_PROTIEN_TOIEN_Msk
Definition: ui2c_reg.h:947
UI2C_PROTSTS_ARBLOIF_Msk
#define UI2C_PROTSTS_ARBLOIF_Msk
Definition: ui2c_reg.h:983
UI2C_STAR_INT_MASK
#define UI2C_STAR_INT_MASK
Definition: usci_i2c.h:84
UI2C_WriteByteTwoRegs
uint8_t UI2C_WriteByteTwoRegs(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t data)
Specify two bytes register address and Write a byte to Slave.
Definition: usci_i2c.c:922
UI2C_CTL_FUNMODE_Msk
#define UI2C_CTL_FUNMODE_Msk
Definition: ui2c_reg.h:857
UI2C_GET_PROT_STATUS
#define UI2C_GET_PROT_STATUS(ui2c)
This macro gets USCI_I2C protocol interrupt flag or bus status.
Definition: usci_i2c.h:232
MASTER_SEND_H_RD_ADDRESS
Definition: usci_i2c.h:37
UI2C_PROTIEN_ARBLOIEN_Msk
#define UI2C_PROTIEN_ARBLOIEN_Msk
Definition: ui2c_reg.h:959
UI2C_T::ADDRMSK1
__IO uint32_t ADDRMSK1
Definition: ui2c_reg.h:837
UI2C_BRGEN_CLKDIV_Msk
#define UI2C_BRGEN_CLKDIV_Msk
Definition: ui2c_reg.h:881
UI2C_PROTIEN_NACKIEN_Msk
#define UI2C_PROTIEN_NACKIEN_Msk
Definition: ui2c_reg.h:956
UI2C_PROTCTL_AA_Msk
#define UI2C_PROTCTL_AA_Msk
Definition: ui2c_reg.h:920
UI2C_SetBusClockFreq
uint32_t UI2C_SetBusClockFreq(UI2C_T *ui2c, uint32_t u32BusClock)
This function sets bus clock frequency of USCI_I2C module.
Definition: usci_i2c.c:301
UI2C_PROTSTS_ERRIF_Msk
#define UI2C_PROTSTS_ERRIF_Msk
Definition: ui2c_reg.h:986
UI2C_ReadByteOneReg
uint8_t UI2C_ReadByteOneReg(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr)
Specify a byte register address and read a byte from Slave.
Definition: usci_i2c.c:1253
MASTER_SEND_START
Definition: usci_i2c.h:43
UI2C_CTL_AA
#define UI2C_CTL_AA
Definition: usci_i2c.h:66
UI2C_BRGEN_CLKDIV_Pos
#define UI2C_BRGEN_CLKDIV_Pos
Definition: ui2c_reg.h:880
UI2C_WriteByte
uint8_t UI2C_WriteByte(UI2C_T *ui2c, uint8_t u8SlaveAddr, uint8_t data)
Write a byte to Slave.
Definition: usci_i2c.c:620