Klon STM32 ve eeprom emulasyonu

Başlatan Mucit23, 12 Aralık 2019, 02:22:44

Mucit23

Selamlar

STM32'de eeprom ihtiyacım oldu. Daha önce birçok defa Flash hafızayı eeprom olarak kullandığım uygulamalar oldu. Şimdi benzer bir ihtiyaçtan dolayı aynı uygulamayı yapmak istedim. Elimde mini STM32 kiti var ve üzerinde muhtemelen klon STM32F103C8 çipi var.

Daha önce birçok defa yaptığım uygulama bu çipte çalışmıyor. Acaba hafıza bölgesinde mi sorun var anlayamadım. Uyguladığım kütüphane budur.

eeprom.c
/**
  ******************************************************************************
  * @file    EEPROM_Emulation/src/eeprom.c 
  * @author  MCD Application Team
  * @version V3.1.0
  * @date    07/27/2009
  * @brief   This file provides all the EEPROM emulation firmware functions.
  ******************************************************************************
  * @copy
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2009 STMicroelectronics</center></h2>
  */ 
/** @addtogroup EEPROM_Emulation
  * @{
  */ 

/* Includes ------------------------------------------------------------------*/
#include "eeprom.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

/* Global variable used to store variable value in read sequence */
uint16_t DataVar 0;

/* Virtual address defined by the user: 0xFFFF value is prohibited */
extern uint16_t VirtAddVarTab[NumbOfVar];

/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
static FLASH_Status EE_Format(void);
static 
uint16_t EE_FindValidPage(uint8_t Operation);
static 
uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddressuint16_t Data);
static 
uint16_t EE_PageTransfer(uint16_t VirtAddressuint16_t Data);

/**
  * @brief  Restore the pages to a known good state in case of page's status
  *   corruption after a power loss.
  * @param  None.
  * @retval - Flash error code: on write Flash error
  *         - FLASH_COMPLETE: on success
  */
uint16_t EE_Init(void)
{
  
uint16_t PageStatus0 6PageStatus1 6;
  
uint16_t VarIdx 0;
  
uint16_t EepromStatus 0ReadStatus 0;
  
int16_t x = -1;
  
uint16_t  FlashStatus;

  
/* Get Page0 status */
  
PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
  
/* Get Page1 status */
  
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);

  
/* Check for invalid header states and repair if necessary */
  
switch (PageStatus0)
  {
    case 
ERASED:
      if (
PageStatus1 == VALID_PAGE/* Page0 erased, Page1 valid */
      
{
        
/* Erase Page0 */
        
FlashStatus FLASH_ErasePage(PAGE0_BASE_ADDRESS);
        
/* If erase operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      else if (
PageStatus1 == RECEIVE_DATA/* Page0 erased, Page1 receive */
      
{
        
/* Erase Page0 */
        
FlashStatus FLASH_ErasePage(PAGE0_BASE_ADDRESS);
        
/* If erase operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
        
/* Mark Page1 as valid */
        
FlashStatus FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESSVALID_PAGE);
        
/* If program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      else 
/* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
      
{
        
/* Erase both Page0 and Page1 and set Page0 as valid page */
        
FlashStatus EE_Format();
        
/* If erase/program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      break;

    case 
RECEIVE_DATA:
      if (
PageStatus1 == VALID_PAGE/* Page0 receive, Page1 valid */
      
{
        
/* Transfer data from Page1 to Page0 */
        
for (VarIdx 0VarIdx NumbOfVarVarIdx++)
        {
          if (( *(
__IO uint16_t*)(PAGE0_BASE_ADDRESS 6)) == VirtAddVarTab[VarIdx])
          {
            
VarIdx;
          }
          if (
VarIdx != x)
          {
            
/* Read the last variables' updates */
            
ReadStatus EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
            
/* In case variable corresponding to the virtual address was found */
            
if (ReadStatus != 0x1)
            {
              
/* Transfer the variable to the Page0 */
              
EepromStatus EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
              
/* If program operation was failed, a Flash error code is returned */
              
if (EepromStatus != FLASH_COMPLETE)
              {
                return 
EepromStatus;
              }
            }
          }
        }
        
/* Mark Page0 as valid */
        
FlashStatus FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESSVALID_PAGE);
        
/* If program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
        
/* Erase Page1 */
        
FlashStatus FLASH_ErasePage(PAGE1_BASE_ADDRESS);
        
/* If erase operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      else if (
PageStatus1 == ERASED/* Page0 receive, Page1 erased */
      
{
        
/* Erase Page1 */
        
FlashStatus FLASH_ErasePage(PAGE1_BASE_ADDRESS);
        
/* If erase operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
        
/* Mark Page0 as valid */
        
FlashStatus FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESSVALID_PAGE);
        
/* If program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      else 
/* Invalid state -> format eeprom */
      
{
        
/* Erase both Page0 and Page1 and set Page0 as valid page */
        
FlashStatus EE_Format();
        
/* If erase/program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      break;

    case 
VALID_PAGE:
      if (
PageStatus1 == VALID_PAGE/* Invalid state -> format eeprom */
      
{
        
/* Erase both Page0 and Page1 and set Page0 as valid page */
        
FlashStatus EE_Format();
        
/* If erase/program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      else if (
PageStatus1 == ERASED/* Page0 valid, Page1 erased */
      
{
        
/* Erase Page1 */
        
FlashStatus FLASH_ErasePage(PAGE1_BASE_ADDRESS);
        
/* If erase operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      else 
/* Page0 valid, Page1 receive */
      
{
        
/* Transfer data from Page0 to Page1 */
        
for (VarIdx 0VarIdx NumbOfVarVarIdx++)
        {
          if ((*(
__IO uint16_t*)(PAGE1_BASE_ADDRESS 6)) == VirtAddVarTab[VarIdx])
          {
            
VarIdx;
          }
          if (
VarIdx != x)
          {
            
/* Read the last variables' updates */
            
ReadStatus EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
            
/* In case variable corresponding to the virtual address was found */
            
if (ReadStatus != 0x1)
            {
              
/* Transfer the variable to the Page1 */
              
EepromStatus EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
              
/* If program operation was failed, a Flash error code is returned */
              
if (EepromStatus != FLASH_COMPLETE)
              {
                return 
EepromStatus;
              }
            }
          }
        }
        
/* Mark Page1 as valid */
        
FlashStatus FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESSVALID_PAGE);
        
/* If program operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
        
/* Erase Page0 */
        
FlashStatus FLASH_ErasePage(PAGE0_BASE_ADDRESS);
        
/* If erase operation was failed, a Flash error code is returned */
        
if (FlashStatus != FLASH_COMPLETE)
        {
          return 
FlashStatus;
        }
      }
      break;

    default:  
/* Any other state -> format eeprom */
      /* Erase both Page0 and Page1 and set Page0 as valid page */
      
FlashStatus EE_Format();
      
/* If erase/program operation was failed, a Flash error code is returned */
      
if (FlashStatus != FLASH_COMPLETE)
      {
        return 
FlashStatus;
      }
      break;
  }

  return 
FLASH_COMPLETE;
}

/**
  * @brief  Returns the last stored variable data, if found, which correspond to
  *   the passed virtual address
  * @param  VirtAddress: Variable virtual address
  * @param  Data: Global variable contains the read variable value
  * @retval Success or error status:
  *           - 0: if variable was found
  *           - 1: if the variable was not found
  *           - NO_VALID_PAGE: if no valid page was found.
  */
uint16_t EE_ReadVariable(uint16_t VirtAddressuint16_tData)
{
  
uint16_t ValidPage PAGE0;
  
uint16_t AddressValue 0x5555ReadStatus 1;
  
uint32_t Address 0x08010000PageStartAddress 0x08010000;

  
/* Get active Page for read operation */
  
ValidPage EE_FindValidPage(READ_FROM_VALID_PAGE);

  
/* Check if there is no valid page */
  
if (ValidPage == NO_VALID_PAGE)
  {
    return  
NO_VALID_PAGE;
  }

  
/* Get the valid Page start Address */
  
PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage PAGE_SIZE));

  
/* Get the valid Page end Address */
  
Address = (uint32_t)((EEPROM_START_ADDRESS 2) + (uint32_t)((ValidPage) * PAGE_SIZE));

  
/* Check each active page address starting from end */
  
while (Address > (PageStartAddress 2))
  {
    
/* Get the current location content to be compared with virtual address */
    
AddressValue = (*(__IO uint16_t*)Address);

    
/* Compare the read address with the virtual address */
    
if (AddressValue == VirtAddress)
    {
      
/* Get content of Address-2 which is variable value */
      
*Data = (*(__IO uint16_t*)(Address 2));

      
/* In case variable value is read, reset ReadStatus flag */
      
ReadStatus 0;

      break;
    }
    else
    {
      
/* Next address location */
      
Address Address 4;
    }
  }

  
/* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
  
return ReadStatus;
}

/**
  * @brief  Writes/upadtes variable data in EEPROM.
  * @param  VirtAddress: Variable virtual address
  * @param  Data: 16 bit data to be written
  * @retval Success or error status:
  *           - FLASH_COMPLETE: on success
  *           - PAGE_FULL: if valid page is full
  *           - NO_VALID_PAGE: if no valid page was found
  *           - Flash error code: on write Flash error
  */
uint16_t EE_WriteVariable(uint16_t VirtAddressuint16_t Data)
{
  
uint16_t Status 0;

  
/* Write the variable virtual address and value in the EEPROM */
  
Status EE_VerifyPageFullWriteVariable(VirtAddressData);

  
/* In case the EEPROM active page is full */
  
if (Status == PAGE_FULL)
  {
    
/* Perform Page transfer */
    
Status EE_PageTransfer(VirtAddressData);
  }

  
/* Return last operation status */
  
return Status;
}

/**
  * @brief  Erases PAGE0 and PAGE1 and writes VALID_PAGE header to PAGE0
  * @param  None
  * @retval Status of the last operation (Flash write or erase) done during
  *         EEPROM formating
  */
static FLASH_Status EE_Format(void)
{
  
FLASH_Status FlashStatus FLASH_COMPLETE;

  
/* Erase Page0 */
  
FlashStatus FLASH_ErasePage(PAGE0_BASE_ADDRESS);

  
/* If erase operation was failed, a Flash error code is returned */
  
if (FlashStatus != FLASH_COMPLETE)
  {
    return 
FlashStatus;
  }

  
/* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
  
FlashStatus FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESSVALID_PAGE);

  
/* If program operation was failed, a Flash error code is returned */
  
if (FlashStatus != FLASH_COMPLETE)
  {
    return 
FlashStatus;
  }

  
/* Erase Page1 */
  
FlashStatus FLASH_ErasePage(PAGE1_BASE_ADDRESS);

  
/* Return Page1 erase operation status */
  
return FlashStatus;
}

/**
  * @brief  Find valid Page for write or read operation
  * @param  Operation: operation to achieve on the valid page.
  *   This parameter can be one of the following values:
  *     @arg READ_FROM_VALID_PAGE: read operation from valid page
  *     @arg WRITE_IN_VALID_PAGE: write operation from valid page
  * @retval Valid page number (PAGE0 or PAGE1) or NO_VALID_PAGE in case
  *   of no valid page was found
  */
static uint16_t EE_FindValidPage(uint8_t Operation)
{
  
uint16_t PageStatus0 6PageStatus1 6;

  
/* Get Page0 actual status */
  
PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);

  
/* Get Page1 actual status */
  
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);

  
/* Write or read operation */
  
switch (Operation)
  {
    case 
WRITE_IN_VALID_PAGE:   /* ---- Write operation ---- */
      
if (PageStatus1 == VALID_PAGE)
      {
        
/* Page0 receiving data */
        
if (PageStatus0 == RECEIVE_DATA)
        {
          return 
PAGE0;         /* Page0 valid */
        
}
        else
        {
          return 
PAGE1;         /* Page1 valid */
        
}
      }
      else if (
PageStatus0 == VALID_PAGE)
      {
        
/* Page1 receiving data */
        
if (PageStatus1 == RECEIVE_DATA)
        {
          return 
PAGE1;         /* Page1 valid */
        
}
        else
        {
          return 
PAGE0;         /* Page0 valid */
        
}
      }
      else
      {
        return 
NO_VALID_PAGE;   /* No valid Page */
      
}

    case 
READ_FROM_VALID_PAGE:  /* ---- Read operation ---- */
      
if (PageStatus0 == VALID_PAGE)
      {
        return 
PAGE0;           /* Page0 valid */
      
}
      else if (
PageStatus1 == VALID_PAGE)
      {
        return 
PAGE1;           /* Page1 valid */
      
}
      else
      {
        return 
NO_VALID_PAGE ;  /* No valid Page */
      
}

    default:
      return 
PAGE0;             /* Page0 valid */
  
}
}

/**
  * @brief  Verify if active page is full and Writes variable in EEPROM.
  * @param  VirtAddress: 16 bit virtual address of the variable
  * @param  Data: 16 bit data to be written as variable value
  * @retval Success or error status:
  *           - FLASH_COMPLETE: on success
  *           - PAGE_FULL: if valid page is full
  *           - NO_VALID_PAGE: if no valid page was found
  *           - Flash error code: on write Flash error
  */
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddressuint16_t Data)
{
  
FLASH_Status FlashStatus FLASH_COMPLETE;
  
uint16_t ValidPage PAGE0;
  
uint32_t Address 0x08010000PageEndAddress 0x080107FF;

  
/* Get valid Page for write operation */
  
ValidPage EE_FindValidPage(WRITE_IN_VALID_PAGE);

  
/* Check if there is no valid page */
  
if (ValidPage == NO_VALID_PAGE)
  {
    return  
NO_VALID_PAGE;
  }

  
/* Get the valid Page start Address */
  
Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage PAGE_SIZE));

  
/* Get the valid Page end Address */
  
PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS 2) + (uint32_t)((ValidPage) * PAGE_SIZE));

  
/* Check each active page address starting from begining */
  
while (Address PageEndAddress)
  {
    
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */
    
if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF)
    {
      
/* Set variable data */
      
FlashStatus FLASH_ProgramHalfWord(AddressData);
      
/* If program operation was failed, a Flash error code is returned */
      
if (FlashStatus != FLASH_COMPLETE)
      {
        return 
FlashStatus;
      }
      
/* Set variable virtual address */
      
FlashStatus FLASH_ProgramHalfWord(Address 2VirtAddress);
      
/* Return program operation status */
      
return FlashStatus;
    }
    else
    {
      
/* Next address location */
      
Address Address 4;
    }
  }

  
/* Return PAGE_FULL in case the valid page is full */
  
return PAGE_FULL;
}

/**
  * @brief  Transfers last updated variables data from the full Page to
  *   an empty one.
  * @param  VirtAddress: 16 bit virtual address of the variable
  * @param  Data: 16 bit data to be written as variable value
  * @retval Success or error status:
  *           - FLASH_COMPLETE: on success
  *           - PAGE_FULL: if valid page is full
  *           - NO_VALID_PAGE: if no valid page was found
  *           - Flash error code: on write Flash error
  */
static uint16_t EE_PageTransfer(uint16_t VirtAddressuint16_t Data)
{
  
FLASH_Status FlashStatus FLASH_COMPLETE;
  
uint32_t NewPageAddress 0x080103FFOldPageAddress 0x08010000;
  
uint16_t ValidPage PAGE0VarIdx 0;
  
uint16_t EepromStatus 0ReadStatus 0;

  
/* Get active Page for read operation */
  
ValidPage EE_FindValidPage(READ_FROM_VALID_PAGE);

  if (
ValidPage == PAGE1)       /* Page1 valid */
  
{
    
/* New page address where variable will be moved to */
    
NewPageAddress PAGE0_BASE_ADDRESS;

    
/* Old page address where variable will be taken from */
    
OldPageAddress PAGE1_BASE_ADDRESS;
  }
  else if (
ValidPage == PAGE0)  /* Page0 valid */
  
{
    
/* New page address where variable will be moved to */
    
NewPageAddress PAGE1_BASE_ADDRESS;

    
/* Old page address where variable will be taken from */
    
OldPageAddress PAGE0_BASE_ADDRESS;
  }
  else
  {
    return 
NO_VALID_PAGE;       /* No valid Page */
  
}

  
/* Set the new Page status to RECEIVE_DATA status */
  
FlashStatus FLASH_ProgramHalfWord(NewPageAddressRECEIVE_DATA);
  
/* If program operation was failed, a Flash error code is returned */
  
if (FlashStatus != FLASH_COMPLETE)
  {
    return 
FlashStatus;
  }

  
/* Write the variable passed as parameter in the new active page */
  
EepromStatus EE_VerifyPageFullWriteVariable(VirtAddressData);
  
/* If program operation was failed, a Flash error code is returned */
  
if (EepromStatus != FLASH_COMPLETE)
  {
    return 
EepromStatus;
  }

  
/* Transfer process: transfer variables from old to the new active page */
  
for (VarIdx 0VarIdx NumbOfVarVarIdx++)
  {
    if (
VirtAddVarTab[VarIdx] != VirtAddress)  /* Check each variable except the one passed as parameter */
    
{
      
/* Read the other last variable updates */
      
ReadStatus EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
      
/* In case variable corresponding to the virtual address was found */
      
if (ReadStatus != 0x1)
      {
        
/* Transfer the variable to the new active page */
        
EepromStatus EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
        
/* If program operation was failed, a Flash error code is returned */
        
if (EepromStatus != FLASH_COMPLETE)
        {
          return 
EepromStatus;
        }
      }
    }
  }

  
/* Erase the old Page: Set old Page status to ERASED status */
  
FlashStatus FLASH_ErasePage(OldPageAddress);
  
/* If erase operation was failed, a Flash error code is returned */
  
if (FlashStatus != FLASH_COMPLETE)
  {
    return 
FlashStatus;
  }

  
/* Set new Page status to VALID_PAGE status */
  
FlashStatus FLASH_ProgramHalfWord(NewPageAddressVALID_PAGE);
  
/* If program operation was failed, a Flash error code is returned */
  
if (FlashStatus != FLASH_COMPLETE)
  {
    return 
FlashStatus;
  }

  
/* Return last operation flash status */
  
return FlashStatus;
}

/**
  * @}
  */ 

/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/

eeprom.h
/**
  ******************************************************************************
  * @file    EEPROM_Emulation/inc/eeprom.h 
  * @author  MCD Application Team
  * @version V3.1.0
  * @date    07/27/2009
  * @brief   This file contains all the functions prototypes for the EEPROM 
  *          emulation firmware library.
  ******************************************************************************
  * @copy
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2009 STMicroelectronics</center></h2>
  */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __EEPROM_H
#define __EEPROM_H

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"

/* Exported constants --------------------------------------------------------*/
/* Define the STM32F10Xxx Flash page size depending on the used STM32 device */
#if defined (STM32F10X_LD) || defined (STM32F10X_MD)
  #define PAGE_SIZE  (uint16_t)0x400  /* Page size = 1KByte */
#elif defined (STM32F10X_HD) || defined (STM32F10X_CL)
  #define PAGE_SIZE  (uint16_t)0x800  /* Page size = 2KByte */
#endif

/* EEPROM start address in Flash */
#define EEPROM_START_ADDRESS    ((uint32_t)0x0800FC00) /* EEPROM emulation start address:
                                                  
after 64KByte of used Flash memory */

/* Pages 0 and 1 base and end addresses */
#define PAGE0_BASE_ADDRESS      ((uint32_t)(EEPROM_START_ADDRESS + 0x000))
#define PAGE0_END_ADDRESS       ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))

#define PAGE1_BASE_ADDRESS      ((uint32_t)(EEPROM_START_ADDRESS + PAGE_SIZE))
#define PAGE1_END_ADDRESS       ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))

/* Used Flash pages for EEPROM emulation */
#define PAGE0                   ((uint16_t)0x0000)
#define PAGE1                   ((uint16_t)0x0001)

/* No valid page define */
#define NO_VALID_PAGE           ((uint16_t)0x00AB)

/* Page status definitions */
#define ERASED                  ((uint16_t)0xFFFF)     /* PAGE is empty */
#define RECEIVE_DATA            ((uint16_t)0xEEEE)     /* PAGE is marked to receive data */
#define VALID_PAGE              ((uint16_t)0x0000)     /* PAGE containing valid data */

/* Valid pages in read and write defines */
#define READ_FROM_VALID_PAGE    ((uint8_t)0x00)
#define WRITE_IN_VALID_PAGE     ((uint8_t)0x01)

/* Page full define */
#define PAGE_FULL               ((uint8_t)0x80)

/* Variables' number */
#define NumbOfVar               ((uint8_t)0x03)

/* Exported types ------------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
uint16_t EE_Init(void);
uint16_t EE_ReadVariable(uint16_t VirtAddressuint16_tData);
uint16_t EE_WriteVariable(uint16_t VirtAddressuint16_t Data);

#endif /* __EEPROM_H */

/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/

Sanal Adres olarak 0x5555, 0x6666, 0x7777 gibi adresler tanımlıyorum. Bu adreslere data yazıp okuma yapıyorum. Düzgün çalışmıyor. Daima sıfır okuyorum.

hafızaya yazmadan önce FLASH_Unlock(); işlemini yapıyorum. Acaba başka atladığım birşey mi var emin değilim. İşlemciden şüphelendim. Bazı çiplerde hafıza bölgeleri sorunlu olabiliyor. Başka bir çiple deneyeceğim. Benzer sorun yaşayan oldumu?

Cemre.

Merhaba, üzerindeki işlemciyi inceleyin, GD32F103 gibi bir kodu vardır muhtemelen. Bir kez  Bluepill diye geçen kartın üzerinde bu işlemciyle karşılaşmıştık ve STM32 CubeIDE ile program atmaya izin vermiyordu.

Mucit23

Baktım şimdi stm32xx yazıyor ama yine şüpheliyim. Bu eeprom emulatörü ile Hafızada yazma okuma işleminin yapıldığını tam olarak nasıl test ederim. Sanal bir address tanımıyoruz ama gerçekte bu veri hangi sayfada hangi adrese yazılıyor? Yazma yapılıp yapılmadığını bu şekilde test etmek istiyorum.

izturk

ben bunu kullnıyorum çalışıyor hocam. forumdan bi konudan almıştım.
bi dene istersen

eeprom.h
#include "stm32f1xx_hal.h"


#ifndef eeprom_fonk
#define eeprom_fonk


#define EEPROM_START_ADDRESS ((uint32_t)0x08040000) //252. page
extern uint16_t eeprom_sabitleri[500],eeprom_sayac;


extern uint16_t seri_no;


uint16_t Read_Flash(uint32_t  adr);
void Unlock_Flash (void);
void Lock_Flash (void);
void Erase_Flash (uint32_t adr);
void Write_Flash (uint32_t adruint16_t data);
void eeprom_yaz(void);
void eeprom_oku(void);


#endif


eeprom.c
#include "eeprom.h"

uint8_t eeprom_bos_sayac=0;
//////////istenilen adresten veri okuma /////////////
uint16_t Read_Flash(uint32_t  adr)
{
  
uint16_t Pntr = (uint16_t *)adr;
  return(*
Pntr);  
}
///////////////// FLASH KILIDI AÇMA ALT PROGRAMI /////////////////////    
void Unlock_Flash (void)
{
  
FLASH->KEYR=0x45670123;  //Flash kilidini açmak için FLASH->KEYR registerine KEY1 ve KEY2 sirayla yazilmalidir
  
FLASH->KEYR=0xCDEF89AB;
}
///////////////// FLASH KILITLEME ALT PROGRAMI ///////////////////// 
void Lock_Flash (void)
{
  
FLASH->CR=0x00000080;  //FLASH_CR registeri resetlendiginde FLASH kiltlenmis olur
}
//////////////// ISTENILEN ADRESTEKI VERIYI FLASHTAN SILME ALT PROGRAMI //////
void Erase_Flash (uint32_t adr)
{
  
FLASH->CR|=0x00000002;            //PER enable
  
FLASH->AR=adr;                    //FLASH->AR registerine silinmek istenen adres yazilir
  
FLASH->CR|=0x00000040;            //STRT anable
  
for(uint32_t d=0;d<100000;d++);
  while((
FLASH->SR&0x00000001)){eeprom_bos_sayac++;}    //Islem bitene kadar bekle(BUSY kontrol ediliyor)
  
FLASH->CR &= ~0x00000042;        //FLASH->CR ilk durumuna aliniyor (kilit hala açik!) 
}
///////////////// ISTENILEN ADRESE VERI YAZMA ALT PROGRAMI /////////////////////
void Write_Flash (uint32_t adruint16_t data)
{
  
FLASH->CR|=0x00000001;          //PG enable
  
*(__IO uint16_t*)adr data;    //istenen adrese istenen data yaziliyor
  
while((FLASH->SR&0x00000001));  //Islem bitene kadar bekle(BUSY kontrol ediliyor)
}
void eeprom_yaz(void)
{
   
      
eeprom_sabitleri[191]= seri_no;
     
  
      
Unlock_Flash();
    
Erase_Flash(EEPROM_START_ADDRESS); 
    for(
eeprom_sayac=0;eeprom_sayac<=499;eeprom_sayac++)
    
Write_Flash(EEPROM_START_ADDRESS+(uint32_t)(eeprom_sayac*2),eeprom_sabitleri[eeprom_sayac]);
    
Lock_Flash(); 
}  

void eeprom_oku(void)
{
for(
eeprom_sayac=0;eeprom_sayac<=499;eeprom_sayac++)
  {
eeprom_sabitleri[eeprom_sayac]= Read_Flash(EEPROM_START_ADDRESS+(eeprom_sayac*2));

  }
  
  
  
seri_no eeprom_sabitleri[191];


}


RaMu

Stm103 klonunda deneyip çalıştırdığım
flasha yazma okuma yspan bir örneğim var.
Pc başında değilim yarına yollarım ancak.
Sorularınıza hızlı cevap alın: http://www.picproje.org/index.php/topic,57135.0.html

mg1980

@RaMu hocam, yollamak yerine sakıncası yoksa buraya koysanız bizler de yararlanırız...

Mucit23

Low Level Flash okuma yazma işlemini denedim çalışıyor. STM32F103C8'de 64'. page'yi bu iş için ayırdım. Fakat Silme yapılacağı zaman bilindiği üzere Sayfanın tamamı siliniyor. Çok sık yazma yapılmayacağından dolayı sorun olmaz sanırım. Eeprom emulator çalışmadı. Ayrıntılı bir debug yapmam lazım çözmek için 

RaMu

Alıntı yapılan: mg1980 - 12 Aralık 2019, 17:59:13@RaMu hocam, yollamak yerine sakıncası yoksa buraya koysanız bizler de yararlanırız...
Olmaz hocam :)
Tabiki forumda paylaşacağım her zamanki gibi.
Lafın gelişi yollarım yazmışım.

Çok bir şeyde değil zaten forumda paylaşılmış bir kodu düzenleyip kullanmıştım,
eeprom emülasyon kısmı vs. yok sadece flasha yazıp okuyor.
Sorularınıza hızlı cevap alın: http://www.picproje.org/index.php/topic,57135.0.html

RaMu

Program CubeMx ile oluşturulup
keil MDK ARM V5 ile yazıldı.

En altta main kısmının tamamı var.

Derlenmiş denemeye hazır isteyen olursa link:
http://www.mediafire.com/file/afxbaxu8oynla9a/BluePill_FlashReadWrite.7z/file


Ne yapıyor:
Program her yeniden basladiginda, eep start adr.indeki
Flash mem.i okur, bir arttirir, geri yazar, tekrar okur,
Bu sayi kadar PC13 ledini yakar sondurur,
Yani devre programlandigindan beri kac defa resetlendi sayar.

Ana programda kullanımı:
  /* USER CODE BEGIN 2 */
	
//---------------------------------------------
	
//program her yeniden basladiginda, eep start adr.indeki 
	
//flash mem.i okur, bir arttirir, geri yazar, tekrar okur, 
	
//bu sayi kadar PC13 ledini yakar sondurur, 
	
//yani devre programlandigindan beri kac defa resetlendi sayar.
	
	
deger_oku Read_Flash(EEPROM_START_ADDRESS);
	
	
deger_yaz deger_oku 1;

	
	
epprom_yaz(EEPROM_START_ADDRESS,deger_yaz);
	
	
deger_oku Read_Flash(EEPROM_START_ADDRESS);

	
	
led_2(deger_oku,500);
	

	
	
led_1(deger_oku,500);
	
	

	
//---------------------------------------------
	

  /* USER CODE END 2 */

Kullanılan fonksiyonlar:
/* USER CODE BEGIN 4 */
void led_1(uint32_t cntuint32_t time)
{
	
if(
cnt>10)
	
cnt 10;
	
cnt cnt 2;
	
while(
cnt--)
	
{
	

	
HAL_GPIO_TogglePin(Led_1_GPIO_Port,Led_1_Pin);
	
HAL_Delay(time);
	
}

}
//--------------------------------------------
void led_2(uint32_t cntuint32_t time)
{
	
if(
cnt>10)
	
cnt 10;
	
cnt cnt 2;
	
while(
cnt--)
	
{
	

	
HAL_GPIO_TogglePin(Led_2_GPIO_Port,Led_2_Pin);
	
HAL_Delay(time);
	
}

}
//-------------------------------------------

//------------------------------------------
//////FLASH EEPROM PROGRALAMA /////

uint16_t Read_Flash(uint32_t  adr)
{
  
uint16_t Pntr = (uint16_t *)adr;
  return(*
Pntr);  
}
///////////////// FLASH KILIDI AÇMA ALT PROGRAMI /////////////////////    
void Unlock_Flash (void)
{
  
FLASH->KEYR=0x45670123;  //Flash kilidini açmak için FLASH->KEYR registerine KEY1 ve KEY2 sirayla yazilmalidir
  
FLASH->KEYR=0xCDEF89AB;
}
///////////////// FLASH KILITLEME ALT PROGRAMI ///////////////////// 
void Lock_Flash (void)
{
  
FLASH->CR=0x00000080;  //FLASH_CR registeri resetlendiginde FLASH kiltlenmis olur
}
//////////////// ISTENILEN ADRESTEKI VERIYI FLASHTAN SILME ALT PROGRAMI //////
void Erase_Flash (uint32_t adr)
{
//Unlock_Flash();
  
FLASH->CR|=0x00000002;            //PER enable
  
FLASH->AR=adr;                    //FLASH->AR registerine silinmek istenen adres yazilir
  
FLASH->CR|=0x00000040;            //STRT anable
  
while((FLASH->SR&0x00000001));    //Islem bitene kadar bekle(BUSY kontrol ediliyor)
  
FLASH->CR &= ~0x00000042;         //FLASH->CR ilk durumuna aliniyor (kilit hala açik!) 
}
///////////////// ISTENILEN ADRESE VERI YAZMA ALT PROGRAMI /////////////////////
void Write_Flash (uint32_t adruint16_t data)
{
  
FLASH->CR|=0x00000001;           //PG enable
  
*(__IO uint16_t*)adr data;     //istenen adrese istenen data yaziliyor
  
while((FLASH->SR&0x00000001));   //Islem bitene kadar bekle(BUSY kontrol ediliyor)
}

void epprom_yaz(uint32_t addressuint16_t deger)
{

    
Unlock_Flash();
    
Erase_Flash(address); 
    
Write_Flashaddress,deger);
    
Lock_Flash(); 
}
	


//-------------------------------------------

//-------------------------------------------
//-------------------------------------------

/* USER CODE END 4 */



Fonksiyon Prototipleri ve
Flash ın neresine yazılacağı ile ilgili sabit tanımlanması:
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static 
void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */
void led_1(uint32_t cntuint32_t time);
void led_2(uint32_t cntuint32_t time);

#define EEPROM_START_ADDRESS ((uint32_t)0x0801F800) //126. page
uint16_t Read_Flash(uint32_t  adr);
void Unlock_Flash (void);
void Lock_Flash (void);
	

void Erase_Flash (uint32_t adr);
void Write_Flash (uint32_t adruint16_t data);
void epprom_yaz(uint32_t addressuint16_t deger);

/* USER CODE END PFP */


main.c
/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  ** This notice applies to any and all portions of this file
  * that are not between comment pairs USER CODE BEGIN and
  * USER CODE END. Other portions of this file, whether 
  * inserted by the user or by software development tools
  * are owned by their respective copyright owners.
  *
  * COPYRIGHT(c) 2019 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
uint16_t deger_yaz 0deger_oku=0;

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static 
void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */
void led_1(uint32_t cntuint32_t time);
void led_2(uint32_t cntuint32_t time);

#define EEPROM_START_ADDRESS ((uint32_t)0x0801F800) //126. page
uint16_t Read_Flash(uint32_t  adr);
void Unlock_Flash (void);
void Lock_Flash (void);
	

void Erase_Flash (uint32_t adr);
void Write_Flash (uint32_t adruint16_t data);
void epprom_yaz(uint32_t addressuint16_t deger);

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  
/* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  
HAL_Init();

  
/* USER CODE BEGIN Init */
	

  
/* USER CODE END Init */

  /* Configure the system clock */
  
SystemClock_Config();

  
/* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  
MX_GPIO_Init();
  
/* USER CODE BEGIN 2 */
	
//---------------------------------------------
	
//program her yeniden basladiginda, eep start adr.indeki 
	
//flash mem.i okur, bir arttirir, geri yazar, tekrar okur, 
	
//bu sayi kadar PC13 ledini yakar sondurur, 
	
//yani devre programlandigindan beri kac defa resetlendi sayar.
	
	
deger_oku Read_Flash(EEPROM_START_ADDRESS);
	
	
deger_yaz deger_oku 1;

	
	
epprom_yaz(EEPROM_START_ADDRESS,deger_yaz);
	
	
deger_oku Read_Flash(EEPROM_START_ADDRESS);

	
	
led_2(deger_oku,500);
	

	
	
led_1(deger_oku,500);
	
	

	
//---------------------------------------------
	

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  
while (1)
  {
	
	

	
	
while(
1);
	
	
	

	
	

    
/* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  
}
  
/* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  
/**Initializes the CPU, AHB and APB busses clocks 
  */
  
RCC_OscInitStruct.OscillatorType RCC_OSCILLATORTYPE_HSE;
  
RCC_OscInitStruct.HSEState RCC_HSE_ON;
  
RCC_OscInitStruct.HSEPredivValue RCC_HSE_PREDIV_DIV1;
  
RCC_OscInitStruct.HSIState RCC_HSI_ON;
  
RCC_OscInitStruct.PLL.PLLState RCC_PLL_ON;
  
RCC_OscInitStruct.PLL.PLLSource RCC_PLLSOURCE_HSE;
  
RCC_OscInitStruct.PLL.PLLMUL RCC_PLL_MUL9;
  if (
HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    
Error_Handler();
  }
  
/**Initializes the CPU, AHB and APB busses clocks 
  */
  
RCC_ClkInitStruct.ClockType RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  
RCC_ClkInitStruct.SYSCLKSource RCC_SYSCLKSOURCE_PLLCLK;
  
RCC_ClkInitStruct.AHBCLKDivider RCC_SYSCLK_DIV1;
  
RCC_ClkInitStruct.APB1CLKDivider RCC_HCLK_DIV2;
  
RCC_ClkInitStruct.APB2CLKDivider RCC_HCLK_DIV1;

  if (
HAL_RCC_ClockConfig(&RCC_ClkInitStructFLASH_LATENCY_2) != HAL_OK)
  {
    
Error_Handler();
  }
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  
GPIO_InitTypeDef GPIO_InitStruct = {0};

  
/* GPIO Ports Clock Enable */
  
__HAL_RCC_GPIOC_CLK_ENABLE();
  
__HAL_RCC_GPIOD_CLK_ENABLE();
  
__HAL_RCC_GPIOB_CLK_ENABLE();
  
__HAL_RCC_GPIOA_CLK_ENABLE();

  
/*Configure GPIO pin Output Level */
  
HAL_GPIO_WritePin(Led_1_GPIO_PortLed_1_PinGPIO_PIN_RESET);

  
/*Configure GPIO pin Output Level */
  
HAL_GPIO_WritePin(Led_2_GPIO_PortLed_2_PinGPIO_PIN_RESET);

  
/*Configure GPIO pin : Led_1_Pin */
  
GPIO_InitStruct.Pin Led_1_Pin;
  
GPIO_InitStruct.Mode GPIO_MODE_OUTPUT_PP;
  
GPIO_InitStruct.Pull GPIO_NOPULL;
  
GPIO_InitStruct.Speed GPIO_SPEED_FREQ_LOW;
  
HAL_GPIO_Init(Led_1_GPIO_Port, &GPIO_InitStruct);

  
/*Configure GPIO pin : Led_2_Pin */
  
GPIO_InitStruct.Pin Led_2_Pin;
  
GPIO_InitStruct.Mode GPIO_MODE_OUTPUT_PP;
  
GPIO_InitStruct.Pull GPIO_NOPULL;
  
GPIO_InitStruct.Speed GPIO_SPEED_FREQ_LOW;
  
HAL_GPIO_Init(Led_2_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */
void led_1(uint32_t cntuint32_t time)
{
	
if(
cnt>10)
	
cnt 10;
	
cnt cnt 2;
	
while(
cnt--)
	
{
	

	
HAL_GPIO_TogglePin(Led_1_GPIO_Port,Led_1_Pin);
	
HAL_Delay(time);
	
}

}
//--------------------------------------------
void led_2(uint32_t cntuint32_t time)
{
	
if(
cnt>10)
	
cnt 10;
	
cnt cnt 2;
	
while(
cnt--)
	
{
	

	
HAL_GPIO_TogglePin(Led_2_GPIO_Port,Led_2_Pin);
	
HAL_Delay(time);
	
}

}
//-------------------------------------------

//------------------------------------------
//////FLASH EEPROM PROGRALAMA /////

uint16_t Read_Flash(uint32_t  adr)
{
  
uint16_t Pntr = (uint16_t *)adr;
  return(*
Pntr);  
}
///////////////// FLASH KILIDI AÇMA ALT PROGRAMI /////////////////////    
void Unlock_Flash (void)
{
  
FLASH->KEYR=0x45670123;  //Flash kilidini açmak için FLASH->KEYR registerine KEY1 ve KEY2 sirayla yazilmalidir
  
FLASH->KEYR=0xCDEF89AB;
}
///////////////// FLASH KILITLEME ALT PROGRAMI ///////////////////// 
void Lock_Flash (void)
{
  
FLASH->CR=0x00000080;  //FLASH_CR registeri resetlendiginde FLASH kiltlenmis olur
}
//////////////// ISTENILEN ADRESTEKI VERIYI FLASHTAN SILME ALT PROGRAMI //////
void Erase_Flash (uint32_t adr)
{
//Unlock_Flash();
  
FLASH->CR|=0x00000002;            //PER enable
  
FLASH->AR=adr;                    //FLASH->AR registerine silinmek istenen adres yazilir
  
FLASH->CR|=0x00000040;            //STRT anable
  
while((FLASH->SR&0x00000001));    //Islem bitene kadar bekle(BUSY kontrol ediliyor)
  
FLASH->CR &= ~0x00000042;         //FLASH->CR ilk durumuna aliniyor (kilit hala açik!) 
}
///////////////// ISTENILEN ADRESE VERI YAZMA ALT PROGRAMI /////////////////////
void Write_Flash (uint32_t adruint16_t data)
{
  
FLASH->CR|=0x00000001;           //PG enable
  
*(__IO uint16_t*)adr data;     //istenen adrese istenen data yaziliyor
  
while((FLASH->SR&0x00000001));   //Islem bitene kadar bekle(BUSY kontrol ediliyor)
}

void epprom_yaz(uint32_t addressuint16_t deger)
{

    
Unlock_Flash();
    
Erase_Flash(address); 
    
Write_Flashaddress,deger);
    
Lock_Flash(); 
}
	


//-------------------------------------------

//-------------------------------------------
//-------------------------------------------

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  
/* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *fileuint32_t line)

  
/* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Sorularınıza hızlı cevap alın: http://www.picproje.org/index.php/topic,57135.0.html

mg1980

Hocam, çok teşekkür ederiz...bir kenarda dursun da CubeIDE'ye adapte edebilir miyiz bakalım..