File content as of revision 33:5b90257d2d57:

#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_WriteRelayStates(uint8_t RelayState1, uint8_t RelayState2) {
    uint8_t  CurrentPage = FP_GetPage(RELAY_BASE_ADDRESS);
    uint32_t CurrentAddress = RELAY1_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(RELAY1_ADDRESS) == RelayState1) &&
        (FP_ReadValue(RELAY2_ADDRESS) == RelayState2)) {
        printf("Relay values don't 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 < (RELAY2_ADDRESS + STEP_ADDRESS)) {
        switch (CurrentAddress) {
            case (RELAY1_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, RelayState1) == HAL_OK) {
                                        printf("Write Relay 1 State OK\r\n");
                                   }
                                   else {
                                        printf("Write Relay 1 State failed, error num %d\r\n", HAL_FLASH_GetError());
                                   }
            break;
            case (RELAY2_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, RelayState2) == HAL_OK) {
                                        printf("Write Relay 2 State OK\r\n");
                                   }
                                   else {
                                        printf("Write Relay 2 State failed, error num %d\r\n", HAL_FLASH_GetError());
                                   }
            break;
            default: break;   
        }
        CurrentAddress = CurrentAddress + STEP_ADDRESS;
    }

    CurrentAddress = RELAY1_ADDRESS;
    while (CurrentAddress < (RELAY2_ADDRESS + STEP_ADDRESS)) {
        switch (CurrentAddress) {
            case (RELAY1_ADDRESS): if (FP_ReadValue(CurrentAddress) == RelayState1) {
                                    printf("Read back Relay 1 State: %d\r\n", FP_ReadValue(CurrentAddress));
                                 }
                                 else {
                                    printf("Write Relay 1 State failed, wrong read back value\r\n"); 
                                    HAL_FLASH_Lock();
                                    return FAILED;
                                 }
            break;
            case (RELAY2_ADDRESS): if (FP_ReadValue(CurrentAddress) == RelayState2) {
                                        printf("Read back Relay 2 State: %d\r\n", FP_ReadValue(CurrentAddress));  
                                    }
                                    else {
                                        printf("Write Relay 2 State failed, wrong read back value\r\n");
                                        HAL_FLASH_Lock();
                                        return FAILED;
                                    }
            break;
            default: break;   
        }
        CurrentAddress = CurrentAddress + STEP_ADDRESS;
    }
    HAL_FLASH_Lock();
    return PASSED;
}

int FP_WriteConfigValues(uint8_t Mode, uint8_t MinOxi, uint8_t MaxOxi, uint32_t UploadPeriod) {
    uint8_t  CurrentPage    = FP_GetPage(CONF_BASE_ADDRESS);    
    uint32_t CurrentAddress = MODE_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(MODE_ADDRESS) == Mode) &&
        (FP_ReadValue(MIN_OXI_ADDRESS) == MinOxi) &&
        (FP_ReadValue(MAX_OXI_ADDRESS) == MaxOxi) &&
        (FP_ReadValue(UPLOAD_PERIOD_ADDRESS) == UploadPeriod)) {
        printf("Configuration values don't 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_ADDRESS + STEP_ADDRESS)) {
        switch (CurrentAddress) {
            case (MODE_ADDRESS): if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, CurrentAddress, Mode) == HAL_OK) {
                                    printf("Write Mode OK\r\n");
                                }
                                else {
                                    printf("Write Mode failed, error num %d\r\n", HAL_FLASH_GetError());
                                }
            break;
            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_ADDRESS): 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 = MODE_ADDRESS;
    while (CurrentAddress < (UPLOAD_PERIOD_ADDRESS + STEP_ADDRESS)) {
        switch (CurrentAddress) {
            case (MODE_ADDRESS): if (FP_ReadValue(CurrentAddress) == Mode) {
                                    printf("Read back Mode: %d\r\n", FP_ReadValue(CurrentAddress));
                                 }
                                 else {
                                    printf("Write Mode failed, wrong read back value\r\n"); 
                                    HAL_FLASH_Lock();
                                    return FAILED;
                                 }
            break;
            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_ADDRESS): 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;
}