sundp
/
STS_MM_M7
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

enhance v13, remove useless code

This commit is contained in:
Yunhorn 2023-10-11 13:47:37 +08:00
parent 741958d525
commit b9bfe99e2e
5 changed files with 426 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
Core/Inc/flash_if.h
View File

@ -35,18 +35,19 @@ extern "C" {
/* Exported types ------------------------------------------------------------*/
/**
* @brief Flash status enumeration
* @brief Flash status
*/
enum
typedef enum
{
FLASH_PARAM_ERROR = -5,
FLASH_LOCK_ERROR = -4,
FLASH_WRITE_ERROR = -3,
FLASH_ERASE_ERROR = -2,
FLASH_ERROR = -1,
FLASH_OK = 0,
FLASH_BUSY = 1
};
FLASH_IF_PARAM_ERROR = -6, /*!< Error Flash invalid parameter */
FLASH_IF_LOCK_ERROR = -5, /*!< Error Flash not locked */
FLASH_IF_WRITE_ERROR = -4, /*!< Error Flash write not possible */
FLASH_IF_READ_ERROR = -3, /*!< Error Flash read not possible */
FLASH_IF_ERASE_ERROR = -2, /*!< Error Flash erase not possible */
FLASH_IF_ERROR = -1, /*!< Error Flash generic */
FLASH_IF_OK = 0, /*!< Flash Success */
FLASH_IF_BUSY = 1 /*!< Flash not available */
} FLASH_IF_StatusTypedef;
/* USER CODE BEGIN ET */
@ -63,51 +64,54 @@ enum
/* USER CODE END EV */
/* Exported macro ------------------------------------------------------------*/
#define PAGE(__ADDRESS__) (uint32_t)((((__ADDRESS__) - FLASH_BASE) % FLASH_BANK_SIZE) / FLASH_PAGE_SIZE) /*!< Get page index from page address */
/* USER CODE BEGIN EM */
/* USER CODE END EM */
/* Exported functions prototypes ---------------------------------------------*/
/**
* @brief This function writes a user flash area (read/modify/write)
* @param address: ptr to user flash area
* @param data: ptr to data to be written
* @param size: number of 32b.
* @param dataTempPage: ptr used to copy already written page in ram
* @return Flash status.
* @brief This function initializes the internal and external flash interface
*
* @param pAllocRamBuffer pointer used to store a FLASH page in RAM when partial replacement is needed
* @return FLASH_IF_StatusTypedef status
*/
int32_t FLASH_IF_Write(uint32_t address, uint8_t *data, uint32_t size, uint8_t *dataTempPage);
FLASH_IF_StatusTypedef FLASH_IF_Init(void *pAllocRamBuffer);
/**
* Writes a 64-bit word in flash at a specific address.
* @param address (in bytes) must be a multiple of 8.
* @param data data to write
* @returns FLASH_OK, FLASH_BUSY, FLASH_ERASE_ERROR
* @brief This function de-initializes the internal and external flash interface
*
* @return FLASH_IF_StatusTypedef status
*/
int32_t FLASH_IF_Write64(uint32_t address, uint64_t data);
FLASH_IF_StatusTypedef FLASH_IF_DeInit(void);
/**
* Erases 'n' flash pages from page number 'page' to page number
* 'page + n - 1'.
* - If 'interrupt' is set to 0, the erasing is performed in polling mode.
* - If 'interrupt' is set to 1, the erasing is performed under FLASH
* interrupt: the function returns immediately and the user is informed of
* the end of erasing procedure by a call to the following function that
* must be implemented by the user: void HWCB_FLASH_EndOfCleanup( void );
* this call-back function is called under FLASH IRQ handler.
* @param page memory start page number
* @param n number of page
* @param interrupt choice polling/interrupt
* @returns FLASH_OK, FLASH_BUSY, FLASH_ERASE_ERROR
* @brief This function writes a data buffer in internal or external flash
*
* @param pDestination pointer of flash address to write. It has to be 8 bytes aligned.
* @param pSource pointer on buffer with data to write
* @param uLength length of data buffer in bytes. It has to be 8 bytes aligned.
* @return FLASH_IF_StatusTypedef status
*/
int32_t FLASH_IF_EraseByPages(uint32_t page, uint16_t n, int32_t interrupt);
FLASH_IF_StatusTypedef FLASH_IF_Write(void *pDestination, const void *pSource, uint32_t uLength);
/**
* Callback
* @brief This function reads a amount of data from flash and copy into the output data buffer
*
* @param pDestination pointer of target location to copy the flash sector
* @param pSource pointer of flash address to read
* @param uLength number of bytes to read
* @return FLASH_IF_StatusTypedef status
*/
void HWCB_FLASH_EndOfCleanup(void);
FLASH_IF_StatusTypedef FLASH_IF_Read(void *pDestination, const void *pSource, uint32_t uLength);
/**
* @brief This function erases a amount of internal or external flash pages depending of the length
*
* @param pStart pointer of flash address to erase
* @param uLength number of bytes to erase
* @return FLASH_IF_StatusTypedef status
*/
FLASH_IF_StatusTypedef FLASH_IF_Erase(void *pStart, uint32_t uLength);
/* USER CODE BEGIN EFP */

4
Core/Inc/yunhorn_sts_prd_conf.h
View File

@ -308,8 +308,8 @@
* Address range 0800 0000H - 0803 FFFFH Size: 0x0004 0000
*/
#define FLASH_USER_START_ADDR ((uint32_t) 0x0803F800U) // Last 2kB of flash
#define FLASH_USER_CONFIG_SIZE ((uint32_t) 0x000007FFU) //0x400=1KB=1024
#define FLASH_USER_START_ADDR ((void *) 0x0803F800U) // Last 2kB of flash
#define FLASH_USER_CONFIG_SIZE ((void *) 0x000007FFU) //0x400=1KB=1024
#define FLASH_USER_END_ADDR (FLASH_USER_START_ADDR + FLASH_USER_CONFIG - 1)
/* 2KB = 2048 = 0x800 End @ of user Flash area */

2
Core/Inc/yunhorn_sts_sensors.h
View File

@ -387,7 +387,7 @@ typedef struct sts_cfg_nvm {
uint8_t periodicity_l; //count of duty cycle duration low {0,9}
uint8_t unit; // time unit of duty cycle duration, in 'S', 'M','H' seconds, minutes, hours
uint8_t length;
uint8_t p[YUNHORN_STS_MAX_NVM_CFG_SIZE-6];
uint8_t p[YUNHORN_STS_MAX_NVM_CFG_SIZE-8];
} sts_cfg_nvm_t;
/**

542
Core/Src/flash_if.c
View File

@ -43,8 +43,8 @@
*/
enum
{
FLASH_EMPTY = 0,
FLASH_NOT_EMPTY = 1
FLASH_IF_MEM_EMPTY = 0,
FLASH_IF_MEM_NOT_EMPTY = 1
};
/* USER CODE BEGIN PD */
@ -52,190 +52,150 @@ enum
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/**
* @brief Get internal flash page index from page address
*/
#define PAGE_INDEX(__ADDRESS__) (uint32_t)((((__ADDRESS__) - FLASH_BASE) % FLASH_BANK_SIZE) / FLASH_PAGE_SIZE)
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
static uint8_t *pAllocatedBuffer = NULL;
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
/* Private Functions prototypes: internal flash ------------------------------*/
/**
* @brief This function writes a data buffer in flash (data are 64-bit aligned).
*
* @note After writing data buffer, the flash content is checked.
* @param pDestination: Start address for target location
* @param pDestination: Start address for target location. It has to be 8 bytes aligned.
* @param pSource: pointer on buffer with data to write
* @param uLength: Length of data buffer in byte. It has to be 64-bit aligned.
* @retval HAL Status.
* @param uLength: Length of data buffer in bytes. It has to be 8 bytes aligned.
* @return FLASH_IF_StatusTypedef status
*/
static int32_t FLASH_IF_Write_Buffer(uint32_t pDestination, uint8_t *pSource, uint32_t uLength);
static FLASH_IF_StatusTypedef FLASH_IF_INT_Write(void *pDestination, const void *pSource, uint32_t uLength);
/**
* @brief This function checks if part of Flash is empty
It handles 32b unaligned address
* @param addr: Start of user flash area
* @param size: number of bytes.
* @retval FLASH_EMPTY or FLASH_NOT_EMPTY.
* @brief This function reads flash
*
* @param pDestination: Start address for target location
* @param pSource: flash address to read
* @param uLength: number of bytes
* @return FLASH_IF_StatusTypedef status
*/
static int32_t FLASH_IF_IsEmpty(uint8_t *addr, uint32_t size);
static FLASH_IF_StatusTypedef FLASH_IF_INT_Read(void *pDestination, const void *pSource, uint32_t uLength);
/**
* @brief This function does an erase of n (depends on Length) pages in user flash area
*
* @param pStart pointer of flash address to be erased
* @param uLength number of bytes
* @return FLASH_IF_StatusTypedef status
*/
static FLASH_IF_StatusTypedef FLASH_IF_INT_Erase(void *pStart, uint32_t uLength);
/**
* @brief This function checks if part of Flash is empty
*
* @param pStart flash address to check
* @param uLength number of bytes to check. It has to be 8 bytes aligned.
* @return int32_t FLASH_IF_MEM_EMPTY or FLASH_IF_MEM_NOT_EMPTY
*/
static int32_t FLASH_IF_INT_IsEmpty(void *pStart, uint32_t uLength);
/**
* @brief Clear error flags raised during previous operation
*
* @retval FLASH_IF_StatusTypedef status
*/
static FLASH_IF_StatusTypedef FLASH_IF_INT_Clear_Error(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Exported functions --------------------------------------------------------*/
int32_t FLASH_IF_Write(uint32_t address, uint8_t *data, uint32_t size, uint8_t *dataTempPage)
FLASH_IF_StatusTypedef FLASH_IF_Init(void *pAllocRamBuffer)
{
FLASH_IF_StatusTypedef ret_status = FLASH_IF_OK;
/* USER CODE BEGIN FLASH_IF_Init_1 */
/* USER CODE END FLASH_IF_Init_1 */
pAllocatedBuffer = (uint8_t *)pAllocRamBuffer;
/* USER CODE BEGIN FLASH_IF_Init_2 */
/* USER CODE END FLASH_IF_Init_2 */
return ret_status;
}
FLASH_IF_StatusTypedef FLASH_IF_DeInit(void)
{
FLASH_IF_StatusTypedef ret_status = FLASH_IF_OK;
/* USER CODE BEGIN FLASH_IF_DeInit_1 */
/* USER CODE END FLASH_IF_DeInit_1 */
pAllocatedBuffer = NULL;
/* USER CODE BEGIN FLASH_IF_DeInit_2 */
/* USER CODE END FLASH_IF_DeInit_2 */
return ret_status;
}
FLASH_IF_StatusTypedef FLASH_IF_Write(void *pDestination, const void *pSource, uint32_t uLength)
{
FLASH_IF_StatusTypedef ret_status = FLASH_IF_ERROR;
/* USER CODE BEGIN FLASH_IF_Write_1 */
/* USER CODE END FLASH_IF_Write_1 */
int32_t status = FLASH_OK;
uint32_t page_start_index = PAGE(address);
uint32_t page_end_index = PAGE(address + size - 1);
uint32_t curr_size = size;
uint32_t curr_dest_addr = address;
uint32_t curr_src_addr = (uint32_t)data;
if ((data == NULL) || ((size % sizeof(uint64_t)) != 0) || ((address % sizeof(uint64_t)) != 0))
if (IS_FLASH_MAIN_MEM_ADDRESS((uint32_t)pDestination))
{
return FLASH_PARAM_ERROR;
ret_status = FLASH_IF_INT_Write(pDestination, pSource, uLength);
}
if (READ_BIT(FLASH->CR, FLASH_CR_LOCK) != 0U)
{
return FLASH_LOCK_ERROR;
}
if (page_start_index != page_end_index)
{
curr_size = FLASH_PAGE_SIZE - (address % FLASH_PAGE_SIZE);
}
for (uint32_t idx = page_start_index; idx <= page_end_index; idx++)
{
if (FLASH_IF_IsEmpty((uint8_t *)curr_dest_addr, curr_size) != FLASH_EMPTY)
{
if (dataTempPage == NULL)
{
return FLASH_PARAM_ERROR;
}
/* backup initial Flash page data in RAM area */
UTIL_MEM_cpy_8(dataTempPage, (uint8_t *)(idx * FLASH_PAGE_SIZE + FLASH_BASE), FLASH_PAGE_SIZE);
/* copy fragment into RAM area */
UTIL_MEM_cpy_8(&dataTempPage[((uint32_t)curr_dest_addr) % FLASH_PAGE_SIZE], (uint8_t *)curr_src_addr, curr_size);
/* erase the Flash sector, to avoid writing twice in RAM */
if (FLASH_IF_EraseByPages(idx, 1, 0) != FLASH_OK)
{
status = FLASH_ERASE_ERROR;
break; /* exit for loop */
}
else
{
/* copy the whole flash sector including fragment from RAM to Flash*/
if (FLASH_IF_Write_Buffer(idx * FLASH_PAGE_SIZE + FLASH_BASE, dataTempPage, FLASH_PAGE_SIZE) != FLASH_OK)
{
status = FLASH_WRITE_ERROR;
break; /* exit for loop */
}
}
}
else
{
if (FLASH_IF_Write_Buffer(curr_dest_addr, (uint8_t *)curr_src_addr, curr_size) != FLASH_OK)
{
status = FLASH_WRITE_ERROR;
break; /* exit for loop */
}
}
/* 2nd part of memory overlapped on 2nd flash sector */
curr_dest_addr += curr_size;
curr_src_addr += curr_size;
curr_size = size - curr_size;
}
return status;
/* USER CODE BEGIN FLASH_IF_Write_2 */
/* USER CODE END FLASH_IF_Write_2 */
return ret_status;
}
int32_t FLASH_IF_Write64(uint32_t address, uint64_t data)
FLASH_IF_StatusTypedef FLASH_IF_Read(void *pDestination, const void *pSource, uint32_t uLength)
{
/* USER CODE BEGIN FLASH_IF_Write64_1 */
FLASH_IF_StatusTypedef ret_status = FLASH_IF_ERROR;
/* USER CODE BEGIN FLASH_IF_Read_1 */
/* USER CODE END FLASH_IF_Write64_1 */
while (*(uint64_t *)address != data)
/* USER CODE END FLASH_IF_Read_1 */
if (IS_FLASH_MAIN_MEM_ADDRESS((uint32_t)pSource))
{
while (LL_FLASH_IsActiveFlag_OperationSuspended());
HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, address, data);
ret_status = FLASH_IF_INT_Read(pDestination, pSource, uLength);
}
/* USER CODE BEGIN FLASH_IF_Read_2 */
return FLASH_OK;
/* USER CODE BEGIN FLASH_IF_Write64_2 */
/* USER CODE END FLASH_IF_Write64_2 */
/* USER CODE END FLASH_IF_Read_2 */
return ret_status;
}
int32_t FLASH_IF_EraseByPages(uint32_t page, uint16_t n, int32_t interrupt)
FLASH_IF_StatusTypedef FLASH_IF_Erase(void *pStart, uint32_t uLength)
{
/* USER CODE BEGIN FLASH_IF_EraseByPages_1 */
FLASH_IF_StatusTypedef ret_status = FLASH_IF_ERROR;
/* USER CODE BEGIN FLASH_IF_Erase_1 */
/* USER CODE END FLASH_IF_EraseByPages_1 */
HAL_StatusTypeDef hal_status;
FLASH_EraseInitTypeDef erase_str;
uint32_t page_error;
erase_str.TypeErase = FLASH_TYPEERASE_PAGES;
erase_str.Page = page;
erase_str.NbPages = n;
/* Erase the Page */
if (interrupt)
/* USER CODE END FLASH_IF_Erase_1 */
/* Check Flash start address */
if (IS_FLASH_MAIN_MEM_ADDRESS((uint32_t)pStart))
{
hal_status = HAL_FLASHEx_Erase_IT(&erase_str);
}
else
{
hal_status = HAL_FLASHEx_Erase(&erase_str, &page_error);
ret_status = FLASH_IF_INT_Erase(pStart, uLength);
}
/* USER CODE BEGIN FLASH_IF_Erase_2 */
return ((hal_status == HAL_OK) ? FLASH_OK : ((hal_status == HAL_BUSY) ? FLASH_BUSY : FLASH_ERASE_ERROR));
/* USER CODE BEGIN FLASH_IF_EraseByPages_2 */
/* USER CODE END FLASH_IF_EraseByPages_2 */
}
void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue)
{
/* USER CODE BEGIN HAL_FLASH_EndOfOperationCallback_1 */
/* USER CODE END HAL_FLASH_EndOfOperationCallback_1 */
/* Call CleanUp callback when all requested pages have been erased */
if (ReturnValue == 0xFFFFFFFFUL)
{
HWCB_FLASH_EndOfCleanup();
}
/* USER CODE BEGIN HAL_FLASH_EndOfOperationCallback_2 */
/* USER CODE END HAL_FLASH_EndOfOperationCallback_2 */
}
void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue)
{
/* USER CODE BEGIN HAL_FLASH_OperationErrorCallback_1 */
/* USER CODE END HAL_FLASH_OperationErrorCallback_1 */
}
void HWCB_FLASH_EndOfCleanup(void)
{
/* USER CODE BEGIN HWCB_FLASH_EndOfCleanup_1 */
/* USER CODE END HWCB_FLASH_EndOfCleanup_1 */
/* USER CODE END FLASH_IF_Erase_2 */
return ret_status;
}
/* USER CODE BEGIN EF */
@ -243,86 +203,282 @@ void HWCB_FLASH_EndOfCleanup(void)
/* USER CODE END EF */
/* Private Functions Definition -----------------------------------------------*/
static int32_t FLASH_IF_Write_Buffer(uint32_t pDestination, uint8_t *pSource, uint32_t uLength)
/* Private Functions : internal flash -----------------------------------------*/
static FLASH_IF_StatusTypedef FLASH_IF_INT_Write(void *pDestination, const void *pSource, uint32_t uLength)
{
/* USER CODE BEGIN FLASH_IF_Write_Buffer_1 */
FLASH_IF_StatusTypedef ret_status = FLASH_IF_OK;
/* USER CODE BEGIN FLASH_IF_INT_Write_1 */
/* USER CODE END FLASH_IF_Write_Buffer_1 */
uint8_t *pSrc = pSource;
uint64_t src_value;
int32_t status = FLASH_OK;
/* USER CODE END FLASH_IF_INT_Write_1 */
uint32_t uDest = (uint32_t)pDestination;
uint32_t uSource = (uint32_t)pSource;
uint32_t length = uLength;
uint32_t page_index;
uint32_t address_offset;
uint32_t start_page_index;
uint32_t page_address;
uint32_t number_pages;
uint32_t current_dest;
uint32_t current_source;
uint32_t current_length;
for (uint32_t i = 0; i < (uLength / sizeof(uint64_t)); i++)
if ((pDestination == NULL) || (pSource == NULL) || !IS_ADDR_ALIGNED_64BITS(uLength)
|| !IS_ADDR_ALIGNED_64BITS((uint32_t)pDestination))
{
UTIL_MEM_cpy_8(&src_value, pSrc, sizeof(uint64_t));
/* Avoid writing 0xFFFFFFFFFFFFFFFFLL on erased Flash */
if (src_value != UINT64_MAX)
{
status = FLASH_IF_Write64(pDestination, src_value);
}
pDestination += sizeof(uint64_t);
pSrc += sizeof(uint64_t);
if (status != FLASH_OK)
{
/* exit the for loop*/
break;
}
return FLASH_IF_PARAM_ERROR;
}
return status;
/* USER CODE BEGIN FLASH_IF_Write_Buffer_2 */
/* Clear error flags raised during previous operation */
ret_status = FLASH_IF_INT_Clear_Error();
/* USER CODE END FLASH_IF_Write_Buffer_2 */
if (ret_status == FLASH_IF_OK)
{
/* Unlock the Flash to enable the flash control register access */
if (HAL_FLASH_Unlock() == HAL_OK)
{
start_page_index = PAGE_INDEX(uDest);
number_pages = PAGE_INDEX(uDest + uLength - 1U) - start_page_index + 1U;
if (number_pages > 1)
{
length = FLASH_PAGE_SIZE - (uDest % FLASH_PAGE_SIZE);
}
for (page_index = start_page_index; page_index < (start_page_index + number_pages); page_index++)
{
page_address = page_index * FLASH_PAGE_SIZE + FLASH_BASE;
if (FLASH_IF_INT_IsEmpty(pDestination, length) != FLASH_IF_MEM_EMPTY)
{
if (pAllocatedBuffer == NULL)
{
ret_status = FLASH_IF_PARAM_ERROR;
break; /* exit for loop */
}
/* backup initial Flash page data in RAM area */
FLASH_IF_INT_Read(pAllocatedBuffer, (const void *)page_address, FLASH_PAGE_SIZE);
/* copy fragment into RAM area */
UTIL_MEM_cpy_8(&pAllocatedBuffer[uDest % FLASH_PAGE_SIZE], (const void *)uSource, length);
/* erase the Flash sector, to avoid writing twice in RAM */
if (FLASH_IF_INT_Erase((void *)page_address, FLASH_PAGE_SIZE) != FLASH_IF_OK)
{
ret_status = FLASH_IF_ERASE_ERROR;
break; /* exit for loop */
}
/* copy the whole flash sector including fragment from RAM to Flash */
current_dest = page_address;
current_source = (uint32_t)pAllocatedBuffer;
current_length = FLASH_PAGE_SIZE;
}
else
{
/* write a part of flash page from selected source data */
current_dest = uDest;
current_source = uSource;
current_length = length;
}
for (address_offset = 0U; address_offset < current_length; address_offset += 8U)
{
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will be done by word */
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, current_dest,
*((uint64_t *)(current_source + address_offset))) == HAL_OK)
{
/* Check the written value */
if (*(uint64_t *)current_dest != *(uint64_t *)(current_source + address_offset))
{
/* Flash content doesn't match SRAM content */
ret_status = FLASH_IF_WRITE_ERROR;
break;
}
/* Increment FLASH Destination address */
current_dest = current_dest + 8U;
}
else
{
/* Error occurred while writing data in Flash memory */
ret_status = FLASH_IF_WRITE_ERROR;
break;
}
}
if (ret_status != FLASH_IF_OK)
{
/* Error occurred while writing data in Flash memory */
break;
}
/* Increment FLASH destination address, source address, and decrease remaining length */
uDest += length;
uSource += length;
length = ((uLength - length) > FLASH_PAGE_SIZE) ? FLASH_PAGE_SIZE : uLength - length;
}
/* Lock the Flash to disable the flash control register access (recommended
* to protect the FLASH memory against possible unwanted operation) */
HAL_FLASH_Lock();
}
else
{
ret_status = FLASH_IF_LOCK_ERROR;
}
}
/* USER CODE BEGIN FLASH_IF_INT_Write_2 */
/* USER CODE END FLASH_IF_INT_Write_2 */
return ret_status;
}
static int32_t FLASH_IF_IsEmpty(uint8_t *addr, uint32_t size)
static FLASH_IF_StatusTypedef FLASH_IF_INT_Read(void *pDestination, const void *pSource, uint32_t uLength)
{
/* USER CODE BEGIN FLASH_IF_IsEmpty_1 */
FLASH_IF_StatusTypedef ret_status = FLASH_IF_OK;
/* USER CODE BEGIN FLASH_IF_INT_Read_1 */
/* USER CODE END FLASH_IF_IsEmpty_1 */
uint64_t *addr64;
uint32_t i;
/* start memory NOT 64bits aligned */
while ((((uint32_t)addr) % sizeof(uint64_t)) != 0)
/* USER CODE END FLASH_IF_INT_Read_1 */
if ((pDestination == NULL) || (pSource == NULL))
{
if (*addr++ != UINT8_MAX)
{
return FLASH_NOT_EMPTY;
}
size--;
return FLASH_IF_PARAM_ERROR;
}
/* addr64 is 64 bits aligned */
addr64 = (uint64_t *)addr;
for (i = 0; i < (size / sizeof(uint64_t)); i++)
UTIL_MEM_cpy_8(pDestination, pSource, uLength);
/* USER CODE BEGIN FLASH_IF_INT_Read_2 */
/* USER CODE END FLASH_IF_INT_Read_2 */
return ret_status;
}
static FLASH_IF_StatusTypedef FLASH_IF_INT_Erase(void *pStart, uint32_t uLength)
{
FLASH_IF_StatusTypedef ret_status = FLASH_IF_OK;
/* USER CODE BEGIN FLASH_IF_INT_Erase_1 */
/* USER CODE END FLASH_IF_INT_Erase_1 */
HAL_StatusTypeDef hal_status = HAL_ERROR;
uint32_t page_error = 0U;
uint32_t uStart = (uint32_t)pStart;
FLASH_EraseInitTypeDef erase_init;
if (pStart == NULL)
{
if (*addr64++ != UINT64_MAX)
return FLASH_IF_PARAM_ERROR;
}
/* Clear error flags raised during previous operation */
ret_status = FLASH_IF_INT_Clear_Error();
if (ret_status == FLASH_IF_OK)
{
/* Unlock the Flash to enable the flash control register access */
if (HAL_FLASH_Unlock() == HAL_OK)
{
return FLASH_NOT_EMPTY;
erase_init.TypeErase = FLASH_TYPEERASE_PAGES;
erase_init.Page = PAGE_INDEX(uStart);
/* Get the number of pages to erase from 1st page */
erase_init.NbPages = PAGE_INDEX(uStart + uLength - 1U) - erase_init.Page + 1U;
/* Erase the Page */
hal_status = HAL_FLASHEx_Erase(&erase_init, &page_error);
if (hal_status != HAL_OK)
{
ret_status = (hal_status == HAL_BUSY) ? FLASH_IF_BUSY : FLASH_IF_ERASE_ERROR;
}
/* Lock the Flash to disable the flash control register access (recommended
* to protect the FLASH memory against possible unwanted operation) */
HAL_FLASH_Lock();
}
else
{
ret_status = FLASH_IF_LOCK_ERROR;
}
}
size -= sizeof(uint64_t) * i;
/* USER CODE BEGIN FLASH_IF_INT_Erase_2 */
/* end memory NOT 64 bits aligned */
addr = (uint8_t *)addr64;
while (size != 0)
/* USER CODE END FLASH_IF_INT_Erase_2 */
return ret_status;
}
static int32_t FLASH_IF_INT_IsEmpty(void *pStart, uint32_t uLength)
{
int32_t status = FLASH_IF_MEM_EMPTY;
/* USER CODE BEGIN FLASH_IF_INT_IsEmpty_1 */
/* USER CODE END FLASH_IF_INT_IsEmpty_1 */
uint32_t index;
for (index = 0; index < uLength; index += 8)
{
if (*addr++ != UINT8_MAX)
if (*(uint64_t *)pStart != UINT64_MAX)
{
return FLASH_NOT_EMPTY;
status = FLASH_IF_MEM_NOT_EMPTY;
break;
}
size--;
pStart = (void *)((uint32_t)pStart + 8U);
}
return FLASH_EMPTY;
/* USER CODE BEGIN FLASH_IF_IsEmpty_2 */
/* USER CODE BEGIN FLASH_IF_INT_IsEmpty_2 */
/* USER CODE END FLASH_IF_IsEmpty_2 */
/* USER CODE END FLASH_IF_INT_IsEmpty_2 */
return status;
}
static FLASH_IF_StatusTypedef FLASH_IF_INT_Clear_Error(void)
{
FLASH_IF_StatusTypedef ret_status = FLASH_IF_LOCK_ERROR;
/* USER CODE BEGIN FLASH_IF_INT_Clear_Error_1 */
/* USER CODE END FLASH_IF_INT_Clear_Error_1 */
/* Unlock the Program memory */
if (HAL_FLASH_Unlock() == HAL_OK)
{
/* Clear all FLASH flags */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS);
/* Unlock the Program memory */
if (HAL_FLASH_Lock() == HAL_OK)
{
ret_status = FLASH_IF_OK;
}
}
/* USER CODE BEGIN FLASH_IF_INT_Clear_Error_2 */
/* USER CODE END FLASH_IF_INT_Clear_Error_2 */
return ret_status;
}
/* USER CODE BEGIN PrFD */
/* USER CODE END PrFD */
/* HAL overload functions ---------------------------------------------------------*/
/**
* @note This function overwrites the __weak one from HAL
*/
void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue)
{
/* USER CODE BEGIN HAL_FLASH_EndOfOperationCallback_1 */
/* USER CODE END HAL_FLASH_EndOfOperationCallback_1 */
if (ReturnValue == 0xFFFFFFFFUL)
{
/* Call when all requested pages have been erased */
}
/* USER CODE BEGIN HAL_FLASH_EndOfOperationCallback_2 */
/* USER CODE END HAL_FLASH_EndOfOperationCallback_2 */
}
/**
* @note This function overwrites the __weak one from HAL
*/
void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue)
{
/* USER CODE BEGIN HAL_FLASH_OperationErrorCallback_1 */
/* USER CODE END HAL_FLASH_OperationErrorCallback_1 */
}
/* USER CODE BEGIN Overload_HAL_weaks */
/* USER CODE END Overload_HAL_weaks */

67
LoRaWAN/App/lora_app.c
View File

@ -46,7 +46,8 @@
volatile uint8_t mems_int1_detected = 0;
volatile uint32_t periodicity_length=0;
volatile uint8_t heart_beat_timer=0, sts_lorawan_joined=0;
volatile sts_cfg_nvm_t sts_cfg_nvm={sts_mtmcode1,sts_mtmcode2, sts_version, sts_hardware_ver, 0x00,0x05,'M',0x03,0x08,0x04,0x02};
volatile sts_cfg_nvm_t sts_cfg_nvm={sts_mtmcode1,sts_mtmcode2, sts_version, sts_hardware_ver,
0x00,0x05,'M',0x03,{0x08,0x04,0x02}};
#ifdef YUNHORN_STS_M7_ENABLED
extern volatile uint8_t sensor_data_ready;
extern volatile STS_M7_SensorDataTypeDef sts_m7_sensorData;
@ -95,8 +96,8 @@ typedef enum TxEventType_e
* @brief LoRaWAN NVM Flash address
* @note last 2 sector of a 128kBytes device
*/
#define LORAWAN_NVM_BASE_ADDRESS ((uint32_t)0x0803F000UL)
#define LORAWAN_NVM_BASE_ADDRESS ((void *)0x0803F000UL)
/* USER CODE BEGIN PD */
static const char *slotStrings[] = { "1", "2", "C", "C_MC", "P", "P_MC" };
/* USER CODE END PD */
@ -550,7 +551,7 @@ static void OnRxData(LmHandlerAppData_t *appData, LmHandlerRxParams_t *params)
case LORAWAN_USER_APP_PORT:
if (appData->BufferSize == 1)
{
AppLedStateOn = (appData->Buffer[0] -0x30) & 0x01;
AppLedStateOn = appData->Buffer[0] & 0x01;
if (AppLedStateOn == RESET)
{
APP_LOG(TS_OFF, VLEVEL_H, "LED OFF\r\n");
@ -944,7 +945,9 @@ static void SendTxData(void)
// sensor_t sensor_data;
STS_M7_SensorDataTypeDef m7_data;
UTIL_TIMER_Time_t nextTxIn = 0;
if (LmHandlerIsBusy() == false)
{
uint32_t i = 0;
//EnvSensors_Read(&sensor_data);
@ -958,8 +961,7 @@ static void SendTxData(void)
{
heart_beat_timer = 0U;
AppData.Buffer[i++] = (uint8_t)(99*batteryLevel/254); //#01
}
if (sensor_data_ready !=0U)
} else
{
sensor_data_ready = 0U;
AppData.Buffer[i++] = (uint8_t)(0xFF & sts_mtmcode1); //mtmcode1; //#01
@ -994,15 +996,6 @@ static void SendTxData(void)
AppData.Buffer[6], (AppData.Buffer[7]*255+AppData.Buffer[8]), (AppData.Buffer[9]*255+AppData.Buffer[10]), (AppData.Buffer[11]*255+AppData.Buffer[12]),
(AppData.Buffer[13]*255+AppData.Buffer[14]),(AppData.Buffer[15]*255+AppData.Buffer[16]),(AppData.Buffer[17]*255+AppData.Buffer[18]),AppData.Buffer[04]);
}
/*
if ((LmHandlerParams.ActiveRegion == LORAMAC_REGION_US915) || (LmHandlerParams.ActiveRegion == LORAMAC_REGION_AU915)
|| (LmHandlerParams.ActiveRegion == LORAMAC_REGION_AS923))
{ }
else
{ }
*/
AppData.BufferSize = i;
@ -1011,8 +1004,8 @@ static void SendTxData(void)
UTIL_TIMER_Stop(&JoinLedTimer);
HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_Pin, GPIO_PIN_RESET); /* LED_RED */
}
if (i>1)
{
//if (i>1)
//{
status = LmHandlerSend(&AppData, LmHandlerParams.IsTxConfirmed, false);
if (LORAMAC_HANDLER_SUCCESS == status)
{
@ -1026,7 +1019,9 @@ static void SendTxData(void)
APP_LOG(TS_ON, VLEVEL_L, "Next Tx in : ~%d second(s)\r\n", (nextTxIn / 1000));
}
}
}
//}
} // if (LmHandlerIsBusy() == false)
if (EventType == TX_ON_TIMER)
{
@ -1167,6 +1162,13 @@ static void OnBeaconStatusChange(LmHandlerBeaconParams_t *params)
/* USER CODE END OnBeaconStatusChange_1 */
}
static void OnSysTimeUpdate(void)
{
/* USER CODE BEGIN OnSysTimeUpdate_1 */
/* USER CODE END OnSysTimeUpdate_1 */
}
static void OnClassChange(DeviceClass_t deviceClass)
{
/* USER CODE BEGIN OnClassChange_1 */
@ -1344,13 +1346,9 @@ static void OnStoreContextRequest(void *nvm, uint32_t nvm_size)
/* USER CODE END OnStoreContextRequest_1 */
/* store nvm in flash */
if (HAL_FLASH_Unlock() == HAL_OK)
if (FLASH_IF_Erase(LORAWAN_NVM_BASE_ADDRESS, FLASH_PAGE_SIZE) == FLASH_IF_OK)
{
if (FLASH_IF_EraseByPages(PAGE(LORAWAN_NVM_BASE_ADDRESS), 1, 0U) == FLASH_OK)
{
FLASH_IF_Write(LORAWAN_NVM_BASE_ADDRESS, (uint8_t *)nvm, nvm_size, NULL);
}
HAL_FLASH_Lock();
FLASH_IF_Write(LORAWAN_NVM_BASE_ADDRESS, (const void *)nvm, nvm_size);
}
/* USER CODE BEGIN OnStoreContextRequest_Last */
@ -1362,7 +1360,7 @@ static void OnRestoreContextRequest(void *nvm, uint32_t nvm_size)
/* USER CODE BEGIN OnRestoreContextRequest_1 */
/* USER CODE END OnRestoreContextRequest_1 */
UTIL_MEM_cpy_8(nvm, (void *)LORAWAN_NVM_BASE_ADDRESS, nvm_size);
FLASH_IF_Read(nvm, LORAWAN_NVM_BASE_ADDRESS, nvm_size);
/* USER CODE BEGIN OnRestoreContextRequest_Last */
/* USER CODE END OnRestoreContextRequest_Last */
@ -1371,7 +1369,7 @@ static void OnRestoreContextRequest(void *nvm, uint32_t nvm_size)
void OnStoreSTSCFGContextRequest(void)
{
/* USER CODE BEGIN OnStoreContextRequest_1 */
uint8_t i=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="", nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE;
uint8_t i=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]={0x0};
#ifdef YUNHORN_STS_M7_ENABLED
sts_cfg_nvm.length = (uint8_t) NVM_CFG_PARAMETER_SIZE;
@ -1397,13 +1395,9 @@ void OnStoreSTSCFGContextRequest(void)
#endif
/* USER CODE END OnStoreContextRequest_1 */
/* store nvm in flash */
if (HAL_FLASH_Unlock() == HAL_OK)
if (FLASH_IF_Erase(STS_CONFIG_NVM_BASE_ADDRESS, FLASH_PAGE_SIZE) == FLASH_IF_OK)
{
if (FLASH_IF_EraseByPages(PAGE(STS_CONFIG_NVM_BASE_ADDRESS), 1, 0U) == FLASH_OK)
{
FLASH_IF_Write(STS_CONFIG_NVM_BASE_ADDRESS, nvm_store_value, YUNHORN_STS_MAX_NVM_CFG_SIZE, NULL);
}
HAL_FLASH_Lock();
FLASH_IF_Write(STS_CONFIG_NVM_BASE_ADDRESS, (const void *)nvm_store_value, YUNHORN_STS_MAX_NVM_CFG_SIZE);
}
/* USER CODE BEGIN OnStoreContextRequest_Last */
@ -1418,10 +1412,11 @@ void OnStoreSTSCFGContextRequest(void)
void OnRestoreSTSCFGContextRequest(uint8_t *cfg_in_nvm)
{
/* USER CODE BEGIN OnRestoreSTSCFGContextRequest_1 */
uint8_t i=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="", nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE;
uint8_t i=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]={0x0};
/* USER CODE END OnRestoreSTSCFGContextRequest_1 */
UTIL_MEM_cpy_8(nvm_store_value, (void *)STS_CONFIG_NVM_BASE_ADDRESS, nvm_store_size);
FLASH_IF_Read(nvm_store_value, STS_CONFIG_NVM_BASE_ADDRESS, YUNHORN_STS_MAX_NVM_CFG_SIZE);
/* USER CODE BEGIN OnRestoreSTSCFGContextRequest_Last */
memcpy(cfg_in_nvm, nvm_store_value, YUNHORN_STS_MAX_NVM_CFG_SIZE);
@ -1436,7 +1431,7 @@ void OnRestoreSTSCFGContextRequest(uint8_t *cfg_in_nvm)
void STS_REBOOT_CONFIG_Init(void)
{
/* USER CODE BEGIN OnRestoreContextRequest_1 */
uint8_t i=0, nvm_stored_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="", nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE;
uint8_t i=0, nvm_stored_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]={0x0}, nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE;
/* USER CODE END OnRestoreContextRequest_1 */
UTIL_MEM_cpy_8(nvm_stored_value, (void *)STS_CONFIG_NVM_BASE_ADDRESS, nvm_store_size);