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

[DemoCode下载] M051的I2C唤醒演示

[复制链接]
2396|11
 楼主| 643757107 发表于 2018-2-27 18:34 | 显示全部楼层 |阅读模式
I2c, TE, AD, slave
复制
  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: 5 $
    

  5.  * $Date: 15/05/22 2:41p $
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    M051 Series I2C Driver Sample Code for Wake-up (Master)
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
    

  10.  *
    

  11.  ******************************************************************************/
    

  12. #include <stdio.h>
    

  13. #include "M051Series.h"
    


  14. 

  15. #define PLLCON_SETTING      SYSCLK_PLLCON_50MHz_XTAL
    

  16. #define PLL_CLOCK           50000000
    


  17. 

  18. /*---------------------------------------------------------------------------------------------------------*/
    

  19. /* Global variables                                                                                        */
    

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

  21. volatile uint8_t g_u8DeviceAddr;
    

  22. volatile uint8_t g_au8MstTxData[3];
    

  23. volatile uint8_t g_u8MstRxData;
    

  24. volatile uint8_t g_u8MstDataLen;
    

  25. volatile uint8_t g_u8MstEndFlag = 0;
    


  26. 

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


  28. 

  29. static volatile I2C_FUNC s_I2C0HandlerFn = NULL;
    


  30. 

  31. /*---------------------------------------------------------------------------------------------------------*/
    

  32. /*  I2C0 IRQ Handler                                                                                       */
    

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

  34. void I2C0_IRQHandler(void)
    

  35. {
    

  36.     uint32_t u32Status;
    


  37. 

  38.     u32Status = I2C_GET_STATUS(I2C0);
    


  39. 

  40.     if(I2C_GET_TIMEOUT_FLAG(I2C0))
    

  41.     {
    

  42.         /* Clear I2C0 Timeout Flag */
    

  43.         I2C_ClearTimeoutFlag(I2C0);
    

  44.     }
    

  45.     else
    

  46.     {
    

  47.         if(s_I2C0HandlerFn != NULL)
    

  48.             s_I2C0HandlerFn(u32Status);
    

  49.     }
    

  50. }
    


  51. 

  52. /*---------------------------------------------------------------------------------------------------------*/
    

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

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

  55. void I2C_MasterTxWakeup(uint32_t u32Status)
    

  56. {
    

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

  58.     {
    

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

  60.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  61.     }
    

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

  63.     {
    

  64.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    

  65.         g_u8MstEndFlag = 1;
    

  66.     }
    

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

  68.     {
    

  69.         I2C_STOP(I2C0);
    

  70.         g_u8MstEndFlag = 1;
    

  71.     }
    

  72.     else
    

  73.     {
    

  74.         /* TO DO */
    

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

  76.     }
    

  77. }
    

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

  79. /*  I2C Rx Callback Function                                                                               */
    

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

  81. void I2C_MasterRx(uint32_t u32Status)
    

  82. {
    

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

  84.     {
    

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

  86.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  87.     }
    

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

  89.     {
    

  90.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
    

  91.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  92.     }
    

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

  94.     {
    

  95.         I2C_STOP(I2C0);
    

  96.         I2C_START(I2C0);
    

  97.     }
    

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

  99.     {
    

  100.         if(g_u8MstDataLen != 2)
    

  101.         {
    

  102.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
    

  103.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  104.         }
    

  105.         else
    

  106.         {
    

  107.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);
    

  108.         }
    

  109.     }
    

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

  111.     {
    

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

  113.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  114.     }
    

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

  116.     {
    

  117.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  118.     }
    

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

  120.     {
    

  121.         g_u8MstRxData = (unsigned char) I2C_GET_DATA(I2C0);
    

  122.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    

  123.         g_u8MstEndFlag = 1;
    

  124.     }
    

  125.     else
    

  126.     {
    

  127.         /* TO DO */
    

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

  129.     }
    

  130. }
    


  131. 

  132. /*---------------------------------------------------------------------------------------------------------*/
    

  133. /*  I2C Tx Callback Function                                                                               */
    

  134. /*---------------------------------------------------------------------------------------------------------*/
    

  135. void I2C_MasterTx(uint32_t u32Status)
    

  136. {
    

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

  138.     {
    

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

  140.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  141.     }
    

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

  143.     {
    

  144.         I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
    

  145.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  146.     }
    

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

  148.     {
    

  149.         I2C_STOP(I2C0);
    

  150.         I2C_START(I2C0);
    

  151.     }
    

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

  153.     {
    

  154.         if(g_u8MstDataLen != 3)
    

  155.         {
    

  156.             I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);
    

  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_u8MstEndFlag = 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 & I2C0 module clock */
    

  197.     CLK_EnableModuleClock(UART0_MODULE);
    

  198.     CLK_EnableModuleClock(I2C0_MODULE);
    


  199. 

  200.     /* Select UART module clock source */
    

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


  202. 

  203.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  205.     /*---------------------------------------------------------------------------------------------------------*/
    


  206. 

  207.     /* Set P3 multi-function pins for UART0 RXD and TXD */
    

  208.     SYS->P3_MFP &= ~(SYS_MFP_P30_Msk | SYS_MFP_P31_Msk);
    

  209.     SYS->P3_MFP |= SYS_MFP_P30_RXD0 | SYS_MFP_P31_TXD0;
    


  210. 

  211.     /* Configure the SDA0 & SCL0 of I2C0 pins */
    

  212.     SYS->P3_MFP &= ~(SYS_MFP_P34_Msk | SYS_MFP_P35_Msk);
    

  213.     SYS->P3_MFP |= SYS_MFP_P34_SDA0 | SYS_MFP_P35_SCL0;
    

  214. }
    


  215. 

  216. void UART0_Init()
    

  217. {
    

  218.     /*---------------------------------------------------------------------------------------------------------*/
    

  219.     /* Init UART                                                                                               */
    

  220.     /*---------------------------------------------------------------------------------------------------------*/
    

  221.     /* Reset IP */
    

  222.     SYS_ResetModule(UART0_RST);
    


  223. 

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

  225.     UART_Open(UART0, 115200);
    

  226. }
    


  227. 

  228. void I2C0_Init(void)
    

  229. {
    

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

  231.     I2C_Open(I2C0, 100000);
    


  232. 

  233.     /* Get I2C0 Bus Clock */
    

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


  235. 

  236.     /* Set I2C 4 Slave Addresses */
    

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

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

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

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


  241. 

  242.     /* Enable I2C interrupt */
    

  243.     I2C_EnableInt(I2C0);
    

  244.     NVIC_EnableIRQ(I2C0_IRQn);
    

  245. }
    


  246. 

  247. void I2C0_Close(void)
    

  248. {
    

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

  250.     I2C_DisableInt(I2C0);
    

  251.     NVIC_DisableIRQ(I2C0_IRQn);
    


  252. 

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

  254.     I2C_Close(I2C0);
    

  255.     CLK_DisableModuleClock(I2C0_MODULE);
    


  256. 

  257. }
    


  258. 

  259. int32_t I2C0_Read_Write_SLAVE(uint8_t slvaddr)
    

  260. {
    

  261.     uint32_t i;
    


  262. 

  263.     g_u8DeviceAddr = slvaddr;
    


  264. 

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

  266.     {
    

  267.         g_au8MstTxData[0] = (uint8_t)((i & 0xFF00) >> 8);
    

  268.         g_au8MstTxData[1] = (uint8_t)(i & 0x00FF);
    

  269.         g_au8MstTxData[2] = (uint8_t)(g_au8MstTxData[1] + 3);
    


  270. 

  271.         g_u8MstDataLen = 0;
    

  272.         g_u8MstEndFlag = 0;
    


  273. 

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

  275.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;
    


  276. 

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

  278.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
    


  279. 

  280.         /* Wait I2C Tx Finish */
    

  281.         while(g_u8MstEndFlag == 0);
    

  282.         g_u8MstEndFlag = 0;
    


  283. 

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

  285.         s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterRx;
    


  286. 

  287.         g_u8MstDataLen = 0;
    

  288.         g_u8DeviceAddr = slvaddr;
    


  289. 

  290.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
    


  291. 

  292.         /* Wait I2C Rx Finish */
    

  293.         while(g_u8MstEndFlag == 0);
    


  294. 

  295.         /* Compare data */
    

  296.         if(g_u8MstRxData != g_au8MstTxData[2])
    

  297.         {
    

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

  299.             return -1;
    

  300.         }
    

  301.     }
    

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

  303.     return 0;
    

  304. }
    


  305. 

  306. /*---------------------------------------------------------------------------------------------------------*/
    

  307. /*  Main Function                                                                                          */
    

  308. /*---------------------------------------------------------------------------------------------------------*/
    

  309. int32_t main(void)
    

  310. {
    

  311.     /* Unlock protected registers */
    

  312.     SYS_UnlockReg();
    


  313. 

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

  315.     SYS_Init();
    


  316. 

  317.     /* Init UART0 for printf */
    

  318.     UART0_Init();
    


  319. 

  320.     /* Lock protected registers */
    

  321.     SYS_LockReg();
    


  322. 

  323.     /*
    

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

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

  326.     */
    


  327. 

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

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

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

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

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


  333. 

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

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

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


  337. 

  338.     /* Init I2C0 to access Slave */
    

  339.     I2C0_Init();
    


  340. 

  341.     printf("\n");
    

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

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

  344.     getchar();
    


  345. 

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

  347.     g_u8DeviceAddr = 0x15;
    


  348. 

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

  350.     s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTxWakeup;
    


  351. 

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

  353.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);
    

  354.     while(g_u8MstEndFlag == 0);
    


  355. 

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

  357.     printf("\n");
    

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

  359.     I2C0_Read_Write_SLAVE(0x15);
    

  360.     I2C0_Read_Write_SLAVE(0x35);
    

  361.     I2C0_Read_Write_SLAVE(0x55);
    

  362.     I2C0_Read_Write_SLAVE(0x75);
    

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


  364. 


  365. 

  366.     /* Access Slave with address mask */
    

  367.     printf("\n");
    

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

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

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

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

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

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


  374. 

  375.     s_I2C0HandlerFn = NULL;
    


  376. 

  377.     /* Close I2C0 */
    

  378.     I2C0_Close();
    


  379. 

  380.     while(1);
    

  381. }


回复

收藏 举报

相关帖子
 楼主| 643757107 发表于 2018-2-27 18:35 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * @version  V3.00
    

  4.  * $Revision: 5 $
    

  5.  * $Date: 14/11/14 11:19a $
    

  6.  * @brief    M051 Series I2C Driver Sample Code for Wake-up (Slave)
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
    

  10.  *
    

  11.  ******************************************************************************/
    

  12. #include <stdio.h>
    

  13. #include "M051Series.h"
    


  14. 

  15. #define PLLCON_SETTING      SYSCLK_PLLCON_50MHz_XTAL
    

  16. #define PLL_CLOCK           50000000
    


  17. 

  18. uint32_t slave_buff_addr;
    

  19. uint8_t g_au8SlvData[256];
    

  20. uint8_t g_au8SlvRxData[3];
    

  21. uint8_t g_u8SlvPWRDNWK, g_u8SlvI2CWK;
    

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

  23. /* Global variables                                                                                        */
    

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

  25. volatile uint8_t g_u8DeviceAddr;
    

  26. volatile uint8_t g_u8SlvDataLen;
    


  27. 

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


  29. 

  30. static I2C_FUNC s_I2C0HandlerFn = NULL;
    


  31. 

  32. /*---------------------------------------------------------------------------------------------------------*/
    

  33. /*  I2C0 IRQ Handler                                                                                       */
    

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

  35. void I2C0_IRQHandler(void)
    

  36. {
    

  37.     uint32_t u32Status;
    


  38. 

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

  40.     if(I2C_GET_WAKEUP_FLAG(I2C0))
    

  41.     {
    

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

  43.         I2C_CLEAR_WAKEUP_FLAG(I2C0);
    

  44.                         
    

  45.         g_u8SlvI2CWK = 1;                
    

  46.                         
    

  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.                           g_u8SlvPWRDNWK = 1;
    

  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_u8SlvDataLen = 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_au8SlvRxData[g_u8SlvDataLen] = (unsigned char)I2C_GET_DATA(I2C0);
    

  92.         g_u8SlvDataLen++;
    


  93. 

  94.         if(g_u8SlvDataLen == 2)
    

  95.         {
    

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

  97.         }
    

  98.         if(g_u8SlvDataLen == 3)
    

  99.         {
    

  100.             g_au8SlvData[slave_buff_addr] = g_au8SlvRxData[2];
    

  101.             g_u8SlvDataLen = 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_au8SlvData[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_u8SlvDataLen = 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_u8SlvDataLen = 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 & I2C0 module clock */
    

  160.     CLK_EnableModuleClock(UART0_MODULE);
    

  161.     CLK_EnableModuleClock(I2C0_MODULE);
    


  162. 

  163.     /* Select UART module clock source */
    

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


  165. 

  166.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  168.     /*---------------------------------------------------------------------------------------------------------*/
    


  169. 

  170.     /* Set P3 multi-function pins for UART0 RXD and TXD */
    

  171.     SYS->P3_MFP &= ~(SYS_MFP_P30_Msk | SYS_MFP_P31_Msk);
    

  172.     SYS->P3_MFP |= SYS_MFP_P30_RXD0 | SYS_MFP_P31_TXD0;
    


  173. 

  174.     /* Configure the SDA0 & SCL0 of I2C0 pins */
    

  175.     SYS->P3_MFP &= ~(SYS_MFP_P34_Msk | SYS_MFP_P35_Msk);
    

  176.     SYS->P3_MFP |= SYS_MFP_P34_SDA0 | SYS_MFP_P35_SCL0;
    

  177. }
    


  178. 

  179. void UART0_Init()
    

  180. {
    

  181.     /*---------------------------------------------------------------------------------------------------------*/
    

  182.     /* Init UART                                                                                               */
    

  183.     /*---------------------------------------------------------------------------------------------------------*/
    

  184.     /* Reset IP */
    

  185.     SYS_ResetModule(UART0_RST);
    


  186. 

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

  188.     UART_Open(UART0, 115200);
    

  189. }
    


  190. 

  191. void I2C0_Init(void)
    

  192. {
    

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

  194.     I2C_Open(I2C0, 100000);
    


  195. 

  196.     /* Get I2C0 Bus Clock */
    

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


  198. 

  199.     /* Set I2C 4 Slave Addresses */
    

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

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

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

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


  204. 

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

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

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

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

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


  210. 

  211.     /* Enable I2C interrupt */
    

  212.     I2C_EnableInt(I2C0);
    

  213.     NVIC_EnableIRQ(I2C0_IRQn);
    

  214. }
    


  215. 

  216. void I2C0_Close(void)
    

  217. {
    

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

  219.     I2C_DisableInt(I2C0);
    

  220.     NVIC_DisableIRQ(I2C0_IRQn);
    


  221. 

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

  223.     I2C_Close(I2C0);
    

  224.     CLK_DisableModuleClock(I2C0_MODULE);
    

  225. }
    


  226. 

  227. /*---------------------------------------------------------------------------------------------------------*/
    

  228. /*  Main Function                                                                                          */
    

  229. /*---------------------------------------------------------------------------------------------------------*/
    

  230. int32_t main(void)
    

  231. {
    

  232.     uint32_t i;
    


  233. 

  234.     /* Unlock protected registers */
    

  235.     SYS_UnlockReg();
    


  236. 

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

  238.     SYS_Init();
    


  239. 

  240.     /* Init UART0 for printf */
    

  241.     UART0_Init();
    


  242. 

  243.     /* Lock protected registers */
    

  244.     SYS_LockReg();;
    


  245. 

  246.     /*
    

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

  248.     */
    

  249.     printf("\n");
    

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

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

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

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

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


  255. 

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

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

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


  259. 

  260.     /* Init I2C0 */
    

  261.     I2C0_Init();
    


  262. 

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

  264.     {
    

  265.         g_au8SlvData[i] = 0;
    

  266.     }
    


  267. 

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

  269.     s_I2C0HandlerFn = I2C_SlaveTRx;
    

  270.                 
    

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

  272.     I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);
    


  273. 

  274.     /* Unlock protected registers */
    

  275.     SYS_UnlockReg();
    


  276. 

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

  278.     CLK->PWRCON |= CLK_PWRCON_PD_WU_INT_EN_Msk;
    

  279.     NVIC_EnableIRQ(PWRWU_IRQn);
    


  280. 

  281.     /* Enable I2C wake-up */
    

  282.     I2C0-> I2CWKUPCON |= I2C_I2CWKUPCON_WKUPEN_Msk;
    


  283. 

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

  285.     CLK->PWRCON |= CLK_PWRCON_PD_WAIT_CPU_Msk;
    


  286. 

  287.     /* Processor use deep sleep */
    

  288.     SCB->SCR = SCB_SCR_SLEEPDEEP_Msk;
    


  289. 

  290.     /* System power down enable */
    

  291.     CLK->PWRCON |= CLK_PWRCON_PWR_DOWN_EN_Msk;
    


  292. 

  293.     printf("\n");
    

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

  295.     printf("\n");
    

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

  297.     /* Waiting for UART printf finish*/
    

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


  299. 

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

  301.     {
    

  302.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    

  303.     }
    


  304. 

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

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

  307.     __WFI();
    

  308.     __NOP();
    

  309.     __NOP();
    

  310.     __NOP();
    


  311. 

  312.     while((g_u8SlvPWRDNWK & g_u8SlvI2CWK) == 0);    
    

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

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

  315.                 
    

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

  317.     CLK->PWRCON &= ~CLK_PWRCON_PD_WU_INT_EN_Msk;
    

  318.     NVIC_DisableIRQ(PWRWU_IRQn);
    


  319. 

  320.     /* Lock protected registers */
    

  321.     SYS_LockReg();
    


  322. 

  323.     printf("\n");
    

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


  325. 

  326.     printf("\n");
    

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


  328. 

  329.     while(1);
    

  330. }
    


  331. 


  332. 


  333. 

  334. [em:21:]
回复

收藏 举报

 楼主| 643757107 发表于 2018-2-27 18:35 | 显示全部楼层
我看了一下例子，只有I2C有这个功能，SPI的就没有。
回复

收藏 举报

 楼主| 643757107 发表于 2018-2-27 18:36 | 显示全部楼层
I2C还是比SPI更强大的，虽然逻辑上比SPI更难理解，但是学会了，用处很大。
回复

收藏 举报

 楼主| 643757107 发表于 2018-2-27 18:36 | 显示全部楼层
用更少的线实现更高效的通信。
回复

收藏 举报

jiekou001 发表于 2018-2-27 19:06 | 显示全部楼层
学会这些常用的接口，比什么都重要。
回复

收藏 举报

xinpian101 发表于 2018-2-27 19:20 | 显示全部楼层
注释很全面啊，很容易理解。
回复

收藏 举报

小明的同学 发表于 2018-2-27 23:34 | 显示全部楼层
没想到这个接口这么好用
回复

收藏 举报

幸福小强 发表于 2018-2-28 22:07 | 显示全部楼层
有没有中文版详细讲这个硬件使用教程的。
回复

收藏 举报

幸福小强 发表于 2018-2-28 22:17 | 显示全部楼层
看来我要好好研究一下这个了，好多人说I2C 不好用，那就是说，用好了，很容易加薪啊
回复

收藏 举报

捉虫天师 发表于 2018-2-28 22:29 | 显示全部楼层
看手册啊，每个厂家的外设结构不同，用的寄存器名字也不同，当然了，你要先掌握这个协议的套路
回复

收藏 举报

xujunyi3611 发表于 2018-2-28 22:40 | 显示全部楼层
楼主的代码很规范呀，赞一个。
回复

收藏 举报

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

本版积分规则

643757107

223

主题

3972

帖子

11

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