轻量级参数管理框架(C语言)

typedef struct
{
    uint16_t usValue;
    uint8_t ucValue;
    uint32_t uiValue;
    float fValue;
    char szString_1[12];
    double dValue;
    int16_t sValue;
    int8_t cValue;
    int32_t iValue;
    char szString_2[10];
}ParamDemo_t;

ParamDemo_t g_tTestVal = {
    .usValue = 20,
    .ucValue = 10,
    .uiValue = 1000,
    .fValue = 3.14,
    .szString_1 = "abcd",
    .dValue = 5.12,
    .sValue = -100,
    .cValue = -2,
    .iValue = 300,
    .szString_2 = "12234",
};

int8_t g_cTest = 50;
char g_szString[10] = "qwer";

static int CheckSValue(const void *pCurParam);

cotParamInfo_t sg_ParamTable[] = {
    COT_PARAM_ITEM_BIND(1, g_tTestVal.usValue, COT_PARAM_UINT16, COT_PARAM_ATTR_WR),
    COT_PARAM_ITEM_BIND(2, g_tTestVal.ucValue, COT_PARAM_UINT8, COT_PARAM_ATTR_WR, 20),
    COT_PARAM_ITEM_BIND(3, g_tTestVal.uiValue, COT_PARAM_UINT32, COT_PARAM_ATTR_WR, 1000, 1000, 10000),
    COT_PARAM_ITEM_BIND(4, g_tTestVal.fValue, COT_PARAM_FLOAT, COT_PARAM_ATTR_WR, 10, -10.5, 10.5),
    COT_PARAM_ITEM_BIND(5, g_tTestVal.szString_1, COT_PARAM_STRING, COT_PARAM_ATTR_WR, "abcd", 3, sizeof(g_tTestVal.szString_1)),
    COT_PARAM_ITEM_BIND(6, g_tTestVal.dValue, COT_PARAM_DOUBLE, COT_PARAM_ATTR_WR, 0, -90.10, 100.10),
    COT_PARAM_ITEM_BIND(7, g_tTestVal.sValue, COT_PARAM_INT16, COT_PARAM_ATTR_WR, 100, -200, 200, CheckSValue), // 添加自定义校验
    COT_PARAM_ITEM_BIND_WITH_NAME(8, "g_cTest", g_cTest, COT_PARAM_INT8, COT_PARAM_ATTR_WR, 50, -100, 100), // 另取参数名
    COT_PARAM_ITEM_BIND(9, g_szString, COT_PARAM_STRING, COT_PARAM_ATTR_WR, "XXX", 3, 6),
};

static int CheckSValue(const void *pCurParam)
{
    const int16_t *p_sValue = (const int16_t *)pCurParam;

    if ((*p_sValue) % 2 != 0)
    {
        return -1;
    }

    return 0;
}


int mian()
{
    cotParam_Init(&sg_tParamManager, sg_ParamTable, COT_PARAM_TABLE_SIZE(sg_ParamTable));
}

// 所有参数校验出错时恢复默认处理
int OnCheckErrorResetHandle(const cotParamInfo_t *pParamInfo, cotParamCheckRet_e eCheckResult)
{
    cotParam_SingleParamResetDefValue(pParamInfo);
    return 0;
}

// 从储存空间读取数据
int OnLoadCallback(uint8_t *pBuf, uint16_t bufSize, uint16_t *pLength)
{
    uint16_t length;
    static uint32_t s_offset = 0;

    if (s_offset < sg_length)
    {
        if (s_offset + bufSize <= sg_length)
        {
            length = bufSize;
            memcpy(pBuf, &sg_buf[s_offset], length);
            s_offset += length;
        }
        else
        {
            length = sg_length - s_offset;
            memcpy(pBuf, &sg_buf[s_offset], length);
            s_offset += length;
        }
    }
    else
    {
        length = 0;
        s_offset = 0;
    }

    *pLength = length;
    return 0;
}

// 写数据至储存空间
int OnSaveCallback(const uint8_t *pBuf, uint16_t len)
{
    static uint32_t s_offset = 0;

    if (len > 0)
    {
        memcpy(&sg_buf[s_offset], pBuf, len);
        s_offset += len;
        sg_length = s_offset;
    }
    else
    {
        s_offset = 0;
    }

    return 0;
}

// 加载参数
void LoadParam(void)
{
    cotParam_Load(&sg_tParamManager, OnLoadCallback);
  
    // 加载后全部参数进行校验（可选）
    cotParam_Check(&sg_tParamManager, OnCheckErrorResetHandle);
}

// 保存参数
void SaveParam(void)
{
    // 保存前全部参数进行校验（可选）
    cotParam_Check(&sg_tParamManager, OnCheckErrorResetHandle);
    cotParam_Save(&sg_tParamManager, OnSaveCallback);
}

// 加载参数
void LoadParam(void)
{
    uint8_t buf[500];
    uint32_t length;

    length = read(buf);
    cotParam_Deserialization(&sg_tParamManager, buf, length);
  
    // 加载后全部参数进行校验（可选）
    cotParam_Check(&sg_tParamManager, OnCheckErrorResetHandle);
}

// 保存参数
void SaveParam(void)
{
    uint8_t buf[500];
    uint32_t length;

    // 保存前全部参数进行校验（可选）
    cotParam_Check(&sg_tParamManager, OnCheckErrorResetHandle);
    length = cotParam_Serialize(&sg_tParamManager, buf);
    write(buf, length);
}

// 加载参数
void LoadParam(void)
{
    uint8_t pBuf = (uint8_t *)malloc(500);  // 申请足够大的内存
    uint32_t length;

    length = read(pBuf, length); // 获取数据的实际长度
    cotParam_Deserialization(&sg_tParamManager, pBuf, length);
  
    // 加载后全部参数进行校验（可选）
    cotParam_Check(&sg_tParamManager, OnCheckErrorResetHandle);
}

// 保存参数
void SaveParam(void)
{
    uint8_t pBuf = (uint8_t *)malloc(cotParam_GetSerializeSize(&sg_tParamManager));
    uint32_t length;

    // 保存前全部参数进行校验（可选）
    cotParam_Check(&sg_tParamManager, OnCheckErrorResetHandle);
    length = cotParam_Serialize(&sg_tParamManager, pBuf);
    write(buf, length);
}

int main()
{
    // 保存
    uint8_t *p_wbuf = (uint8_t *)malloc(cotParam_GetSerializeSize(&sg_tParamManager));
  
    uint32_t length = cotParam_Serialize(&sg_tParamManager, p_wbuf);
    write(p_wbuf, length);
    free(p_wbuf);
    p_wbuf = NULL;

    // 加载
    uint8_t *p_rbuf = (uint8_t *)malloc(cotParam_GetSerializeSize(&sg_tParamManager));
  
    uint32_t length = read(r_buf);
    cotParam_Deserialization(&sg_tParamManager, p_rbuf, length);
    write(p_rbuf, length);
    free(p_rbuf);
    p_rbuf = NULL;
}

// 对某个变量当前参数进行范围校验，得到校验结果后自行处理
cotParam_SingleParamSelfCheck(cotParam_FindParamByParamPtr(&sg_tParamManager, &g_test_3), &eCheckResult);

if (eCheckResult != COT_PARAM_CHECK_OK) // 修改后检查
{
    cotParam_SingleParamResetDefValue(cotParam_FindParamByParamPtr(&sg_tParamManager, &g_test_3)); // 如果校验失败，则恢复为默认值
}


// 对某个变量参数变更后（当前值已经变化）进行校验处理，若超出范围则恢复默认
g_test_3 = 1000;
cotParam_SingleParamCheckProcess(cotParam_FindParamByParamPtr(&sg_tParamManager, &g_test_3), COT_PARAM_RESET_DEF);

// 对某个变量参数在需要变更前（当前值没有变化）进行校验处理，得到校验结果后自行处理
double tmp = 1000;
cotParam_SingleParamCheckInput(cotParam_FindParamByParamPtr(&sg_tParamManager, &g_test_3), &tmp, &eCheckResult);

if (eCheckResult == COT_PARAM_CHECK_OK)
{
    g_test_3 = tmp;// 如果校验成功，则修改
}

// 对某个变量参数在需要变更前（当前值没有变化）进行校验处理，若新的值超出范围则不更新变量参数当前的值
double tmp = 1000;
cotParam_SingleParamUpdate(cotParam_FindParamByParamPtr(&sg_tParamManager, &g_test_3), &tmp, COT_PARAM_RESET_NONE)

static int CheckTestS16(const void *pCurParam)
{
    const int16_t *p_test_s16 = (const int16_t *)pCurParam;

    /* 需要校验 g_test_s16 为2的倍数（建议不能直接使用 g_test_s16 去判断，因为回调函数入参不一定时该值，
       虽然类型是一样的）*/
    if ((*p_test_s16) % 2 != 0)  
    {
        return -1;
    }

    return 0; // 0表示自定义校验成功，其他表示失败
}

cotParamInfo_t sg_ParamTable[] = {
    COT_PARAM_ITEM_BIND(1, g_test_1, COT_PARAM_INT16, COT_PARAM_ATTR_WR),
    COT_PARAM_ITEM_BIND(2, g_test_2, COT_PARAM_UINT16, COT_PARAM_ATTR_WR, 20),
    COT_PARAM_ITEM_BIND(3, g_test_float, COT_PARAM_FLOAT, COT_PARAM_ATTR_READ, 3.15, -10, 10),
    COT_PARAM_ITEM_BIND(6, g_test_s8, COT_PARAM_INT8, COT_PARAM_ATTR_WR, 10, -10, 15),
    COT_PARAM_ITEM_BIND(7, g_test_s16, COT_PARAM_INT16, COT_PARAM_ATTR_WR, 100, -100, 3000, CheckTestS16), // 设置自定义校验
    COT_PARAM_ITEM_BIND(8, g_test_s32, COT_PARAM_INT32, COT_PARAM_ATTR_WR, 1000, -900, 10000),
}