LPCOpen Platform
LPCOpen Platform for NXP LPC Microcontrollers
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
i2c.c
Go to the documentation of this file.
1 /*
2  * @brief I2C example
3  * This example show how to use the I2C interface
4  *
5  * @note
6  * Copyright(C) NXP Semiconductors, 2012
7  * All rights reserved.
8  *
9  * @par
10  * Software that is described herein is for illustrative purposes only
11  * which provides customers with programming information regarding the
12  * LPC products. This software is supplied "AS IS" without any warranties of
13  * any kind, and NXP Semiconductors and its licensor disclaim any and
14  * all warranties, express or implied, including all implied warranties of
15  * merchantability, fitness for a particular purpose and non-infringement of
16  * intellectual property rights. NXP Semiconductors assumes no responsibility
17  * or liability for the use of the software, conveys no license or rights under any
18  * patent, copyright, mask work right, or any other intellectual property rights in
19  * or to any products. NXP Semiconductors reserves the right to make changes
20  * in the software without notification. NXP Semiconductors also makes no
21  * representation or warranty that such application will be suitable for the
22  * specified use without further testing or modification.
23  *
24  * @par
25  * Permission to use, copy, modify, and distribute this software and its
26  * documentation is hereby granted, under NXP Semiconductors' and its
27  * licensor's relevant copyrights in the software, without fee, provided that it
28  * is used in conjunction with NXP Semiconductors microcontrollers. This
29  * copyright, permission, and disclaimer notice must appear in all copies of
30  * this code.
31  */
32 
33 #include "board.h"
34 #include "chip.h"
35 
80 /*****************************************************************************
81  * Private types/enumerations/variables
82  ****************************************************************************/
83 
84  #define I2CDEV_UDA1380_ADDR (0x34 >> 1)
85 #define I2CDEV_STMPE811_ADDR (0x82 >> 1)
86 
87 /* Own Slave address in Slave I2C device */
88 #define I2CDEV_S_ADDR (0x90 >> 1)
89 
90 /* Max buffer length */
91 #define BUFFER_SIZE 0xFF
92 
93 #define C_GLCD_H_SIZE 240
94 #define C_GLCD_V_SIZE 320
95 
96 static char menu[] =
97  "\n\rHello NXP Semiconductors \n\r"
98  "I2C demo \n\r"
99  "\n\rPress 1-5 to select I2C running mode or 'ESC' to terminate the demo:\n\r\n\r"
100  "\t 1 - I2C Polling Master\n\r"
101  "\t 2 - I2C Interrupt Master\n\r"
102  "\t 3 - I2C Polling Slave \n\r"
103  "\t 4 - I2C Interrupt Slave \n\r"
104  "\t 5 - I2C TouchScreen \n\r"
105  "\n\rNote: Master mode can only run combine with Slave mode and vice versa.";
106 static char menu1[] = "\n\r \t - Press x to exit this mode!\n\r";
107 static char menu2[] = "\n\rI2C demo terminated!";
108 static char menu3[] = "\t - Press c to continue...\n\r";
109 
110 static volatile bool complete;
111 static volatile bool isMasterMode = true;
112 
113 /*****************************************************************************
114  * Public types/enumerations/variables
115  ****************************************************************************/
116 
117 /*****************************************************************************
118  * Private functions
119  ****************************************************************************/
120 
121 /* Print Welcome menu */
122 static void print_menu(void)
123 {
124  DEBUGOUT(menu);
125 }
126 
127 /* Initialize buffer */
128 static void Buffer_Init(uint8_t *buffer, uint8_t type)
129 {
130  uint8_t i;
131 
132  if (type) {
133  for (i = 0; i < BUFFER_SIZE; i++)
134  buffer[i] = i;
135  }
136  else {
137  for (i = 0; i < BUFFER_SIZE; i++)
138  buffer[i] = 0;
139  }
140 }
141 
142 /* I2C master application in polling mode */
143 static void App_I2C_Polling_Master(void)
144 {
145  I2C_M_SETUP_Type transferMCfg;
146  uint8_t buffer = 0xFF, regAddr = 0xBA;
147  uint8_t Master_Buf[BUFFER_SIZE];
148  uint8_t *pdat;
149  uint32_t i = 0;
150 
151  /* Enable Master I2C operation */
153 
154  while (1) {
155  DEBUGOUT("\n\r\n\rI2C Polling Master is running...\n\r");
156  DEBUGOUT(menu1);
157  DEBUGOUT(menu3);
158 
159  while (1) {
160  buffer = DEBUGIN();
161  if ((buffer == 'x') || (buffer == 'X')) {
162  /* Disable Master I2C operation */
164  return;
165  }
166  else if ((buffer == 'c') || (buffer == 'C')) {
167  break;
168  }
169  }
170  /* Transmit */
171  DEBUGOUT("\n\rPress '1' to transmit");
172  while (1) {
173  buffer = DEBUGIN();
174  if (buffer == '1') {
175  break;
176  }
177  }
178  DEBUGOUT("\n\rTransmitting...");
179 
180  /* Initialize buffer */
181  Buffer_Init(Master_Buf, 1);
182 
183  transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
184  transferMCfg.tx_data = Master_Buf;
185  transferMCfg.tx_length = sizeof(Master_Buf);
187 
188  /* Receive */
189  DEBUGOUT("\n\rPress '2' to receive");
190  while (1) {
191  buffer = DEBUGIN();
192  if (buffer == '2') {
193  break;
194  }
195  }
196  DEBUGOUT("\n\rReceiving...");
197 
198  /* Initialize buffer */
199  Buffer_Init(Master_Buf, 0);
200 
201  transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
202  transferMCfg.rx_data = Master_Buf;
203  transferMCfg.rx_length = sizeof(Master_Buf);
205 
206  pdat = Master_Buf;
207  // Verify
208  for (i = 0; i < sizeof(Master_Buf); i++)
209  if (*pdat++ != i) {
210  DEBUGOUT("\n\rVerify error!");
211  break;
212  }
213  if (i == sizeof(Master_Buf)) {
214  DEBUGOUT("\n\rVerify successfully!");
215  }
216 
217  /* Transmit and receive */
218  DEBUGOUT("\n\rPress '3' to Transmit, then repeat start and receive...");
219  while (1) {
220  buffer = DEBUGIN();
221  if (buffer == '3') {
222  break;
223  }
224  }
225 
226  /* Initialize buffer */
227  Buffer_Init(Master_Buf, 0);
228 
229  transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
230  transferMCfg.tx_data = &regAddr;
231  transferMCfg.tx_length = 1;
232  transferMCfg.rx_data = Master_Buf;
233  transferMCfg.rx_length = sizeof(Master_Buf);
235 
236  pdat = Master_Buf;
237  // Verify
238  for (i = 0; i < sizeof(Master_Buf); i++)
239  if (*pdat++ != i) {
240  DEBUGOUT("\n\rVerify error!");
241  break;
242  }
243  if (i == sizeof(Master_Buf)) {
244  DEBUGOUT("\n\rVerify successfully!");
245  }
246  }
247 }
248 
249 /* I2C master application using interrupt */
250 static void App_I2C_Interrupt_Master(void)
251 {
252  I2C_M_SETUP_Type transferMCfg;
253  uint8_t buffer = 0xFF, regAddr = 0xBA;
254  uint8_t Master_Buf[BUFFER_SIZE];
255  uint8_t *pdat;
256  uint32_t i = 0;
257 
258  /* Enable Master I2C operation */
260 
261  while (1) {
262  DEBUGOUT("\n\r\n\rI2C Interrupt Master is running...\n\r");
263  DEBUGOUT(menu1);
264  DEBUGOUT(menu3);
265 
266  while (1) {
267  buffer = DEBUGIN();
268  if ((buffer == 'x') || (buffer == 'X')) {
269  /* Disable Master I2C operation */
271  return;
272  }
273  else if ((buffer == 'c') || (buffer == 'C')) {
274  break;
275  }
276  }
277  /* Transmit */
278  DEBUGOUT("\n\rPress '1' to transmit");
279  while (1) {
280  buffer = DEBUGIN();
281  if (buffer == '1') {
282  break;
283  }
284  }
285  DEBUGOUT("\n\rTransmitting...");
286 
287  /* Initialize buffer */
288  Buffer_Init(Master_Buf, 1);
289 
290  complete = false;
291  transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
292  transferMCfg.tx_data = Master_Buf;
293  transferMCfg.tx_length = sizeof(Master_Buf);
295  NVIC_EnableIRQ(I2C1_IRQn);
296  while (!complete) ;
297 
298  /* Receive */
299  DEBUGOUT("\n\rPress '2' to receive");
300  while (1) {
301  buffer = DEBUGIN();
302  if (buffer == '2') {
303  break;
304  }
305  }
306  DEBUGOUT("\n\rReceiving...");
307 
308  /* Initialize buffer */
309  Buffer_Init(Master_Buf, 0);
310 
311  complete = false;
312  transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
313  transferMCfg.rx_data = Master_Buf;
314  transferMCfg.rx_length = sizeof(Master_Buf);
316  NVIC_EnableIRQ(I2C1_IRQn);
317  while (!complete) ;
318 
319  pdat = Master_Buf;
320  // Verify
321  for (i = 0; i < sizeof(Master_Buf); i++)
322  if (*pdat++ != i) {
323  DEBUGOUT("\n\rVerify error!");
324  break;
325  }
326  if (i == sizeof(Master_Buf)) {
327  DEBUGOUT("\n\rVerify successfully!");
328  }
329 
330  /* Transmit and receive */
331  DEBUGOUT("\n\rPress '3' to Transmit, then repeat start and receive...");
332  while (1) {
333  buffer = DEBUGIN();
334  if (buffer == '3') {
335  break;
336  }
337  }
338 
339  /* Initialize buffer */
340  Buffer_Init(Master_Buf, 0);
341 
342  complete = false;
343  transferMCfg.sl_addr7bit = I2CDEV_S_ADDR;
344  transferMCfg.tx_data = &regAddr;
345  transferMCfg.tx_length = 1;
346  transferMCfg.rx_data = Master_Buf;
347  transferMCfg.rx_length = sizeof(Master_Buf);
349  NVIC_EnableIRQ(I2C1_IRQn);
350  while (!complete) ;
351 
352  pdat = Master_Buf;
353  // Verify
354  for (i = 0; i < sizeof(Master_Buf); i++)
355  if (*pdat++ != i) {
356  DEBUGOUT("\n\rVerify error!");
357  break;
358  }
359  if (i == sizeof(Master_Buf)) {
360  DEBUGOUT("\n\rVerify successfully!");
361  }
362  }
363 }
364 
365 /* I2C slave application in polling mode */
366 static void App_I2C_Polling_Slave(void)
367 {
368  I2C_S_SETUP_Type transferSCfg;
369  uint8_t buffer = 0xFF, regAddr = 0xBA;
370  uint8_t Slave_Buf[BUFFER_SIZE], S_buff = 0;
371  uint8_t *pdat;
372  uint32_t i = 0;
373 
374  /* Enable Slave I2C operation */
376 
377  while (1) {
378  DEBUGOUT("\n\r\n\rI2C Polling Slave is running...\n\r");
379  DEBUGOUT(menu1);
380  DEBUGOUT(menu3);
381  while (1) {
382  buffer = DEBUGIN();
383  if ((buffer == 'x') || (buffer == 'X')) {
384  /* Disable Slave I2C operation */
386  return;
387  }
388  else if ((buffer == 'c') || (buffer == 'C')) {
389  break;
390  }
391  }
392 
393  /* Receive */
394  DEBUGOUT("\n\rPress '1' to Start");
395  while (1) {
396  buffer = DEBUGIN();
397  if (buffer == '1') {
398  break;
399  }
400  }
401  DEBUGOUT("\n\rReceiving...");
402 
403  /* Initialize buffer */
404  Buffer_Init(Slave_Buf, 0);
405 
406  transferSCfg.rx_data = Slave_Buf;
407  transferSCfg.rx_length = sizeof(Slave_Buf);
409 
410  pdat = Slave_Buf;
411  // Verify
412  for (i = 0; i < sizeof(Slave_Buf); i++)
413  if (*pdat++ != i) {
414  DEBUGOUT("\n\rVerify error!");
415  break;
416  }
417  if (i == sizeof(Slave_Buf)) {
418  DEBUGOUT("\n\rVerify successfully!");
419  }
420 
421  /* Transmit */
422  DEBUGOUT("\n\rTransmitting...");
423 
424  /* Initialize buffer */
425  Buffer_Init(Slave_Buf, 1);
426 
427  transferSCfg.tx_data = Slave_Buf;
428  transferSCfg.tx_length = sizeof(Slave_Buf);
430 
431  /* Receive and transmit */
432  DEBUGOUT("\n\rStart Receive, wait for repeat start and transmit...");
433 
434  /* Initialize buffer */
435  Buffer_Init(Slave_Buf, 1);
436 
437  transferSCfg.rx_data = &S_buff;
438  transferSCfg.rx_length = 1;
440  if (S_buff == regAddr) {
441  transferSCfg.tx_data = Slave_Buf;
442  transferSCfg.tx_length = sizeof(Slave_Buf);
444  }
445  }
446 }
447 
448 /* I2C slave application using interrupt */
449 static void App_I2C_Interrupt_Slave(void)
450 {
451  I2C_S_SETUP_Type transferSCfg;
452  uint8_t buffer = 0xFF, regAddr = 0xBA;
453  uint8_t Slave_Buf[BUFFER_SIZE], S_buff = 0;
454  uint8_t *pdat;
455  uint32_t i = 0;
456 
457  /* Enable Slave I2C operation */
459 
460  while (1) {
461  DEBUGOUT("\n\r\n\rI2C Interrupt Slave is running...\n\r");
462  DEBUGOUT(menu1);
463  DEBUGOUT(menu3);
464  while (1) {
465  buffer = DEBUGIN();
466  if ((buffer == 'x') || (buffer == 'X')) {
467  /* Disable Slave I2C operation */
469  return;
470  }
471  else if ((buffer == 'c') || (buffer == 'C')) {
472  break;
473  }
474  }
475  /* Receive */
476  DEBUGOUT("\n\rPress '1' to Start");
477 
478  while (1) {
479  buffer = DEBUGIN();
480  if (buffer == '1') {
481  break;
482  }
483  }
484  DEBUGOUT("\n\rReceiving...");
485 
486  /* Initialize buffer */
487  Buffer_Init(Slave_Buf, 0);
488 
489  complete = false;
490  transferSCfg.rx_data = Slave_Buf;
491  transferSCfg.rx_length = sizeof(Slave_Buf);
493  NVIC_EnableIRQ(I2C1_IRQn);
494  while (!complete) ;
495 
496  pdat = Slave_Buf;
497  // Verify
498  for (i = 0; i < sizeof(Slave_Buf); i++)
499  if (*pdat++ != i) {
500  DEBUGOUT("\n\rVerify error!");
501  break;
502  }
503  if (i == sizeof(Slave_Buf)) {
504  DEBUGOUT("\n\rVerify successfully!");
505  }
506 
507  /* Transmit */
508  DEBUGOUT("\n\rTransmitting...");
509 
510  /* Initialize buffer */
511  Buffer_Init(Slave_Buf, 1);
512 
513  complete = false;
514  transferSCfg.tx_data = Slave_Buf;
515  transferSCfg.tx_length = sizeof(Slave_Buf);
517  NVIC_EnableIRQ(I2C1_IRQn);
518  while (!complete) ;
519 
520  /* Receive and transmit */
521  DEBUGOUT("\n\rStart Receive, wait for repeat start and transmit...");
522 
523  /* Initialize buffer */
524  Buffer_Init(Slave_Buf, 1);
525 
526  complete = false;
527  transferSCfg.rx_data = &S_buff;
528  transferSCfg.rx_length = 1;
530  NVIC_EnableIRQ(I2C1_IRQn);
531  while (!complete) ;
532 
533  if (S_buff == regAddr) {
534  complete = false;
535  transferSCfg.tx_data = Slave_Buf;
536  transferSCfg.tx_length = sizeof(Slave_Buf);
538  NVIC_EnableIRQ(I2C1_IRQn);
539  while (!complete) ;
540  }
541  }
542 }
543 
544 /* I2C touch screen mode application */
545 static void App_I2C_TouchScreen(void)
546 {
547 #if defined(BOARD_KEIL_MCB_18574357)
548  int16_t x, y;
549  FlagStatus exitflag = RESET;
550  uint8_t buffer = 0;
551 
552  /* Enable Master I2C operation */
554  DEBUGOUT(menu1);
555 
556  while (exitflag == RESET) {
557 
558  buffer = DEBUGIN();
559  if ((buffer == 'x') || (buffer == 'X')) {
560  exitflag = SET;
561  }
562 
563  if (GetTouchPos(&x, &y)) {
564  DEBUGOUT("\n\r\n\rX = %d", x);
565  DEBUGOUT("\n\rY = %d", y);
566  }
567  }
568 
569  /* Disable Master I2C operation */
571 #endif
572 }
573 
574 /*****************************************************************************
575  * Public functions
576  ****************************************************************************/
577 
582 void I2C1_IRQHandler(void)
583 {
584  if (isMasterMode) { /* Master Mode */
587  complete = true;
588  NVIC_DisableIRQ(I2C1_IRQn);
589  }
590  }
591  else { /* Slave Mode */
594  complete = true;
595  NVIC_DisableIRQ(I2C1_IRQn);
596  }
597  }
598 }
599 
604 int main(void)
605 {
606  I2C_OWNSLAVEADDR_CFG_Type OwnSlavAdr;
607  FlagStatus exitflag;
608  uint8_t buffer = 0xFF;
609 
610  Board_Init();
613 
614  /* print welcome screen */
615  print_menu();
616 
617  /* Init I2C1 */
620 
621  /* Set Own slave address for I2C1 device */
622  OwnSlavAdr.GeneralCallState = DISABLE;
623  OwnSlavAdr.SlaveAddrChannel = 0;
624  OwnSlavAdr.SlaveAddrMaskValue = 0xFF;
625  OwnSlavAdr.SlaveAddr_7bit = I2CDEV_S_ADDR;
626  Chip_I2C_SetOwnSlaveAddr(LPC_I2C1, &OwnSlavAdr);
627 
628  exitflag = RESET;
629  /* Read some data from the buffer */
630  while (exitflag == RESET) {
631  buffer = DEBUGIN();
632 
633  switch (buffer) {
634  case '1': /* Master Polling Mode */
636  print_menu();
637  break;
638 
639  case '2': /* Master Interrupt Mode */
640  isMasterMode = true;
642  print_menu();
643  break;
644 
645  case '3': /* Slave Polling Mode */
647  print_menu();
648  break;
649 
650  case '4': /* Slave Interrupt Mode */
651  isMasterMode = false;
653  print_menu();
654  break;
655 
656  case '5': /* Touch Screen */
658  print_menu();
659  break;
660 
661  case 27:
662  /* ESC key, set exit flag */
663  DEBUGOUT(menu2);
664  exitflag = SET;
665  break;
666 
667  default:
668  break;
669  }
670  }
671 
674 
675  return 0;
676 }
677