[技术问答] nuc100的硬件IIC好用吗?我怎么感觉官方的有点复杂?

[复制链接]
802|21
| 2019-7-8 12:57 | 显示全部楼层
好像都一样吧,官方提供的有例子,不过最好先看手册和头文件部分。

使用特权

评论回复
| 2019-7-8 12:58 | 显示全部楼层
主要是跟I2C 的外设通信用。比如收音机模块,存储模块,或者I2C接口的显示屏。

使用特权

评论回复
 楼主 | 2019-7-8 14:02 | 显示全部楼层
wahahaheihei 发表于 2019-7-8 12:58
主要是跟I2C 的外设通信用。比如收音机模块,存储模块,或者I2C接口的显示屏。 ...

有没有参考?

使用特权

评论回复
| 2019-7-8 15:06 | 显示全部楼层
有啊,等下我去给你找下载链接。

使用特权

评论回复
| 2019-7-8 15:13 | 显示全部楼层
http://bbs.21ic.com/icview-844424-1-1.html
官方没下载地址了,论坛有朋友分享。

使用特权

评论回复
| 2019-7-8 15:29 | 显示全部楼层
NUC100_120BSP_v3.00.004.zip (7.57 MB, 下载次数: 1)

使用特权

评论回复
| 2019-7-8 15:30 | 显示全部楼层
  1. /**************************************************************************//**
  2. * [url=home.php?mod=space&uid=288409]@file[/url]     main.c
  3. * [url=home.php?mod=space&uid=895143]@version[/url]  V3.00
  4. * $Revision: 3 $
  5. * $Date: 15/05/20 3:58p $
  6. * @brief
  7. *           Show a I2C Master how to access Slave.
  8. *           This sample code needs to work with I2C_Slave.
  9. * @note
  10. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  11. *
  12. ******************************************************************************/
  13. #include <stdio.h>
  14. #include "NUC100Series.h"

  15. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  16. #define PLL_CLOCK           50000000

  17. /*---------------------------------------------------------------------------------------------------------*/
  18. /* Global variables                                                                                        */
  19. /*---------------------------------------------------------------------------------------------------------*/
  20. volatile uint8_t g_u8DeviceAddr;
  21. volatile uint8_t g_au8MstTxData[3];
  22. volatile uint8_t g_u8MstRxData;
  23. volatile uint8_t g_u8MstDataLen;
  24. volatile uint8_t g_u8MstEndFlag = 0;

  25. typedef void (*I2C_FUNC)(uint32_t u32Status);

  26. static volatile I2C_FUNC s_I2C0HandlerFn = NULL;

  27. /*---------------------------------------------------------------------------------------------------------*/
  28. /*  I2C0 IRQ Handler                                                                                       */
  29. /*---------------------------------------------------------------------------------------------------------*/
  30. void I2C0_IRQHandler(void)
  31. {
  32.     uint32_t u32Status;

  33.     u32Status = I2C_GET_STATUS(I2C0);

  34.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  35.     {
  36.         /* Clear I2C0 Timeout Flag */
  37.         I2C_ClearTimeoutFlag(I2C0);
  38.     }
  39.     else
  40.     {
  41.         if(s_I2C0HandlerFn != NULL)
  42.             s_I2C0HandlerFn(u32Status);
  43.     }
  44. }

  45. /*---------------------------------------------------------------------------------------------------------*/
  46. /*  I2C Rx Callback Function                                                                               */
  47. /*---------------------------------------------------------------------------------------------------------*/
  48. void I2C_MasterRx(uint32_t u32Status)
  49. {
  50.     if(u32Status == 0x08)                       /* START has been transmitted and prepare SLA+W */
  51.     {
  52.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */
  53.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  54.     }
  55.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  56.     {
  57.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  58.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  59.     }
  60.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  61.     {
  62.         I2C_STOP(I2C0);
  63.         I2C_START(I2C0);
  64.     }
  65.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  66.     {
  67.         if(g_u8MstDataLen != 2)
  68.         {
  69.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  70.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  71.         }
  72.         else
  73.         {
  74.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);
  75.         }
  76.     }
  77.     else if(u32Status == 0x10)                  /* Repeat START has been transmitted and prepare SLA+R */
  78.     {
  79.         I2C_SET_DATA(I2C0, ((g_u8DeviceAddr << 1) | 0x01));   /* Write SLA+R to Register I2CDAT */
  80.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  81.     }
  82.     else if(u32Status == 0x40)                  /* SLA+R has been transmitted and ACK has been received */
  83.     {
  84.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  85.     }
  86.     else if(u32Status == 0x58)                  /* DATA has been received and NACK has been returned */
  87.     {
  88.         g_u8MstRxData = (unsigned char) I2C_GET_DATA(I2C0);
  89.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  90.         g_u8MstEndFlag = 1;
  91.     }
  92.     else
  93.     {
  94.         /* TO DO */
  95.         printf("Status 0x%x is NOT processed\n", u32Status);
  96.     }
  97. }
  98. /*---------------------------------------------------------------------------------------------------------*/
  99. /*  I2C Tx Callback Function                                                                               */
  100. /*---------------------------------------------------------------------------------------------------------*/
  101. void I2C_MasterTx(uint32_t u32Status)
  102. {
  103.     if(u32Status == 0x08)                       /* START has been transmitted */
  104.     {
  105.         I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);    /* Write SLA+W to Register I2CDAT */
  106.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  107.     }
  108.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  109.     {
  110.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  111.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  112.     }
  113.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  114.     {
  115.         I2C_STOP(I2C0);
  116.         I2C_START(I2C0);
  117.     }
  118.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  119.     {
  120.         if(g_u8MstDataLen != 3)
  121.         {
  122.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  123.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  124.         }
  125.         else
  126.         {
  127.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  128.             g_u8MstEndFlag = 1;
  129.         }
  130.     }
  131.     else
  132.     {
  133.         /* TO DO */
  134.         printf("Status 0x%x is NOT processed\n", u32Status);
  135.     }
  136. }

  137. void SYS_Init(void)
  138. {
  139.     /*---------------------------------------------------------------------------------------------------------*/
  140.     /* Init System Clock                                                                                       */
  141.     /*---------------------------------------------------------------------------------------------------------*/

  142.     /* Enable Internal RC 22.1184MHz clock */
  143.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  144.     /* Waiting for Internal RC clock ready */
  145.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  146.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  147.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  148.     /* Enable external XTAL 12MHz clock */
  149.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  150.     /* Waiting for external XTAL clock ready */
  151.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  152.     /* Set core clock as PLL_CLOCK from PLL */
  153.     CLK_SetCoreClock(PLL_CLOCK);

  154.     /* Enable UART module clock */
  155.     CLK_EnableModuleClock(UART0_MODULE);

  156.     /* Enable I2C0 module clock */
  157.     CLK_EnableModuleClock(I2C0_MODULE);

  158.     /* Select UART module clock source */
  159.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));

  160.     /*---------------------------------------------------------------------------------------------------------*/
  161.     /* Init I/O Multi-function                                                                                 */
  162.     /*---------------------------------------------------------------------------------------------------------*/

  163.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  164.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  165.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  166.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  167.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  168.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  169. }

  170. void UART0_Init()
  171. {
  172.     /*---------------------------------------------------------------------------------------------------------*/
  173.     /* Init UART                                                                                               */
  174.     /*---------------------------------------------------------------------------------------------------------*/
  175.     /* Reset IP */
  176.     SYS_ResetModule(UART0_RST);

  177.     /* Configure UART0 and set UART0 Baudrate */
  178.     UART_Open(UART0, 115200);
  179. }

  180. void I2C0_Init(void)
  181. {
  182.     /* Open I2C module and set bus clock */
  183.     I2C_Open(I2C0, 100000);

  184.     /* Get I2C0 Bus Clock */
  185.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  186.     /* Set I2C 4 Slave Addresses */
  187.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
  188.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
  189.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
  190.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */

  191.     /* Enable I2C interrupt */
  192.     I2C_EnableInt(I2C0);
  193.     NVIC_EnableIRQ(I2C0_IRQn);
  194. }

  195. void I2C0_Close(void)
  196. {
  197.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  198.     I2C_DisableInt(I2C0);
  199.     NVIC_DisableIRQ(I2C0_IRQn);

  200.     /* Disable I2C0 and close I2C0 clock */
  201.     I2C_Close(I2C0);
  202.     CLK_DisableModuleClock(I2C0_MODULE);

  203. }

  204. int32_t I2C0_Read_Write_SLAVE(uint8_t slvaddr)
  205. {
  206.     uint32_t i;

  207.     g_u8DeviceAddr = slvaddr;

  208.     for(i = 0; i < 0x100; i++)
  209.     {
  210.         g_au8MstTxData[0] = (uint8_t)((i & 0xFF00) >> 8);
  211.         g_au8MstTxData[1] = (uint8_t)(i & 0x00FF);
  212.         g_au8MstTxData[2] = (uint8_t)(g_au8MstTxData[1] + 3);

  213.         g_u8MstDataLen = 0;
  214.         g_u8MstEndFlag = 0;

  215.         /* I2C function to write data to slave */
  216.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;

  217.         /* I2C as master sends START signal */
  218.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  219.         /* Wait I2C Tx Finish */
  220.         while(g_u8MstEndFlag == 0);
  221.         g_u8MstEndFlag = 0;

  222.         /* I2C function to read data from slave */
  223.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterRx;

  224.         g_u8MstDataLen = 0;
  225.         g_u8DeviceAddr = slvaddr;

  226.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  227.         /* Wait I2C Rx Finish */
  228.         while(g_u8MstEndFlag == 0);

  229.         /* Compare data */
  230.         if(g_u8MstRxData != g_au8MstTxData[2])
  231.         {
  232.             printf("I2C Byte Write/Read Failed, Data 0x%x\n", g_u8MstRxData);
  233.             return -1;
  234.         }
  235.     }
  236.     printf("Master Access Slave (0x%X) Test OK\n", slvaddr);
  237.     return 0;
  238. }
  239. /*---------------------------------------------------------------------------------------------------------*/
  240. /*  Main Function                                                                                          */
  241. /*---------------------------------------------------------------------------------------------------------*/
  242. int32_t main(void)
  243. {
  244.     /* Unlock protected registers */
  245.     SYS_UnlockReg();

  246.     /* Init System, IP clock and multi-function I/O */
  247.     SYS_Init();

  248.     /* Init UART0 for printf */
  249.     UART0_Init();

  250.     /* Lock protected registers */
  251.     SYS_LockReg();

  252.     /*
  253.         This sample code sets I2C bus clock to 100kHz. Then, Master accesses Slave with Byte Write
  254.         and Byte Read operations, and check if the read data is equal to the programmed data.
  255.     */
  256.     printf("\n");
  257.     printf("+--------------------------------------------------------+\n");
  258.     printf("| NUC100 I2C Driver Sample Code(Master) for access Slave |\n");
  259.     printf("|                                                        |\n");
  260.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)                |\n");
  261.     printf("+--------------------------------------------------------+\n");

  262.     printf("Configure I2C0 as a master.\n");
  263.     printf("The I/O connection for I2C0:\n");
  264.     printf("I2C0_SDA(PA.8), I2C0_SCL(PA.9)\n");

  265.     /* Init I2C0 */
  266.     I2C0_Init();

  267.     printf("\n");
  268.     printf("Check I2C Slave(I2C0) is running first!\n");
  269.     printf("Press any key to continue.\n");
  270.     getchar();

  271.     /* Access Slave with no address */
  272.     printf("\n");
  273.     printf(" == No Mask Address ==\n");
  274.     I2C0_Read_Write_SLAVE(0x15);
  275.     I2C0_Read_Write_SLAVE(0x35);
  276.     I2C0_Read_Write_SLAVE(0x55);
  277.     I2C0_Read_Write_SLAVE(0x75);
  278.     printf("SLAVE Address test OK.\n");

  279.     /* Access Slave with address mask */
  280.     printf("\n");
  281.     printf(" == Mask Address ==\n");
  282.     I2C0_Read_Write_SLAVE(0x15 & ~0x01);
  283.     I2C0_Read_Write_SLAVE(0x35 & ~0x04);
  284.     I2C0_Read_Write_SLAVE(0x55 & ~0x01);
  285.     I2C0_Read_Write_SLAVE(0x75 & ~0x04);
  286.     printf("SLAVE Address Mask test OK.\n");

  287.     s_I2C0HandlerFn = NULL;

  288.     /* Close I2C0 */
  289.     I2C0_Close();

  290.     while(1);
  291. }



复制代码

使用特权

评论回复
| 2019-7-8 15:30 | 显示全部楼层
  1. /**************************************************************************//**
  2. * @file     main.c
  3. * @version  V3.00
  4. * $Revision: 2 $
  5. * $Date: 14/12/29 3:20p $
  6. * @brief
  7. *           Show how to set I2C in Slave mode and receive the data from Master.
  8. *           This sample code needs to work with I2C_Master.
  9. * @note
  10. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  11. *
  12. ******************************************************************************/
  13. #include <stdio.h>
  14. #include "NUC100Series.h"

  15. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  16. #define PLL_CLOCK           50000000

  17. uint32_t slave_buff_addr;
  18. uint8_t g_au8SlvData[256];
  19. uint8_t g_au8SlvRxData[3];
  20. /*---------------------------------------------------------------------------------------------------------*/
  21. /* Global variables                                                                                        */
  22. /*---------------------------------------------------------------------------------------------------------*/
  23. volatile uint8_t g_u8DeviceAddr;
  24. volatile uint8_t g_u8SlvDataLen;

  25. typedef void (*I2C_FUNC)(uint32_t u32Status);

  26. static I2C_FUNC s_I2C0HandlerFn = NULL;

  27. /*---------------------------------------------------------------------------------------------------------*/
  28. /*  I2C0 IRQ Handler                                                                                       */
  29. /*---------------------------------------------------------------------------------------------------------*/
  30. void I2C0_IRQHandler(void)
  31. {
  32.     uint32_t u32Status;

  33.     u32Status = I2C_GET_STATUS(I2C0);

  34.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  35.     {
  36.         /* Clear I2C0 Timeout Flag */
  37.         I2C_ClearTimeoutFlag(I2C0);
  38.     }
  39.     else
  40.     {
  41.         if(s_I2C0HandlerFn != NULL)
  42.             s_I2C0HandlerFn(u32Status);
  43.     }
  44. }

  45. /*---------------------------------------------------------------------------------------------------------*/
  46. /*  I2C TRx Callback Function                                                                               */
  47. /*---------------------------------------------------------------------------------------------------------*/
  48. void I2C_SlaveTRx(uint32_t u32Status)
  49. {
  50.     if(u32Status == 0x60)                       /* Own SLA+W has been receive; ACK has been return */
  51.     {
  52.         g_u8SlvDataLen = 0;
  53.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  54.     }
  55.     else if(u32Status == 0x80)                 /* Previously address with own SLA address
  56.                                                    Data has been received; ACK has been returned*/
  57.     {
  58.         g_au8SlvRxData[g_u8SlvDataLen] = (unsigned char) I2C_GET_DATA(I2C0);
  59.         g_u8SlvDataLen++;

  60.         if(g_u8SlvDataLen == 2)
  61.         {
  62.             slave_buff_addr = (g_au8SlvRxData[0] << 8) + g_au8SlvRxData[1];
  63.         }
  64.         if(g_u8SlvDataLen == 3)
  65.         {
  66.             g_au8SlvData[slave_buff_addr] = g_au8SlvRxData[2];
  67.             g_u8SlvDataLen = 0;
  68.         }

  69.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  70.     }
  71.     else if(u32Status == 0xA8)                  /* Own SLA+R has been receive; ACK has been return */
  72.     {
  73.         I2C_SET_DATA(I2C0, g_au8SlvData[slave_buff_addr]);
  74.         slave_buff_addr++;
  75.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  76.     }
  77.     else if(u32Status == 0xC0)                 /* Data byte or last data in I2CDAT has been transmitted
  78.                                                    Not ACK has been received */
  79.     {
  80.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  81.     }
  82.     else if(u32Status == 0x88)                 /* Previously addressed with own SLA address; NOT ACK has
  83.                                                    been returned */
  84.     {
  85.         g_u8SlvDataLen = 0;
  86.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  87.     }
  88.     else if(u32Status == 0xA0)                 /* A STOP or repeated START has been received while still
  89.                                                    addressed as Slave/Receiver*/
  90.     {
  91.         g_u8SlvDataLen = 0;
  92.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  93.     }
  94.     else
  95.     {
  96.         /* TO DO */
  97.         printf("Status 0x%x is NOT processed\n", u32Status);
  98.     }
  99. }

  100. void SYS_Init(void)
  101. {
  102.     /*---------------------------------------------------------------------------------------------------------*/
  103.     /* Init System Clock                                                                                       */
  104.     /*---------------------------------------------------------------------------------------------------------*/

  105.     /* Enable Internal RC 22.1184MHz clock */
  106.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  107.     /* Waiting for Internal RC clock ready */
  108.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  109.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  110.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  111.     /* Enable external XTAL 12MHz clock */
  112.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  113.     /* Waiting for external XTAL clock ready */
  114.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  115.     /* Set core clock as PLL_CLOCK from PLL */
  116.     CLK_SetCoreClock(PLL_CLOCK);

  117.     /* Enable UART module clock */
  118.     CLK_EnableModuleClock(UART0_MODULE);

  119.     /* Enable I2C0 module clock */
  120.     CLK_EnableModuleClock(I2C0_MODULE);

  121.     /* Select UART module clock source */
  122.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));

  123.     /*---------------------------------------------------------------------------------------------------------*/
  124.     /* Init I/O Multi-function                                                                                 */
  125.     /*---------------------------------------------------------------------------------------------------------*/

  126.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  127.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  128.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  129.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  130.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  131.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  132. }

  133. void UART0_Init()
  134. {
  135.     /*---------------------------------------------------------------------------------------------------------*/
  136.     /* Init UART                                                                                               */
  137.     /*---------------------------------------------------------------------------------------------------------*/
  138.     /* Reset IP */
  139.     SYS_ResetModule(UART0_RST);

  140.     /* Configure UART0 and set UART0 Baudrate */
  141.     UART_Open(UART0, 115200);
  142. }


  143. void I2C0_Init(void)
  144. {
  145.     /* Open I2C module and set bus clock */
  146.     I2C_Open(I2C0, 100000);

  147.     /* Get I2C0 Bus Clock */
  148.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  149.     /* Set I2C 4 Slave Addresses */
  150.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
  151.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
  152.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
  153.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */

  154.     /* Set I2C 4 Slave Addresses Mask */
  155.     I2C_SetSlaveAddrMask(I2C0, 0, 0x01);
  156.     I2C_SetSlaveAddrMask(I2C0, 1, 0x04);
  157.     I2C_SetSlaveAddrMask(I2C0, 2, 0x01);
  158.     I2C_SetSlaveAddrMask(I2C0, 3, 0x04);

  159.     /* Enable I2C interrupt */
  160.     I2C_EnableInt(I2C0);
  161.     NVIC_EnableIRQ(I2C0_IRQn);
  162. }

  163. void I2C0_Close(void)
  164. {
  165.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  166.     I2C_DisableInt(I2C0);
  167.     NVIC_DisableIRQ(I2C0_IRQn);

  168.     /* Disable I2C0 and close I2C0 clock */
  169.     I2C_Close(I2C0);
  170.     CLK_DisableModuleClock(I2C0_MODULE);

  171. }

  172. /*---------------------------------------------------------------------------------------------------------*/
  173. /*  Main Function                                                                                          */
  174. /*---------------------------------------------------------------------------------------------------------*/
  175. int32_t main(void)
  176. {
  177.     uint32_t i;

  178.     /* Unlock protected registers */
  179.     SYS_UnlockReg();

  180.     /* Init System, IP clock and multi-function I/O */
  181.     SYS_Init();

  182.     /* Init UART0 for printf */
  183.     UART0_Init();

  184.     /* Lock protected registers */
  185.     SYS_LockReg();

  186.     /*
  187.         This sample code sets I2C bus clock to 100kHz. Then, Master accesses Slave with Byte Write
  188.         and Byte Read operations, and check if the read data is equal to the programmed data.
  189.     */

  190.     printf("+------------------------------------------------------_-+\n");
  191.     printf("|  NUC100 I2C Driver Sample Code(Slave) for access Slave |\n");
  192.     printf("|                                                        |\n");
  193.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)                |\n");
  194.     printf("+-------------------------------------------------------_+\n");

  195.     printf("Configure I2C0 as a slave.\n");
  196.     printf("The I/O connection for I2C0:\n");
  197.     printf("I2C0_SDA(PA.8), I2C0_SCL(PA.9)\n");

  198.     /* Init I2C0 */
  199.     I2C0_Init();

  200.     /* I2C enter no address SLV mode */
  201.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

  202.     for(i = 0; i < 0x100; i++)
  203.     {
  204.         g_au8SlvData[i] = 0;
  205.     }

  206.     /* I2C function to Slave receive/transmit data */
  207.     s_I2C0HandlerFn = I2C_SlaveTRx;

  208.     printf("\n");
  209.     printf("I2C Slave Mode is Running.\n");

  210.     while(1);
  211. }



复制代码

使用特权

评论回复
| 2019-7-8 15:30 | 显示全部楼层
  1. /**************************************************************************//**
  2. * @file     main.c
  3. * @version  V3.00
  4. * $Revision: 3 $
  5. * $Date: 15/05/20 3:58p $
  6. * @brief
  7. *           Show how to wake up MCU from Power-down.
  8. *           This sample code needs to work with I2C_Wakeup_Slave.
  9. * @note
  10. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  11. *
  12. ******************************************************************************/
  13. #include <stdio.h>
  14. #include "NUC100Series.h"

  15. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  16. #define PLL_CLOCK           50000000

  17. /*---------------------------------------------------------------------------------------------------------*/
  18. /* Global variables                                                                                        */
  19. /*---------------------------------------------------------------------------------------------------------*/
  20. volatile uint8_t g_u8DeviceAddr;
  21. volatile uint8_t g_au8MstTxData[3];
  22. volatile uint8_t g_u8MstRxData;
  23. volatile uint8_t g_u8MstDataLen;
  24. volatile uint8_t g_u8MstEndFlag = 0;

  25. typedef void (*I2C_FUNC)(uint32_t u32Status);

  26. static volatile I2C_FUNC s_I2C0HandlerFn = NULL;

  27. /*---------------------------------------------------------------------------------------------------------*/
  28. /*  I2C0 IRQ Handler                                                                                       */
  29. /*---------------------------------------------------------------------------------------------------------*/
  30. void I2C0_IRQHandler(void)
  31. {
  32.     uint32_t u32Status;

  33.     u32Status = I2C_GET_STATUS(I2C0);

  34.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  35.     {
  36.         /* Clear I2C0 Timeout Flag */
  37.         I2C_ClearTimeoutFlag(I2C0);
  38.     }
  39.     else
  40.     {
  41.         if(s_I2C0HandlerFn != NULL)
  42.             s_I2C0HandlerFn(u32Status);
  43.     }
  44. }

  45. /*---------------------------------------------------------------------------------------------------------*/
  46. /*  I2C Master Tx Wake Up Callback Function                                                                        */
  47. /*---------------------------------------------------------------------------------------------------------*/
  48. void I2C_MasterTxWakeup(uint32_t u32Status)
  49. {
  50.     if(u32Status == 0x08)                       /* START has been transmitted */
  51.     {
  52.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */
  53.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  54.     }
  55.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  56.     {
  57.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  58.         g_u8MstEndFlag = 1;
  59.     }
  60.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NOT ACK has been received */
  61.     {
  62.         I2C_STOP(I2C0);
  63.         g_u8MstEndFlag = 1;
  64.     }
  65.     else
  66.     {
  67.         /* TO DO */
  68.         printf("Status 0x%x is NOT processed\n", u32Status);
  69.     }
  70. }
  71. /*---------------------------------------------------------------------------------------------------------*/
  72. /*  I2C Rx Callback Function                                                                               */
  73. /*---------------------------------------------------------------------------------------------------------*/
  74. void I2C_MasterRx(uint32_t u32Status)
  75. {
  76.     if(u32Status == 0x08)                       /* START has been transmitted and prepare SLA+W */
  77.     {
  78.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */
  79.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  80.     }
  81.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  82.     {
  83.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  84.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  85.     }
  86.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  87.     {
  88.         I2C_STOP(I2C0);
  89.         I2C_START(I2C0);
  90.     }
  91.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  92.     {
  93.         if(g_u8MstDataLen != 2)
  94.         {
  95.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  96.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  97.         }
  98.         else
  99.         {
  100.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);
  101.         }
  102.     }
  103.     else if(u32Status == 0x10)                  /* Repeat START has been transmitted and prepare SLA+R */
  104.     {
  105.         I2C_SET_DATA(I2C0, ((g_u8DeviceAddr << 1) | 0x01)); /* Write SLA+R to Register I2CDAT */
  106.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  107.     }
  108.     else if(u32Status == 0x40)                  /* SLA+R has been transmitted and ACK has been received */
  109.     {
  110.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  111.     }
  112.     else if(u32Status == 0x58)                  /* DATA has been received and NACK has been returned */
  113.     {
  114.         g_u8MstRxData = (unsigned char) I2C_GET_DATA(I2C0);
  115.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  116.         g_u8MstEndFlag = 1;
  117.     }
  118.     else
  119.     {
  120.         /* TO DO */
  121.         printf("Status 0x%x is NOT processed\n", u32Status);
  122.     }
  123. }

  124. /*---------------------------------------------------------------------------------------------------------*/
  125. /*  I2C Tx Callback Function                                                                               */
  126. /*---------------------------------------------------------------------------------------------------------*/
  127. void I2C_MasterTx(uint32_t u32Status)
  128. {
  129.     if(u32Status == 0x08)                       /* START has been transmitted */
  130.     {
  131.         I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);    /* Write SLA+W to Register I2CDAT */
  132.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  133.     }
  134.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  135.     {
  136.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  137.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  138.     }
  139.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  140.     {
  141.         I2C_STOP(I2C0);
  142.         I2C_START(I2C0);
  143.     }
  144.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  145.     {
  146.         if(g_u8MstDataLen != 3)
  147.         {
  148.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  149.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  150.         }
  151.         else
  152.         {
  153.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  154.             g_u8MstEndFlag = 1;
  155.         }
  156.     }
  157.     else
  158.     {
  159.         /* TO DO */
  160.         printf("Status 0x%x is NOT processed\n", u32Status);
  161.     }
  162. }

  163. void SYS_Init(void)
  164. {
  165.     /*---------------------------------------------------------------------------------------------------------*/
  166.     /* Init System Clock                                                                                       */
  167.     /*---------------------------------------------------------------------------------------------------------*/

  168.     /* Enable Internal RC 22.1184MHz clock */
  169.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  170.     /* Waiting for Internal RC clock ready */
  171.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  172.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  173.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  174.     /* Enable external XTAL 12MHz clock */
  175.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  176.     /* Waiting for external XTAL clock ready */
  177.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  178.     /* Set core clock as PLL_CLOCK from PLL */
  179.     CLK_SetCoreClock(PLL_CLOCK);

  180.     /* Enable UART module clock */
  181.     CLK_EnableModuleClock(UART0_MODULE);

  182.     /* Enable I2C0 module clock */
  183.     CLK_EnableModuleClock(I2C0_MODULE);

  184.     /* Select UART module clock source */
  185.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));

  186.     /*---------------------------------------------------------------------------------------------------------*/
  187.     /* Init I/O Multi-function                                                                                 */
  188.     /*---------------------------------------------------------------------------------------------------------*/

  189.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  190.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  191.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  192.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  193.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  194.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  195. }

  196. void UART0_Init()
  197. {
  198.     /*---------------------------------------------------------------------------------------------------------*/
  199.     /* Init UART                                                                                               */
  200.     /*---------------------------------------------------------------------------------------------------------*/
  201.     /* Reset IP */
  202.     SYS_ResetModule(UART0_RST);

  203.     /* Configure UART0 and set UART0 Baudrate */
  204.     UART_Open(UART0, 115200);
  205. }

  206. void I2C0_Init(void)
  207. {
  208.     /* Open I2C module and set bus clock */
  209.     I2C_Open(I2C0, 100000);

  210.     /* Get I2C0 Bus Clock */
  211.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  212.     /* Set I2C 4 Slave Addresses */
  213.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
  214.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
  215.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
  216.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */

  217.     /* Enable I2C interrupt */
  218.     I2C_EnableInt(I2C0);
  219.     NVIC_EnableIRQ(I2C0_IRQn);
  220. }

  221. void I2C0_Close(void)
  222. {
  223.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  224.     I2C_DisableInt(I2C0);
  225.     NVIC_DisableIRQ(I2C0_IRQn);

  226.     /* Disable I2C0 and close I2C0 clock */
  227.     I2C_Close(I2C0);
  228.     CLK_DisableModuleClock(I2C0_MODULE);

  229. }

  230. int32_t I2C0_Read_Write_SLAVE(uint8_t slvaddr)
  231. {
  232.     uint32_t i;

  233.     g_u8DeviceAddr = slvaddr;

  234.     for(i = 0; i < 0x100; i++)
  235.     {
  236.         g_au8MstTxData[0] = (uint8_t)((i & 0xFF00) >> 8);
  237.         g_au8MstTxData[1] = (uint8_t)(i & 0x00FF);
  238.         g_au8MstTxData[2] = (uint8_t)(g_au8MstTxData[1] + 3);

  239.         g_u8MstDataLen = 0;
  240.         g_u8MstEndFlag = 0;

  241.         /* I2C function to write data to slave */
  242.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;

  243.         /* I2C as master sends START signal */
  244.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  245.         /* Wait I2C Tx Finish */
  246.         while(g_u8MstEndFlag == 0);
  247.         g_u8MstEndFlag = 0;

  248.         /* I2C function to read data from slave */
  249.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterRx;

  250.         g_u8MstDataLen = 0;
  251.         g_u8DeviceAddr = slvaddr;

  252.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  253.         /* Wait I2C Rx Finish */
  254.         while(g_u8MstEndFlag == 0);

  255.         /* Compare data */
  256.         if(g_u8MstRxData != g_au8MstTxData[2])
  257.         {
  258.             printf("I2C Byte Write/Read Failed, Data 0x%x\n", g_u8MstRxData);
  259.             return -1;
  260.         }
  261.     }
  262.     printf("Master Access Slave (0x%X) Test OK\n", slvaddr);
  263.     return 0;
  264. }

  265. /*---------------------------------------------------------------------------------------------------------*/
  266. /*  Main Function                                                                                          */
  267. /*---------------------------------------------------------------------------------------------------------*/
  268. int32_t main(void)
  269. {
  270.     /* Unlock protected registers */
  271.     SYS_UnlockReg();

  272.     /* Init System, IP clock and multi-function I/O */
  273.     SYS_Init();

  274.     /* Init UART0 for printf */
  275.     UART0_Init();

  276.     /* Lock protected registers */
  277.     SYS_LockReg();

  278.     /*
  279.         This sample code sets I2C bus clock to 100kHz. After wake-up, then accesses Slave with Byte
  280.         Write and Byte Read operations, and check if the read data is equal to the programmed data.
  281.     */

  282.     printf("+------------------------------------------------------------------------+\n");
  283.     printf("| NUC100 I2C Driver Sample Code (Master) for wake-up & access Slave test |\n");
  284.     printf("|                                                                        |\n");
  285.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)                                |\n");
  286.     printf("+------------------------------------------------------------------------+\n");

  287.     printf("Configure I2C0 as a master.\n");
  288.     printf("The I/O connection for I2C0:\n");
  289.     printf("I2C0_SDA(P3.4), I2C0_SCL(P3.5)\n");

  290.     /* Init I2C0 to access Slave */
  291.     I2C0_Init();

  292.     printf("\n");
  293.     printf("Check I2C slave at power down status.\n");
  294.     printf("Press any key to Wake up slave.\n");
  295.     getchar();

  296.     /* Set the Slave address to wake-up*/
  297.     g_u8DeviceAddr = 0x15;

  298.     /* I2C function to wake-up slave*/
  299.     s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTxWakeup;

  300.     /* Send a START condition to bus */
  301.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
  302.     while(g_u8MstEndFlag == 0);

  303.     /*Access to the corresponding address Slave*/
  304.     printf("\n");
  305.     printf(" == No Mask Address ==\n");
  306.     I2C0_Read_Write_SLAVE(0x15);
  307.     I2C0_Read_Write_SLAVE(0x35);
  308.     I2C0_Read_Write_SLAVE(0x55);
  309.     I2C0_Read_Write_SLAVE(0x75);
  310.     printf("SLAVE Address test OK.\n");


  311.     /* Access Slave with address mask */
  312.     printf("\n");
  313.     printf(" == Mask Address ==\n");
  314.     I2C0_Read_Write_SLAVE(0x15 & ~0x01);
  315.     I2C0_Read_Write_SLAVE(0x35 & ~0x04);
  316.     I2C0_Read_Write_SLAVE(0x55 & ~0x01);
  317.     I2C0_Read_Write_SLAVE(0x75 & ~0x04);
  318.     printf("SLAVE Address Mask test OK.\n");

  319.     s_I2C0HandlerFn = NULL;

  320.     /* Close I2C0 */
  321.     I2C0_Close();

  322.     while(1);
  323. }
复制代码

使用特权

评论回复
| 2019-7-8 15:31 | 显示全部楼层
  1. /**************************************************************************//**
  2. * @file     main.c
  3. * @version  V3.00
  4. * $Revision: 2 $
  5. * $Date: 14/12/29 3:16p $
  6. * @brief
  7. *           Show how to wake up MCU from Power-down mode through I2C interface.
  8. *           This sample code needs to work with I2C_Wakeup_Master.
  9. * @note
  10. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  11. *
  12. ******************************************************************************/
  13. #include <stdio.h>
  14. #include "NUC100Series.h"

  15. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  16. #define PLL_CLOCK           50000000

  17. uint32_t slave_buff_addr;
  18. uint8_t g_au8SlvData[256];
  19. uint8_t g_au8SlvRxData[3];
  20. uint8_t g_u8SlvPWRDNWK, g_u8SlvI2CWK;
  21. /*---------------------------------------------------------------------------------------------------------*/
  22. /* Global variables                                                                                        */
  23. /*---------------------------------------------------------------------------------------------------------*/
  24. volatile uint8_t g_u8DeviceAddr;
  25. volatile uint8_t g_u8SlvDataLen;

  26. typedef void (*I2C_FUNC)(uint32_t u32Status);

  27. static I2C_FUNC s_I2C0HandlerFn = NULL;

  28. /*---------------------------------------------------------------------------------------------------------*/
  29. /*  I2C0 IRQ Handler                                                                                       */
  30. /*---------------------------------------------------------------------------------------------------------*/
  31. void I2C0_IRQHandler(void)
  32. {
  33.     uint32_t u32Status;

  34.     /* Check I2C Wake-up interrupt flag set or not */
  35.     if(I2C_GET_WAKEUP_FLAG(I2C0))
  36.     {
  37.         /* Clear I2C Wake-up interrupt flag */
  38.         I2C_CLEAR_WAKEUP_FLAG(I2C0);

  39.         g_u8SlvI2CWK = 1;

  40.         return;
  41.     }

  42.     u32Status = I2C_GET_STATUS(I2C0);

  43.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  44.     {
  45.         /* Clear I2C0 Timeout Flag */
  46.         I2C_ClearTimeoutFlag(I2C0);
  47.     }
  48.     else
  49.     {
  50.         if(s_I2C0HandlerFn != NULL)
  51.             s_I2C0HandlerFn(u32Status);
  52.     }
  53. }
  54. /*---------------------------------------------------------------------------------------------------------*/
  55. /*  Power Wake-up IRQ Handler                                                                                       */
  56. /*---------------------------------------------------------------------------------------------------------*/
  57. void PWRWU_IRQHandler(void)
  58. {
  59.     /* Check system power down mode wake-up interrupt flag */
  60.     if(((CLK->PWRCON) & CLK_PWRCON_PD_WU_STS_Msk) != 0)
  61.     {
  62.         /* Clear system power down wake-up interrupt flag */
  63.         CLK->PWRCON |= CLK_PWRCON_PD_WU_STS_Msk;

  64.         g_u8SlvPWRDNWK = 1;
  65.     }
  66. }

  67. /*---------------------------------------------------------------------------------------------------------*/
  68. /*  I2C Slave Transmit/Receive Callback Function                                                                               */
  69. /*---------------------------------------------------------------------------------------------------------*/
  70. void I2C_SlaveTRx(uint32_t u32Status)
  71. {
  72.     if(u32Status == 0x60)                       /* Own SLA+W has been receive; ACK has been return */
  73.     {
  74.         g_u8SlvDataLen = 0;
  75.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  76.     }
  77.     else if(u32Status == 0x80)                 /* Previously address with own SLA address
  78.                                                    Data has been received; ACK has been returned*/
  79.     {
  80.         g_au8SlvRxData[g_u8SlvDataLen] = (unsigned char)I2C_GET_DATA(I2C0);
  81.         g_u8SlvDataLen++;

  82.         if(g_u8SlvDataLen == 2)
  83.         {
  84.             slave_buff_addr = (g_au8SlvRxData[0] << 8) + g_au8SlvRxData[1];
  85.         }
  86.         if(g_u8SlvDataLen == 3)
  87.         {
  88.             g_au8SlvData[slave_buff_addr] = g_au8SlvRxData[2];
  89.             g_u8SlvDataLen = 0;
  90.         }
  91.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  92.     }
  93.     else if(u32Status == 0xA8)                  /* Own SLA+R has been receive; ACK has been return */
  94.     {
  95.         I2C_SET_DATA(I2C0, g_au8SlvData[slave_buff_addr]);
  96.         slave_buff_addr++;
  97.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  98.     }
  99.     else if(u32Status == 0xC0)                 /* Data byte or last data in I2CDAT has been transmitted
  100.                                                    Not ACK has been received */
  101.     {
  102.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  103.     }
  104.     else if(u32Status == 0x88)                 /* Previously addressed with own SLA address; NOT ACK has
  105.                                                    been returned */
  106.     {
  107.         g_u8SlvDataLen = 0;
  108.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  109.     }
  110.     else if(u32Status == 0xA0)                 /* A STOP or repeated START has been received while still
  111.                                                    addressed as Slave/Receiver*/
  112.     {
  113.         g_u8SlvDataLen = 0;
  114.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  115.     }
  116.     else
  117.     {
  118.         /* TO DO */
  119.         printf("Status 0x%x is NOT processed\n", u32Status);
  120.     }
  121. }

  122. void SYS_Init(void)
  123. {
  124.     /*---------------------------------------------------------------------------------------------------------*/
  125.     /* Init System Clock                                                                                       */
  126.     /*---------------------------------------------------------------------------------------------------------*/

  127.     /* Enable Internal RC 22.1184MHz clock */
  128.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  129.     /* Waiting for Internal RC clock ready */
  130.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  131.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  132.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  133.     /* Enable external XTAL 12MHz clock */
  134.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  135.     /* Waiting for external XTAL clock ready */
  136.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  137.     /* Set core clock as PLL_CLOCK from PLL */
  138.     CLK_SetCoreClock(PLL_CLOCK);

  139.     /* Enable UART module clock */
  140.     CLK_EnableModuleClock(UART0_MODULE);

  141.     /* Enable I2C0 module clock */
  142.     CLK_EnableModuleClock(I2C0_MODULE);

  143.     /* Select UART module clock source */
  144.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));


  145.     /*---------------------------------------------------------------------------------------------------------*/
  146.     /* Init I/O Multi-function                                                                                 */
  147.     /*---------------------------------------------------------------------------------------------------------*/

  148.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  149.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  150.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  151.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  152.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  153.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  154. }

  155. void UART0_Init()
  156. {
  157.     /*---------------------------------------------------------------------------------------------------------*/
  158.     /* Init UART                                                                                               */
  159.     /*---------------------------------------------------------------------------------------------------------*/
  160.     /* Reset IP */
  161.     SYS_ResetModule(UART0_RST);

  162.     /* Configure UART0 and set UART0 Baudrate */
  163.     UART_Open(UART0, 115200);
  164. }

  165. void I2C0_Init(void)
  166. {
  167.     /* Open I2C module and set bus clock */
  168.     I2C_Open(I2C0, 100000);

  169.     /* Get I2C0 Bus Clock */
  170.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  171.     /* Set I2C 4 Slave Addresses */
  172.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
  173.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
  174.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
  175.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */

  176.     /* Set I2C 4 Slave Addresses Mask */
  177.     I2C_SetSlaveAddrMask(I2C0, 0, 0x01);
  178.     I2C_SetSlaveAddrMask(I2C0, 1, 0x04);
  179.     I2C_SetSlaveAddrMask(I2C0, 2, 0x01);
  180.     I2C_SetSlaveAddrMask(I2C0, 3, 0x04);

  181.     /* Enable I2C interrupt */
  182.     I2C_EnableInt(I2C0);
  183.     NVIC_EnableIRQ(I2C0_IRQn);
  184. }

  185. void I2C0_Close(void)
  186. {
  187.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  188.     I2C_DisableInt(I2C0);
  189.     NVIC_DisableIRQ(I2C0_IRQn);

  190.     /* Disable I2C0 and close I2C0 clock */
  191.     I2C_Close(I2C0);
  192.     CLK_DisableModuleClock(I2C0_MODULE);
  193. }

  194. /*---------------------------------------------------------------------------------------------------------*/
  195. /*  Main Function                                                                                          */
  196. /*---------------------------------------------------------------------------------------------------------*/
  197. int32_t main(void)
  198. {
  199.     uint32_t i;

  200.     /* Unlock protected registers */
  201.     SYS_UnlockReg();

  202.     /* Init System, IP clock and multi-function I/O */
  203.     SYS_Init();

  204.     /* Init UART0 for printf */
  205.     UART0_Init();

  206.     /* Lock protected registers */
  207.     SYS_LockReg();;

  208.     /*
  209.         This sample code is I2C SLAVE mode and it simulates EEPROM function
  210.     */
  211.     printf("\n");
  212.     printf("+----------------------------------------------------------------------+\n");
  213.     printf("| NUC100 I2C Driver Sample Code (Slave) for wake-up & access Slave test |\n");
  214.     printf("|                                                                      |\n");
  215.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)                              |\n");
  216.     printf("+----------------------------------------------------------------------+\n");

  217.     printf("Configure I2C0 as a slave.\n");
  218.     printf("The I/O connection for I2C0:\n");
  219.     printf("I2C0_SDA(P3.4), I2C0_SCL(P3.5)\n");

  220.     /* Init I2C0 */
  221.     I2C0_Init();

  222.     for(i = 0; i < 0x100; i++)
  223.     {
  224.         g_au8SlvData[i] = 0;
  225.     }

  226.     /* I2C function to Transmit/Receive data as slave */
  227.     s_I2C0HandlerFn = I2C_SlaveTRx;

  228.     /* Set I2C0 enter Not Address SLAVE mode */
  229.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

  230.     /* Unlock protected registers */
  231.     SYS_UnlockReg();

  232.     /* Enable power wake-up interrupt */
  233.     CLK->PWRCON |= CLK_PWRCON_PD_WU_INT_EN_Msk;
  234.     NVIC_EnableIRQ(PWRWU_IRQn);

  235.     /* Enable I2C wake-up */
  236.     I2C0-> I2CWKUPCON |= I2C_I2CWKUPCON_WKUPEN_Msk;

  237.     /* Enable Chip enter power down mode */
  238.     CLK->PWRCON |= CLK_PWRCON_PD_WAIT_CPU_Msk;

  239.     /* Processor use deep sleep */
  240.     SCB->SCR = SCB_SCR_SLEEPDEEP_Msk;

  241.     /* System power down enable */
  242.     CLK->PWRCON |= CLK_PWRCON_PWR_DOWN_EN_Msk;

  243.     printf("\n");
  244.     printf("Enter PD 0x%x 0x%x\n", I2C0->I2CON , I2C0->I2CSTATUS);
  245.     printf("\n");
  246.     printf("CHIP enter power down status.\n");
  247.     /* Waiting for UART printf finish*/
  248.     while(((UART0->FSR) & UART_FSR_TE_FLAG_Msk) == 0);

  249.     if(((I2C0->I2CON)&I2C_I2CON_SI_Msk) != 0)
  250.     {
  251.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  252.     }

  253.     /*  Use WFI instruction to idle the CPU. NOTE:
  254.         If ICE is attached, system will wakeup immediately because ICE is a wakeup event. */
  255.     __WFI();
  256.     __NOP();
  257.     __NOP();
  258.     __NOP();

  259.     while((g_u8SlvPWRDNWK & g_u8SlvI2CWK) == 0);
  260.     printf("Power-down Wake-up INT 0x%x\n", ((CLK->PWRCON) & CLK_PWRCON_PD_WU_STS_Msk));
  261.     printf("I2C0 WAKE INT 0x%x\n", I2C0->I2CWKUPSTS);

  262.     /* Disable power wake-up interrupt */
  263.     CLK->PWRCON &= ~CLK_PWRCON_PD_WU_INT_EN_Msk;
  264.     NVIC_DisableIRQ(PWRWU_IRQn);

  265.     /* Lock protected registers */
  266.     SYS_LockReg();

  267.     printf("\n");
  268.     printf("Slave wake-up from power down status.\n");

  269.     printf("\n");
  270.     printf("Slave Waiting for receiving data.\n");

  271.     while(1);
  272. }



复制代码

使用特权

评论回复
| 2019-7-8 15:31 | 显示全部楼层
  1. /**************************************************************************//**
  2. * @file     main.c
  3. * @version  V3.00
  4. * $Revision: 3 $
  5. * $Date: 15/05/20 3:58p $
  6. * @brief    Show how to use I2C interface to access EEPROM.
  7. * @note
  8. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  9. *
  10. ******************************************************************************/
  11. #include <stdio.h>
  12. #include "NUC100Series.h"

  13. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  14. #define PLL_CLOCK           50000000


  15. /*---------------------------------------------------------------------------------------------------------*/
  16. /* Global variables                                                                                        */
  17. /*---------------------------------------------------------------------------------------------------------*/
  18. volatile uint8_t g_u8DeviceAddr;
  19. volatile uint8_t g_au8TxData[3];
  20. volatile uint8_t g_u8RxData;
  21. volatile uint8_t g_u8DataLen;
  22. volatile uint8_t g_u8EndFlag = 0;

  23. typedef void (*I2C_FUNC)(uint32_t u32Status);

  24. static I2C_FUNC s_I2C0HandlerFn = NULL;

  25. /*---------------------------------------------------------------------------------------------------------*/
  26. /*  I2C0 IRQ Handler                                                                                       */
  27. /*---------------------------------------------------------------------------------------------------------*/
  28. void I2C0_IRQHandler(void)
  29. {
  30.     uint32_t u32Status;

  31.     u32Status = I2C_GET_STATUS(I2C0);
  32.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  33.     {
  34.         /* Clear I2C0 Timeout Flag */
  35.         I2C_ClearTimeoutFlag(I2C0);
  36.     }
  37.     else
  38.     {
  39.         if(s_I2C0HandlerFn != NULL)
  40.             s_I2C0HandlerFn(u32Status);
  41.     }
  42. }

  43. /*---------------------------------------------------------------------------------------------------------*/
  44. /*  I2C Rx Callback Function                                                                               */
  45. /*---------------------------------------------------------------------------------------------------------*/
  46. void I2C_MasterRx(uint32_t u32Status)
  47. {
  48.     if(u32Status == 0x08)                       /* START has been transmitted and prepare SLA+W */
  49.     {
  50.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */
  51.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  52.     }
  53.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  54.     {
  55.         I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
  56.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  57.     }
  58.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  59.     {
  60.         I2C_STOP(I2C0);
  61.         I2C_START(I2C0);
  62.     }
  63.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  64.     {
  65.         if(g_u8DataLen != 2)
  66.         {
  67.             I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
  68.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  69.         }
  70.         else
  71.         {
  72.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);
  73.         }
  74.     }
  75.     else if(u32Status == 0x10)                  /* Repeat START has been transmitted and prepare SLA+R */
  76.     {
  77.         I2C_SET_DATA(I2C0, ((g_u8DeviceAddr << 1) | 0x01));   /* Write SLA+R to Register I2CDAT */
  78.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  79.     }
  80.     else if(u32Status == 0x40)                  /* SLA+R has been transmitted and ACK has been received */
  81.     {
  82.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  83.     }
  84.     else if(u32Status == 0x58)                  /* DATA has been received and NACK has been returned */
  85.     {
  86.         g_u8RxData = (unsigned char) I2C_GET_DATA(I2C0);
  87.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  88.         g_u8EndFlag = 1;
  89.     }
  90.     else
  91.     {
  92.         /* TO DO */
  93.         printf("Status 0x%x is NOT processed\n", u32Status);
  94.     }
  95. }

  96. /*---------------------------------------------------------------------------------------------------------*/
  97. /*  I2C Tx Callback Function                                                                               */
  98. /*---------------------------------------------------------------------------------------------------------*/
  99. void I2C_MasterTx(uint32_t u32Status)
  100. {
  101.     if(u32Status == 0x08)                       /* START has been transmitted */
  102.     {
  103.         I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);    /* Write SLA+W to Register I2CDAT */
  104.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  105.     }
  106.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  107.     {
  108.         I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
  109.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  110.     }
  111.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  112.     {
  113.         I2C_STOP(I2C0);
  114.         I2C_START(I2C0);
  115.     }
  116.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  117.     {
  118.         if(g_u8DataLen != 3)
  119.         {
  120.             I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
  121.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  122.         }
  123.         else
  124.         {
  125.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  126.             g_u8EndFlag = 1;
  127.         }
  128.     }
  129.     else
  130.     {
  131.         /* TO DO */
  132.         printf("Status 0x%x is NOT processed\n", u32Status);
  133.     }
  134. }

  135. void SYS_Init(void)
  136. {
  137.     /*---------------------------------------------------------------------------------------------------------*/
  138.     /* Init System Clock                                                                                       */
  139.     /*---------------------------------------------------------------------------------------------------------*/

  140.     /* Enable Internal RC 22.1184MHz clock */
  141.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  142.     /* Waiting for Internal RC clock ready */
  143.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  144.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  145.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  146.     /* Enable external XTAL 12MHz clock */
  147.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  148.     /* Waiting for external XTAL clock ready */
  149.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  150.     /* Set core clock as PLL_CLOCK from PLL */
  151.     CLK_SetCoreClock(PLL_CLOCK);

  152.     /* Enable UART module clock */
  153.     CLK_EnableModuleClock(UART0_MODULE);

  154.     /* Enable I2C0 module clock */
  155.     CLK_EnableModuleClock(I2C0_MODULE);

  156.     /* Select UART module clock source */
  157.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));


  158.     /*---------------------------------------------------------------------------------------------------------*/
  159.     /* Init I/O Multi-function                                                                                 */
  160.     /*---------------------------------------------------------------------------------------------------------*/

  161.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  162.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  163.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  164.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  165.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  166.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  167. }

  168. void UART0_Init()
  169. {
  170.     /*---------------------------------------------------------------------------------------------------------*/
  171.     /* Init UART                                                                                               */
  172.     /*---------------------------------------------------------------------------------------------------------*/
  173.     /* Reset IP */
  174.     SYS_ResetModule(UART0_RST);

  175.     /* Configure UART0 and set UART0 Baudrate */
  176.     UART_Open(UART0, 115200);
  177. }

  178. void I2C0_Close(void)
  179. {
  180.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  181.     I2C_DisableInt(I2C0);
  182.     NVIC_DisableIRQ(I2C0_IRQn);

  183.     /* Disable I2C0 and close I2C0 clock */
  184.     I2C_Close(I2C0);
  185.     CLK_DisableModuleClock(I2C0_MODULE);

  186. }

  187. void I2C0_Init(void)
  188. {
  189.     /* Open I2C module and set bus clock */
  190.     I2C_Open(I2C0, 100000);

  191.     /* Get I2C0 Bus Clock */
  192.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  193.     /* Set I2C 4 Slave Addresses */
  194.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
  195.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
  196.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
  197.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */

  198.     /* Enable I2C interrupt */
  199.     I2C_EnableInt(I2C0);
  200.     NVIC_EnableIRQ(I2C0_IRQn);
  201. }

  202. /*---------------------------------------------------------------------------------------------------------*/
  203. /*  Main Function                                                                                          */
  204. /*---------------------------------------------------------------------------------------------------------*/
  205. int32_t main(void)
  206. {
  207.     uint32_t i;

  208.     /* Unlock protected registers */
  209.     SYS_UnlockReg();

  210.     /* Init System, IP clock and multi-function I/O */
  211.     SYS_Init();

  212.     /* Lock protected registers */
  213.     SYS_LockReg();

  214.     /* Init UART0 for printf */
  215.     UART0_Init();

  216.     /*
  217.         This sample code sets I2C bus clock to 100kHz. Then, accesses EEPROM 24LC64 with Byte Write
  218.         and Byte Read operations, and check if the read data is equal to the programmed data.
  219.     */

  220.     printf("+-------------------------------------------------------+\n");
  221.     printf("|    NUC100 I2C Driver Sample Code with EEPROM 24LC64   |\n");
  222.     printf("+-------------------------------------------------------+\n");

  223.     /* Init I2C0 to access EEPROM */
  224.     I2C0_Init();

  225.     g_u8DeviceAddr = 0x50;

  226.     for(i = 0; i < 0x100; i++)
  227.     {
  228.         g_au8TxData[0] = (uint8_t)((i & 0xFF00) >> 8);
  229.         g_au8TxData[1] = (uint8_t)(i & 0x00FF);
  230.         g_au8TxData[2] = (uint8_t)(g_au8TxData[1] + 3);

  231.         g_u8DataLen = 0;
  232.         g_u8EndFlag = 0;

  233.         /* I2C function to write data to slave */
  234.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;

  235.         /* I2C as master sends START signal */
  236.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  237.         /* Wait I2C Tx Finish */
  238.         while(g_u8EndFlag == 0);
  239.         g_u8EndFlag = 0;

  240.         /* I2C function to read data from slave */
  241.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterRx;

  242.         g_u8DataLen = 0;
  243.         g_u8DeviceAddr = 0x50;

  244.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  245.         /* Wait I2C Rx Finish */
  246.         while(g_u8EndFlag == 0);

  247.         /* Compare data */
  248.         if(g_u8RxData != g_au8TxData[2])
  249.         {
  250.             printf("I2C Byte Write/Read Failed, Data 0x%x\n", g_u8RxData);
  251.             return -1;
  252.         }
  253.     }
  254.     printf("I2C0 Access EEPROM Test OK\n");

  255.     s_I2C0HandlerFn = NULL;

  256.     /* Close I2C0 */
  257.     I2C0_Close();

  258.     while(1);
  259. }



复制代码

使用特权

评论回复
| 2019-7-8 15:31 | 显示全部楼层
  1. /**************************************************************************//**
  2. * @file     main.c
  3. * @version  V3.00
  4. * $Revision: 3 $
  5. * $Date: 15/05/20 3:58p $
  6. * @brief
  7. *           Show how a Master uses I2C address 0x0 to write data to Slave.
  8. *           This sample code needs to work with I2C_GCMode_Slave.
  9. * @note
  10. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  11. *
  12. ******************************************************************************/
  13. #include <stdio.h>
  14. #include "NUC100Series.h"

  15. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  16. #define PLL_CLOCK           50000000

  17. /*---------------------------------------------------------------------------------------------------------*/
  18. /* Global variables                                                                                        */
  19. /*---------------------------------------------------------------------------------------------------------*/
  20. volatile uint8_t g_u8DeviceAddr;
  21. volatile uint8_t g_au8MstTxData[3];
  22. volatile uint8_t g_u8MstDataLen;
  23. volatile uint8_t g_u8MstEndFlag = 0;

  24. typedef void (*I2C_FUNC)(uint32_t u32Status);

  25. static I2C_FUNC s_I2C0HandlerFn = NULL;

  26. /*---------------------------------------------------------------------------------------------------------*/
  27. /*  I2C0 IRQ Handler                                                                                       */
  28. /*---------------------------------------------------------------------------------------------------------*/
  29. void I2C0_IRQHandler(void)
  30. {
  31.     uint32_t u32Status;

  32.     u32Status = I2C_GET_STATUS(I2C0);

  33.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  34.     {
  35.         /* Clear I2C0 Timeout Flag */
  36.         I2C_ClearTimeoutFlag(I2C0);
  37.     }
  38.     else
  39.     {
  40.         if(s_I2C0HandlerFn != NULL)
  41.             s_I2C0HandlerFn(u32Status);
  42.     }
  43. }

  44. /*---------------------------------------------------------------------------------------------------------*/
  45. /*  I2C Tx Callback Function                                                                               */
  46. /*---------------------------------------------------------------------------------------------------------*/
  47. void I2C_MasterTx(uint32_t u32Status)
  48. {
  49.     if(u32Status == 0x08)                       /* START has been transmitted */
  50.     {
  51.         I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);    /* Write SLA+W to Register I2CDAT */
  52.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  53.     }
  54.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
  55.     {
  56.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  57.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  58.     }
  59.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
  60.     {
  61.         I2C_STOP(I2C0);
  62.         I2C_START(I2C0);
  63.     }
  64.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
  65.     {
  66.         if(g_u8MstDataLen != 3)
  67.         {
  68.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
  69.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
  70.         }
  71.         else
  72.         {
  73.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
  74.             g_u8MstEndFlag = 1;
  75.         }
  76.     }
  77.     else
  78.     {
  79.         /* TO DO */
  80.         printf("Status 0x%x is NOT processed\n", u32Status);
  81.     }
  82. }

  83. void SYS_Init(void)
  84. {
  85.     /*---------------------------------------------------------------------------------------------------------*/
  86.     /* Init System Clock                                                                                       */
  87.     /*---------------------------------------------------------------------------------------------------------*/

  88.     /* Enable Internal RC 22.1184MHz clock */
  89.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  90.     /* Waiting for Internal RC clock ready */
  91.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  92.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  93.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  94.     /* Enable external XTAL 12MHz clock */
  95.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  96.     /* Waiting for external XTAL clock ready */
  97.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  98.     /* Set core clock as PLL_CLOCK from PLL */
  99.     CLK_SetCoreClock(PLL_CLOCK);

  100.     /* Enable UART module clock */
  101.     CLK_EnableModuleClock(UART0_MODULE);

  102.     /* Enable I2C0 module clock */
  103.     CLK_EnableModuleClock(I2C0_MODULE);

  104.     /* Select UART module clock source */
  105.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));

  106.     /*---------------------------------------------------------------------------------------------------------*/
  107.     /* Init I/O Multi-function                                                                                 */
  108.     /*---------------------------------------------------------------------------------------------------------*/

  109.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  110.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  111.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  112.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  113.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  114.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  115. }

  116. void UART0_Init()
  117. {
  118.     /*---------------------------------------------------------------------------------------------------------*/
  119.     /* Init UART                                                                                               */
  120.     /*---------------------------------------------------------------------------------------------------------*/
  121.     /* Reset IP */
  122.     SYS_ResetModule(UART0_RST);

  123.     /* Configure UART0 and set UART0 Baudrate */
  124.     UART_Open(UART0, 115200);
  125. }

  126. void I2C0_Init(void)
  127. {
  128.     /* Open I2C module and set bus clock */
  129.     I2C_Open(I2C0, 100000);

  130.     /* Get I2C0 Bus Clock */
  131.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  132.     /* Set I2C 4 Slave Addresses */
  133.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
  134.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
  135.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
  136.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */

  137.     /* Enable I2C interrupt */
  138.     I2C_EnableInt(I2C0);
  139.     NVIC_EnableIRQ(I2C0_IRQn);
  140. }

  141. void I2C0_Close(void)
  142. {
  143.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  144.     I2C_DisableInt(I2C0);
  145.     NVIC_DisableIRQ(I2C0_IRQn);

  146.     /* Disable I2C0 and close I2C0 clock */
  147.     I2C_Close(I2C0);
  148.     CLK_DisableModuleClock(I2C0_MODULE);

  149. }


  150. /*---------------------------------------------------------------------------------------------------------*/
  151. /*  Main Function                                                                                          */
  152. /*---------------------------------------------------------------------------------------------------------*/
  153. int32_t main(void)
  154. {
  155.     uint32_t i;

  156.     /* Unlock protected registers */
  157.     SYS_UnlockReg();

  158.     /* Init System, IP clock and multi-function I/O */
  159.     SYS_Init();

  160.     /* Init UART0 for printf */
  161.     UART0_Init();

  162.     /* Lock protected registers */
  163.     SYS_LockReg();

  164.     /*
  165.         This sample code sets I2C bus clock to 100kHz. Then, accesses Slave (GC Mode) with Byte Write
  166.         and Byte Read operations, and check if the read data is equal to the programmed data.
  167.     */
  168.     printf("\n");
  169.     printf("+------------------------------------------------------------------+\n");
  170.     printf("| NUC100 I2C Driver Sample Code (Master) for access Slave (GC Mode)|\n");
  171.     printf("|                                                                  |\n");
  172.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)(Address: 0x00)           |\n");
  173.     printf("+------------------------------------------------------------------+\n");

  174.     printf("Configure I2C0 as a master.\n");
  175.     printf("The I/O connection for I2C0:\n");
  176.     printf("I2C0_SDA(PA.8), I2C0_SCL(PA.9)\n");

  177.     /* Init I2C0 to access EEPROM */
  178.     I2C0_Init();

  179.     printf("\n");

  180.     /* Send Slave GC Mode address */
  181.     g_u8DeviceAddr = 0x00;

  182.     printf("Check I2C Slave(I2C0) is running first!\n");
  183.     printf("Press any key to continue.\n");
  184.     getchar();
  185.     for(i = 0; i < 0x100; i++)
  186.     {
  187.         g_au8MstTxData[0] = (uint8_t)((i & 0xFF00) >> 8);
  188.         g_au8MstTxData[1] = (uint8_t)(i & 0x00FF);
  189.         g_au8MstTxData[2] = (uint8_t)(g_au8MstTxData[1] + 3);

  190.         g_u8MstDataLen = 0;
  191.         g_u8MstEndFlag = 0;

  192.         /* I2C function to write data to slave */
  193.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;

  194.         /* I2C as master sends START signal */
  195.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);

  196.         /* Wait I2C Tx Finish */
  197.         while(g_u8MstEndFlag == 0);
  198.     }
  199.     printf("Master Access Slave(0x%X) at GC Mode Test OK\n", g_u8DeviceAddr);

  200.     s_I2C0HandlerFn = NULL;

  201.     /* Close I2C0 */
  202.     I2C0_Close();

  203.     while(1);
  204. }



复制代码

使用特权

评论回复
| 2019-7-8 15:32 | 显示全部楼层
  1. /**************************************************************************//**
  2. * @file     main.c
  3. * @version  V3.00
  4. * $Revision: 2 $
  5. * $Date: 14/12/29 3:23p $
  6. * @brief
  7. *           Show a Slave how to receive data from Master in GC (General Call) mode.
  8. *           This sample code needs to work with I2C_GCMode_Master.
  9. * @note
  10. * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
  11. *
  12. ******************************************************************************/
  13. #include <stdio.h>
  14. #include "NUC100Series.h"

  15. #define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT
  16. #define PLL_CLOCK           50000000

  17. volatile uint32_t slave_buff_addr;
  18. volatile uint8_t g_au8SlvData[256];
  19. volatile uint8_t g_au8SlvRxData[3];
  20. /*---------------------------------------------------------------------------------------------------------*/
  21. /* Global variables                                                                                        */
  22. /*---------------------------------------------------------------------------------------------------------*/
  23. volatile uint8_t g_u8DeviceAddr;
  24. volatile uint8_t g_au8SlvTxData[3];
  25. volatile uint8_t g_u8SlvDataLen;
  26. volatile uint8_t g_u8SlvEndFlag = 0;

  27. typedef void (*I2C_FUNC)(uint32_t u32Status);

  28. static I2C_FUNC s_I2C0HandlerFn = NULL;

  29. /*---------------------------------------------------------------------------------------------------------*/
  30. /*  I2C0 IRQ Handler                                                                                       */
  31. /*---------------------------------------------------------------------------------------------------------*/
  32. void I2C0_IRQHandler(void)
  33. {
  34.     uint32_t u32Status;

  35.     u32Status = I2C_GET_STATUS(I2C0);

  36.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
  37.     {
  38.         /* Clear I2C0 Timeout Flag */
  39.         I2C_ClearTimeoutFlag(I2C0);
  40.     }
  41.     else
  42.     {
  43.         if(s_I2C0HandlerFn != NULL)
  44.             s_I2C0HandlerFn(u32Status);
  45.     }
  46. }

  47. /*---------------------------------------------------------------------------------------------------------*/
  48. /*  I2C GC mode Rx Callback Function                                                                       */
  49. /*---------------------------------------------------------------------------------------------------------*/
  50. void I2C_GCSlaveRx(uint32_t u32Status)
  51. {
  52.     if(u32Status == 0x70)                      /* Reception of the general call address and one more data byte;
  53.                                                                         ACK has been return */
  54.     {
  55.         g_u8SlvDataLen = 0;
  56.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  57.     }
  58.     else if(u32Status == 0x90)                 /* Previously addressed with General Call; Data has been received
  59.                                                    ACK has been returned */
  60.     {
  61.         g_au8SlvRxData[g_u8SlvDataLen] = (unsigned char) I2C_GET_DATA(I2C0);
  62.         g_u8SlvDataLen++;

  63.         if(g_u8SlvDataLen == 2)
  64.         {
  65.             slave_buff_addr = (g_au8SlvRxData[0] << 8) + g_au8SlvRxData[1];
  66.         }
  67.         if(g_u8SlvDataLen == 3)
  68.         {
  69.             g_au8SlvData[slave_buff_addr] = g_au8SlvRxData[2];
  70.             g_u8SlvDataLen = 0;
  71.         }
  72.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  73.     }
  74.     else if(u32Status == 0x98)                 /* Previously addressed with General Call; Data byte has been
  75.                                                    received; NOT ACK has been returned */
  76.     {
  77.         g_u8SlvDataLen = 0;
  78.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  79.     }
  80.     else if(u32Status == 0xA0)                 /* A STOP or repeated START has been received while still addressed
  81.                                                    as SLV receiver */
  82.     {
  83.         g_u8SlvDataLen = 0;
  84.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
  85.         if(slave_buff_addr == 0xFF)
  86.         {
  87.             g_u8SlvEndFlag = 1;
  88.         }
  89.     }
  90.     else
  91.     {
  92.         /* TO DO */
  93.         printf("Status 0x%x is NOT processed\n", u32Status);
  94.     }
  95. }

  96. void SYS_Init(void)
  97. {
  98.     /*---------------------------------------------------------------------------------------------------------*/
  99.     /* Init System Clock                                                                                       */
  100.     /*---------------------------------------------------------------------------------------------------------*/

  101.     /* Enable Internal RC 22.1184MHz clock */
  102.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);

  103.     /* Waiting for Internal RC clock ready */
  104.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);

  105.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
  106.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));

  107.     /* Enable external XTAL 12MHz clock */
  108.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);

  109.     /* Waiting for external XTAL clock ready */
  110.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);

  111.     /* Set core clock as PLL_CLOCK from PLL */
  112.     CLK_SetCoreClock(PLL_CLOCK);

  113.     /* Enable UART module clock */
  114.     CLK_EnableModuleClock(UART0_MODULE);

  115.     /* Enable I2C0 module clock */
  116.     CLK_EnableModuleClock(I2C0_MODULE);

  117.     /* Select UART module clock source */
  118.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));


  119.     /*---------------------------------------------------------------------------------------------------------*/
  120.     /* Init I/O Multi-function                                                                                 */
  121.     /*---------------------------------------------------------------------------------------------------------*/

  122.     /* Set GPB multi-function pins for UART0 RXD and TXD */
  123.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
  124.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;

  125.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
  126.     SYS->GPA_MFP &= ~(SYS_GPA_MFP_PA8_Msk | SYS_GPA_MFP_PA9_Msk);
  127.     SYS->GPA_MFP |= SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
  128. }


  129. void UART0_Init()
  130. {
  131.     /*---------------------------------------------------------------------------------------------------------*/
  132.     /* Init UART                                                                                               */
  133.     /*---------------------------------------------------------------------------------------------------------*/
  134.     /* Reset IP */
  135.     SYS_ResetModule(UART0_RST);

  136.     /* Configure UART0 and set UART0 Baudrate */
  137.     UART_Open(UART0, 115200);
  138. }

  139. void I2C0_Init(void)
  140. {
  141.     /* Open I2C module and set bus clock */
  142.     I2C_Open(I2C0, 100000);

  143.     /* Get I2C0 Bus Clock */
  144.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));

  145.     /* Set I2C 4 Slave Addresses and Enable GC Mode */
  146.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 1);   /* Slave Address : 0x15 */
  147.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 1);   /* Slave Address : 0x35 */
  148.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 1);   /* Slave Address : 0x55 */
  149.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 1);   /* Slave Address : 0x75 */

  150.     /* Set I2C 4 Slave Addresses Mask */
  151.     I2C_SetSlaveAddrMask(I2C0, 0, 0x01);
  152.     I2C_SetSlaveAddrMask(I2C0, 1, 0x04);
  153.     I2C_SetSlaveAddrMask(I2C0, 2, 0x01);
  154.     I2C_SetSlaveAddrMask(I2C0, 3, 0x04);

  155.     /* Enable I2C interrupt */
  156.     I2C_EnableInt(I2C0);
  157.     NVIC_EnableIRQ(I2C0_IRQn);
  158. }

  159. void I2C0_Close(void)
  160. {
  161.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
  162.     I2C_DisableInt(I2C0);
  163.     NVIC_DisableIRQ(I2C0_IRQn);

  164.     /* Disable I2C0 and close I2C0 clock */
  165.     I2C_Close(I2C0);
  166.     CLK_DisableModuleClock(I2C0_MODULE);

  167. }

  168. /*---------------------------------------------------------------------------------------------------------*/
  169. /*  Main Function                                                                                          */
  170. /*---------------------------------------------------------------------------------------------------------*/
  171. int32_t main(void)
  172. {
  173.     uint32_t i;

  174.     /* Unlock protected registers */
  175.     SYS_UnlockReg();

  176.     /* Init System, IP clock and multi-function I/O */
  177.     SYS_Init();

  178.     /* Init UART0 for printf */
  179.     UART0_Init();

  180.     /* Lock protected registers */
  181.     SYS_LockReg();

  182.     /*
  183.         This sample code sets I2C bus clock to 100kHz. Then, accesses Slave (GC Mode) with Byte Write
  184.         and Byte Read operations, and check if the read data is equal to the programmed data.
  185.     */

  186.     printf("\n");
  187.     printf("+-----------------------------------------------------------------+\n");
  188.     printf("| NUC100 I2C Driver Sample Code (Slave) for access Slave (GC Mode)|\n");
  189.     printf("|                                                                 |\n");
  190.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)(Address: 0x00)          |\n");
  191.     printf("+-----------------------------------------------------------------+\n");

  192.     printf("Configure I2C0 as a slave.\n");
  193.     printf("The I/O connection for I2C0:\n");
  194.     printf("I2C0_SDA(PA.8), I2C0_SCL(PA.9)\n");

  195.     /* Init I2C0 */
  196.     I2C0_Init();

  197.     /* I2C enter no address SLV mode */
  198.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

  199.     /* Clear receive buffer */
  200.     for(i = 0; i < 0x100; i++)
  201.     {
  202.         g_au8SlvData[i] = 0;
  203.     }

  204.     g_u8SlvEndFlag = 0;

  205.     /* I2C function to Slave receive data */
  206.     s_I2C0HandlerFn = I2C_GCSlaveRx;

  207.     printf("\n");
  208.     printf("Slave(GC Mode) waiting for receiving data.\n");
  209.     while(g_u8SlvEndFlag == 0);

  210.     /* Check receive data correct or not */
  211.     for(i = 0; i < 0x100; i++)
  212.     {
  213.         g_au8SlvTxData[0] = (uint8_t)((i & 0xFF00) >> 8);
  214.         g_au8SlvTxData[1] = (uint8_t)(i & 0x00FF);
  215.         g_au8SlvTxData[2] = (uint8_t)(g_au8SlvTxData[1] + 3);
  216.         if(g_au8SlvData[i] != g_au8SlvTxData[2])
  217.         {
  218.             printf("GC Mode Receive data fail.\n");
  219.             while(1);
  220.         }
  221.     }

  222.     printf("GC Mode receive data OK.\n");

  223.     s_I2C0HandlerFn = NULL;

  224.     /* Close I2C0 */
  225.     I2C0_Close();

  226.     while(1);
  227. }



复制代码

使用特权

评论回复
| 2019-7-8 15:32 | 显示全部楼层
I2C的所有例子都给你提供了,包括工程开发包的BSP。

使用特权

评论回复
 楼主 | 2019-7-8 15:49 | 显示全部楼层
wahahaheihei 发表于 2019-7-8 15:13
http://bbs.21ic.com/icview-844424-1-1.html
官方没下载地址了,论坛有朋友分享。

官方示例没看懂

使用特权

评论回复
| 2019-7-8 15:50 | 显示全部楼层
哪儿没懂啊。给你讲讲。

使用特权

评论回复
| 2019-7-8 15:53 | 显示全部楼层
是不是里面那个函数指针没懂啊。那个是指向函数的指针。用于哪个回调的。

使用特权

评论回复
| 2019-7-8 15:54 | 显示全部楼层
552375d22f6b84a51e.png
初始化

使用特权

评论回复
| 2019-7-8 15:55 | 显示全部楼层
最后2行是设置中断的,如果不用中断可以不要最后2行。

使用特权

评论回复
扫描二维码,随时随地手机跟帖
您需要登录后才可以回帖 登录 | 注册

本版积分规则

我要发帖 投诉建议 创建版块 申请版主

快速回复

您需要登录后才可以回帖
登录 | 注册
高级模式

论坛热帖

在线客服 快速回复 返回顶部 返回列表