propman.c

Open DMT Client C Source code

    { PROP_ELAPSED_4_VALUE       , "ela.4.value"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_5_VALUE       , "ela.5.value"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_6_VALUE       , "ela.6.value"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_7_VALUE       , "ela.7.value"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_0_LIMIT       , "ela.0.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_1_LIMIT       , "ela.1.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_2_LIMIT       , "ela.2.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_3_LIMIT       , "ela.3.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_4_LIMIT       , "ela.4.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_5_LIMIT       , "ela.5.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_6_LIMIT       , "ela.6.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_ELAPSED_7_LIMIT       , "ela.7.limit"    , KVT_UINT32            ,    SAVE  ,  1,  "0" },

    // --- Generic sensor properties
    { PROP_UNDERVOLTAGE_LIMIT    , "bat.limit"      , KVT_UINT32            ,    SAVE  ,  1,  "0" },
    { PROP_SENSOR_CONFIG_0       , "sen.0.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_1       , "sen.1.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_2       , "sen.2.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_3       , "sen.3.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_4       , "sen.4.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_5       , "sen.5.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_6       , "sen.6.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_CONFIG_7       , "sen.7.conf"     , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_0        , "sen.0.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_1        , "sen.1.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_2        , "sen.2.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_3        , "sen.3.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_4        , "sen.4.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_5        , "sen.5.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_6        , "sen.6.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_SENSOR_RANGE_7        , "sen.7.range"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },

    // --- Temperature properties
    { PROP_TEMP_SAMPLE_INTRVL    , "tmp.smprate"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_TEMP_REPORT_INTRVL    , "tmp.rptrate"    , KVT_UINT32            ,    SAVE  ,  2,  "0,0" },
    { PROP_TEMP_CONFIG_0         , "tmp.0.conf"     , KVT_INT16             ,    SAVE  ,  2,  "0,0" },
    { PROP_TEMP_CONFIG_1         , "tmp.1.conf"     , KVT_INT16             ,    SAVE  ,  2,  "0,0" },
    { PROP_TEMP_CONFIG_2         , "tmp.2.conf"     , KVT_INT16             ,    SAVE  ,  2,  "0,0" },
    { PROP_TEMP_CONFIG_3         , "tmp.3.conf"     , KVT_INT16             ,    SAVE  ,  2,  "0,0" },
    { PROP_TEMP_RANGE_0          , "tmp.0.range"    , KVT_INT16|KVT_DEC(1)  ,    SAVE  ,  2,  "0.0,0.0" },
    { PROP_TEMP_RANGE_1          , "tmp.1.range"    , KVT_INT16|KVT_DEC(1)  ,    SAVE  ,  2,  "0.0,0.0" },
    { PROP_TEMP_RANGE_2          , "tmp.2.range"    , KVT_INT16|KVT_DEC(1)  ,    SAVE  ,  2,  "0.0,0.0" },
    { PROP_TEMP_RANGE_3          , "tmp.3.range"    , KVT_INT16|KVT_DEC(1)  ,    SAVE  ,  2,  "0.0,0.0" },

};

#define PROP_COUNT      (sizeof(properties) / sizeof(properties[0]))

// ----------------------------------------------------------------------------
// forward definitions

static void _propInitKeyValueFromString(KeyValue_t *kv, const char *s, utBool internal);

// ----------------------------------------------------------------------------
// Property table accessor functions

/* get KeyValue_t entry at specified index */
KeyValue_t *propGetKeyValueAt(int ndx)
{
    if ((ndx >= 0) && (ndx < PROP_COUNT)) {
        return &properties[ndx];
    }
    return (KeyValue_t*)0;
}

/* get KeyValue entry for specified key */
KeyValue_t *propGetKeyValueEntry(Key_t key)
{
    if (binarySearchOK) {
        // binary search (PROPERTY KEYS MUST BE IN ASCENDING ORDER!)
        int s = 0, e = PROP_COUNT;
        for (;s < e;) {
            int b = (e + s) / 2;
            KeyValue_t *kv = &properties[b];
            if (kv->key == key) {
                return kv;
            } else
            if (key < kv->key) {
                e = b;
            } else {
                s = b + 1;
            }
        }
    } else {
        // linear search
        int i;
        for (i = 0; i < PROP_COUNT; i++) {
            KeyValue_t *kv = &properties[i];
            if (kv->key == key) {
                return kv;
            }
        }
    }
    logWARNING(LOGSRC,"Key not found: 0x%04X", key);
    return (KeyValue_t*)0;
}

/* get KeyValue entry for specified key */
KeyValue_t *propGetKeyValueEntryByName(const char *keyName)
{
    // could stand some optimizing
    int i;
    for (i = 0; i < PROP_COUNT; i++) {
        KeyValue_t *kv = &properties[i];
        if (strEqualsIgnoreCase(kv->name,keyName)) {
            return kv;
        }
    }
    return (KeyValue_t*)0;
}

// ----------------------------------------------------------------------------

static KeyData_t *_propGetData(KeyValue_t *kv)
{
    if (!kv) {
        // return null if the KeyValue pointer is invalid
        return (KeyData_t*)0;
    } else
    if (kv->type & KVT_POINTER) {
        // never return null if the KeyValue pointer itself is valid
        return (kv->data.p.buf)? (KeyData_t*)kv->data.p.buf : (KeyData_t*)"";
    } else {
        return &(kv->data);
    }
}

static UInt16 _propGetDataCapacity(KeyValue_t *kv)
{
    if (!kv) {
        return 0;
    } else
    if (kv->type & KVT_POINTER) {
        return (kv->data.p.buf)? kv->data.p.bufLen : 0;
    } else {
        return sizeof(kv->data);
    }
}

// ----------------------------------------------------------------------------
// Property table flag modification

// set KVA_READONLY state
utBool propSetReadOnly(Key_t key, utBool readOnly)
{
    KeyValue_t *kv = propGetKeyValueEntry(key);
    if (kv) {
        if (readOnly) {
            kv->attr |= KVA_READONLY;
        } else {
            kv->attr &= ~KVA_READONLY;
        }
        return utTrue;
    }
    return utFalse;
}

// set KVA_SAVE state
utBool propSetSave(Key_t key, utBool save)
{
    KeyValue_t *kv = propGetKeyValueEntry(key);
    if (kv) {
        if (save) {
            kv->attr |= KVA_SAVE;
        } else {
            kv->attr &= ~KVA_SAVE;
        }
        return utTrue;
    }
    return utFalse;
}

// ----------------------------------------------------------------------------
// Property table alternate buffer support

utBool propSetAltBuffer(Key_t key, void *buf, int bufLen)
{
    KeyValue_t *kv = propGetKeyValueEntry(key);
    if (kv) {
        kv->type         |= KVT_POINTER;
        kv->data.p.buf    = buf;
        kv->data.p.bufLen = bufLen;
        return utTrue;
    }
    return utFalse;
}

/* return pointer to data */
void *propGetPointer(Key_t key, UInt16 *maxLen, UInt16 *dtaLen)
{
    KeyValue_t *kv = propGetKeyValueEntry(key);
    if (!kv) {
        if (maxLen) { *maxLen = 0; }
        if (dtaLen) { *dtaLen = 0; }
        return (UInt8*)0;
    } else {
        KeyData_t *keyDataBuf = _propGetData(kv);
        UInt16     keyDataSiz = _propGetDataCapacity(kv);
        if (maxLen) { *maxLen = keyDataSiz; }
        if (dtaLen) { *dtaLen = kv->dataSize; }
        return (void*)keyDataBuf;
    }
}

// ----------------------------------------------------------------------------
// type conversion functions

/* encode GPS value into byte array */
static int _propEncodeGPS(GPSOdometer_t *gps, FmtBuffer_t *dest)
{
    if (BUFFER_DATA(dest) && (BUFFER_DATA_SIZE(dest) >= 4)) {
        binFmtPrintf(dest, "%4u", (UInt32)(gps?gps->fixtime:0L));
        int destLen = BUFFER_DATA_SIZE(dest);
        if ((destLen >= 16) || ((destLen >= 12) && (destLen < 14))) {
            gpsPointEncode8(BUFFER_DATA(dest), (gps?&(gps->point):0));
            binAppendFmtField(dest, 8, 'g');
            binAdvanceFmtBuffer(dest, 8);
            if (destLen >= 16) {
                binFmtPrintf(dest, "%4u", (UInt32)(gps?gps->meters:0L));
            }
        } else
        if ((destLen >= 14) || ((destLen >= 10) && (destLen < 12))) {
            gpsPointEncode6(BUFFER_DATA(dest), (gps?&(gps->point):0));
            binAppendFmtField(dest, 6, 'g');
            binAdvanceFmtBuffer(dest, 6);
            if (destLen >= 14) {
                binFmtPrintf(dest, "%4u", (UInt32)(gps?gps->meters:0L));
            }
        }
        return BUFFER_DATA_LENGTH(dest);
    } else {
        // invalid data length
        return -1;
    }
}

/* decode GPS value from byte array */
static int _propDecodeGPS(GPSOdometer_t *gps, const UInt8 *data , int dataLen)
{
    // Valid lengths:
    //   10/14 - low resolution GPS fix
    //   12/16 - high resolution GPS fix
    if (gps && data && (dataLen >= 4)) {
        gps->fixtime = binDecodeInt32(data, 4, utFalse);
        gpsPointClear(&(gps->point));
        gps->meters = 0L;
        int len = 4;
        if ((dataLen == 10) || (dataLen == 14)) {
            gpsPointDecode6(&(gps->point), &data[len]);
            len += 6;
            if (dataLen == 14) {
                gps->meters = binDecodeInt32(&data[len], 4, utFalse);
                len += 4;
            }
        } else
        if ((dataLen == 12) || (dataLen == 16)) {
            gpsPointDecode8(&(gps->point), &data[len]);
            len += 8;
            if (dataLen == 16) {
                gps->meters = binDecodeInt32(&data[len], 4, utFalse);
                len += 4;
            }
        }
        return len;
    } else {
        return -1;
    }
}

// ----------------------------------------------------------------------------
// Property value refresh/change notification

static void (*propFtn_PropertyGet)(PropertyRefresh_t mode, Key_t key, UInt8 *args, int argLen);
static void (*propFtn_PropertySet)(PropertyRefresh_t mode, Key_t key, UInt8 *args, int argLen);

static void _propRefresh(PropertyRefresh_t mode, KeyValue_t *kv, UInt8 *args, int argLen)
{
    if (kv) {
        if (propFtn_PropertyGet && (mode & PROP_REFRESH_GET)) {
            (*propFtn_PropertyGet)(PROP_REFRESH_GET, kv->key, args, argLen);
        }
        if (propFtn_PropertySet && (mode & PROP_REFRESH_SET)) {
            (*propFtn_PropertySet)(PROP_REFRESH_SET, kv->key, (UInt8*)0, 0);
        }
    }
}

void propSetNotifyFtn(PropertyRefresh_t mode, void (*ftn)(PropertyRefresh_t,Key_t,UInt8*,int))
{
    if (mode & PROP_REFRESH_GET) {
        propFtn_PropertyGet = ftn;
    }
    if (mode & PROP_REFRESH_SET) {
        propFtn_PropertySet = ftn;
    }
}

// ----------------------------------------------------------------------------
// Property table command handler support

utBool propSetCommandFtn(Key_t key, CommandError_t (*cmd)(int pi, Key_t key, const UInt8 *data, int dataLen))
{
    KeyValue_t *kv = propGetKeyValueEntry(key);
    if (kv && (KVT_TYPE(kv->type) == KVT_COMMAND)) {
        KeyData_t *keyDataBuf = _propGetData(kv);
        keyDataBuf->cmd = cmd;
        kv->lenNdx      = 1;
        kv->dataSize    = sizeof(keyDataBuf->cmd); // sizeof(void*)
        return utTrue;
    }
    return utFalse;
}