meshx_nvs.h File Reference

Header file for MeshX Non-Volatile Storage (NVS) operations. More...

#include <stdint.h>
#include <meshx_common.h>
#include "meshx_control_task.h"
#include "meshx_os_timer.h"

Go to the source code of this file.

Data Structures
struct	meshx_nvs
	Structure to hold the MeshX NVS data. More...

Macros
#define	MESHX_NVS_TIMER_PERIOD_DEF   1000
#define	MESHX_NVS_TIMER_PERIOD   MESHX_NVS_TIMER_PERIOD_DEF
#define	MESHX_NVS_AUTO_COMMIT   true
#define	MESHX_NVS_NO_AUTO_COMMIT   false

Typedefs
typedef struct meshx_nvs	meshx_nvs_t

Functions
meshx_err_t	meshx_nvs_init (void)
	MeshX NVS Initialisation.
meshx_err_t	meshx_nvs_erase (void)
	Erase all key-value pairs stored in the NVS.
meshx_err_t	meshx_nvs_commit (void)
	Commit changes to the NVS.
meshx_err_t	meshx_nvs_close (void)
	Close the NVS handle.
meshx_err_t	meshx_nvs_remove (char const *key)
	Remove a key-value pair from the NVS.
meshx_err_t	meshx_nvs_open (uint16_t cid, uint16_t pid, uint32_t commit_timeout_ms)
	Open the NVS with a timeout.
meshx_err_t	meshx_nvs_get (char const *key, void *blob, uint16_t blob_size)
	Get a value from the NVS.
meshx_err_t	meshx_nvs_set (char const *key, void const *blob, uint16_t blob_size, bool arm_timer)
	Set a value in the NVS.
meshx_err_t	meshx_nvs_element_ctx_get (uint16_t element_id, meshx_element_type_t element_type, void *blob, size_t blob_size)
	Retrieve the context of a specific element from NVS.
meshx_err_t	meshx_nvs_element_ctx_set (uint16_t element_id, meshx_element_type_t element_type, const void *blob, size_t blob_size)
	Store the context of a specific element to NVS.
meshx_err_t	meshx_nvs_element_ctx_remove (uint16_t element_id, meshx_element_type_t element_type)
	Remove the context of a specific element from NVS.

Detailed Description

Header file for MeshX Non-Volatile Storage (NVS) operations.

This file provides APIs to manage the Non-Volatile Storage (NVS) used in the MeshX system. It includes functions to read, write, erase, and manage key-value pairs stored persistently.

Author

Pranjal Chanda

Macro Definition Documentation

MESHX_NVS_AUTO_COMMIT

#define MESHX_NVS_AUTO_COMMIT   true

MESHX_NVS_NO_AUTO_COMMIT

#define MESHX_NVS_NO_AUTO_COMMIT   false

MESHX_NVS_TIMER_PERIOD

#define MESHX_NVS_TIMER_PERIOD   MESHX_NVS_TIMER_PERIOD_DEF

MESHX_NVS_TIMER_PERIOD_DEF

#define MESHX_NVS_TIMER_PERIOD_DEF   1000

Typedef Documentation

meshx_nvs_t

typedef struct meshx_nvs meshx_nvs_t

Function Documentation

meshx_nvs_close()

meshx_err_t meshx_nvs_close

(

void

)

Close the NVS handle.

This function releases any resources associated with the NVS handle.

Returns

• MESHX_SUCCESS: Success.

{
    meshx_err_t err = MESHX_SUCCESS;
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    err = meshx_nvs_plat_close(meshx_nvs_inst.meshx_nvs_handle);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "nvs_close %p", (void *)err);
    }
 
#if MESHX_NVS_TIMER_PERIOD
    err = meshx_os_timer_delete(&(meshx_nvs_inst.meshx_nvs_commit_tmr));
#endif /* MESHX_NVS_TIMER_PERIOD */
    meshx_nvs_inst.init = 0;
    return err;
}

meshx_nvs_commit()

meshx_err_t meshx_nvs_commit

(

void

)

Commit changes to the NVS.

This function ensures that any pending changes to the NVS are flushed to persistent storage.

Returns

• MESHX_SUCCESS: Success.

{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = MESHX_SUCCESS;
    meshx_nvs_write_list_t *cur = meshx_nvs_write_list_head;
    meshx_nvs_write_list_t *prev;
 
    if (!cur) return MESHX_SUCCESS;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "Committing pending NVS writes...");
 
    while (cur) {
        err = meshx_nvs_plat_write(meshx_nvs_inst.meshx_nvs_handle, cur->key, cur->data, cur->len);
        if (err) {
            MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "commit failed for key: %s", cur->key);
        }
        prev = cur;
        cur = cur->next;
        free(prev);
    }
 
    meshx_nvs_write_list_head = NULL;
 
    if (err == MESHX_SUCCESS) {
        // Only commit to platform once, after all writes
        err = meshx_nvs_plat_commit(meshx_nvs_inst.meshx_nvs_handle);
    }
 
    return err;
}

meshx_nvs_element_ctx_get()

meshx_err_t meshx_nvs_element_ctx_get	(	uint16_t	element_id,
		meshx_element_type_t	element_type,
		void *	blob,
		size_t	blob_size )

Retrieve the context of a specific element from NVS.

Parameters

[in]	element_id	The ID of the element whose context is to be retrieved.
[in]	element_type	The type of the element.
[out]	blob	Pointer to the buffer where the retrieved context will be stored.
[in]	blob_size	Size of the buffer provided to store the context.

Returns

• MESHX_SUCCESS: Successfully retrieved the context.

{
    char key[MESHX_KEY_NAME_MAX_SIZE];
    meshx_tiny_snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, (uint8_t)element_type, element_id);
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_element_ctx_get: key=%s, size=%d", key, (int)blob_size);
    return meshx_nvs_get(key, blob, blob_size);
}

meshx_nvs_element_ctx_remove()

meshx_err_t meshx_nvs_element_ctx_remove	(	uint16_t	element_id,
		meshx_element_type_t	element_type )

Remove the context of a specific element from NVS.

Parameters

[in]	element_id	The ID of the element whose context is to be removed.
[in]	element_type	The type of the element.

Returns

• MESHX_SUCCESS: Successfully removed the context.

{
    char key[MESHX_KEY_NAME_MAX_SIZE];
    if (element_type == MESHX_ELEMENT_TYPE_ALL)
    {
        meshx_err_t err = MESHX_SUCCESS;
        for (uint8_t t = 0; t < (uint8_t)MESHX_ELEMENT_TYPE_MAX; t++)
        {
            snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, t, element_id);
            meshx_err_t temp_err = meshx_nvs_remove(key);
            if (temp_err != MESHX_SUCCESS && temp_err != MESHX_NOT_FOUND)
            {
                err = temp_err;
            }
        }
        return err;
    }
    snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, (uint8_t)element_type, element_id);
    meshx_tiny_snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, (uint8_t)element_type, element_id);
    return meshx_nvs_remove(key);
}

meshx_nvs_element_ctx_set()

meshx_err_t meshx_nvs_element_ctx_set	(	uint16_t	element_id,
		meshx_element_type_t	element_type,
		const void *	blob,
		size_t	blob_size )

Store the context of a specific element to NVS.

Parameters

[in]	element_id	The ID of the element whose context is to be stored.
[in]	element_type	The type of the element.
[in]	blob	Pointer to the buffer containing the context to be stored.
[in]	blob_size	Size of the buffer containing the context.

Returns

• MESHX_SUCCESS: Successfully stored the context.

{
    char key[MESHX_KEY_NAME_MAX_SIZE];
    meshx_tiny_snprintf(key, MESHX_KEY_NAME_MAX_SIZE, MESHX_NVS_ELEMENT_CTX, (uint8_t)element_type, element_id);
    return meshx_nvs_set(key, blob, (uint16_t) blob_size, MESHX_NVS_AUTO_COMMIT);
}

meshx_nvs_erase()

meshx_err_t meshx_nvs_erase

(

void

)

Erase all key-value pairs stored in the NVS.

This function clears all data stored in the Non-Volatile Storage.

Returns

• MESHX_SUCCESS: Success.

{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return meshx_nvs_plat_erase(meshx_nvs_inst.meshx_nvs_handle);
}

meshx_nvs_get()

meshx_err_t meshx_nvs_get	(	char const *	key,
		void *	blob,
		uint16_t	blob_size )

Get a value from the NVS.

This function retrieves a value associated with the given key from the NVS.

Parameters

[in]	key	The key identifying the value to be retrieved.
[out]	blob	Pointer to the buffer where the value will be stored.
[in]	blob_size	Size of the buffer in bytes.

Returns

• MESHX_SUCCESS: Success.

{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
    return meshx_nvs_plat_read(meshx_nvs_inst.meshx_nvs_handle, key, blob, blob_size);
}

meshx_nvs_init()

meshx_err_t meshx_nvs_init

(

void

)

MeshX NVS Initialisation.

Returns

• MESHX_SUCCESS: Success.

{
    meshx_err_t err = MESHX_SUCCESS;
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MODULE_ID_COMPONENT_MESHX_NVS, &meshx_nvs_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
    err = control_task_msg_subscribe(CONTROL_TASK_MSG_CODE_SYSTEM, CONTROL_TASK_MSG_EVT_SYSTEM_NVS_COMMIT, &meshx_nvs_control_msg_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "control_task_msg_subscribe failed: (%d)", err);
        return err;
    }
 
    return err;
}

meshx_nvs_open()

meshx_err_t meshx_nvs_open	(	uint16_t	cid,
		uint16_t	pid,
		uint32_t	commit_timeout_ms )

Open the NVS with a timeout.

This function initializes the NVS and sets a timeout for stability operations.

Note

NVS Namespace: MESHX_NVS_NAMESPACE

Parameters

[in]	cid	Company ID
[in]	pid	Product ID
[in]	commit_timeout_ms	Timeout for stability operations in milliseconds.

Note

commit_timeout_ms = 0 -> use MESHX_NVS_TIMER_PERIOD

Returns

• MESHX_SUCCESS: Success.

{
    if (meshx_nvs_inst.init == MESHX_NVS_INIT_MAGIC)
    {
        return MESHX_INVALID_STATE;
    }
 
    meshx_err_t err;
 
    err = meshx_nvs_plat_open(&(meshx_nvs_inst.meshx_nvs_handle));
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "nvs_open %p", (void *)err);
        return err;
    }
 
#if MESHX_NVS_TIMER_PERIOD
    if(commit_timeout_ms == 0)
    {
        commit_timeout_ms = MESHX_NVS_TIMER_PERIOD;
    }
    err = meshx_os_timer_create(
        MESHX_NVS_TIMER_NAME,
        commit_timeout_ms,
        MESHX_NVS_RELOAD_ONE_SHOT,
        &meshx_nvs_os_timer_cb,
        &(meshx_nvs_inst.meshx_nvs_commit_tmr));
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "os_timer_create %p", (void *)err);
        return err;
    }
#else
    MESHX_UNUSED(commit_timeout_ms);
#endif /* MESHX_NVS_TIMER_PERIOD */
 
    meshx_nvs_inst.init = MESHX_NVS_INIT_MAGIC;
 
    err = meshx_nvs_get(
        MESHX_NVS_NAMESPACE_CID,
            &(meshx_nvs_inst.cid),
        sizeof(meshx_nvs_inst.cid));
 
    if (err == MESHX_SUCCESS)
    {
        err = meshx_nvs_get(
            MESHX_NVS_NAMESPACE_PID,
                &(meshx_nvs_inst.pid),
            sizeof(meshx_nvs_inst.pid));
    }
 
    if(err != MESHX_SUCCESS)
    {
        MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_NVS, "Product ID not found in NVS reinitializing MeshX NVS (err: 0x%x)", err);
        err = meshx_nvs_erase_prod_init(cid, pid);
    }
 
    else
    {
        if (meshx_nvs_inst.cid == cid && meshx_nvs_inst.pid == pid)
        {
            MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "Product ID match: %x|%x", meshx_nvs_inst.pid, meshx_nvs_inst.cid);
        }
        else
        {
            MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_NVS, "Product ID mismatch: %x|%x (Expected: %x|%x)", meshx_nvs_inst.pid, meshx_nvs_inst.cid, pid, cid);
            err = meshx_nvs_erase_prod_init(cid, pid);
        }
    }
 
    return err;
}

meshx_nvs_remove()

meshx_err_t meshx_nvs_remove

(

char const *

key

)

Remove a key-value pair from the NVS.

This function deletes a specific key-value pair from the NVS based on the provided key.

Parameters

[in]

key

The key identifying the value to be removed.

Returns

• MESHX_SUCCESS: Success.

{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    return meshx_nvs_plat_remove(meshx_nvs_inst.meshx_nvs_handle, key);
}

meshx_nvs_set()

meshx_err_t meshx_nvs_set	(	char const *	key,
		void const *	blob,
		uint16_t	blob_size,
		bool	arm_timer )

Set a value in the NVS.

This function stores a value associated with the given key in the NVS.

Parameters

[in]	key	The key identifying the value to be stored.
[in]	blob	Pointer to the buffer containing the value.
[in]	blob_size	Size of the buffer in bytes.
[in]	arm_timer	Re-arm stability timer and auto commit

Returns

• MESHX_SUCCESS: Success.

{
    if (meshx_nvs_inst.init != MESHX_NVS_INIT_MAGIC)
        return MESHX_INVALID_STATE;
 
    if (blob_size > MESHX_KEY_VALUE_MAX_SIZE)
        return MESHX_INVALID_ARG;
 
    // Check if key already exists in list → overwrite instead of duplicate
    meshx_nvs_write_list_t *cur = meshx_nvs_write_list_head;
    while (cur) {
        if (strncmp(cur->key, key, MESHX_KEY_NAME_MAX_SIZE-1) == 0)
        {
            cur->key[MESHX_KEY_NAME_MAX_SIZE - 1] = '\0';
            memcpy(cur->data, blob, blob_size);
            cur->len = blob_size;
            goto restart_timer;  // skip new node alloc
        }
        cur = cur->next;
    }
 
    // Allocate new node
    meshx_nvs_write_list_t *node = malloc(sizeof(meshx_nvs_write_list_t));
    if (!node) return MESHX_NO_MEM;
 
    strncpy(node->key, key, MESHX_KEY_NAME_MAX_SIZE);
    memcpy(node->data, blob, blob_size);
    node->len = blob_size;
    node->next = meshx_nvs_write_list_head;
    meshx_nvs_write_list_head = node;
 
restart_timer:
    if (arm_timer)
    {
#if MESHX_NVS_TIMER_PERIOD
        meshx_err_t err = meshx_os_timer_restart(meshx_nvs_inst.meshx_nvs_commit_tmr);
        if (err)
        {
            MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_os_timer_restart failed: (%d)", err);
        }
#else
        meshx_nvs_commit();
#endif /* MESHX_NVS_TIMER_PERIOD */
    }
 
    return MESHX_SUCCESS;
}