21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › MINI51的IIC通信
返回列表 发新帖我要提问

[DemoCode下载] MINI51的IIC通信

[复制链接]
1056|5
 楼主| 598330983 发表于 2019-4-30 20:17 | 显示全部楼层 |阅读模式
MINI51, iic通信, AC
[Mini51][I2C]Master_Slave_communication.zip (468.99 KB, 下载次数: 7)
回复

收藏 举报

相关帖子
 楼主| 598330983 发表于 2019-4-30 20:18 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     main.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V0.10
    

  4.  * $Revision: 4 $
    

  5.  * $Date: 13/10/07 3:56p $ 
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    Mini51 Series I2C Driver Sample Code
    

  7.  *
    

  8.  * @note
    

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

  10. *****************************************************************************/ 
    

  11. #include <stdio.h>
    

  12. #include "Mini51Series.h"
    


  13. 

  14. /*---------------------------------------------------------------------------------------------------------*/
    

  15. /* Global variables                                                                                        */
    

  16. /*---------------------------------------------------------------------------------------------------------*/
    


  17. 

  18. volatile uint8_t g_u8DeviceAddr;
    

  19. volatile uint8_t g_u8DataLen;
    

  20. volatile uint8_t rawlenth;
    

  21. volatile uint8_t g_au8Reg;
    

  22. volatile uint8_t g_u8EndFlag = 0;
    

  23. uint8_t *g_au8Buffer;
    


  24. 

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


  26. 

  27. I2C_FUNC __IO s_I2CHandlerFn = NULL;
    


  28. 

  29. /*---------------------------------------------------------------------------------------------------------*/
    

  30. /*  I2C IRQ Handler                                                                                       */
    

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

  32. void I2C_IRQHandler(void)
    

  33. {
    

  34.     uint32_t u32Status;
    


  35. 

  36.     u32Status = I2C_GET_STATUS(I2C);
    


  37. 

  38.     if (I2C_GET_TIMEOUT_FLAG(I2C))
    

  39.     {
    

  40.         /* Clear I2C Timeout Flag */
    

  41.         I2C_ClearTimeoutFlag(I2C);                   
    

  42.     }    
    

  43.     else
    

  44.     {
    

  45.         if (s_I2CHandlerFn != NULL)
    

  46.             s_I2CHandlerFn(u32Status);
    

  47.     }
    

  48. }
    


  49. 

  50. /*---------------------------------------------------------------------------------------------------------*/
    

  51. /*  I2C Rx multi Callback Function                                                                               */
    

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

  53. void I2C_MasterRx_multi(uint32_t u32Status)
    

  54. {
    

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

  56.     {
    

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

  58.         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  59.     }
    

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

  61.     {
    

  62.         I2C_SET_DATA(I2C, g_au8Reg);
    

  63.         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  64.     }
    

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

  66.     {
    

  67.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_STA | I2C_STO);
    

  68.     }
    

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

  70.     {
    

  71.         if (rawlenth > 0)
    

  72.                                         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_STA);//repeat start
    

  73.                                 else
    

  74.                                 {
    

  75.                                         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_STO);
    

  76.                                         g_u8EndFlag = 1;
    

  77.                                 }
    

  78.     }
    

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

  80.     {
    

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

  82.         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  83.     }
    

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

  85.     {
    

  86.                                 if (rawlenth > 1)
    

  87.                                         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  88.                                 else
    

  89.                                         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  90.     }
    

  91.                 else if(u32Status == 0x50)                  /* DATA has been received and ACK has been returned */
    

  92.     {
    

  93.         g_au8Buffer[g_u8DataLen++] = (unsigned char) I2C_GetData(I2C);
    

  94.         if (g_u8DataLen < (rawlenth-1))
    

  95.                                 {
    

  96.                                         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  97.                                 }
    

  98.                                 else
    

  99.                                 {
    

  100.                                         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  101.                                 }
    

  102.     }
    

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

  104.     {
    

  105.         g_au8Buffer[g_u8DataLen++] = (unsigned char) I2C_GetData(I2C);
    

  106.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_STO);
    

  107.         g_u8EndFlag = 1;
    

  108.     }
    

  109.     else
    

  110.     {
    

  111.         /* TO DO */
    

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

  113.     }
    

  114. }
    

  115. /*---------------------------------------------------------------------------------------------------------*/
    

  116. /*  I2C Tx multi Callback Function                                                                               */
    

  117. /*---------------------------------------------------------------------------------------------------------*/
    

  118. void I2C_MasterTx_multi(uint32_t u32Status)
    

  119. {
    

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

  121.     {
    

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

  123.         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  124.     }
    

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

  126.     {
    

  127.         I2C_SET_DATA(I2C, g_au8Reg);
    

  128.         I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  129.     }
    

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

  131.     {
    

  132.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_STA | I2C_STO);
    

  133.     }
    

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

  135.     {
    

  136.         if(g_u8DataLen < rawlenth)
    

  137.         {
    

  138.             I2C_SET_DATA(I2C, g_au8Buffer[g_u8DataLen++]);
    

  139.             I2C_SET_CONTROL_REG(I2C, I2C_SI);
    

  140.         }
    

  141.         else
    

  142.         {
    

  143.             I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_STO);
    

  144.             g_u8EndFlag = 1;
    

  145.         }
    

  146.     }
    

  147.     else
    

  148.     {
    

  149.         /* TO DO */
    

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

  151.     }
    

  152. }
    


  153. 

  154. void SYS_Init(void)
    

  155. {
    

  156.     /* Unlock protected registers */
    

  157.     SYS_UnlockReg();
    


  158. 

  159. /*---------------------------------------------------------------------------------------------------------*/
    

  160. /* Init System Clock                                                                                       */
    

  161. /*---------------------------------------------------------------------------------------------------------*/
    


  162. 

  163.     /* Unlock protected registers */
    

  164.     SYS_UnlockReg();
    


  165. 

  166.     /* Enable external 12MHz XTAL, internal 22.1184MHz */
    

  167.     CLK->PWRCON |= CLK_PWRCON_XTL12M | CLK_PWRCON_IRC22M_EN_Msk;
    


  168. 

  169.     /* Waiting for clock ready */
    

  170.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL_STB_Msk | CLK_CLKSTATUS_IRC22M_STB_Msk);
    


  171. 

  172.     /* Switch HCLK clock source to XTL, STCLK to XTL */
    

  173.     CLK->CLKSEL0 = CLK_CLKSEL0_STCLK_S_XTAL | CLK_CLKSEL0_HCLK_S_XTAL;
    


  174. 

  175.     /* Enable IP clock */        
    

  176.     CLK->APBCLK = CLK_APBCLK_UART_EN_Msk;
    

  177.     
    

  178.     /* Select IP clock source */
    

  179.     CLK->CLKSEL1 = CLK_CLKSEL1_UART_S_XTAL;
    


  180. 

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

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

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

  184.     /* Set P0 multi-function pins for UART RXD and TXD */
    

  185.     SYS->P0_MFP = SYS_MFP_P01_RXD | SYS_MFP_P00_TXD;
    

  186.     
    

  187.     /* Set P3.4 and P3.5 for I2C SDA and SCL */
    

  188.     SYS->P3_MFP = SYS_MFP_P34_SDA | SYS_MFP_P35_SCL;
    

  189.     
    

  190.     /* Lock protected registers */
    

  191.     SYS_LockReg();
    

  192.     
    

  193.     /* Update System Core Clock */
    

  194.     SystemCoreClockUpdate();
    

  195. }
    


  196. 

  197. void UART_Init(void)
    

  198. {
    

  199. /*---------------------------------------------------------------------------------------------------------*/
    

  200. /* Init UART                                                                                               */
    

  201. /*---------------------------------------------------------------------------------------------------------*/
    

  202.      /* Reset IP */
    

  203.     SYS->IPRSTC2 |=  SYS_IPRSTC2_UART_RST_Msk;
    

  204.     SYS->IPRSTC2 &= ~SYS_IPRSTC2_UART_RST_Msk;
    

  205.     
    

  206.     UART->BAUD = UART_BAUD_DIV_X_EN_Msk | UART_BAUD_DIV_X_ONE_Msk | (((__XTAL + (115200/2)) / 115200)-2);    
    

  207.     UART->LCR = 0x3 | (0x0 << UART_LCR_PBE_Pos) | (0x0 << UART_LCR_NSB_Pos) ;
    

  208. }
    


  209. 

  210. void I2C_Init(void)
    

  211. {    
    

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

  213.     I2C_Open(I2C, 100000);
    

  214.     
    

  215.      /* Set I2C 4 Slave Addresses */            
    

  216.     I2C_SetSlaveAddr(I2C, 0, 0x15, 0);   /* Slave Address : 0x15 */
    

  217.     I2C_SetSlaveAddr(I2C, 1, 0x35, 0);   /* Slave Address : 0x35 */
    

  218.     I2C_SetSlaveAddr(I2C, 2, 0x55, 0);   /* Slave Address : 0x55 */
    

  219.     I2C_SetSlaveAddr(I2C, 3, 0x75, 0);   /* Slave Address : 0x75 */
    


  220. 

  221.     /* Enable I2C interrupt */
    

  222.     I2C_EnableInt(I2C);
    

  223.     NVIC_EnableIRQ(I2C_IRQn);
    

  224. }
    


  225. 

  226. void I2C0_Write_SLAVE_multi(uint8_t slvaddr,uint16_t slvraw,uint8_t slvreg,uint8_t *data)
    

  227. {
    

  228.                 
    

  229.                                 g_u8DeviceAddr = slvaddr;
    

  230.                                 rawlenth=slvraw;
    

  231.                                 g_au8Reg = slvreg;
    

  232.                                 g_au8Buffer=data;
    


  233. 

  234.         g_u8DataLen = 0;
    

  235.         g_u8EndFlag = 0;
    


  236. 

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

  238.         s_I2CHandlerFn = (I2C_FUNC)I2C_MasterTx_multi;
    


  239. 

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

  241.         I2C_SET_CONTROL_REG(I2C, I2C_STA);
    


  242. 

  243.         /* Wait I2C Tx Finish */
    

  244.         while(g_u8EndFlag == 0);
    

  245.         g_u8EndFlag = 0;
    

  246. }
    


  247. 

  248. void I2C0_Read_SLAVE_multi(uint8_t slvaddr,uint16_t slvraw,uint8_t slvreg,uint8_t *data)
    

  249. { 
    

  250.         g_u8DeviceAddr = slvaddr;
    

  251.                                 rawlenth=slvraw;
    

  252.         g_au8Reg = slvreg ;
    

  253.                                 g_au8Buffer=data;
    


  254. 

  255.         g_u8EndFlag = 0;
    

  256.         g_u8DataLen = 0;
    

  257.         
    

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

  259.         s_I2CHandlerFn = (I2C_FUNC)I2C_MasterRx_multi;
    

  260.         I2C_SET_CONTROL_REG(I2C, I2C_STA);
    


  261. 

  262.         /* Wait I2C Rx Finish */
    

  263.         while(g_u8EndFlag == 0);
    

  264.         
    

  265. }
    


  266. 

  267. /*---------------------------------------------------------------------------------------------------------*/
    

  268. /*  Main Function                                                                                          */
    

  269. /*---------------------------------------------------------------------------------------------------------*/
    

  270. int32_t main (void)
    

  271. {
    

  272.     uint8_t u8Data[10];
    

  273.                 uint8_t DID,slvreg;
    

  274.                 uint32_t i;
    

  275.                 uint8_t *Buffer;
    

  276.                 uint16_t raw;
    

  277.                 
    


  278. 

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

  280.     SYS_Init();     
    


  281. 

  282.     /* Init UART for printf */
    

  283.     UART_Init();
    


  284. 

  285.     /*
    

  286.         This sample code sets I2C bus clock to 100kHz. Then, accesses EEPROM 24LC64 with Byte Write 
    

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

  288.     */
    

  289.    
    

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

  291.     printf("|    Mini51 I2C Driver Sample Code with EEPROM 24LC64    |\n");
    

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

  293.     
    

  294.     /* Init I2C to access EEPROM */ 
    

  295.     I2C_Init();
    

  296.         
    

  297.     printf("\n");
    

  298.     printf("Check I2C Slave(I2C0) is running first!\n");
    

  299.     printf("Press any key to continue.\n");
    

  300.     getchar();
    


  301. 

  302.     /* Access Slave with no address */
    

  303.     printf("\n");
    

  304.                                 
    

  305.                 DID=0x15;
    

  306.                 slvreg=0x66;
    

  307.                 raw=10;
    

  308.                 Buffer=u8Data;                
    

  309.                 for (i=0;i<raw;i++)
    

  310.                 {
    

  311.                         Buffer[i]=1<<(i%8);
    

  312.                 }
    

  313.                 
    

  314.     I2C0_Write_SLAVE_multi(DID,raw,slvreg,Buffer);
    

  315.                 I2C0_Read_SLAVE_multi(DID,raw,slvreg,Buffer);
    

  316.                 
    

  317.                 /* Compare data */
    

  318.     for (i=0;i<raw;i++)
    

  319.                 {
    

  320.                         if(Buffer[i] != 1<<(i%8))
    

  321.                         {
    

  322.                                         printf("I2C Byte Write/Read Failed, Data 0x%x\n", Buffer[i]);
    

  323. //                                         while(1);
    

  324.                         }
    

  325.                         printf("Master Access Slave Register:0x%X  Data:0x%X Test OK\n", (slvreg+i), Buffer[i]);        
    

  326.                 }
    

  327.                                 
    

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

  329.                 
    

  330.                 s_I2CHandlerFn = NULL;
    

  331.                 
    

  332.     /* Close I2C */
    

  333.     I2C_Close(I2C);
    


  334. 

  335.     return 0;
    

  336. }
    


  337. 


  338. 


  339.
回复

收藏 举报

 楼主| 598330983 发表于 2019-4-30 20:18 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     main.c
    

  3.  * @version  V0.10
    

  4.  * $Revision: 4 $
    

  5.  * $Date: 13/10/07 3:56p $ 
    

  6.  * @brief    Mini51 Series I2C Driver Sample Code
    

  7.  *
    

  8.  * @note
    

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

  10. *****************************************************************************/ 
    

  11. #include <stdio.h>
    

  12. #include "Mini51Series.h"
    


  13. 

  14. uint32_t slave_buff_addr;
    

  15. uint8_t g_u8SlvData[256];
    

  16. uint8_t g_au8RxData;
    

  17. /*---------------------------------------------------------------------------------------------------------*/
    

  18. /* Global variables                                                                                        */
    

  19. /*---------------------------------------------------------------------------------------------------------*/
    

  20. uint8_t g_u8DeviceAddr;
    

  21. uint8_t g_u8DataLen;
    


  22. 

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


  24. 

  25. I2C_FUNC __IO s_I2CHandlerFn = NULL;
    


  26. 

  27. /*---------------------------------------------------------------------------------------------------------*/
    

  28. /*  I2C IRQ Handler                                                                                       */
    

  29. /*---------------------------------------------------------------------------------------------------------*/
    

  30. void I2C_IRQHandler(void)
    

  31. {
    

  32.     uint32_t u32Status;
    


  33. 

  34.     u32Status = I2C_GET_STATUS(I2C);
    


  35. 

  36.     if (I2C_GET_TIMEOUT_FLAG(I2C))
    

  37.     {
    

  38.         /* Clear I2C Timeout Flag */
    

  39.         I2C_ClearTimeoutFlag(I2C);                   
    

  40.     }    
    

  41.     else
    

  42.     {
    

  43.         if (s_I2CHandlerFn != NULL)
    

  44.             s_I2CHandlerFn(u32Status);
    

  45.     }
    

  46. }
    


  47. 

  48. /*---------------------------------------------------------------------------------------------------------*/
    

  49. /*  I2C TRx Callback Function                                                                               */
    

  50. /*---------------------------------------------------------------------------------------------------------*/
    

  51. void I2C_SlaveTRx(uint32_t u32Status)
    

  52. {
    

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

  54.     {
    

  55.         g_u8DataLen = 0;
    

  56.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  57.     }
    

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

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

  60.     {
    

  61.         g_au8RxData = (unsigned char) I2C_GET_DATA(I2C);
    

  62.         g_u8DataLen++;
    


  63. 

  64.         if(g_u8DataLen == 1)
    

  65.         {
    

  66.             slave_buff_addr = g_au8RxData;
    

  67.         }
    

  68.         else
    

  69.         {
    

  70.             g_u8SlvData[slave_buff_addr+(g_u8DataLen-2)] = g_au8RxData;
    

  71.         }
    

  72.                                 
    

  73.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  74.     }
    

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

  76.     {
    

  77.                      I2C_SET_DATA(I2C, g_u8SlvData[slave_buff_addr]);
    

  78.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  79.     }
    

  80.                 else if(u32Status == 0xB8)                 /* Data byte in I2CDAT has been transmitted
    

  81.                                                    ACK has been received */
    

  82.     {
    

  83.         slave_buff_addr=slave_buff_addr+1;
    

  84.                                 I2C_SET_DATA(I2C, g_u8SlvData[slave_buff_addr]);
    

  85.                                 I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  86.     }
    

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

  88.                                                    Not ACK has been received */
    

  89.     {
    

  90.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  91.     }
    

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

  93.                                                    been returned */
    

  94.     {
    

  95.         g_u8DataLen = 0;
    

  96.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  97.     }
    

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

  99.                                                    addressed as Slave/Receiver*/
    

  100.     {
    

  101.         g_u8DataLen = 0;
    

  102.         I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  103.     }
    

  104.     else
    

  105.     {
    

  106.         /* TO DO */
    

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

  108.     }
    

  109. }
    


  110. 

  111. void SYS_Init(void)
    

  112. {
    

  113.     /* Unlock protected registers */
    

  114.     SYS_UnlockReg();
    


  115. 

  116. /*---------------------------------------------------------------------------------------------------------*/
    

  117. /* Init System Clock                                                                                       */
    

  118. /*---------------------------------------------------------------------------------------------------------*/
    


  119. 

  120.     /* Unlock protected registers */
    

  121.     SYS_UnlockReg();
    


  122. 

  123.     /* Enable external 12MHz XTAL, internal 22.1184MHz */
    

  124.     CLK->PWRCON |= CLK_PWRCON_XTL12M | CLK_PWRCON_IRC22M_EN_Msk;
    


  125. 

  126.     /* Waiting for clock ready */
    

  127.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL_STB_Msk | CLK_CLKSTATUS_IRC22M_STB_Msk);
    


  128. 

  129.     /* Switch HCLK clock source to XTL, STCLK to XTL */
    

  130.     CLK->CLKSEL0 = CLK_CLKSEL0_STCLK_S_XTAL | CLK_CLKSEL0_HCLK_S_XTAL;
    


  131. 

  132.     /* Enable IP clock */        
    

  133.     CLK->APBCLK = CLK_APBCLK_UART_EN_Msk;
    

  134.     
    

  135.     /* Select IP clock source */
    

  136.     CLK->CLKSEL1 = CLK_CLKSEL1_UART_S_XTAL;
    


  137. 

  138. /*---------------------------------------------------------------------------------------------------------*/
    

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

  140. /*---------------------------------------------------------------------------------------------------------*/
    

  141.     /* Set P0 multi-function pins for UART RXD and TXD */
    

  142.     SYS->P0_MFP = SYS_MFP_P01_RXD | SYS_MFP_P00_TXD;
    

  143.     
    

  144.     /* Set P3.4 and P3.5 for I2C SDA and SCL */
    

  145.     SYS->P3_MFP = SYS_MFP_P34_SDA | SYS_MFP_P35_SCL;
    

  146.     
    

  147.     /* Lock protected registers */
    

  148.     SYS_LockReg();
    

  149.     
    

  150.     /* Update System Core Clock */
    

  151.     SystemCoreClockUpdate();
    

  152. }
    


  153. 

  154. void UART_Init(void)
    

  155. {
    

  156. /*---------------------------------------------------------------------------------------------------------*/
    

  157. /* Init UART                                                                                               */
    

  158. /*---------------------------------------------------------------------------------------------------------*/
    

  159.      /* Reset IP */
    

  160.     SYS->IPRSTC2 |=  SYS_IPRSTC2_UART_RST_Msk;
    

  161.     SYS->IPRSTC2 &= ~SYS_IPRSTC2_UART_RST_Msk;
    

  162.     
    

  163.     UART->BAUD = UART_BAUD_DIV_X_EN_Msk | UART_BAUD_DIV_X_ONE_Msk | (((__XTAL + (115200/2)) / 115200)-2);    
    

  164.     UART->LCR = 0x3 | (0x0 << UART_LCR_PBE_Pos) | (0x0 << UART_LCR_NSB_Pos) ;
    

  165. }
    


  166. 

  167. void I2C_Init(void)
    

  168. {    
    

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

  170.     I2C_Open(I2C, 100000);
    

  171.     
    

  172.      /* Set I2C 4 Slave Addresses */            
    

  173.     I2C_SetSlaveAddr(I2C, 0, 0x15, 0);   /* Slave Address : 0x15 */
    

  174.     I2C_SetSlaveAddr(I2C, 1, 0x35, 0);   /* Slave Address : 0x35 */
    

  175.     I2C_SetSlaveAddr(I2C, 2, 0x55, 0);   /* Slave Address : 0x55 */
    

  176.     I2C_SetSlaveAddr(I2C, 3, 0x75, 0);   /* Slave Address : 0x75 */
    


  177. 

  178.     /* Enable I2C interrupt */
    

  179.     I2C_EnableInt(I2C);
    

  180.     NVIC_EnableIRQ(I2C_IRQn);
    

  181. }
    


  182. 

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

  184. /*  Main Function                                                                                          */
    

  185. /*---------------------------------------------------------------------------------------------------------*/
    

  186. int32_t main (void)
    

  187. {
    

  188.     uint32_t i;
    


  189. 

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

  191.     SYS_Init();     
    


  192. 

  193.     /* Init UART for printf */
    

  194.     UART_Init();
    


  195. 

  196.     /*
    

  197.         This sample code sets I2C bus clock to 100kHz. Then, accesses EEPROM 24LC64 with Byte Write 
    

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

  199.     */
    

  200.    
    

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

  202.     printf("|    Mini51 I2C Driver Sample Code with EEPROM 24LC64    |\n");
    

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

  204.     
    

  205.     /* Init I2C to access EEPROM */ 
    

  206.     I2C_Init();
    

  207.       
    

  208.                 /* I2C enter no address SLV mode */
    

  209.     I2C_SET_CONTROL_REG(I2C, I2C_SI | I2C_AA);
    

  210.                 
    

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

  212.     {
    

  213.         g_u8SlvData[i] = 0;
    

  214.     }
    

  215.                 
    

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

  217.                 s_I2CHandlerFn = I2C_SlaveTRx;
    


  218. 

  219.                 printf("\n");
    

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


  221. 

  222.     while(1);
    

  223. }
    


  224. 


  225. 


  226.
回复

收藏 举报

heisexingqisi 发表于 2019-4-30 20:49 | 显示全部楼层
IIC学的不好，参考参考。
回复

收藏 举报

xuanhuanzi 发表于 2019-4-30 21:20 | 显示全部楼层
以前玩51都是IO模拟
回复

收藏 举报

 楼主| 598330983 发表于 2019-5-2 20:40 | 显示全部楼层
函数指针的高级用法
回复

收藏 举报

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

本版积分规则

598330983

267

主题

5575

帖子

22

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