STM32072B_EVAL BSP User Manual: stm32072b_eval_eeprom.c Source File

STM32072B EVAL BSP Drivers

stm32072b_eval_eeprom.c
Go to the documentation of this file.
00001 /**
00002 ******************************************************************************
00003 * @file    stm32072b_eval_eeprom.c
00004 * @author  MCD Application Team
00005 * @brief   This file provides a set of functions needed to manage a M24LR64 
00006 *          I2C EEPROM memory.
00007 *          
00008 *          =================================================================== 
00009 *          Notes:
00010 *           - This driver is intended for STM32F0xx families devices only.     
00011 *           - The I2C EEPROM memory (M24LR64) is available on separate daughter 
00012 *             board ANT7-M24LR-A, which is provided with the STM32072B 
00013 *             EVAL board.
00014 *             To use this driver with M24LR64, you have to connect
00015 *             the ANT7-M24LR-A to CN2 connector of STM32072B EVAL board.
00016 *          ===================================================================
00017 *              
00018 *          It implements a high level communication layer for read and write 
00019 *          from/to this memory. The needed STM32F0xx hardware resources (I2C
00020 *          and GPIO) are defined in stm32072b_eval.h file,
00021 *          and the initialization is performed depending of EEPROMs
00022 *          in EEPROM_IO_Init() function declared in stm32072b_eval.c file.
00023 *          You can easily tailor this driver to any other development board, 
00024 *          by just adapting the defines for hardware resources and 
00025 *          EEPROM_IO_Init() function. 
00026 *             
00027 *          @note In this driver, basic read and write functions
00028 *          (BSP_EEPROM_ReadBuffer() and BSP_EEPROM_WriteBuffer())
00029 *          use Polling mode to perform the data transfer to/from EEPROM memories.
00030 
00031 *     +-----------------------------------------------------------------+
00032 *     |               Pin assignment for M24LR64 EEPROM                 |
00033 *     +---------------------------------------+-----------+-------------+
00034 *     |  STM32F0xx I2C Pins                   |   EEPROM  |   Pin       |
00035 *     +---------------------------------------+-----------+-------------+
00036 *     | EEPROM_I2C_SDA_PIN (PB7)/ SDA         |   SDA     |    1        |
00037 *     | .                                     |   NC      |    2        |
00038 *     | EEPROM_I2C_SCL_PIN/ SCL               |   SCL     |    3        |
00039 *     | EX_RESET(PD7)                         |   RESET   |    4        |
00040 *     | .                                     |   VDD     |    5        |
00041 *     | .                                     |   NC      |    6        |
00042 *     | .                                     |   GND     |    7        |
00043 *     | .                                     |   NC      |    8        |
00044 *     +---------------------------------------+-----------+-------------+
00045 *
00046 ******************************************************************************
00047 * @attention
00048 *
00049 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
00050 *
00051 * Redistribution and use in source and binary forms, with or without modification,
00052 * are permitted provided that the following conditions are met:
00053 *   1. Redistributions of source code must retain the above copyright notice,
00054 *      this list of conditions and the following disclaimer.
00055 *   2. Redistributions in binary form must reproduce the above copyright notice,
00056 *      this list of conditions and the following disclaimer in the documentation
00057 *      and/or other materials provided with the distribution.
00058 *   3. Neither the name of STMicroelectronics nor the names of its contributors
00059 *      may be used to endorse or promote products derived from this software
00060 *      without specific prior written permission.
00061 *
00062 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00063 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00064 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00065 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00066 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00067 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00068 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00069 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00070 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00071 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00072 *
00073 ******************************************************************************
00074 */
00075 
00076 /* Includes ------------------------------------------------------------------*/
00077 #include "stm32072b_eval_eeprom.h"
00078 
00079 /** @addtogroup BSP
00080 * @{
00081 */
00082 
00083 /** @addtogroup STM32072B_EVAL
00084   * @{
00085   */
00086 
00087 /** @addtogroup STM32072B_EVAL_EEPROM
00088   * @brief      This file includes the I2C EEPROM driver 
00089   *             of STM32072B-EVAL board.
00090   * @{
00091   */
00092 
00093 /** @defgroup STM32072B_EVAL_EEPROM_Private_Variables Private Variables
00094   * @{
00095   */
00096 __IO uint16_t  EEPROMAddress = 0;
00097 __IO uint16_t  EEPROMPageSize = 0;
00098 __IO uint16_t  EEPROMDataRead;
00099 __IO uint8_t   EEPROMDataWrite;
00100 
00101 static EEPROM_DrvTypeDef *EEPROM_SelectedDevice = 0;
00102 /**
00103   * @}
00104   */ 
00105 
00106 /** @defgroup STM32072B_EVAL_EEPROM_Private_Functions Private Functions
00107   * @{
00108   */
00109 static uint32_t EEPROM_I2C_Init(void);
00110 static uint32_t EEPROM_I2C_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint32_t* NumByteToRead);
00111 static uint32_t EEPROM_I2C_WritePage(uint8_t* pBuffer, uint16_t WriteAddr, uint32_t* NumByteToWrite);
00112 static uint32_t EEPROM_I2C_WaitEepromStandbyState(void);
00113 
00114 /**
00115   * @}
00116   */ 
00117 
00118 /** @defgroup STM32072B_EVAL_EEPROM_Private_Types Private Types
00119   * @{
00120   */
00121 /* EEPROM I2C driver typedef */
00122 EEPROM_DrvTypeDef EEPROM_I2C_Drv =
00123 {
00124   EEPROM_I2C_Init,
00125   EEPROM_I2C_ReadBuffer,
00126   EEPROM_I2C_WritePage
00127 };
00128 /**
00129   * @}
00130   */
00131 
00132 /** @addtogroup STM32072B_EVAL_EEPROM_Exported_Functions
00133   * @{
00134   */
00135 
00136 /**
00137   * @brief  Initializes peripherals used by the I2C EEPROM driver.
00138   * 
00139   * @note There are 2 different versions of M24LR64 (A01 & A02).
00140   *             Then try to connect on 1st one (EEPROM_I2C_ADDRESS_A01) 
00141   *             and if problem, check the 2nd one (EEPROM_I2C_ADDRESS_A02)
00142   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00143   *         different from EEPROM_OK (0)
00144   */
00145 uint32_t BSP_EEPROM_Init(void)
00146 { 
00147   EEPROM_SelectedDevice = &EEPROM_I2C_Drv;
00148   if(EEPROM_SelectedDevice->Init != 0)
00149   {
00150     return (EEPROM_SelectedDevice->Init());
00151   }
00152   else
00153   {
00154     return EEPROM_FAIL;
00155   }
00156 }
00157 
00158 /**
00159   * @brief  Reads a block of data from the EEPROM device selected.
00160   * @param  pBuffer  pointer to the buffer that receives the data read from 
00161   *         the EEPROM.
00162   * @param  ReadAddr  EEPROM's internal address to start reading from.
00163   * @param  NumByteToRead  pointer to the variable holding number of bytes to 
00164   *         be read from the EEPROM.
00165   * 
00166   *        @note The variable pointed by NumByteToRead is reset to 0 when all the 
00167   *              data are read from the EEPROM. Application should monitor this 
00168   *              variable in order know when the transfer is complete.
00169   * 
00170   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00171   *         different from EEPROM_OK (0) or the timeout user callback.
00172   */
00173 uint32_t BSP_EEPROM_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint32_t* NumByteToRead)
00174 {
00175   if(EEPROM_SelectedDevice->ReadBuffer != 0)
00176   {
00177     return (EEPROM_SelectedDevice->ReadBuffer(pBuffer, ReadAddr, NumByteToRead));
00178   }
00179   else
00180   {
00181     return EEPROM_FAIL;
00182   }
00183 }
00184 
00185 /**
00186   * @brief  Writes buffer of data to the EEPROM device selected.
00187   * @param  pBuffer  pointer to the buffer  containing the data to be written 
00188   *         to the EEPROM.
00189   * @param  WriteAddr  EEPROM's internal address to write to.
00190   * @param  NumByteToWrite  number of bytes to write to the EEPROM.
00191   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00192   *         different from EEPROM_OK (0) or the timeout user callback.
00193   */
00194 uint32_t BSP_EEPROM_WriteBuffer(uint8_t* pBuffer, uint16_t WriteAddr, uint32_t NumByteToWrite)
00195 {
00196   uint16_t numofpage = 0, numofsingle = 0, count = 0;
00197   uint16_t addr = 0;
00198   uint32_t dataindex = 0;
00199   uint32_t status = EEPROM_OK;
00200 
00201   addr = WriteAddr % EEPROMPageSize;
00202   count = EEPROMPageSize - addr;
00203   numofpage =  NumByteToWrite / EEPROMPageSize;
00204   numofsingle = NumByteToWrite % EEPROMPageSize;
00205 
00206   if(EEPROM_SelectedDevice->WritePage == 0)
00207   {
00208     return EEPROM_FAIL;
00209   }
00210   
00211   /*!< If WriteAddr is EEPROM_PAGESIZE aligned  */
00212   if(addr == 0) 
00213   {
00214     /*!< If NumByteToWrite < EEPROM_PAGESIZE */
00215     if(numofpage == 0) 
00216     {
00217       /* Store the number of data to be written */
00218       dataindex = numofsingle;
00219       /* Start writing data */
00220       status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00221       if (status != EEPROM_OK)
00222       {
00223         return status;
00224       }
00225     }
00226     /*!< If NumByteToWrite > EEPROM_PAGESIZE */
00227     else  
00228     {
00229       while(numofpage--)
00230       {
00231         /* Store the number of data to be written */
00232         dataindex = EEPROMPageSize;        
00233         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00234         if (status != EEPROM_OK)
00235         {
00236           return status;
00237         }
00238         
00239         WriteAddr +=  EEPROMPageSize;
00240         pBuffer += EEPROMPageSize;
00241       }
00242 
00243       if(numofsingle!=0)
00244       {
00245         /* Store the number of data to be written */
00246         dataindex = numofsingle;          
00247         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00248         if (status != EEPROM_OK)
00249         {
00250           return status;
00251         }
00252       }
00253     }
00254   }
00255   /*!< If WriteAddr is not EEPROM_PAGESIZE aligned  */
00256   else 
00257   {
00258     /*!< If NumByteToWrite < EEPROM_PAGESIZE */
00259     if(numofpage== 0) 
00260     {
00261       /*!< If the number of data to be written is more than the remaining space 
00262       in the current page: */
00263       if (NumByteToWrite > count)
00264       {
00265         /* Store the number of data to be written */
00266         dataindex = count;        
00267         /*!< Write the data contained in same page */
00268         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00269         if (status != EEPROM_OK)
00270         {
00271           return status;
00272         }
00273         
00274         /* Store the number of data to be written */
00275         dataindex = (NumByteToWrite - count);          
00276         /*!< Write the remaining data in the following page */
00277         status = EEPROM_SelectedDevice->WritePage((uint8_t*)(pBuffer + count), (WriteAddr + count), (uint32_t*)(&dataindex));
00278         if (status != EEPROM_OK)
00279         {
00280           return status;
00281         }
00282       }
00283       else      
00284       {
00285         /* Store the number of data to be written */
00286         dataindex = numofsingle;         
00287         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00288         if (status != EEPROM_OK)
00289         {
00290           return status;
00291         }
00292       }
00293     }
00294     /*!< If NumByteToWrite > EEPROM_PAGESIZE */
00295     else
00296     {
00297       NumByteToWrite -= count;
00298       numofpage =  NumByteToWrite / EEPROMPageSize;
00299       numofsingle = NumByteToWrite % EEPROMPageSize;
00300       
00301       if(count != 0)
00302       {  
00303         /* Store the number of data to be written */
00304         dataindex = count;         
00305         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00306         if (status != EEPROM_OK)
00307         {
00308           return status;
00309         }
00310         WriteAddr += count;
00311         pBuffer += count;
00312       } 
00313       
00314       while(numofpage--)
00315       {
00316         /* Store the number of data to be written */
00317         dataindex = EEPROMPageSize;          
00318         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00319         if (status != EEPROM_OK)
00320         {
00321           return status;
00322         }
00323         WriteAddr +=  EEPROMPageSize;
00324         pBuffer += EEPROMPageSize;  
00325       }
00326       if(numofsingle != 0)
00327       {
00328         /* Store the number of data to be written */
00329         dataindex = numofsingle;           
00330         status = EEPROM_SelectedDevice->WritePage(pBuffer, WriteAddr, (uint32_t*)(&dataindex));
00331         if (status != EEPROM_OK)
00332         {
00333           return status;
00334         }
00335       }
00336     }
00337   }
00338   
00339   /* If all operations OK, return EEPROM_OK (0) */
00340   return EEPROM_OK;
00341 }
00342 
00343 /**
00344   * @brief  Basic management of the timeout situation.
00345   * @retval None.
00346   */
00347 __weak void BSP_EEPROM_TIMEOUT_UserCallback(void)
00348 {
00349 }
00350 /**
00351   * @}
00352   */
00353 
00354 /** @addtogroup STM32072B_EVAL_EEPROM_Private_Functions
00355   * @{
00356   */ 
00357 
00358 /**
00359   * @brief  Initializes peripherals used by the I2C EEPROM driver.
00360   * 
00361   * @note There are 2 different versions of M24LR64 (A01 & A02).
00362   *             Then try to connect on 1st one (EEPROM_I2C_ADDRESS_A01) 
00363   *             and if problem, check the 2nd one (EEPROM_I2C_ADDRESS_A02)
00364   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00365   *         different from EEPROM_OK (0)
00366   */
00367 static uint32_t EEPROM_I2C_Init(void)
00368 {
00369   EEPROM_IO_Init();
00370 
00371   /*Select the EEPROM address for M24LR64 A02 and check if OK*/
00372   EEPROMAddress = EEPROM_ADDRESS_M24LR64_A01;
00373   EEPROMPageSize = EEPROM_PAGESIZE_M24LR64;
00374   if (EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
00375   {
00376     /*Select the EEPROM address for M24LR64 A01 and check if OK*/
00377     EEPROMAddress = EEPROM_ADDRESS_M24LR64_A02;
00378     EEPROMPageSize = EEPROM_PAGESIZE_M24LR64;
00379     if (EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
00380     {
00381       return EEPROM_FAIL;
00382     }
00383   }
00384 
00385   return EEPROM_OK;
00386 }
00387 
00388 /**
00389   * @brief  Reads a block of data from the I2C EEPROM.
00390   * @param  pBuffer  pointer to the buffer that receives the data read from 
00391   *         the EEPROM.
00392   * @param  ReadAddr  EEPROM's internal address to start reading from.
00393   * @param  NumByteToRead  pointer to the variable holding number of bytes to 
00394   *         be read from the EEPROM.
00395   * 
00396   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00397   *         different from EEPROM_OK (0) or the timeout user callback.
00398   */
00399 static uint32_t EEPROM_I2C_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint32_t* NumByteToRead)
00400 {  
00401   uint32_t buffersize = *NumByteToRead;
00402   
00403   if (EEPROM_IO_ReadData(EEPROMAddress, ReadAddr, pBuffer, buffersize) != HAL_OK)
00404   {
00405     return EEPROM_FAIL;
00406   }
00407   
00408   /* If all operations OK, return EEPROM_OK (0) */
00409   return EEPROM_OK;
00410 }
00411 
00412 /**
00413   * @brief  Writes more than one byte to the EEPROM with a single WRITE cycle.
00414   *
00415   * @note   The number of bytes (combined to write start address) must not 
00416   *         cross the EEPROM page boundary. This function can only write into
00417   *         the boundaries of an EEPROM page.
00418   *         This function doesn't check on boundaries condition (in this driver 
00419   *         the function BSP_EEPROM_WriteBuffer() which calls EEPROM_WritePage() is 
00420   *         responsible of checking on Page boundaries).
00421   * 
00422   * @param  pBuffer  pointer to the buffer containing the data to be written to 
00423   *         the EEPROM.
00424   * @param  WriteAddr  EEPROM's internal address to write to.
00425   * @param  NumByteToWrite  pointer to the variable holding number of bytes to 
00426   *         be written into the EEPROM. 
00427   * 
00428   *        @note The variable pointed by NumByteToWrite is reset to 0 when all the 
00429   *              data are written to the EEPROM. Application should monitor this 
00430   *              variable in order know when the transfer is complete.
00431   * 
00432   * 
00433   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00434   *         different from EEPROM_OK (0) or the timeout user callback.
00435   */
00436 static uint32_t EEPROM_I2C_WritePage(uint8_t* pBuffer, uint16_t WriteAddr, uint32_t* NumByteToWrite)
00437 { 
00438   uint32_t buffersize = *NumByteToWrite;
00439 
00440   if (EEPROM_IO_WriteData(EEPROMAddress, WriteAddr, pBuffer, buffersize) != HAL_OK)
00441   {
00442     return EEPROM_FAIL;
00443   }
00444   
00445   /* Wait for EEPROM Standby state */
00446   if (EEPROM_I2C_WaitEepromStandbyState() != EEPROM_OK) 
00447   {
00448     return EEPROM_FAIL;
00449   }
00450   
00451   return EEPROM_OK;
00452 }
00453 
00454 /**
00455   * @brief  Wait for EEPROM I2C Standby state.
00456   * 
00457   * @note  This function allows to wait and check that EEPROM has finished the 
00458   *        last operation. It is mostly used after Write operation: after receiving
00459   *        the buffer to be written, the EEPROM may need additional time to actually
00460   *        perform the write operation. During this time, it doesn't answer to
00461   *        I2C packets addressed to it. Once the write operation is complete
00462   *        the EEPROM responds to its address.
00463   * 
00464   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00465   *         different from EEPROM_OK (0) or the timeout user callback.
00466   */
00467 static uint32_t EEPROM_I2C_WaitEepromStandbyState(void)  
00468 {
00469   /* Check if the maximum allowed number of trials has bee reached */
00470   if (EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK)
00471   {
00472     /* If the maximum number of trials has been reached, exit the function */
00473     BSP_EEPROM_TIMEOUT_UserCallback();
00474     return EEPROM_TIMEOUT;
00475   }
00476   return EEPROM_OK;
00477 }
00478 
00479 /**
00480   * @}
00481   */
00482 
00483 /**
00484   * @}
00485   */
00486 
00487 /**
00488   * @}
00489   */
00490 
00491 /**
00492   * @}
00493   */  
00494 
00495 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Generated on Wed Jul 5 2017 08:56:10 for STM32072B_EVAL BSP User Manual by   doxygen 1.7.6.1