diff --git a/Core/Inc/flash_if.h b/Core/Inc/flash_if.h
index bbb41b1..8741487 100644
--- a/Core/Inc/flash_if.h
+++ b/Core/Inc/flash_if.h
@@ -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 */
 
diff --git a/Core/Inc/yunhorn_sts_prd_conf.h b/Core/Inc/yunhorn_sts_prd_conf.h
index d68b3ef..853aad9 100644
--- a/Core/Inc/yunhorn_sts_prd_conf.h
+++ b/Core/Inc/yunhorn_sts_prd_conf.h
@@ -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 	*/
 
diff --git a/Core/Inc/yunhorn_sts_sensors.h b/Core/Inc/yunhorn_sts_sensors.h
index e366ba7..7bf7afe 100644
--- a/Core/Inc/yunhorn_sts_sensors.h
+++ b/Core/Inc/yunhorn_sts_sensors.h
@@ -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;
 
 /**
diff --git a/Core/Src/flash_if.c b/Core/Src/flash_if.c
index 71738dd..c99cdfc 100644
--- a/Core/Src/flash_if.c
+++ b/Core/Src/flash_if.c
@@ -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 */
diff --git a/LoRaWAN/App/lora_app.c b/LoRaWAN/App/lora_app.c
index 4c47de9..a5c314c 100644
--- a/LoRaWAN/App/lora_app.c
+++ b/LoRaWAN/App/lora_app.c
@@ -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);