21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 使用USB及I2C 去存取EEPROM
返回列表 发新帖我要提问

[DemoCode下载] 使用USB及I2C 去存取EEPROM

[复制链接]
 楼主| a_ziliu 发表于 2016-12-26 10:43 | 显示全部楼层 |阅读模式
EEPROM, I2c, USB, AC
使用USB 及I2C去存取EEPROM
EC_NUC230_240_HID_EEPROM.zip (1.13 MB, 下载次数: 35)
回复 赏

举报

相关帖子
643757107 发表于 2016-12-26 14:47 | 显示全部楼层
EEPROM一般是I2C 的接口吧，如果用USB去弄，那意思是用这个芯片的USB接口来跟计算机通信了？
回复 赏

举报

langziwuliao 发表于 2016-12-26 16:49 | 显示全部楼层
对的
回复 赏

举报

598330983 发表于 2016-12-26 16:50 | 显示全部楼层
一般常用的EEPROM都是I2C接口。
回复 赏

举报

nobleliom 发表于 2016-12-30 20:08 | 显示全部楼层
usb接口操作eeprom，这个怎么实现呢？好像无法操作吧，eeprom用的是I2C
回复 赏

举报

yiyigirl2014 发表于 2016-12-31 10:03 | 显示全部楼层
帮楼主贴出来，方便大家阅读
复制
  1. /******************************************************************************
    

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

  3.  * [url=home.php?mod=space&uid=247401]@brief[/url]    NANO100 series USBD driver source file
    

  4.  * [url=home.php?mod=space&uid=895143]@version[/url]  2.0.0
    

  5.  * [url=home.php?mod=space&uid=212281]@date[/url]     22, March, 2013
    

  6.  *
    

  7.  * @note
    

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

  9.  ******************************************************************************/
    

  10. #include <stdio.h>
    

  11. #include "NUC230_240.h"
    

  12. #include "hid_transfer.h"
    

  13. #define I2C_EEPROM I2C1
    

  14. #define I2C_EEPROM_IRQn I2C1_IRQn
    


  15. 

  16. void EnableCLKO(uint32_t u32ClkSrc, uint32_t u32ClkDiv)
    

  17. {
    

  18.     /* CLKO = clock source / 2^(u32ClkDiv + 1) */
    

  19.     CLK->FRQDIV = CLK_FRQDIV_DIVIDER_EN_Msk | u32ClkDiv;
    


  20. 

  21.     /* Enable CLKO clock source */
    

  22.     CLK->APBCLK |= CLK_APBCLK_FDIV_EN_Msk;
    


  23. 

  24.     /* Select CLKO clock source */
    

  25.     CLK->CLKSEL2 = (CLK->CLKSEL2 & (~CLK_CLKSEL2_FRQDIV_S_Msk)) | u32ClkSrc;
    

  26. }
    


  27. 

  28. /*--------------------------------------------------------------------------*/
    

  29. void SYS_Init(void)
    

  30. {
    


  31. 

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

  33.     /* Init System Clock                                                                                       */
    

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


  35. 

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

  37.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);
    


  38. 

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

  40.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);
    


  41. 

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

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


  44. 

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

  46.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  47. 

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

  49.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  50. 

  51.     /* Set Flash Access Delay */
    

  52.     FMC->FATCON |= FMC_FATCON_FOMSEL1_Msk | FMC_FATCON_FOMSEL0_Msk;
    


  53. 

  54.     /* Set core clock */
    

  55.     CLK_SetCoreClock(72000000);
    


  56. 

  57.     /* Enable module clock */
    

  58.     CLK_EnableModuleClock(UART0_MODULE);
    

  59.     CLK_EnableModuleClock(USBD_MODULE);
    


  60. 

  61.     /* Select module clock source */
    

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

  63.     CLK_SetModuleClock(USBD_MODULE, 0, CLK_CLKDIV_USB(3));
    


  64. 


  65. 

  66.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  68.     /*---------------------------------------------------------------------------------------------------------*/
    


  69. 

  70.     /* Set GPB multi-function pins for UART0 RXD and TXD, and Clock Output */
    

  71.     SYS->GPB_MFP |= (SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD | SYS_GPB_MFP_PB8_CLKO);
    

  72.     SYS->ALT_MFP |=  SYS_ALT_MFP_PB8_CLKO;
    


  73. 

  74.     /* Enable CLKO(PB8) for monitor HCLK. CLKO = HCLK/8 Hz*/
    

  75.     EnableCLKO((2 << CLK_CLKSEL2_FRQDIV_S_Pos), 2);
    

  76. }
    


  77. 


  78. 

  79. void UART0_Init(void)
    

  80. {
    

  81.     /*---------------------------------------------------------------------------------------------------------*/
    

  82.     /* Init UART                                                                                               */
    

  83.     /*---------------------------------------------------------------------------------------------------------*/
    

  84.     /* Reset IP */
    

  85.     SYS->IPRSTC2 |=  SYS_IPRSTC2_UART0_RST_Msk;
    

  86.     SYS->IPRSTC2 &= ~SYS_IPRSTC2_UART0_RST_Msk;
    


  87. 

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

  89.     UART0->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HXT, 115200);
    

  90.     UART0->LCR = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
    

  91. }
    

  92. extern uint8_t volatile g_u8EP3Ready;
    


  93. 

  94. typedef __packed struct {
    

  95.     uint8_t u8PID;
    

  96.     uint8_t u8Command;
    

  97.     uint8_t u8Size;
    

  98.     uint8_t u8Buffer[61];        
    

  99. } CMD_T;
    


  100. 

  101. CMD_T gCmd;
    

  102. #define I2C_SET_ADDRESS 0x01
    

  103. #define I2C_WRITE 0x02
    

  104. #define I2C_READ 0x03
    


  105. 

  106. uint8_t g_u8DeviceAddr;
    

  107. uint8_t g_u8RxData;
    

  108. uint8_t g_u8DataLen;
    

  109. volatile uint8_t g_u8EndFlag = 0;
    


  110. 

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

  112. static I2C_FUNC s_I2CHandlerFn = NULL;
    


  113. 

  114. /*---------------------------------------------------------------------------------------------------------*/
    

  115. /*  I2C IRQ Handler                                                                                       */
    

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

  117. void I2C1_IRQHandler(void)
    

  118. {
    

  119.     uint32_t u32Status;
    


  120. 

  121.     u32Status = I2C_EEPROM->I2CSTATUS;
    


  122. 

  123.     if (I2C_EEPROM->I2CTOC & I2C_I2CTOC_TIF_Msk)
    

  124.     {
    

  125.         /* Clear I2C Timeout Flag */
    

  126.         I2C_EEPROM->I2CTOC |= I2C_I2CTOC_TIF_Msk;                   
    

  127.     }    
    

  128.     else
    

  129.     {
    

  130.         if (s_I2CHandlerFn != NULL)
    

  131.             s_I2CHandlerFn(u32Status);
    

  132.     }
    

  133. }
    


  134. 

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

  136. /*  I2C Initial Function                                                                                       */
    

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

  138. __INLINE void I2C_PIN_Init(void)
    

  139. {
    

  140.                 /* Set GPA10,11 multi-function pins for I2C1 SDA and SCL */
    

  141.                 SYS->GPA_MFP |= SYS_GPA_MFP_PA10_I2C1_SDA|SYS_GPA_MFP_PA11_I2C1_SCL;
    

  142.         
    

  143.           /* Enable I2C1 clock */        
    

  144.     CLK->APBCLK |= CLK_APBCLK_I2C1_EN_Msk;
    

  145.         
    

  146.     /* Reset I2C1 */
    

  147.     SYS->IPRSTC2 |=  SYS_IPRSTC2_I2C1_RST_Msk;
    

  148.     SYS->IPRSTC2 &= ~SYS_IPRSTC2_I2C1_RST_Msk;        
    

  149. }
    


  150. 

  151. void I2C_EEPROM_Init(void)
    

  152. {
    

  153.                 I2C_PIN_Init();
    

  154.     /* Enable I2C Controller */
    

  155.     //I2C_EEPROM->I2CON |= I2C_I2CON_ENS1_Msk;
    

  156.     
    

  157.     /* I2C clock divider, I2C Bus Clock = PCLK / (4*120) = 100kHz */
    

  158.     //I2C_EEPROM->I2CLK = I2C_I2CLK_DIV4(u8Divider);
    

  159.     I2C_Open(I2C_EEPROM, 100000);
    

  160.     /* Enable I2C interrupt and set corresponding NVIC bit */
    

  161.     I2C_EEPROM->I2CON |= I2C_I2CON_EI_Msk;
    

  162.     NVIC_EnableIRQ(I2C_EEPROM_IRQn);
    

  163. }
    


  164. 


  165. 

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

  167. /*  I2C Rx Callback Function                                                                               */
    

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

  169. void I2C_MasterRx(uint32_t u32Status)
    

  170. {
    

  171.         #if 0
    

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

  173.     {
    

  174.         I2C_EEPROM->I2CDAT = g_u8DeviceAddr << 1;     /* Write SLA+W to Register I2CDAT */
    

  175.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  176.     }   
    

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

  178.     {
    

  179.         I2C_EEPROM->I2CDAT = gCmd.u8Buffer[g_u8DataLen++];
    

  180.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  181.     }
    

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

  183.     {
    

  184.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STA_STO_SI);
    

  185.     }
    

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

  187.     {
    

  188.         if (g_u8DataLen != 2)
    

  189.         {
    

  190.             I2C_EEPROM->I2CDAT = gCmd.u8Buffer[g_u8DataLen++];
    

  191.             I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  192.         }
    

  193.         else
    

  194.         {
    

  195.             I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STA_SI);
    

  196.         }       
    

  197.     }
    

  198.                 #endif
    

  199.     if (u32Status == 0x08)                 /* Repeat START has been transmitted and prepare SLA+R */
    

  200.     {
    

  201.         I2C_EEPROM->I2CDAT = ((g_u8DeviceAddr << 1) | 0x01);   /* Write SLA+R to Register I2CDAT */
    

  202.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  203.     }
    

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

  205.     {
    

  206.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI|I2C_I2CON_SI_AA);
    

  207.     }       
    

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

  209.     {
    

  210.                           if(g_u8DataLen!= gCmd.u8Size-1)
    

  211.                                 {
    

  212.         gCmd.u8Buffer[g_u8DataLen++]= I2C_EEPROM->I2CDAT;
    

  213.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI|I2C_I2CON_SI_AA);
    

  214.         }else{
    

  215.                                 gCmd.u8Buffer[g_u8DataLen++]= I2C_EEPROM->I2CDAT;
    

  216.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  217.                                 }
    

  218.     }
    

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

  220.     {
    

  221.         g_u8RxData = I2C_EEPROM->I2CDAT;
    

  222.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STO_SI);
    

  223.         g_u8EndFlag = 1;
    

  224.     }
    

  225.     else
    

  226.     {
    

  227.         /* TO DO */
    

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

  229.                                 while(1);
    

  230.     }           
    

  231. }
    


  232. 

  233. /*---------------------------------------------------------------------------------------------------------*/
    

  234. /*  I2C Tx Callback Function                                                                               */
    

  235. /*---------------------------------------------------------------------------------------------------------*/
    

  236. void I2C_MasterTx(uint32_t u32Status)
    

  237. {
    

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

  239.     {
    

  240.         I2C_EEPROM->I2CDAT = g_u8DeviceAddr << 1;     /* Write SLA+W to Register I2CDAT */
    

  241.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  242.     }   
    

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

  244.     {
    

  245.         I2C_EEPROM->I2CDAT = gCmd.u8Buffer[g_u8DataLen++];
    

  246.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  247.     }
    

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

  249.     {
    

  250.         I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STA_STO_SI);
    

  251.     }   
    

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

  253.     {
    

  254.         if (g_u8DataLen != gCmd.u8Size)
    

  255.         {
    

  256.             I2C_EEPROM->I2CDAT = gCmd.u8Buffer[g_u8DataLen++];
    

  257.             I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_SI);
    

  258.         }
    

  259.         else
    

  260.         {
    

  261.             I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STO_SI);
    

  262.             g_u8EndFlag = 1;
    

  263.         }       
    

  264.     }
    

  265.     else
    

  266.     {
    

  267.         /* TO DO */
    

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

  269.                                 while(1);
    

  270.     }       
    

  271. }
    


  272. 

  273. void I2C_EEPROM_Write(void)
    

  274. {
    

  275.                 g_u8DataLen = 0;
    

  276.                 g_u8EndFlag = 0;
    

  277.                 
    

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

  279.                 s_I2CHandlerFn = (I2C_FUNC)I2C_MasterTx;
    

  280.                 
    

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

  282.                 I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STA);
    


  283. 

  284.                 /* Wait I2C Tx Finish */
    

  285.                 while (g_u8EndFlag == 0);        
    

  286. }
    


  287. 

  288. /*---------------------------------------------------------------------------------------------------------*/
    

  289. /*  Read I2C EEPROM                                                                                        */
    

  290. /*---------------------------------------------------------------------------------------------------------*/
    

  291. uint8_t I2C_EEPROM_Read(void)
    

  292. {
    

  293.                 g_u8DataLen = 0;
    

  294.                 g_u8EndFlag = 0;
    

  295.                 
    

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

  297.                 s_I2CHandlerFn = (I2C_FUNC)I2C_MasterRx;
    

  298.                 
    

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

  300.                 I2C_SET_CONTROL_REG(I2C_EEPROM, I2C_I2CON_STA);
    


  301. 

  302.                 /* Wait I2C Tx Finish */
    

  303.                 while (g_u8EndFlag == 0);        
    

  304.         
    

  305.                 return g_u8RxData;
    

  306. }
    


  307. 


  308. 

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

  310. /*  Main Function                                                                                          */
    

  311. /*---------------------------------------------------------------------------------------------------------*/
    

  312. int32_t main(void)
    

  313. {
    

  314.          uint8_t *ptrOut, *ptrIn;
    

  315.     /*
    

  316.         This sample code demonstrate how to use HID interface to transfer data
    

  317.         between PC and USB device.
    

  318.         A demo window tool are also included in "WindowsTool" directory with this
    

  319.         sample code. User can use it to test data transfer with this sample code.
    


  320. 

  321.     */
    


  322. 

  323.     /* Unlock write-protected registers */
    

  324.     SYS_UnlockReg();
    


  325. 

  326.     /* Init system and multi-funcition I/O */
    

  327.     SYS_Init();
    


  328. 

  329.     /* Init UART for debug message */
    

  330.     UART0_Init();
    

  331.           I2C_EEPROM_Init();
    

  332.     printf("NuMicro USB HID Transfer Sample\n");
    


  333. 

  334.     /* Open USB controller */
    

  335.     USBD_Open(&gsInfo, HID_ClassRequest, NULL);
    


  336. 

  337.     /*Init Endpoint configuration for HID */
    

  338.     HID_Init();
    


  339. 

  340.     /* Start USB device */
    

  341.     USBD_Start();
    


  342. 

  343.     /* Enable USB device interrupt */
    

  344.     NVIC_EnableIRQ(USBD_IRQn);
    


  345. 

  346.     while(1)
    

  347.                 {                
    

  348.                 if(g_u8EP3Ready==1)
    

  349.                 {
    

  350.                         g_u8EP3Ready=0;
    

  351.                             
    

  352.     /* Interrupt OUT */
    

  353.       ptrOut = (uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP3));
    

  354.                         ptrIn = (uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP2));
    

  355.      
    

  356.       USBD_MemCopy((uint8_t *)&gCmd, ptrOut, 64);
    

  357.                         
    

  358.                         if(gCmd.u8Command==I2C_SET_ADDRESS)
    

  359.                         {
    

  360.                                 g_u8DeviceAddr=gCmd.u8Size;
    

  361.                                 printf("i2c address 0x%x\n\r",gCmd.u8Size);
    

  362.                         }
    

  363.                         
    

  364.                         if(gCmd.u8Command==I2C_WRITE)
    

  365.                         {
    

  366.                                 printf("i2c write\n\r");
    

  367.        I2C_EEPROM_Write();
    

  368.                         }
    

  369.                         
    

  370.                  if(gCmd.u8Command==I2C_READ)
    

  371.                         {
    

  372.                                 printf("i2c read\n\r");
    

  373.        I2C_EEPROM_Read();
    

  374.                         }
    

  375.                         gCmd.u8PID+=1;
    

  376.                         
    

  377.                         
    

  378.                         USBD_MemCopy(ptrIn, (void *)&gCmd, 64);
    

  379.                         USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);                        
    

  380.       USBD_SET_PAYLOAD_LEN(EP2, EP2_MAX_PKT_SIZE);
    

  381.                   }
    

  382.                 }
    

  383. }
    


  384. 


  385. 


  386. 

  387. /*** (C) COPYRIGHT 2013 Nuvoton Technology Corp. ***/


回复 赏

举报

huangcunxiake 发表于 2016-12-31 10:29 | 显示全部楼层
原来是I2C 读写外部的存储器
回复 赏

举报

捉虫天师 发表于 2016-12-31 20:32 | 显示全部楼层
我认为单片机最复杂的其实是时钟系统
回复 赏

举报

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

本版积分规则

a_ziliu

100

主题

310

帖子

6

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