events.c

Open DMT Client C Source code

// ----------------------------------------------------------------------------
// Copyright 2006-2007, Martin D. Flynn
// All rights reserved
// ----------------------------------------------------------------------------
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
// http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ----------------------------------------------------------------------------
// Description:
//  GPS/Data event manager. 
//  Generates and manages events.
// ---
// Change History:
//  2006/01/04  Martin D. Flynn
//     -Initial release
//  2007/01/28  Martin D. Flynn
//     -Changed to support elapsed time resolution of 1 second.
//  2007/02/11  Martin D. Flynn
//     -Added FIELD_OBC_COOLANT_LEVEL, FIELD_OBC_OIL_PRESSURE
//     -Changed FIELD_OBC_ENGINE_TEMP to FIELD_OBC_COOLANT_TEMP and added hiRes mode
//  2007/02/25  Martin D. Flynn
//     -Changed 'FIELD_OBC_FAULT_CODE' to 'FIELD_OBC_J1708_FAULT'
//     -Changed 'obcFaultCode' to 'obcJ1708Fault'
//  2007/03/11  Martin D. Flynn
//     -Added support for 'FIELD_OBC_FUEL_USED'
// ----------------------------------------------------------------------------

#include "stdafx.h" // TARGET_WINCE
#define SKIP_TRANSPORT_MEDIA_CHECK // only if TRANSPORT_MEDIA not used in this file 
#include "custom/defaults.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <sys/time.h>

#include "custom/log.h"

#include "tools/stdtypes.h"
#include "tools/bintools.h"
#include "tools/strtools.h"
#include "tools/utctools.h"

#include "events.h"

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

/* define standard resolution fixed packet type */
static FieldDef_t   FixedFields_30[] = {
    EVENT_FIELD(FIELD_STATUS_CODE   , LO_RES, 0, 2),
    EVENT_FIELD(FIELD_TIMESTAMP     , LO_RES, 0, 4),
    EVENT_FIELD(FIELD_GPS_POINT     , LO_RES, 0, 6),
    EVENT_FIELD(FIELD_SPEED         , LO_RES, 0, 1),
    EVENT_FIELD(FIELD_HEADING       , LO_RES, 0, 1),
    EVENT_FIELD(FIELD_ALTITUDE      , LO_RES, 0, 2),
    EVENT_FIELD(FIELD_DISTANCE      , LO_RES, 0, 3),
    EVENT_FIELD(FIELD_SEQUENCE      , LO_RES, 0, 1),
};
static CustomDef_t FixedPacket_30 = {
    PKT_CLIENT_FIXED_FMT_STD,
    (sizeof(FixedFields_30)/sizeof(FixedFields_30[0])),
    FixedFields_30
};

/* define high resolution fixed packet type */
static FieldDef_t   FixedFields_31[] = {
    EVENT_FIELD(FIELD_STATUS_CODE   , HI_RES, 0, 2),
    EVENT_FIELD(FIELD_TIMESTAMP     , HI_RES, 0, 4),
    EVENT_FIELD(FIELD_GPS_POINT     , HI_RES, 0, 8),
    EVENT_FIELD(FIELD_SPEED         , HI_RES, 0, 2),
    EVENT_FIELD(FIELD_HEADING       , HI_RES, 0, 2),
    EVENT_FIELD(FIELD_ALTITUDE      , HI_RES, 0, 3),
    EVENT_FIELD(FIELD_DISTANCE      , HI_RES, 0, 3),
    EVENT_FIELD(FIELD_SEQUENCE      , HI_RES, 0, 1),
};
static CustomDef_t FixedPacket_31 = {
    PKT_CLIENT_FIXED_FMT_HIGH,
    (sizeof(FixedFields_31)/sizeof(FixedFields_31[0])),
    FixedFields_31
};

/* table of predefined formats */
static CustomDef_t *FixedEventTable[] = {
    &FixedPacket_30,
    &FixedPacket_31,
};

/* table of custom formats */
static CustomDef_t *CustomEventTable[] = {
    (CustomDef_t*)0,
    (CustomDef_t*)0,
    (CustomDef_t*)0,
    (CustomDef_t*)0,
    (CustomDef_t*)0
};

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

utBool evAddCustomDefinition(CustomDef_t *cd)
{
    int i, maxSize;
    maxSize = sizeof(CustomEventTable)/sizeof(CustomEventTable[0]);
    for (i = 0; i < maxSize; i++) {
        if (!CustomEventTable[i]) {
            CustomEventTable[i] = cd;
            return utTrue;
        }
    }
    return utFalse;
}

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

static void _evSetFieldMask(Event_t *er, UInt16 type)
{
    if (er) {
        UInt16 ndx = type / 8;
        if (ndx < sizeof(er->fieldMask)) {
            UInt16 bit = type % 8;
            er->fieldMask[ndx] |= (1 << bit);
        }
    }
}

utBool evIsFieldSet(Event_t *er, UInt16 type)
{
    if (er) {
        UInt16 ndx = type / 8;
        if (ndx < sizeof(er->fieldMask)) {
            UInt16 bit = type % 8;
            return (er->fieldMask[ndx] & (1 << bit))? utTrue : utFalse;
        }
    }
    return utFalse;
}

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

static CustomDef_t *_evGetCustomDefinitionForType(ClientPacketType_t hdrType)
{
    int i, maxSize;
    
    /* first check fixed formats */
    maxSize = sizeof(FixedEventTable)/sizeof(FixedEventTable[0]);
    for (i = 0; (i < maxSize) && FixedEventTable[i]; i++) {
        if (hdrType == FixedEventTable[i]->hdrType) {
            return FixedEventTable[i];
        }
    }
    
    /* check custom formats */
    maxSize = sizeof(CustomEventTable)/sizeof(CustomEventTable[0]);
    for (i = 0; (i < maxSize) && CustomEventTable[i]; i++) {
        if (hdrType == CustomEventTable[i]->hdrType) {
            return CustomEventTable[i];
        }
    }
    
    /* still not found */
    return (CustomDef_t*)0;
}

static Event_t * _evClearEvent(Event_t *er)
{
    if (er) {
        
        /* clear entire structure */
        memset(er, 0, sizeof(Event_t));
        
        /* default timestamp */
        er->timestamp[0]    = utcGetTimeSec();
        
        /* gps point */
        int gi;
        for (gi = 0; gi < sizeof(er->gpsPoint)/sizeof(er->gpsPoint[0]); gi++) {
            gpsPointClear(&(er->gpsPoint[gi]));
        }
        
        /* gps attributes */
        er->speedKPH        = GPS_UNDEFINED_SPEED;
        er->heading         = GPS_UNDEFINED_HEADING;
        er->altitude        = GPS_UNDEFINED_ALTITUDE;
        er->distanceKM      = GPS_UNDEFINED_DISTANCE;
        er->odometerKM      = GPS_UNDEFINED_DISTANCE;

        /* sensor init */
#ifdef EVENT_INCL_TEMPERATURE
        int ai;
        for (ai = 0; ai < sizeof(er->tempLO)/sizeof(er->tempLO[0]); ai++) {
            er->tempLO[ai]   = GPS_UNDEFINED_TEMPERATURE;
            er->tempHI[ai]   = GPS_UNDEFINED_TEMPERATURE;
            er->tempAV[ai]   = GPS_UNDEFINED_TEMPERATURE;
        }
#endif

        /* misc */
        er->topSpeedKPH     = GPS_UNDEFINED_SPEED;

        /* gps */
#ifdef EVENT_INCL_GPS_STATS
        er->gpsHorzAccuracy = GPS_UNDEFINED_ACCURACY;
        er->gpsVertAccuracy = GPS_UNDEFINED_ACCURACY;
        er->gpsMagVariation = GPS_UNDEFINED_MAG_VARIATION;
        er->gpsGeoidHeight  = GPS_UNDEFINED_GEOID_HEIGHT;
        er->gpsPDOP         = GPS_UNDEFINED_DOP;
        er->gpsHDOP         = GPS_UNDEFINED_DOP;
        er->gpsVDOP         = GPS_UNDEFINED_DOP;
#endif

    }
    return er;
}

#define LIMIT_INDEX(N,L)    (((N) >= (L))? ((L) - 1) : (N))
Event_t *evParseEventPacket(Packet_t *pkt, Event_t *er)
{
    
    /* get event format definition */
    CustomDef_t *custDef = _evGetCustomDefinitionForType(pkt->hdrType);
    if (!custDef) {
        //logERROR(LOGSRC,"Custom event definition not found: %04X", pkt->hdrType);
        return (Event_t*)0;
    }
    
    /* field info */
    UInt8 fldLen  = custDef->fldLen;
    FieldDef_t *fld = custDef->fld;

    /* source buffer */
    Buffer_t bb, *bf = binBuffer(&bb, pkt->data, pkt->dataLen, BUFFER_SOURCE);
    
    /* clear event structure before we begin */
    _evClearEvent(er);
    
    /* parse custom fields */
    int i;
    for (i = 0; i < fldLen; i++) {
        int   len        = (int)fld[i].length;
        UInt8 ndx        = (UInt8)fld[i].index;
        utBool isHiRes   = fld[i].hiRes;
        UInt32 uVal32    = 0L;
        Int32 iVal32     = 0L;
        switch ((EventFieldType_t)fld[i].type) {
            
            case FIELD_STATUS_CODE      : // hex
                // 'len' had better be '2' (however, no checking is made at this point)
                binBufScanf(bf, "%*x", len, &uVal32);
                er->statusCode = (UInt16)uVal32;
                _evSetFieldMask(er, fld[i].type);
                break;
            case FIELD_TIMESTAMP        :
                // 'len' had better be '4' (however, no checking is made at this point)
                ndx = LIMIT_INDEX(ndx, sizeof(er->timestamp)/sizeof(er->timestamp[0]));
                binBufScanf(bf, "%*u", len, &(er->timestamp[ndx]));
                _evSetFieldMask(er, fld[i].type);
                break;
            case FIELD_INDEX            :
                binBufScanf(bf, "%*u", len, &(er->index));
                _evSetFieldMask(er, fld[i].type);
                break;
                
            case FIELD_GPS_POINT        :
                // 'len' had better be '6' or '8' (however, no checking is made at this point)
                ndx = LIMIT_INDEX(ndx, sizeof(er->gpsPoint)/sizeof(er->gpsPoint[0]));
                binBufScanf(bf, "%*g", len, &(er->gpsPoint[ndx]));
                _evSetFieldMask(er, fld[i].type);
                break;
            case FIELD_GPS_AGE          :
                binBufScanf(bf, "%*u", len, &(er->gpsAge));
                _evSetFieldMask(er, fld[i].type);
                break;
            case FIELD_SPEED            : // double
                binBufScanf(bf, "%*u", len, &uVal32);
                er->speedKPH = isHiRes? ((double)uVal32 / 10.0) : (double)uVal32;
                _evSetFieldMask(er, fld[i].type);
                break;
            case FIELD_HEADING          : // double
                binBufScanf(bf, (isHiRes? "%*u" : "%*x"), len, &uVal32);