21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › M0518使用I2C的唤醒功能
返回列表 发新帖我要提问

[DemoCode下载] M0518使用I2C的唤醒功能

[复制链接]
1939|6
 楼主| yiyigirl2014 发表于 2017-5-29 13:47 | 显示全部楼层 |阅读模式
I2c, M0518, TE, TI
复制
  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: 2 $
    

  5.  * $Date: 14/12/25 10:24a $
    

  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 "M0518.h"
    


  15. 

  16. #define PLLCON_SETTING      SYSCLK_PLLCON_50MHz_XTAL
    

  17. #define PLL_CLOCK           50000000
    


  18. 


  19. 

  20. /*---------------------------------------------------------------------------------------------------------*/
    

  21. /* Global variables                                                                                        */
    

  22. /*---------------------------------------------------------------------------------------------------------*/
    

  23. volatile uint8_t g_u8DeviceAddr;
    

  24. volatile uint8_t g_au8TxData[3];
    

  25. volatile uint8_t g_u8RxData;
    

  26. volatile uint8_t g_u8DataLen;
    

  27. volatile uint8_t g_u8EndFlag = 0;
    


  28. 

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


  30. 

  31. static volatile I2C_FUNC s_I2C0HandlerFn = NULL;
    


  32. 

  33. /*---------------------------------------------------------------------------------------------------------*/
    

  34. /*  I2C0 IRQ Handler                                                                                       */
    

  35. /*---------------------------------------------------------------------------------------------------------*/
    

  36. void I2C0_IRQHandler(void)
    

  37. {
    

  38.     uint32_t u32Status;
    


  39. 

  40.     u32Status = I2C_GET_STATUS(I2C0);
    


  41. 

  42.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
    

  43.     {
    

  44.         /* Clear I2C0 Timeout Flag */
    

  45.         I2C_ClearTimeoutFlag(I2C0);
    

  46.     }
    

  47.     else
    

  48.     {
    

  49.         if(s_I2C0HandlerFn != NULL)
    

  50.             s_I2C0HandlerFn(u32Status);
    

  51.     }
    

  52. }
    


  53. 

  54. /*---------------------------------------------------------------------------------------------------------*/
    

  55. /*  I2C Master Tx Wake Up Callback Function                                                                        */
    

  56. /*---------------------------------------------------------------------------------------------------------*/
    

  57. void I2C_MasterTxWakeup(uint32_t u32Status)
    

  58. {
    

  59.     if(u32Status == 0x08)                       /* START has been transmitted */
    

  60.     {
    

  61.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */
    

  62.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  63.     }
    

  64.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
    

  65.     {
    

  66.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    

  67.         g_u8EndFlag = 1;
    

  68.     }
    

  69.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NOT ACK has been received */
    

  70.     {
    

  71.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    

  72.         g_u8EndFlag = 1;
    

  73.     }
    

  74.     else
    

  75.     {
    

  76.         /* TO DO */
    

  77.         printf("Status 0x%x is NOT processed\n", u32Status);
    

  78.     }
    

  79. }
    

  80. /*---------------------------------------------------------------------------------------------------------*/
    

  81. /*  I2C Rx Callback Function                                                                               */
    

  82. /*---------------------------------------------------------------------------------------------------------*/
    

  83. void I2C_MasterRx(uint32_t u32Status)
    

  84. {
    

  85.     if(u32Status == 0x08)                       /* START has been transmitted and prepare SLA+W */
    

  86.     {
    

  87.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */
    

  88.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  89.     }
    

  90.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
    

  91.     {
    

  92.         I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    

  93.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  94.     }
    

  95.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
    

  96.     {
    

  97.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_STO_SI);
    

  98.     }
    

  99.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
    

  100.     {
    

  101.         if(g_u8DataLen != 2)
    

  102.         {
    

  103.             I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    

  104.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  105.         }
    

  106.         else
    

  107.         {
    

  108.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);
    

  109.         }
    

  110.     }
    

  111.     else if(u32Status == 0x10)                  /* Repeat START has been transmitted and prepare SLA+R */
    

  112.     {
    

  113.         I2C_SET_DATA(I2C0, ((g_u8DeviceAddr << 1) | 0x01)); /* Write SLA+R to Register I2CDAT */
    

  114.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  115.     }
    

  116.     else if(u32Status == 0x40)                  /* SLA+R has been transmitted and ACK has been received */
    

  117.     {
    

  118.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  119.     }
    

  120.     else if(u32Status == 0x58)                  /* DATA has been received and NACK has been returned */
    

  121.     {
    

  122.         g_u8RxData = (unsigned char) I2C_GET_DATA(I2C0);
    

  123.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    

  124.         g_u8EndFlag = 1;
    

  125.     }
    

  126.     else
    

  127.     {
    

  128.         /* TO DO */
    

  129.         printf("Status 0x%x is NOT processed\n", u32Status);
    

  130.     }
    

  131. }
    


  132. 

  133. /*---------------------------------------------------------------------------------------------------------*/
    

  134. /*  I2C Tx Callback Function                                                                               */
    

  135. /*---------------------------------------------------------------------------------------------------------*/
    

  136. void I2C_MasterTx(uint32_t u32Status)
    

  137. {
    

  138.     if(u32Status == 0x08)                       /* START has been transmitted */
    

  139.     {
    

  140.         I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);    /* Write SLA+W to Register I2CDAT */
    

  141.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  142.     }
    

  143.     else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */
    

  144.     {
    

  145.         I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    

  146.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  147.     }
    

  148.     else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */
    

  149.     {
    

  150.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_STO_SI);
    

  151.     }
    

  152.     else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */
    

  153.     {
    

  154.         if(g_u8DataLen != 3)
    

  155.         {
    

  156.             I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    

  157.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  158.         }
    

  159.         else
    

  160.         {
    

  161.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    

  162.             g_u8EndFlag = 1;
    

  163.         }
    

  164.     }
    

  165.     else
    

  166.     {
    

  167.         /* TO DO */
    

  168.         printf("Status 0x%x is NOT processed\n", u32Status);
    

  169.     }
    

  170. }
    


  171. 

  172. void SYS_Init(void)
    

  173. {
    

  174.     /*---------------------------------------------------------------------------------------------------------*/
    

  175.     /* Init System Clock                                                                                       */
    

  176.     /*---------------------------------------------------------------------------------------------------------*/
    


  177. 

  178.     /* Enable Internal RC 22.1184MHz clock */
    

  179.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);
    


  180. 

  181.     /* Waiting for Internal RC clock ready */
    

  182.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);
    


  183. 

  184.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
    

  185.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));
    


  186. 

  187.     /* Enable external XTAL 12MHz clock */
    

  188.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  189. 

  190.     /* Waiting for external XTAL clock ready */
    

  191.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  192. 

  193.     /* Set core clock as PLL_CLOCK from PLL */
    

  194.     CLK_SetCoreClock(PLL_CLOCK);
    


  195. 

  196.     /* Enable UART module clock */
    

  197.     CLK_EnableModuleClock(UART0_MODULE);
    


  198. 

  199.     /* Enable I2C0 module clock */
    

  200.     CLK_EnableModuleClock(I2C0_MODULE);
    


  201. 

  202.     /* Select UART module clock source */
    

  203.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    


  204. 


  205. 

  206.     /*---------------------------------------------------------------------------------------------------------*/
    

  207.     /* Init I/O Multi-function                                                                                 */
    

  208.     /*---------------------------------------------------------------------------------------------------------*/
    


  209. 

  210.     /* Set GPB multi-function pins for UART0 RXD and TXD */
    

  211.     SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;
    


  212. 

  213.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
    

  214.     SYS->GPA_MFP = SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
    

  215. }
    


  216. 

  217. void UART0_Init()
    

  218. {
    

  219.     /*---------------------------------------------------------------------------------------------------------*/
    

  220.     /* Init UART                                                                                               */
    

  221.     /*---------------------------------------------------------------------------------------------------------*/
    

  222.     /* Reset IP */
    

  223.     SYS_ResetModule(UART0_RST);
    


  224. 

  225.     /* Configure UART0 and set UART0 Baudrate */
    

  226.     UART_Open(UART0, 115200);
    

  227. }
    


  228. 

  229. void I2C0_Init(void)
    

  230. {
    

  231.     /* Open I2C module and set bus clock */
    

  232.     I2C_Open(I2C0, 100000);
    


  233. 

  234.     /* Get I2C0 Bus Clock */
    

  235.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));
    


  236. 

  237.     /* Set I2C 4 Slave Addresses */
    

  238.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
    

  239.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
    

  240.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
    

  241.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */
    


  242. 

  243.     /* Enable I2C interrupt */
    

  244.     I2C_EnableInt(I2C0);
    

  245.     NVIC_EnableIRQ(I2C0_IRQn);
    

  246. }
    


  247. 

  248. void I2C0_Close(void)
    

  249. {
    

  250.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
    

  251.     I2C_DisableInt(I2C0);
    

  252.     NVIC_DisableIRQ(I2C0_IRQn);
    


  253. 

  254.     /* Disable I2C0 and close I2C0 clock */
    

  255.     I2C_Close(I2C0);
    

  256.     CLK_DisableModuleClock(I2C0_MODULE);
    


  257. 

  258. }
    


  259. 

  260. int32_t I2C0_Read_Write_SLAVE(uint8_t slvaddr)
    

  261. {
    

  262.     uint32_t i;
    


  263. 

  264.     g_u8DeviceAddr = slvaddr;
    


  265. 

  266.     for(i = 0; i < 0x100; i++)
    

  267.     {
    

  268.         g_au8TxData[0] = (uint8_t)((i & 0xFF00) >> 8);
    

  269.         g_au8TxData[1] = (uint8_t)(i & 0x00FF);
    

  270.         g_au8TxData[2] = (uint8_t)(g_au8TxData[1] + 3);
    


  271. 

  272.         g_u8DataLen = 0;
    

  273.         g_u8EndFlag = 0;
    


  274. 

  275.         /* I2C function to write data to slave */
    

  276.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;
    


  277. 

  278.         /* I2C as master sends START signal */
    

  279.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
    


  280. 

  281.         /* Wait I2C Tx Finish */
    

  282.         while(g_u8EndFlag == 0);
    

  283.         g_u8EndFlag = 0;
    


  284. 

  285.         /* I2C function to read data from slave */
    

  286.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterRx;
    


  287. 

  288.         g_u8DataLen = 0;
    

  289.         g_u8DeviceAddr = slvaddr;
    


  290. 

  291.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
    


  292. 

  293.         /* Wait I2C Rx Finish */
    

  294.         while(g_u8EndFlag == 0);
    


  295. 

  296.         /* Compare data */
    

  297.         if(g_u8RxData != g_au8TxData[2])
    

  298.         {
    

  299.             printf("I2C Byte Write/Read Failed, Data 0x%x\n", g_u8RxData);
    

  300.             return -1;
    

  301.         }
    

  302.     }
    

  303.     printf("Master Access Slave (0x%X) Test OK\n", slvaddr);
    

  304.     return 0;
    

  305. }
    


  306. 

  307. /*---------------------------------------------------------------------------------------------------------*/
    

  308. /*  Main Function                                                                                          */
    

  309. /*---------------------------------------------------------------------------------------------------------*/
    

  310. int32_t main(void)
    

  311. {
    

  312.     /* Unlock protected registers */
    

  313.     SYS_UnlockReg();
    


  314. 

  315.     /* Init System, IP clock and multi-function I/O */
    

  316.     SYS_Init();
    


  317. 

  318.     /* Init UART0 for printf */
    

  319.     UART0_Init();
    


  320. 

  321.     /* Lock protected registers */
    

  322.     SYS_LockReg();
    


  323. 

  324.     /*
    

  325.         This sample code sets I2C bus clock to 100kHz. After wake-up, then accesses Slave with Byte
    

  326.         Write and Byte Read operations, and check if the read data is equal to the programmed data.
    

  327.     */
    


  328. 

  329.     printf("+------------------------------------------------------------------------+\n");
    

  330.     printf("| M0518 I2C Driver Sample Code (Master) for wake-up & access Slave test |\n");
    

  331.     printf("|                                                                        |\n");
    

  332.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)                                |\n");
    

  333.     printf("+------------------------------------------------------------------------+\n");
    


  334. 

  335.     printf("Configure I2C0 as a master.\n");
    

  336.     printf("The I/O connection for I2C0:\n");
    

  337.     printf("I2C0_SDA(P3.4), I2C0_SCL(P3.5)\n");
    


  338. 

  339.     /* Init I2C0 to access Slave */
    

  340.     I2C0_Init();
    


  341. 

  342.     printf("\n");
    

  343.     printf("Check I2C slave at power down status.\n");
    

  344.     printf("Press any key to Wake up slave.\n");
    

  345.     getchar();
    


  346. 

  347.     /* Set the Slave address to wake-up*/
    

  348.     g_u8DeviceAddr = 0x15;
    


  349. 

  350.     /* I2C function to wake-up slave*/
    

  351.     s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTxWakeup;
    


  352. 

  353.     /* Send a START condition to bus */
    

  354.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
    

  355.     while(g_u8EndFlag == 0);
    


  356. 

  357.     printf("\n");
    

  358.     printf("Press any key to continue access slave.\n");
    

  359.     getchar();
    


  360. 

  361.     /*Access to the corresponding address Slave*/
    

  362.     printf("\n");
    

  363.     printf(" == No Mask Address ==\n");
    

  364.     I2C0_Read_Write_SLAVE(0x15);
    

  365.     I2C0_Read_Write_SLAVE(0x35);
    

  366.     I2C0_Read_Write_SLAVE(0x55);
    

  367.     I2C0_Read_Write_SLAVE(0x75);
    

  368.     printf("SLAVE Address test OK.\n");
    


  369. 


  370. 

  371.     /* Access Slave with address mask */
    

  372.     printf("\n");
    

  373.     printf(" == Mask Address ==\n");
    

  374.     I2C0_Read_Write_SLAVE(0x15 & ~0x01);
    

  375.     I2C0_Read_Write_SLAVE(0x35 & ~0x04);
    

  376.     I2C0_Read_Write_SLAVE(0x55 & ~0x01);
    

  377.     I2C0_Read_Write_SLAVE(0x75 & ~0x04);
    

  378.     printf("SLAVE Address Mask test OK.\n");
    


  379. 

  380.     s_I2C0HandlerFn = NULL;
    


  381. 

  382.     /* Close I2C0 */
    

  383.     I2C0_Close();
    


  384. 

  385.     return 0;
    

  386. }


回复

收藏 举报

相关帖子
 楼主| yiyigirl2014 发表于 2017-5-29 13:48 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * @version  V3.00
    

  4.  * $Revision: 3 $
    

  5.  * $Date: 14/12/25 10:24a $
    

  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 "M0518.h"
    


  15. 

  16. #define PLLCON_SETTING      SYSCLK_PLLCON_50MHz_XTAL
    

  17. #define PLL_CLOCK           50000000
    


  18. 

  19. uint32_t slave_buff_addr;
    

  20. uint8_t g_u8SlvData[256];
    

  21. uint8_t g_au8RxData[3];
    

  22. /*---------------------------------------------------------------------------------------------------------*/
    

  23. /* Global variables                                                                                        */
    

  24. /*---------------------------------------------------------------------------------------------------------*/
    

  25. volatile uint8_t g_u8DeviceAddr;
    

  26. volatile uint8_t g_au8TxData[3];
    

  27. volatile uint8_t g_u8RxData;
    

  28. volatile uint8_t g_u8DataLen;
    


  29. 

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


  31. 

  32. static I2C_FUNC s_I2C0HandlerFn = NULL;
    


  33. 

  34. /*---------------------------------------------------------------------------------------------------------*/
    

  35. /*  I2C0 IRQ Handler                                                                                       */
    

  36. /*---------------------------------------------------------------------------------------------------------*/
    

  37. void I2C0_IRQHandler(void)
    

  38. {
    

  39.     uint32_t u32Status;
    


  40. 

  41.     /* Check I2C Wake-up interrupt flag set or not */
    

  42.     if(I2C_GET_WAKEUP_FLAG(I2C0))
    

  43.     {
    

  44.         /* Clear I2C Wake-up interrupt flag */
    

  45.         I2C_CLEAR_WAKEUP_FLAG(I2C0);
    

  46.         printf("I2C0 WAKE INT 0x%x\n", I2C0->I2CWKUPSTS);
    

  47.         return;
    

  48.     }
    


  49. 

  50.     u32Status = I2C_GET_STATUS(I2C0);
    


  51. 

  52.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
    

  53.     {
    

  54.         /* Clear I2C0 Timeout Flag */
    

  55.         I2C_ClearTimeoutFlag(I2C0);
    

  56.     }
    

  57.     else
    

  58.     {
    

  59.         if(s_I2C0HandlerFn != NULL)
    

  60.             s_I2C0HandlerFn(u32Status);
    

  61.     }
    

  62. }
    

  63. /*---------------------------------------------------------------------------------------------------------*/
    

  64. /*  Power Wake-up IRQ Handler                                                                                       */
    

  65. /*---------------------------------------------------------------------------------------------------------*/
    

  66. void PWRWU_IRQHandler(void)
    

  67. {
    

  68.     /* Check system power down mode wake-up interrupt flag */
    

  69.     if(((CLK->PWRCON) & CLK_PWRCON_PD_WU_STS_Msk) != 0)
    

  70.     {
    

  71.         /* Clear system power down wake-up interrupt flag */
    

  72.         CLK->PWRCON |= CLK_PWRCON_PD_WU_STS_Msk;
    


  73. 

  74.         printf("Power-down Wake-up INT 0x%x\n", ((CLK->PWRCON) & CLK_PWRCON_PD_WU_STS_Msk));
    

  75.     }
    

  76. }
    


  77. 

  78. /*---------------------------------------------------------------------------------------------------------*/
    

  79. /*  I2C Slave Transmit/Receive Callback Function                                                                               */
    

  80. /*---------------------------------------------------------------------------------------------------------*/
    

  81. void I2C_SlaveTRx(uint32_t u32Status)
    

  82. {
    

  83.     if(u32Status == 0x60)                       /* Own SLA+W has been receive; ACK has been return */
    

  84.     {
    

  85.         g_u8DataLen = 0;
    

  86.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    

  87.     }
    

  88.     else if(u32Status == 0x80)                 /* Previously address with own SLA address
    

  89.                                                    Data has been received; ACK has been returned*/
    

  90.     {
    

  91.         g_au8RxData[g_u8DataLen] = (unsigned char)I2C_GET_DATA(I2C0);
    

  92.         g_u8DataLen++;
    


  93. 

  94.         if(g_u8DataLen == 2)
    

  95.         {
    

  96.             slave_buff_addr = (g_au8RxData[0] << 8) + g_au8RxData[1];
    

  97.         }
    

  98.         if(g_u8DataLen == 3)
    

  99.         {
    

  100.             g_u8SlvData[slave_buff_addr] = g_au8RxData[2];
    

  101.             g_u8DataLen = 0;
    

  102.         }
    

  103.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    

  104.     }
    

  105.     else if(u32Status == 0xA8)                  /* Own SLA+R has been receive; ACK has been return */
    

  106.     {
    

  107.         I2C_SET_DATA(I2C0, g_u8SlvData[slave_buff_addr]);
    

  108.         slave_buff_addr++;
    

  109.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    

  110.     }
    

  111.     else if(u32Status == 0xC0)                 /* Data byte or last data in I2CDAT has been transmitted
    

  112.                                                    Not ACK has been received */
    

  113.     {
    

  114.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    

  115.     }
    

  116.     else if(u32Status == 0x88)                 /* Previously addressed with own SLA address; NOT ACK has
    

  117.                                                    been returned */
    

  118.     {
    

  119.         g_u8DataLen = 0;
    

  120.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    

  121.     }
    

  122.     else if(u32Status == 0xA0)                 /* A STOP or repeated START has been received while still
    

  123.                                                    addressed as Slave/Receiver*/
    

  124.     {
    

  125.         g_u8DataLen = 0;
    

  126.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    

  127.     }
    

  128.     else
    

  129.     {
    

  130.         /* TO DO */
    

  131.         printf("Status 0x%x is NOT processed\n", u32Status);
    

  132.     }
    

  133. }
    


  134. 

  135. void SYS_Init(void)
    

  136. {
    

  137.     /*---------------------------------------------------------------------------------------------------------*/
    

  138.     /* Init System Clock                                                                                       */
    

  139.     /*---------------------------------------------------------------------------------------------------------*/
    


  140. 

  141.     /* Enable Internal RC 22.1184MHz clock */
    

  142.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);
    


  143. 

  144.     /* Waiting for Internal RC clock ready */
    

  145.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);
    


  146. 

  147.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
    

  148.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));
    


  149. 

  150.     /* Enable external XTAL 12MHz clock */
    

  151.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  152. 

  153.     /* Waiting for external XTAL clock ready */
    

  154.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  155. 

  156.     /* Set core clock as PLL_CLOCK from PLL */
    

  157.     CLK_SetCoreClock(PLL_CLOCK);
    


  158. 

  159.     /* Enable UART module clock */
    

  160.     CLK_EnableModuleClock(UART0_MODULE);
    


  161. 

  162.     /* Enable I2C0 module clock */
    

  163.     CLK_EnableModuleClock(I2C0_MODULE);
    


  164. 

  165.     /* Select UART module clock source */
    

  166.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    


  167. 


  168. 

  169.     /*---------------------------------------------------------------------------------------------------------*/
    

  170.     /* Init I/O Multi-function                                                                                 */
    

  171.     /*---------------------------------------------------------------------------------------------------------*/
    


  172. 

  173.     /* Set GPB multi-function pins for UART0 RXD and TXD */
    

  174.     SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;
    


  175. 

  176.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
    

  177.     SYS->GPA_MFP = SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
    

  178. }
    


  179. 

  180. void UART0_Init()
    

  181. {
    

  182.     /*---------------------------------------------------------------------------------------------------------*/
    

  183.     /* Init UART                                                                                               */
    

  184.     /*---------------------------------------------------------------------------------------------------------*/
    

  185.     /* Reset IP */
    

  186.     SYS_ResetModule(UART0_RST);
    


  187. 

  188.     /* Configure UART0 and set UART0 Baudrate */
    

  189.     UART_Open(UART0, 115200);
    

  190. }
    


  191. 

  192. void I2C0_Init(void)
    

  193. {
    

  194.     /* Open I2C module and set bus clock */
    

  195.     I2C_Open(I2C0, 100000);
    


  196. 

  197.     /* Get I2C0 Bus Clock */
    

  198.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));
    


  199. 

  200.     /* Set I2C 4 Slave Addresses */
    

  201.     I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */
    

  202.     I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */
    

  203.     I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */
    

  204.     I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */
    


  205. 

  206.     /* Set I2C 4 Slave Addresses Mask */
    

  207.     I2C_SetSlaveAddrMask(I2C0, 0, 0x01);
    

  208.     I2C_SetSlaveAddrMask(I2C0, 1, 0x04);
    

  209.     I2C_SetSlaveAddrMask(I2C0, 2, 0x01);
    

  210.     I2C_SetSlaveAddrMask(I2C0, 3, 0x04);
    


  211. 

  212.     /* Enable I2C interrupt */
    

  213.     I2C_EnableInt(I2C0);
    

  214.     NVIC_EnableIRQ(I2C0_IRQn);
    

  215. }
    


  216. 

  217. void I2C0_Close(void)
    

  218. {
    

  219.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
    

  220.     I2C_DisableInt(I2C0);
    

  221.     NVIC_DisableIRQ(I2C0_IRQn);
    


  222. 

  223.     /* Disable I2C0 and close I2C0 clock */
    

  224.     I2C_Close(I2C0);
    

  225.     CLK_DisableModuleClock(I2C0_MODULE);
    

  226. }
    


  227. 

  228. /*---------------------------------------------------------------------------------------------------------*/
    

  229. /*  Main Function                                                                                          */
    

  230. /*---------------------------------------------------------------------------------------------------------*/
    

  231. int32_t main(void)
    

  232. {
    

  233.     uint32_t i;
    


  234. 

  235.     /* Unlock protected registers */
    

  236.     SYS_UnlockReg();
    


  237. 

  238.     /* Init System, IP clock and multi-function I/O */
    

  239.     SYS_Init();
    


  240. 

  241.     /* Init UART0 for printf */
    

  242.     UART0_Init();
    


  243. 

  244.     /* Lock protected registers */
    

  245.     SYS_LockReg();;
    


  246. 

  247.     /*
    

  248.         This sample code is I2C SLAVE mode and it simulates EEPROM function
    

  249.     */
    

  250.     printf("\n");
    

  251.     printf("+----------------------------------------------------------------------+\n");
    

  252.     printf("| M0518 I2C Driver Sample Code (Slave) for wake-up & access Slave test |\n");
    

  253.     printf("|                                                                      |\n");
    

  254.     printf("| I2C Master (I2C0) <---> I2C Slave(I2C0)                              |\n");
    

  255.     printf("+----------------------------------------------------------------------+\n");
    


  256. 

  257.     printf("Configure I2C0 as a slave.\n");
    

  258.     printf("The I/O connection for I2C0:\n");
    

  259.     printf("I2C0_SDA(P3.4), I2C0_SCL(P3.5)\n");
    


  260. 

  261.     /* Init I2C0 */
    

  262.     I2C0_Init();
    


  263. 

  264.     /* Set I2C0 enter Not Address SLAVE mode */
    

  265.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    


  266. 

  267.     /* Unlock protected registers */
    

  268.     SYS_UnlockReg();
    


  269. 

  270.     /* Enable power wake-up interrupt */
    

  271.     CLK->PWRCON |= CLK_PWRCON_PD_WU_INT_EN_Msk;
    

  272.     NVIC_EnableIRQ(PWRWU_IRQn);
    


  273. 

  274.     /* Enable I2C wake-up */
    

  275.     I2C_EnableWakeup(I2C0);
    


  276. 

  277.     /* Enable Chip enter power down mode */
    

  278.     CLK->PWRCON |= CLK_PWRCON_PD_WAIT_CPU_Msk;
    


  279. 

  280.     /* Processor use deep sleep */
    

  281.     SCB->SCR = SCB_SCR_SLEEPDEEP_Msk;
    


  282. 

  283.     /* System power down enable */
    

  284.     CLK->PWRCON |= CLK_PWRCON_PWR_DOWN_EN_Msk;
    


  285. 

  286.     printf("\n");
    

  287.     printf("Enter PD 0x%x 0x%x\n", I2C0->I2CON , I2C0->I2CSTATUS);
    

  288.     printf("\n");
    

  289.     printf("CHIP enter power down status.\n");
    

  290.     /* Waiting for UART printf finish*/
    

  291.     while(((UART0->FSR) & UART_FSR_TE_FLAG_Msk) == 0);
    


  292. 

  293.     if(((I2C0->I2CON)&I2C_I2CON_SI_Msk) != 0)
    

  294.     {
    

  295.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  296.     }
    


  297. 

  298.     /*  Use WFI instruction to idle the CPU. NOTE:
    

  299.         If ICE is attached, system will wakeup immediately because ICE is a wakeup event. */
    

  300.     __WFI();
    

  301.     __NOP();
    

  302.     __NOP();
    

  303.     __NOP();
    


  304. 

  305.     /* Disable power wake-up interrupt */
    

  306.     CLK->PWRCON &= ~CLK_PWRCON_PD_WU_INT_EN_Msk;
    

  307.     NVIC_DisableIRQ(PWRWU_IRQn);
    


  308. 

  309.     /* Lock protected registers */
    

  310.     SYS_LockReg();
    


  311. 

  312.     printf("\n");
    

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


  314. 

  315.     for(i = 0; i < 0x100; i++)
    

  316.     {
    

  317.         g_u8SlvData[i] = 0;
    

  318.     }
    


  319. 

  320.     /* I2C function to Transmit/Receive data as slave */
    

  321.     s_I2C0HandlerFn = I2C_SlaveTRx;
    


  322. 

  323.     printf("\n");
    

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


  325. 

  326.     while(1);
    

  327. }
    


  328. 


  329.
回复

收藏 举报

 楼主| yiyigirl2014 发表于 2017-5-29 13:49 | 显示全部楼层
当系统休眠后还可以通过通信接口唤醒，非常适用
回复

收藏 举报

zhuomuniao110 发表于 2017-5-29 18:35 | 显示全部楼层
充分利用了串口的调试功能。
回复

收藏 举报

 楼主| yiyigirl2014 发表于 2017-6-5 19:18 | 显示全部楼层
必须的充分利用，不用再搞个显示屏了。
回复

收藏 举报

langziwuliao 发表于 2017-6-5 20:40 | 显示全部楼层
太长了，我居然没看完~
就算看完了也看不懂，哈哈
回复

收藏 举报

gejigeji521 发表于 2017-6-6 11:56 | 显示全部楼层
看的我头都大了，不过略懂了。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

yiyigirl2014

230

主题

3676

帖子

10

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