meshx_nvs.c File Reference

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

#include "meshx_nvs.h"
#include "unit_test.h"
#include "interface/utils/meshx_nvs_interface.h"
#include "meshx_control_task.h"
#include "interface/utils/meshx_tiny_printf.h"

Data Structures
struct	meshx_nvs_write_list
	Linked list structure used to store key-value pairs that need to be written to NVS. More...

Macros
#define	MESHX_NVS_INIT_MAGIC   0x5489
#define	MESHX_NVS_NAMESPACE_PID   "MESHX_PID"
#define	MESHX_NVS_NAMESPACE_CID   "MESHX_CID"
#define	MESHX_NVS_TIMER_NAME   "MESHX_COMMIT_TIMER"
#define	MESHX_NVS_ELEMENT_CTX   "MXE_%02x_%04x"
#define	MESHX_NVS_RELOAD_ONE_SHOT   0
#define	MESHX_KEY_NAME_MAX_SIZE   16
#define	MESHX_KEY_VALUE_MAX_SIZE   256
#define	MESHX_NVS_UNIT_TEST_KEY   "MESHX_UT"

Typedefs
typedef struct meshx_nvs_write_list	meshx_nvs_write_list_t
typedef enum meshx_nvs_cli_cmd	meshx_nvs_cli_cmd_t
	MeshX NVS unit test command IDs.

Enumerations
enum	meshx_nvs_cli_cmd {   MESHX_NVS_CLI_CMD_OPEN ,   MESHX_NVS_CLI_CMD_SET ,   MESHX_NVS_CLI_CMD_GET ,   MESHX_NVS_CLI_CMD_COMMIT ,   MESHX_NVS_CLI_CMD_REMOVE ,   MESHX_NVS_CLI_CMD_ERASE ,   MESHX_NVS_CLI_CMD_CLOSE ,   MESHX_NVS_CLI_MAX }
	MeshX NVS unit test command IDs. More...

Functions
static meshx_err_t	meshx_nvs_unit_test_cb_handler (int cmd_id, int argc, char **argv)
	Callback handler for MeshX NVS unit test command.
static meshx_err_t	meshx_nvs_control_msg_handler (dev_struct_t *pdev, control_task_msg_evt_t evt, void *params)
static void	meshx_nvs_os_timer_cb (const meshx_os_timer_t *p_timer)
	MeshX NVS Timer callback.
static meshx_err_t	meshx_nvs_erase_prod_init (uint16_t cid, uint16_t pid)
	Erase the NVS and set the product ID.
meshx_err_t	meshx_nvs_init (void)
	MeshX NVS Initialisation.
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_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_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.

Variables
meshx_nvs_write_list_t *	meshx_nvs_write_list_head = NULL
	Head of the linked list used to store key-value pairs that need to be written to NVS.
static meshx_nvs_t	meshx_nvs_inst

Detailed Description

Implementation for MeshX Non-Volatile Storage (NVS) operations.

Copyright © 2024 - 2025 MeshX

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_KEY_NAME_MAX_SIZE

#define MESHX_KEY_NAME_MAX_SIZE   16

MESHX_KEY_VALUE_MAX_SIZE

#define MESHX_KEY_VALUE_MAX_SIZE   256

MESHX_NVS_ELEMENT_CTX

#define MESHX_NVS_ELEMENT_CTX   "MXE_%02x_%04x"

MESHX_NVS_INIT_MAGIC

#define MESHX_NVS_INIT_MAGIC   0x5489

MESHX_NVS_NAMESPACE_CID

#define MESHX_NVS_NAMESPACE_CID   "MESHX_CID"

MESHX_NVS_NAMESPACE_PID

#define MESHX_NVS_NAMESPACE_PID   "MESHX_PID"

MESHX_NVS_RELOAD_ONE_SHOT

#define MESHX_NVS_RELOAD_ONE_SHOT   0

MESHX_NVS_TIMER_NAME

#define MESHX_NVS_TIMER_NAME   "MESHX_COMMIT_TIMER"

MESHX_NVS_UNIT_TEST_KEY

#define MESHX_NVS_UNIT_TEST_KEY   "MESHX_UT"

Typedef Documentation

meshx_nvs_cli_cmd_t

typedef enum meshx_nvs_cli_cmd meshx_nvs_cli_cmd_t

MeshX NVS unit test command IDs.

meshx_nvs_write_list_t

typedef struct meshx_nvs_write_list meshx_nvs_write_list_t

Enumeration Type Documentation

meshx_nvs_cli_cmd

enum meshx_nvs_cli_cmd

MeshX NVS unit test command IDs.

Enumerator
MESHX_NVS_CLI_CMD_OPEN
MESHX_NVS_CLI_CMD_SET
MESHX_NVS_CLI_CMD_GET
MESHX_NVS_CLI_CMD_COMMIT
MESHX_NVS_CLI_CMD_REMOVE
MESHX_NVS_CLI_CMD_ERASE
MESHX_NVS_CLI_CMD_CLOSE
MESHX_NVS_CLI_MAX

                              {
    MESHX_NVS_CLI_CMD_OPEN,         /* ut 3 0 0 */
    MESHX_NVS_CLI_CMD_SET,          /* ut 3 1 1 [arm_timer?] */
    MESHX_NVS_CLI_CMD_GET,          /* ut 3 2 0 */
    MESHX_NVS_CLI_CMD_COMMIT,       /* ut 3 3 0 */
    MESHX_NVS_CLI_CMD_REMOVE,       /* ut 3 4 0 */
    MESHX_NVS_CLI_CMD_ERASE,        /* ut 3 5 0 */
    MESHX_NVS_CLI_CMD_CLOSE,        /* ut 3 6 0 */
    MESHX_NVS_CLI_MAX
}meshx_nvs_cli_cmd_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_control_msg_handler()

meshx_err_t meshx_nvs_control_msg_handler ( dev_struct_t * pdev, control_task_msg_evt_t evt, void * params )

static

{
    if (evt & CONTROL_TASK_MSG_EVT_SYSTEM_NVS_COMMIT) {
        meshx_nvs_commit();
    }
    return MESHX_SUCCESS;
}

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_erase_prod_init()

meshx_err_t meshx_nvs_erase_prod_init ( uint16_t cid, uint16_t pid )

static

Erase the NVS and set the product ID.

This function erases the NVS and sets the product ID.

Parameters

[in]	cid	Company ID
[in]	pid	Product ID

Returns

• MESHX_SUCCESS: Success.

{
    meshx_err_t err = MESHX_SUCCESS;
    err = meshx_nvs_erase();
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_erase %p", (void *)err);
        return err;
    }
 
    meshx_nvs_inst.pid = pid;
    meshx_nvs_inst.cid = cid;
 
    err = meshx_nvs_set(
        MESHX_NVS_NAMESPACE_PID,
        &(meshx_nvs_inst.pid),
        sizeof(meshx_nvs_inst.pid),
        MESHX_NVS_NO_AUTO_COMMIT);
 
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_set %p", (void *)err);
        return err;
    }
 
    err = meshx_nvs_set(
        MESHX_NVS_NAMESPACE_CID,
        &(meshx_nvs_inst.cid),
        sizeof(meshx_nvs_inst.cid),
        MESHX_NVS_AUTO_COMMIT);
 
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "meshx_nvs_set %p", (void *)err);
        return err;
    }
 
    meshx_nvs_commit();
 
    return err;
}

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_os_timer_cb()

void meshx_nvs_os_timer_cb ( const meshx_os_timer_t * p_timer )

static

MeshX NVS Timer callback.

Note

This is responsible for performing the commit after stability timeout

Parameters

[in]

p_timer

meshx_os_timer param pointer *

{
    MESHX_UNUSED(p_timer);
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "%s fire -> Offloading commit to control task", OS_TMER_GET_TIMER_NAME(p_timer));
 
    control_task_msg_publish(CONTROL_TASK_MSG_CODE_SYSTEM, CONTROL_TASK_MSG_EVT_SYSTEM_NVS_COMMIT, NULL, 0);
}

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;
}

meshx_nvs_unit_test_cb_handler()

meshx_err_t meshx_nvs_unit_test_cb_handler ( int cmd_id, int argc, char ** argv )

static

Callback handler for MeshX NVS unit test command.

This function handles MeshX NVS unit test command by processing the provided command ID and arguments.

Parameters

[in]	cmd_id	The command ID to be processed.
[in]	argc	The number of arguments provided.
[in]	argv	The array of arguments.

Returns

• MESHX_SUCCESS: Success
• MESHX_INVALID_ARG: Invalid arguments
• Other error codes depending on the implementation

{
    meshx_err_t err = MESHX_SUCCESS;
    uint32_t ut_blob = 0xDEAD;
    uint32_t ut_blob_get = 0x00;
    bool arm_timer;
 
    MESHX_UNUSED(argc);
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_NVS, "argc|cmd_id: %d|%d", argc, cmd_id);
    if (cmd_id >= MESHX_NVS_CLI_MAX)
    {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "Invalid number of arguments");
        return MESHX_INVALID_ARG;
    }
 
    switch(cmd_id)
    {
        case MESHX_NVS_CLI_CMD_OPEN:
            /* MeshX NVS Open uses defaut values */
            err = meshx_nvs_open(CONFIG_CID_ID, CONFIG_PID_ID, 0);
            break;
        case MESHX_NVS_CLI_CMD_SET:
            arm_timer = UT_GET_ARG(0, bool, argv) == 0 ? MESHX_NVS_NO_AUTO_COMMIT : MESHX_NVS_AUTO_COMMIT;
            err = meshx_nvs_set(MESHX_NVS_UNIT_TEST_KEY, &ut_blob, sizeof(ut_blob), arm_timer);
            break;
        case MESHX_NVS_CLI_CMD_GET:
            err = meshx_nvs_get(MESHX_NVS_UNIT_TEST_KEY, &ut_blob_get, sizeof(ut_blob_get));
            if(err == MESHX_SUCCESS && ut_blob != ut_blob_get)
                MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_NVS, "MESHX NVS Integrety Test Failed");
            break;
        case MESHX_NVS_CLI_CMD_COMMIT:
            err = meshx_nvs_commit();
            break;
        case MESHX_NVS_CLI_CMD_REMOVE:
            err = meshx_nvs_remove(MESHX_NVS_UNIT_TEST_KEY);
            break;
        case MESHX_NVS_CLI_CMD_ERASE:
            err = meshx_nvs_erase();
            break;
        case MESHX_NVS_CLI_CMD_CLOSE:
            err = meshx_nvs_close();
            break;
        default:
            err = MESHX_INVALID_ARG;
            break;
    }
 
    return err;
}

Variable Documentation

meshx_nvs_inst

meshx_nvs_t meshx_nvs_inst

static

meshx_nvs_write_list_head

meshx_nvs_write_list_t* meshx_nvs_write_list_head = NULL

Head of the linked list used to store key-value pairs that need to be written to NVS.