21ic电子技术开发论坛 › 单片机与嵌入式系统 › 小华半导体 › 【华大测评】+24C02
返回列表 发新帖我要提问

[综合信息] 【华大测评】+24C02

[复制链接]
669|0
 楼主| Cjy_JDxy 发表于 2020-6-1 18:33 | 显示全部楼层 |阅读模式
I2c, TI, se, TE
今天搞了一下AT24C02.
原理图：
3.jpg
程序：
复制
  1. #include "hc32_ddl.h"
    


  2. 

  3. /*******************************************************************************
    

  4.  * Local type definitions ('typedef')
    

  5.  ******************************************************************************/
    


  6. 

  7. /*******************************************************************************
    

  8.  * Local pre-processor symbols/macros ('#define')
    

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

  10. /* Define I2C unit used for the example */
    

  11. #define I2C_CH                          (M4_I2C1)
    

  12. /* Define E2PROM device address */
    

  13. #define E2_ADDRESS                      0x50u
    

  14. /* AT24C02 page length is 8byte*/
    

  15. #define PAGE_LEN                        8u
    

  16. /* Define test address for read and write */
    

  17. #define DATA_TEST_ADDR                  0x00u
    

  18. /* Define port and pin for SDA and SCL */
    

  19. #define I2C1_SCL_PORT                   (PortC)
    

  20. #define I2C1_SCL_PIN                    (Pin04)
    

  21. #define I2C1_SDA_PORT                   (PortC)
    

  22. #define I2C1_SDA_PIN                    (Pin05)
    


  23. 

  24. #define TIMEOUT                         0x10000ul
    


  25. 

  26. #define I2C_RET_OK                      0u
    

  27. #define I2C_RET_ERROR                   1u
    


  28. 

  29. #define GENERATE_START                  0x00u
    

  30. #define GENERATE_RESTART                0x01u
    


  31. 

  32. #define E2_ADDRESS_W                    0x00u
    

  33. #define E2_ADDRESS_R                    0x01u
    


  34. 

  35. /* LED0 Port/Pin definition */
    

  36. #define  LED0_PORT        (PortE)
    

  37. #define  LED0_PIN         (Pin06)
    


  38. 

  39. /* LED1 Port/Pin definition */
    

  40. #define  LED1_PORT        (PortA)
    

  41. #define  LED1_PIN         (Pin07)
    


  42. 

  43. /* LED0~1 toggle definition */
    

  44. #define  LED0_TOGGLE()    (PORT_Toggle(LED0_PORT, LED0_PIN))
    

  45. #define  LED1_TOGGLE()    (PORT_Toggle(LED1_PORT, LED1_PIN))
    


  46. 

  47. /*******************************************************************************
    

  48.  * Global variable definitions (declared in header file with 'extern')
    

  49.  ******************************************************************************/
    


  50. 

  51. /*******************************************************************************
    

  52.  * Local function prototypes ('static')
    

  53.  ******************************************************************************/
    


  54. 

  55. /*******************************************************************************
    

  56.  * Local variable definitions ('static')
    

  57.  ******************************************************************************/
    


  58. 

  59. /*******************************************************************************
    

  60.  * Function implementation - global ('extern') and local ('static')
    

  61.  ******************************************************************************/
    


  62. 

  63. /**
    

  64.  ******************************************************************************
    

  65.  ** \brief  Send start or restart condition
    

  66.  **
    

  67.  ** \param  none
    

  68.  **
    

  69.  ** \retval Process result
    

  70.  **         - I2C_RET_ERROR  Send failed
    

  71.  **         - I2C_RET_OK     Send success
    

  72.  ******************************************************************************/
    

  73. static uint8_t E2_StartOrRestart(uint8_t u8Start)
    

  74. {
    

  75.     uint32_t u32TimeOut = TIMEOUT;
    

  76.     en_flag_status_t enFlagBusy = Reset;
    

  77.     en_flag_status_t enFlagStartf = Reset;
    


  78. 

  79.     /* generate start or restart signal */
    

  80.     if(GENERATE_START == u8Start)
    

  81.     {
    

  82.         /* Wait I2C bus idle */
    

  83.         while(Set == I2C_GetStatus(I2C_CH, I2C_SR_BUSY))
    

  84.         {
    

  85.             if(0ul == (u32TimeOut--))
    

  86.             {
    

  87.                 return I2C_RET_ERROR;
    

  88.             }
    

  89.         }
    


  90. 

  91.         I2C_GenerateStart(I2C_CH , Enable);
    

  92.     }
    

  93.     else
    

  94.     {
    

  95.         /* Clear start status flag */
    

  96.         I2C_ClearStatus(I2C_CH, I2C_CLR_STARTFCLR);
    

  97.         /* Send restart condition */
    

  98.         I2C_GenerateReStart(I2C_CH , Enable);
    

  99.     }
    


  100. 

  101.     /* Judge if start success*/
    

  102.     u32TimeOut = TIMEOUT;
    

  103.     while(1)
    

  104.     {
    

  105.         enFlagBusy = I2C_GetStatus(I2C_CH, I2C_SR_BUSY);
    

  106.         enFlagStartf = I2C_GetStatus(I2C_CH, I2C_SR_STARTF);
    

  107.         if(enFlagBusy && enFlagStartf)
    

  108.         {
    

  109.             break;
    

  110.         }
    

  111.         if(0ul == (u32TimeOut--))
    

  112.         {
    

  113.             return I2C_RET_ERROR;
    

  114.         }
    

  115.     }
    


  116. 

  117.     return I2C_RET_OK;
    

  118. }
    


  119. 

  120. /**
    

  121.  ******************************************************************************
    

  122.  ** \brief  Send e2prom device address
    

  123.  **
    

  124.  ** \param  u16Adr  The slave address
    

  125.  **
    

  126.  ** \retval Process result
    

  127.  **         - I2C_RET_ERROR  Send failed
    

  128.  **         - I2C_RET_OK     Send success
    

  129.  ******************************************************************************/
    

  130. static uint8_t E2_SendAdr(uint8_t u8Adr)
    

  131. {
    

  132.     uint32_t u32TimeOut = TIMEOUT;
    


  133. 

  134.     /* Wait tx buffer empty */
    

  135.     while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_TEMPTYF))
    

  136.     {
    

  137.         if(0ul == (u32TimeOut--))
    

  138.         {
    

  139.             return I2C_RET_ERROR;
    

  140.         }
    

  141.     }
    


  142. 

  143.     /* Send I2C address */
    

  144.     I2C_SendData(I2C_CH, u8Adr);
    


  145. 

  146.     if(E2_ADDRESS_W == (u8Adr & 0x01u))
    

  147.     {
    

  148.         /* If in master transfer process, Need wait transfer end*/
    

  149.         uint32_t u32TimeOut = TIMEOUT;
    

  150.         while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_TENDF))
    

  151.         {
    

  152.             if(0ul == (u32TimeOut--))
    

  153.             {
    

  154.                 return I2C_RET_ERROR;
    

  155.             }
    

  156.         }
    

  157.     }
    


  158. 

  159.     /* Check ACK */
    

  160.     u32TimeOut = TIMEOUT;
    

  161.     while(Set == I2C_GetStatus(I2C_CH, I2C_SR_NACKDETECTF))
    

  162.     {
    

  163.         if(0ul == (u32TimeOut--))
    

  164.         {
    

  165.             return I2C_RET_ERROR;
    

  166.         }
    

  167.     }
    


  168. 

  169.     return I2C_RET_OK;
    

  170. }
    


  171. 

  172. /**
    

  173.  ******************************************************************************
    

  174.  ** \brief  Send data address to e2prom
    

  175.  **
    

  176.  ** \param  u8DataAdr  Data address to be send
    

  177.  **
    

  178.  ** \retval Process result
    

  179.  **         - I2C_RET_ERROR  Send failed
    

  180.  **         - I2C_RET_OK     Send success
    

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

  182. static uint8_t E2_SendDataAdr(uint8_t u8DataAdr)
    

  183. {
    

  184.     uint32_t u32TimeOut = TIMEOUT;
    


  185. 

  186.     /* Wait tx buffer empty */
    

  187.     u32TimeOut = TIMEOUT;
    

  188.     while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_TEMPTYF))
    

  189.     {
    

  190.         if(0ul == (u32TimeOut--))
    

  191.         {
    

  192.             return I2C_RET_ERROR;
    

  193.         }
    

  194.     }
    


  195. 

  196.     /* Send one byte data */
    

  197.     I2C_SendData(I2C_CH, u8DataAdr);
    


  198. 

  199.     /* Wait transfer end*/
    

  200.     u32TimeOut = TIMEOUT;
    

  201.     while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_TENDF))
    

  202.     {
    

  203.         if(0ul == (u32TimeOut--))
    

  204.         {
    

  205.             return I2C_RET_ERROR;
    

  206.         }
    

  207.     }
    


  208. 

  209.     /* Check ACK */
    

  210.     u32TimeOut = TIMEOUT;
    

  211.     while(Set == I2C_GetStatus(I2C_CH, I2C_SR_NACKDETECTF))
    

  212.     {
    

  213.         if(0ul == (u32TimeOut--))
    

  214.         {
    

  215.             return I2C_RET_ERROR;
    

  216.         }
    

  217.     }
    


  218. 

  219.     return I2C_RET_OK;
    

  220. }
    


  221. 

  222. /**
    

  223.  ******************************************************************************
    

  224.  ** \brief  Send data to e2prom
    

  225.  **
    

  226.  ** \param  pTxData  Pointer to the data buffer
    

  227.  ** \param  u32Size  Data size
    

  228.  **
    

  229.  ** \retval Process result
    

  230.  **         - I2C_RET_ERROR  Send failed
    

  231.  **         - I2C_RET_OK     Send success
    

  232.  ******************************************************************************/
    

  233. static uint8_t E2_WriteData(uint8_t *pTxData, uint32_t u32Size)
    

  234. {
    

  235.     uint32_t u32TimeOut = TIMEOUT;
    


  236. 

  237.     while(u32Size--)
    

  238.     {
    

  239.         /* Wait tx buffer empty */
    

  240.         u32TimeOut = TIMEOUT;
    

  241.         while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_TEMPTYF))
    

  242.         {
    

  243.             if(0ul == (u32TimeOut--))
    

  244.             {
    

  245.                 return I2C_RET_ERROR;
    

  246.             }
    

  247.         }
    


  248. 

  249.         /* Send one byte data */
    

  250.         I2C_SendData(I2C_CH, *pTxData++);
    


  251. 

  252.         /* Wait transfer end*/
    

  253.         u32TimeOut = TIMEOUT;
    

  254.         while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_TENDF))
    

  255.         {
    

  256.             if(0ul == (u32TimeOut--))
    

  257.             {
    

  258.                 return I2C_RET_ERROR;
    

  259.             }
    

  260.         }
    


  261. 

  262.         /* Check ACK */
    

  263.         u32TimeOut = TIMEOUT;
    

  264.         while(Set == I2C_GetStatus(I2C_CH, I2C_SR_NACKDETECTF))
    

  265.         {
    

  266.             if(0ul == (u32TimeOut--))
    

  267.             {
    

  268.                 return I2C_RET_ERROR;
    

  269.             }
    

  270.         }
    

  271.     }
    


  272. 

  273.     return I2C_RET_OK;
    

  274. }
    


  275. 

  276. /**
    

  277.  ******************************************************************************
    

  278.  ** \brief  Receive data from e2prom
    

  279.  **
    

  280.  ** \param  pTxData  Pointer to the data buffer
    

  281.  ** \param  u32Size  Data size
    

  282.  **
    

  283.  ** \retval Process result
    

  284.  **         - I2C_RET_ERROR  Send failed
    

  285.  **         - I2C_RET_OK     Send success
    

  286.  ******************************************************************************/
    

  287. static uint8_t E2_RevData(uint8_t *pRxData, uint32_t u32Size)
    

  288. {
    

  289.     uint32_t u32TimeOut = TIMEOUT;
    


  290. 

  291.     for(uint32_t i=0ul; i<u32Size; i++)
    

  292.     {
    

  293.         /* if the last byte receive, need config NACK*/
    

  294.         if(i == (u32Size - 1ul))
    

  295.         {
    

  296.             I2C_NackConfig(I2C_CH, Enable);
    

  297.         }
    


  298. 

  299.         /* Wait receive full flag*/
    

  300.         u32TimeOut = TIMEOUT;
    

  301.         while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_RFULLF))
    

  302.         {
    

  303.             if(0ul == (u32TimeOut--))
    

  304.             {
    

  305.                 return I2C_RET_ERROR;
    

  306.             }
    

  307.         }
    


  308. 

  309.         /* read data from register*/
    

  310.         *pRxData++ = I2C_ReadData(I2C_CH);
    

  311.     }
    


  312. 

  313.     return I2C_RET_OK;
    

  314. }
    


  315. 

  316. /**
    

  317.  ******************************************************************************
    

  318.  ** \brief  General stop condition to e2prom
    

  319.  **
    

  320.  ** \param  None
    

  321.  **
    

  322.  ** \retval Process result
    

  323.  **         - I2C_RET_ERROR  Send failed
    

  324.  **         - I2C_RET_OK     Send success
    

  325.  ******************************************************************************/
    

  326. uint8_t E2_Stop(void)
    

  327. {
    

  328.     uint32_t u32TimeOut;
    


  329. 

  330.     /* Wait I2C bus busy */
    

  331.     u32TimeOut = TIMEOUT;
    

  332.     while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_BUSY))
    

  333.     {
    

  334.         if(0ul == (u32TimeOut--))
    

  335.         {
    

  336.             return I2C_RET_ERROR;
    

  337.         }
    

  338.     }
    


  339. 

  340.     I2C_GenerateStop(I2C_CH, Enable);
    


  341. 

  342.     /* Wait STOPF */
    

  343.     u32TimeOut = TIMEOUT;
    

  344.     while(Reset == I2C_GetStatus(I2C_CH, I2C_SR_STOPF))
    

  345.     {
    

  346.         if(0ul == (u32TimeOut--))
    

  347.         {
    

  348.             return I2C_RET_ERROR;
    

  349.         }
    

  350.     }
    


  351. 

  352.     return I2C_RET_OK;
    

  353. }
    


  354. 

  355. /**
    

  356.  ******************************************************************************
    

  357.  ** \brief  Initialize the I2C peripheral for e2prom
    

  358.  **
    

  359.  ** \param  None
    

  360.  **
    

  361.  ** \retval Process result
    

  362.  **         - I2C_RET_ERROR  failed
    

  363.  **         - I2C_RET_OK     success
    

  364.  ******************************************************************************/
    

  365. uint8_t E2_Initialize(void)
    

  366. {
    

  367.     stc_i2c_init_t stcI2cInit;
    

  368.     stc_clk_freq_t stcClkFreq;
    


  369. 

  370.     I2C_DeInit(I2C_CH);
    


  371. 

  372.     /* Get system clock frequency */
    

  373.     CLK_GetClockFreq(&stcClkFreq);
    


  374. 

  375.     MEM_ZERO_STRUCT(stcI2cInit);
    

  376.     stcI2cInit.u32Pclk3 = stcClkFreq.pclk3Freq;
    

  377.     stcI2cInit.enI2cMode = I2cMaster;
    

  378.     stcI2cInit.u32Baudrate = 100000ul;
    

  379.     stcI2cInit.u32SclTime = 0ul;
    

  380.     I2C_Init(I2C_CH, &stcI2cInit);
    


  381. 

  382.     I2C_Cmd(I2C_CH, Enable);
    


  383. 

  384.     return I2C_RET_OK;
    

  385. }
    


  386. 

  387. /**
    

  388.  ******************************************************************************
    

  389.  ** \brief  Initialize the system clock for the sample
    

  390.  **
    

  391.  ** \param  None
    

  392.  **
    

  393.  ** \retval None
    

  394.  ******************************************************************************/
    

  395. static void SysClkIni(void)
    

  396. {
    

  397.     en_clk_sys_source_t     enSysClkSrc;
    

  398.     stc_clk_sysclk_cfg_t    stcSysClkCfg;
    

  399.     stc_clk_xtal_cfg_t      stcXtalCfg;
    

  400.     stc_clk_mpll_cfg_t      stcMpllCfg;
    


  401. 

  402.     MEM_ZERO_STRUCT(enSysClkSrc);
    

  403.     MEM_ZERO_STRUCT(stcSysClkCfg);
    

  404.     MEM_ZERO_STRUCT(stcXtalCfg);
    

  405.     MEM_ZERO_STRUCT(stcMpllCfg);
    


  406. 

  407.     /* Set bus clk div. */
    

  408.     stcSysClkCfg.enHclkDiv = ClkSysclkDiv1;   // Max 168MHz
    

  409.     stcSysClkCfg.enExclkDiv = ClkSysclkDiv2;  // Max 84MHz
    

  410.     stcSysClkCfg.enPclk0Div = ClkSysclkDiv1;  // Max 168MHz
    

  411.     stcSysClkCfg.enPclk1Div = ClkSysclkDiv2;  // Max 84MHz
    

  412.     stcSysClkCfg.enPclk2Div = ClkSysclkDiv4;  // Max 60MHz
    

  413.     stcSysClkCfg.enPclk3Div = ClkSysclkDiv4;  // Max 42MHz
    

  414.     stcSysClkCfg.enPclk4Div = ClkSysclkDiv2;  // Max 84MHz
    

  415.     CLK_SysClkConfig(&stcSysClkCfg);
    


  416. 

  417.     /* Switch system clock source to MPLL. */
    

  418.     /* Use Xtal32 as MPLL source. */
    

  419.     stcXtalCfg.enMode = ClkXtalModeOsc;
    

  420.     stcXtalCfg.enDrv = ClkXtalLowDrv;
    

  421.     stcXtalCfg.enFastStartup = Enable;
    

  422.     CLK_XtalConfig(&stcXtalCfg);
    

  423.     CLK_XtalCmd(Enable);
    


  424. 

  425.     /* MPLL config. */
    

  426.     stcMpllCfg.pllmDiv = 1u;
    

  427.     stcMpllCfg.plln =42u;
    

  428.     stcMpllCfg.PllpDiv = 2u;
    

  429.     stcMpllCfg.PllqDiv = 2u;
    

  430.     stcMpllCfg.PllrDiv = 2u;
    

  431.     CLK_SetPllSource(ClkPllSrcXTAL);
    

  432.     CLK_MpllConfig(&stcMpllCfg);
    


  433. 

  434.     /* flash read wait cycle setting */
    

  435.     EFM_Unlock();
    

  436.     EFM_SetLatency(EFM_LATENCY_5);
    

  437.     EFM_Lock();
    


  438. 

  439.     /* Enable MPLL. */
    

  440.     CLK_MpllCmd(Enable);
    


  441. 

  442.     /* Wait MPLL ready. */
    

  443.     while(Set != CLK_GetFlagStatus(ClkFlagMPLLRdy))
    

  444.     {
    

  445.       ;
    

  446.     }
    


  447. 

  448.     /* Switch system clock source to MPLL. */
    

  449.     CLK_SetSysClkSource(CLKSysSrcMPLL);
    

  450. }
    


  451. 

  452. /**
    

  453.  ******************************************************************************
    

  454.  ** \brief  Judge the result. LED0 toggle when result is error status.
    

  455.  **
    

  456.  ** \param  u8Result
    

  457.  **
    

  458.  ** \retval None
    

  459.  ******************************************************************************/
    

  460. static void JudgeResult(uint8_t u8Result)
    

  461. {
    

  462.     if(I2C_RET_ERROR == u8Result)
    

  463.     {
    

  464.         while(1)
    

  465.         {
    

  466.             LED0_TOGGLE();
    

  467.             Ddl_Delay1ms(500ul);
    

  468.         }
    

  469.     }
    

  470. }
    


  471. 

  472. /**
    

  473.  *******************************************************************************
    

  474.  ** \brief  Main function of template project
    

  475.  **
    

  476.  ** \param  None
    

  477.  **
    

  478.  ** \retval int32_t return value, if needed
    

  479.  **
    

  480.  ******************************************************************************/
    

  481. int32_t main(void)
    

  482. {
    

  483.     uint8_t u8TxBuf[PAGE_LEN];
    

  484.     uint8_t u8RxBuf[PAGE_LEN];
    

  485.     uint32_t i;
    

  486.     uint8_t u8Ret = I2C_RET_OK;
    

  487.     stc_port_init_t stcPortInit;
    


  488. 

  489.     for(i=0ul; i<PAGE_LEN; i++)
    

  490.     {
    

  491.         u8TxBuf[i] = (uint8_t)i+1u;
    

  492.     }
    

  493.     memset(u8RxBuf, 0x00, PAGE_LEN);
    


  494. 

  495.     /* Initialize system clock*/
    

  496.     SysClkIni();
    


  497. 

  498.     /*initiallize LED port*/
    

  499.     MEM_ZERO_STRUCT(stcPortInit);
    


  500. 

  501.     stcPortInit.enPinMode = Pin_Mode_Out;
    

  502.     stcPortInit.enExInt = Enable;
    

  503.     stcPortInit.enPullUp = Enable;
    


  504. 

  505.     /* LED0 Port/Pin initialization */
    

  506.     PORT_Init(LED0_PORT, LED0_PIN, &stcPortInit);
    


  507. 

  508.     /* LED1 Port/Pin initialization */
    

  509.     PORT_Init(LED1_PORT, LED1_PIN, &stcPortInit);
    


  510. 

  511.     /* Initialize I2C port*/
    

  512.     PORT_SetFunc(I2C1_SCL_PORT, I2C1_SCL_PIN, Func_I2c1_Scl, Disable);
    

  513.     PORT_SetFunc(I2C1_SDA_PORT, I2C1_SDA_PIN, Func_I2c1_Sda, Disable);
    


  514. 

  515.     /* Enable I2C Peripheral*/
    

  516.     PWC_Fcg1PeriphClockCmd(PWC_FCG1_PERIPH_I2C1, Enable);
    

  517.     /* Initialize I2C peripheral and enable function*/
    

  518.     E2_Initialize();
    


  519. 

  520.     /* E2prom byte write*/
    

  521.     u8Ret = E2_StartOrRestart(GENERATE_START);
    

  522.     JudgeResult(u8Ret);
    

  523.     u8Ret = E2_SendAdr((uint8_t)(E2_ADDRESS<<1u)|E2_ADDRESS_W);
    

  524.     JudgeResult(u8Ret);
    

  525.     u8Ret = E2_SendDataAdr(DATA_TEST_ADDR);
    

  526.     JudgeResult(u8Ret);
    

  527.     u8Ret = E2_WriteData(u8TxBuf, 1u);
    

  528.     JudgeResult(u8Ret);
    

  529.     u8Ret = E2_Stop();
    

  530.     JudgeResult(u8Ret);
    


  531. 

  532.     /* 5mS delay for e2prom*/
    

  533.     Ddl_Delay1ms(5ul);
    


  534. 

  535.     /* E2prom ramdom read*/
    

  536.     u8Ret = E2_StartOrRestart(GENERATE_START);
    

  537.     JudgeResult(u8Ret);
    

  538.     u8Ret = E2_SendAdr((uint8_t)(E2_ADDRESS<<1u)|E2_ADDRESS_W);
    

  539.     JudgeResult(u8Ret);
    

  540.     u8Ret = E2_SendDataAdr(DATA_TEST_ADDR);
    

  541.     JudgeResult(u8Ret);
    


  542. 

  543.     u8Ret = E2_StartOrRestart(GENERATE_RESTART);
    

  544.     JudgeResult(u8Ret);
    

  545.     u8Ret = E2_SendAdr((uint8_t)(E2_ADDRESS<<1u)|E2_ADDRESS_R);
    

  546.     JudgeResult(u8Ret);
    

  547.     u8Ret = E2_RevData(u8RxBuf, 1u);
    

  548.     JudgeResult(u8Ret);
    

  549.     u8Ret = E2_Stop();
    

  550.     JudgeResult(u8Ret);
    


  551. 

  552.     /* Compare the data */
    

  553.     if(0x01u != u8RxBuf[0])
    

  554.     {
    

  555.         /* e2prom byte write error*/
    

  556.         while(1)
    

  557.         {
    

  558.             LED0_TOGGLE();
    

  559.             Ddl_Delay1ms(500ul);
    

  560.         }
    

  561.     }
    


  562. 

  563.     /* 5mS delay for e2prom*/
    

  564.     Ddl_Delay1ms(5ul);
    

  565.     /* E2prom page write*/
    

  566.     u8Ret = E2_StartOrRestart(GENERATE_START);
    

  567.     JudgeResult(u8Ret);
    

  568.     u8Ret = E2_SendAdr((uint8_t)(E2_ADDRESS<<1u)|E2_ADDRESS_W);
    

  569.     JudgeResult(u8Ret);
    

  570.     u8Ret = E2_SendDataAdr(DATA_TEST_ADDR);
    

  571.     JudgeResult(u8Ret);
    

  572.     u8Ret = E2_WriteData(u8TxBuf, PAGE_LEN);
    

  573.     JudgeResult(u8Ret);
    

  574.     u8Ret = E2_Stop();
    

  575.     JudgeResult(u8Ret);
    


  576. 

  577.     /* 5mS delay for e2prom*/
    

  578.     Ddl_Delay1ms(5ul);
    


  579. 

  580.     /* E2prom sequential read*/
    

  581.     u8Ret = E2_StartOrRestart(GENERATE_START);
    

  582.     JudgeResult(u8Ret);
    

  583.     u8Ret = E2_SendAdr((uint8_t)(E2_ADDRESS<<1u)|E2_ADDRESS_W);
    

  584.     JudgeResult(u8Ret);
    

  585.     u8Ret = E2_SendDataAdr(DATA_TEST_ADDR);
    

  586.     JudgeResult(u8Ret);
    


  587. 

  588.     u8Ret = E2_StartOrRestart(GENERATE_RESTART);
    

  589.     JudgeResult(u8Ret);
    

  590.     u8Ret = E2_SendAdr((uint8_t)(E2_ADDRESS<<1u)|E2_ADDRESS_R);
    

  591.     JudgeResult(u8Ret);
    

  592.     u8Ret = E2_RevData(u8RxBuf, PAGE_LEN);
    

  593.     JudgeResult(u8Ret);
    

  594.     u8Ret = E2_Stop();
    

  595.     JudgeResult(u8Ret);
    


  596. 

  597.     /* Compare the data */
    

  598.     for(i=0ul; i<PAGE_LEN; i++)
    

  599.     {
    

  600.         if(u8TxBuf[i] != u8RxBuf[i])
    

  601.         {
    

  602.             /* e2prom page write error*/
    

  603.             while(1)
    

  604.             {
    

  605.                 LED0_TOGGLE();
    

  606.                 Ddl_Delay1ms(500ul);
    

  607.             }
    

  608.         }
    

  609.     }
    


  610. 

  611.     /* e2prom sample success*/
    

  612.     while(1)
    

  613.     {
    

  614.         LED1_TOGGLE();
    

  615.         Ddl_Delay1ms(500ul);
    

  616.     }
    

  617. }
    


  618. 

  619. /*******************************************************************************
    

  620.  * EOF (not truncated)
    

  621.  ******************************************************************************/
效果图：
1.jpg
板子上LED2闪烁，读写正常。
回复

收藏 举报

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

本版积分规则

Cjy_JDxy
个人签名：绿水本无忧因风皱面，青山原不老为雪白头。

553

主题

3530

帖子

20

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