File content as of revision 28:82f5420bf388:

#include "flash_programming.h"
#include "stm32l4xx_hal_flash.h"

uint32_t PageError = 0;

FLASH_EraseInitTypeDef EraseInitStruct;

uint32_t FP_GetPage(uint32_t Addr) {
  uint32_t page = 0;
  
  if (Addr < (FLASH_BASE + FLASH_BANK_SIZE))
  {
    /* Bank 1 */
    page = (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
  }
  else
  {
    /* Bank 2 */
    page = (Addr - (FLASH_BASE + FLASH_BANK_SIZE)) / FLASH_PAGE_SIZE;
  }
  
  return page;
}

int FP_ClearFlags() {
    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_PGSERR);
    if((__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPERR))  || (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PROGERR)) || 
       (__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR)) || (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGAERR))  || 
       (__HAL_FLASH_GET_FLAG(FLASH_FLAG_SIZERR)) || (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGSERR))) {
        printf("Clear flag error\r\n");
        return FAILED;
    }    
    return PASSED;
}

uint32_t FP_ReadValue(uint32_t Addr) {
    uint32_t ReturnValue = *(__IO uint32_t*)Addr;
    return ReturnValue;
}

int FP_WriteMode(uint32_t WriteModeValue) {
    uint8_t  CurrentPage = FP_GetPage(MODE_BASE_ADDRESS);
    uint32_t CurrentAddress = (MODE_BASE_ADDRESS + STEP_ADDRESS);
    
    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
    EraseInitStruct.Banks       = FLASH_BANK_1;
    EraseInitStruct.Page        = CurrentPage;
    EraseInitStruct.NbPages     = 1;      
    
    if (FP_ClearFlags() != PASSED) {
        return FAILED;
    }
    HAL_FLASH_Unlock();  
    
    if (FP_ReadValue(CurrentAddress) == WriteModeValue) {
        printf("Value does not change, no need to write\r\n");
        HAL_FLASH_Lock();
        return PASSED;
    }
    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
        printf("Erase error, error num %d\r\n", HAL_FLASH_GetError());
    }  
    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, WriteModeValue) == HAL_OK) {
        printf("Write OK\r\n");
    }
    else {
        printf("Write failed, error num %d\r\n", HAL_FLASH_GetError());   
    }
    uint32_t readBack = FP_ReadValue(CurrentAddress);
    printf("Read back: %d\r\n", readBack);   
    if (readBack != WriteModeValue) {
        printf("Write failed, wrong read back value\r\n");
        HAL_FLASH_Lock();
        return FAILED;
    }
    HAL_FLASH_Lock();
    return PASSED;
}

int FP_WriteConfigValues(uint8_t MinOxi, uint8_t MaxOxi, uint32_t UploadPeriod) {
    uint8_t  CurrentPage    = FP_GetPage(CONF_BASE_ADDRESS);    
    uint32_t CurrentAddress = MIN_OXI_ADDRESS;
    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
    EraseInitStruct.Banks       = FLASH_BANK_1;
    EraseInitStruct.Page        = CurrentPage;
    EraseInitStruct.NbPages     = 1;     

    if (FP_ClearFlags() != PASSED) {
        return FAILED;
    }
    HAL_FLASH_Unlock();  
    
    if ((FP_ReadValue(MIN_OXI_ADDRESS) == MinOxi) &&
        (FP_ReadValue(MAX_OXI_ADDRESS) == MaxOxi) &&
        (FP_ReadValue(UPLOAD_PERIOD_ARRESS) == UploadPeriod)) {
        printf("Value does not change, no need to write\r\n");
        HAL_FLASH_Lock();
        return PASSED;
    }
    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
        printf("Erase error, error num %d\r\n", HAL_FLASH_GetError());
    }  
    while (CurrentAddress < (UPLOAD_PERIOD_ARRESS + STEP_ADDRESS)) {
        switch (CurrentAddress) {
            case (MIN_OXI_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, MinOxi) == HAL_OK) {
                                        printf("Write MinOxi OK\r\n");
                                    }
                                    else {
                                        printf("Write MinOxi failed, error num %d\r\n", HAL_FLASH_GetError());
                                    }
            break;
            case (MAX_OXI_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, MaxOxi) == HAL_OK) {
                                        printf("Write MaxOxi OK\r\n");
                                    }
                                    else {
                                        printf("Write MaxOxi failed, error num %d\r\n", HAL_FLASH_GetError());
                                    }
            break;
            case (UPLOAD_PERIOD_ARRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, UploadPeriod) == HAL_OK) {
                                        printf("Write UploadPeriod OK\r\n");
                                    }
                                    else {
                                        printf("Write UploadPeriod failed, error num %d\r\n", HAL_FLASH_GetError());
                                    }
            break;
            default: break;   
        }
        CurrentAddress = CurrentAddress + STEP_ADDRESS;
    }
    
    CurrentAddress = MIN_OXI_ADDRESS;
    while (CurrentAddress < (UPLOAD_PERIOD_ARRESS + STEP_ADDRESS)) {
        switch (CurrentAddress) {
            case (MIN_OXI_ADDRESS): if (FP_ReadValue(CurrentAddress) == MinOxi) {
                                        printf("Read back MinOxi: %d\r\n", FP_ReadValue(CurrentAddress));  
                                    }
                                    else {
                                        printf("Write MinOxi failed, wrong read back value\r\n");
                                        HAL_FLASH_Lock();
                                        return FAILED;
                                    }
            break;
            case (MAX_OXI_ADDRESS): if (FP_ReadValue(CurrentAddress) == MaxOxi) {
                                        printf("Read back MaxOxi: %d\r\n", FP_ReadValue(CurrentAddress));  
                                    }
                                    else {
                                        printf("Write MaxOxi failed, wrong read back value\r\n");
                                        HAL_FLASH_Lock();
                                        return FAILED;
                                    }
            break;
            case (UPLOAD_PERIOD_ARRESS): if (FP_ReadValue(CurrentAddress) == UploadPeriod) {
                                        printf("Read back UploadPeriod: %d\r\n", FP_ReadValue(CurrentAddress));  
                                    }
                                    else {
                                        printf("Write UploadPeriod failed, wrong read back value\r\n");
                                        HAL_FLASH_Lock();
                                        return FAILED;
                                    }
            break;
            default: break;   
        }
        CurrentAddress = CurrentAddress + STEP_ADDRESS;
    }
    HAL_FLASH_Lock();
    return PASSED;
}