meshx_ro_cfg.h File Reference

Persistent Serialized Configuration Loader (Read-Only). More...

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "meshx_err.h"

Go to the source code of this file.

Functions
meshx_err_t	meshx_ro_cfg_init (uint16_t *cid, uint16_t *pid, char *product_name, size_t name_max_len, uint8_t *uuid)
	Initialize and load the MeshX configuration from the meshx_cfg partition.

Detailed Description

Persistent Serialized Configuration Loader (Read-Only).

Copyright © 2024 - 2025 MeshX

Function Documentation

meshx_ro_cfg_init()

meshx_err_t meshx_ro_cfg_init	(	uint16_t *	cid,
		uint16_t *	pid,
		char *	product_name,
		size_t	name_max_len,
		uint8_t *	uuid )

Initialize and load the MeshX configuration from the meshx_cfg partition.

This function locates the meshx_cfg partition using FAL, validates the CRC-16-CCITT checksums of the header and payload, decodes the Protobuf payload using nanopb, and applies the configuration (e.g., global IDs, element composition, and GPIO bindings).

If the loaded UUID is all zeros (or missing), the system should fall back to the legacy UUID generation method (e.g., based on device MAC).

Parameters

[out]	cid	Pointer to store the loaded Company ID.
[out]	pid	Pointer to store the loaded Product ID.
[out]	product_name	Buffer to store the loaded product name.
[in]	name_max_len	Maximum length of the product_name buffer.
[out]	uuid	Buffer to store the loaded 16-byte UUID.

Returns

meshx_err_t MESHX_SUCCESS on success, or an error code on failure.

                                                                                                                    {
    meshx_fal_partition_t part;
    if (meshx_fal_find_partition("meshx_cfg", &part) != MESHX_SUCCESS) {
        MESHX_LOGI(MODULE_ID_RO_CFG, "No meshx_cfg partition found");
        return MESHX_NOT_FOUND;
    }
 
    meshx_cfg_header_t header;
    if (meshx_fal_read(&part, 0, (uint8_t *)&header, MESHX_HDR_SIZE) != MESHX_SUCCESS) {
        return MESHX_ERR_PLAT;
    }
 
    if (header.magic != MESHX_CFG_MAGIC) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Invalid config magic (0x%08X, exp: 0x%08X)", header.magic, MESHX_CFG_MAGIC);
        return MESHX_ERR_RO_CFG_FORMAT;
    }
 
    if (header.version != MESHX_CFG_VERSION) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Unsupported config version (0x%02X)", header.version);
        return MESHX_ERR_RO_CFG_VERSION;
    }
 
    if (header.schema_id != MESHX_SCHEMA_ID) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Schema mismatch! Binary ID: 0x%08X, Firmware ID: 0x%08X",
                   header.schema_id, MESHX_SCHEMA_ID);
        return MESHX_ERR_RO_CFG_VERSION;
    }
 
    // Validate header CRC (all fields except header_crc and payload_crc)
    uint16_t expected_hdr_crc = calc_crc16_ccitt((uint8_t *)&header, MESHX_HDR_SIZE - 4);
    if (header.header_crc != expected_hdr_crc) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Config header CRC mismatch (calc: 0x%04X, exp: 0x%04X)", expected_hdr_crc, header.header_crc);
        return MESHX_ERR_RO_CFG_CRC;
    }
 
    size_t payload_len = header.total_len - MESHX_HDR_SIZE;
    uint8_t *payload = malloc(payload_len);
    if (!payload) return MESHX_NO_MEM;
 
    if (meshx_fal_read(&part, MESHX_HDR_SIZE, payload, payload_len) != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Failed to read config payload");
        free(payload);
        return MESHX_ERR_PLAT;
    }
 
    uint16_t expected_pld_crc = calc_crc16_ccitt(payload, payload_len);
    if (header.payload_crc != expected_pld_crc) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Config payload CRC mismatch (calc: 0x%04X, exp: 0x%04X)", expected_pld_crc, header.payload_crc);
        free(payload);
        return MESHX_ERR_RO_CFG_CRC;
    }
 
    MeshXConfig config = MeshXConfig_init_zero;
    config.elements.funcs.decode = elements_decode_cb;
    config.gpio.funcs.decode = gpio_decode_cb;
    config.bindings.funcs.decode = bindings_decode_cb;
 
    pb_istream_t stream = pb_istream_from_buffer(payload, payload_len);
 
    meshx_builder_begin();
 
    if (!pb_decode(&stream, MeshXConfig_fields, &config)) {
        MESHX_LOGE(MODULE_ID_RO_CFG, "Config protobuf decode failed");
        free(payload);
        return MESHX_ERR_RO_CFG_FORMAT;
    }
 
    meshx_builder_commit();
 
    if (config.has_product) {
        if (cid) *cid = config.product.cid;
        if (pid) *pid = config.product.pid;
        if (product_name) {
            strncpy(product_name, config.product.name, name_max_len - 1);
            product_name[name_max_len - 1] = '\0';
        }
        if (uuid && config.product.has_uuid) {
            memcpy(uuid, config.product.uuid, 16);
            MESHX_LOGD(MODULE_ID_RO_CFG, "Loaded UUID: %02X%02X%02X%02X...", uuid[0], uuid[1], uuid[2], uuid[3]);
        }
        MESHX_LOGI(MODULE_ID_RO_CFG, "Loaded Config: CID 0x%04X, PID 0x%04X, Name: %s",
                 config.product.cid, config.product.pid, config.product.name);
    }   
 
    free(payload);
    return MESHX_SUCCESS;
}