Question

I’m in the process of designing a embedded C data storage module. It will be included by files/modules who want access to this “shared” system-wide data. Multiple tasks aggregate dozens of inputs (GPIO, CAN, I2C/SPI/SSP data, etc) and stores those values off using the API. Then, other tasks can access the data safely through the API. The system is an embedded app with an RTOS, so mutexes are used to protect the data. These ideas will be used regardless of the implementation

I’ve designed something like this in the past, and I’m trying to improve upon it. I’m currently halfway through a new implementation and I’m running into a few hiccups and would really benefit from a fresh perspective.

Quick rundown of the requirements of this module:

Ideally, there would be one interface that can access the variables (one get, one set).

I’d like to return different variable types (floats, ints, etc). This means macros are probably needed.

I’m not pressed for code space, but it’s always a concern

Quick gets/sets are absolutely paramount (which means storing in strings ala xml/json is out)

No new variables need to be added during runtime. Everything is statically defined at boot

The question is how would you go about designing something like this? Enumerations, structures, accessors, macros, etc? I’m not looking for code here, just discussing general overall design ideas. If there’s a solution on the internet that addresses these sorts of things, perhaps even just a link is sufficient.

Answer 1

Figured I’d update one of my only unaccepted questions. Here’s my final implementation. Been using this for over a year and it works fantastic. Very easy to add variables to and very little overhead for the benefit it gives us.

lib_data.h:

#ifndef __LIB_DATA_H
#define __LIB_DATA_H

#include <type.h>

/****************************************************************************************
 * Constant Definitions
 ***************************************************************************************/

/* Varname, default value (uint32_t) */
#define DATA_LIST                                                                       \
  DM(D_VAR1, 0)                                                                         \
  DM(D_VAR2, 1)                                                                         \
  DM(D_VAR3, 43)

#define DM(y, z)    y,

/* create data structure from the macro */
typedef enum {
    DATA_LIST
    NUM_DATA_VARIABLES
} dataNames_t;

typedef struct {
    dataNames_t name;
    uint32_t value;
} dataPair_t;

/* the macro has to be undefined to allow the fault list to be reused without being
 * defined multiple times
 *
 * this requires:
 * a file specific lint option to suppress the rule for use of #undef
 */
#undef DM

/****************************************************************************************
 * Data Prototypes
 ***************************************************************************************/

/****************************************************************************************
 * External Function Prototypes
 ***************************************************************************************/

/**
 * Fetch a machine parameter
 *
 * \param dataName The variable from DATA_LIST that you want to fetch
 *
 * \return The value of the requested parameter
 *
 */
uint32_t lib_data_Get(dataNames_t dataName);

/**
 * Set a machine parameter
 *
 * \param dataName The variable from DATA_LIST that you want to set
 * \param dataVal The value you want to set the variable to
 *
 * \return void
 *
 */
void lib_data_Set(dataNames_t dataName, uint32_t dataVal);

#endif /* __LIB_DATA_H */

lib_data.c:

#include <type.h>
#include "lib_data.h"

/****************************************************************************************
 * Variable Declarations
***************************************************************************************/
/* Used to initialize the data array with defaults ##U appends a 'U' to the bare
 * integer specified in the DM macro */

#define DM(y, z)               \
    dataArray[y].name = y;     \
    dataArray[y].value = z##U;

static bool_t dataInitialized = FALSE;
static dataPair_t dataArray[NUM_DATA_VARIABLES];

/****************************************************************************************
 * Private Function Prototypes
 ***************************************************************************************/
static void lib_data_Init(void);

/****************************************************************************************
 * Public Functions
 ***************************************************************************************/
uint32_t lib_data_Get(dataNames_t dataName) {
    if(!dataInitialized) {
        lib_data_Init();
    }

    /* Should only be used on systems that do word-sized asm reads/writes.
     * If the lib gets extended to multi-word storage capabilities, a mutex
     * is necessary to protect against multi-threaded access */
    return dataArray[dataName].value;
}

void lib_data_Set(dataNames_t dataName, uint32_t dataVal) {
    if(!dataInitialized) {
        lib_data_Init();
    }

    /* Should only be used on systems that do word-sized asm reads/writes.
     * If the lib gets extended to multi-word storage capabilities, a mutex
     * is necessary to protect against multi-threaded access */
    dataArray[dataName].value = dataVal;
}

/****************************************************************************************
 * Private Functions
 ***************************************************************************************/

/**
 * initialize the machine data tables
 *
 * \param none
 *
 * \return none
 *
 */
static void lib_data_Init(void) {
    /* Invoke the macro to initialize dataArray */
    DATA_LIST
    dataInitialized = TRUE;
}