events.c

Open DMT Client C Source code

                break;
            case FIELD_SENSOR32_HIGH    :
                ndx = LIMIT_INDEX(ndx, sizeof(er->sensor32HI)/sizeof(er->sensor32HI[0]));
                binFmtPrintf(bf, "%*u", len, (UInt32)er->sensor32HI[ndx]);
                break;
            case FIELD_SENSOR32_AVER    :
                ndx = LIMIT_INDEX(ndx, sizeof(er->sensor32AV)/sizeof(er->sensor32AV[0]));
                binFmtPrintf(bf, "%*u", len, (UInt32)er->sensor32AV[ndx]);
                break;
#endif
#ifdef EVENT_INCL_TEMPERATURE
            case FIELD_TEMP_LOW         : // double +/-
                ndx = LIMIT_INDEX(ndx, sizeof(er->tempLO)/sizeof(er->tempLO[0]));
                iVal32 = isHiRes? (Int32)ROUND(er->tempLO[ndx] * 10.0) : (Int32)ROUND(er->tempLO[ndx]);
                if (len <= 1) {
                    if (iVal32 < -TEMPERATURE_LO_RES_INVALID) { iVal32 = -TEMPERATURE_LO_RES_INVALID; } else
                    if (iVal32 >  TEMPERATURE_LO_RES_INVALID) { iVal32 =  TEMPERATURE_LO_RES_INVALID; }
                } else {
                    if (iVal32 < -TEMPERATURE_HI_RES_INVALID) { iVal32 = -TEMPERATURE_HI_RES_INVALID; } else
                    if (iVal32 >  TEMPERATURE_HI_RES_INVALID) { iVal32 =  TEMPERATURE_HI_RES_INVALID; }
                }
                binFmtPrintf(bf, "%*i", len, iVal32);
                break;
            case FIELD_TEMP_HIGH        : // double +/-
                ndx = LIMIT_INDEX(ndx, sizeof(er->tempHI)/sizeof(er->tempHI[0]));
                iVal32 = isHiRes? (Int32)ROUND(er->tempHI[ndx] * 10.0) : (Int32)ROUND(er->tempHI[ndx]);
                if (len <= 1) {
                    if (iVal32 < -TEMPERATURE_LO_RES_INVALID) { iVal32 = -TEMPERATURE_LO_RES_INVALID; } else
                    if (iVal32 >  TEMPERATURE_LO_RES_INVALID) { iVal32 =  TEMPERATURE_LO_RES_INVALID; }
                } else {
                    if (iVal32 < -TEMPERATURE_HI_RES_INVALID) { iVal32 = -TEMPERATURE_HI_RES_INVALID; } else
                    if (iVal32 >  TEMPERATURE_HI_RES_INVALID) { iVal32 =  TEMPERATURE_HI_RES_INVALID; }
                }
                binFmtPrintf(bf, "%*i", len, iVal32);
                break;
            case FIELD_TEMP_AVER        : // double +/-
                ndx = LIMIT_INDEX(ndx, sizeof(er->tempAV)/sizeof(er->tempAV[0]));
                iVal32 = isHiRes? (Int32)ROUND(er->tempAV[ndx] * 10.0) : (Int32)ROUND(er->tempAV[ndx]);
                if (len <= 1) {
                    if (iVal32 < -TEMPERATURE_LO_RES_INVALID) { iVal32 = -TEMPERATURE_LO_RES_INVALID; } else
                    if (iVal32 >  TEMPERATURE_LO_RES_INVALID) { iVal32 =  TEMPERATURE_LO_RES_INVALID; }
                } else {
                    if (iVal32 < -TEMPERATURE_HI_RES_INVALID) { iVal32 = -TEMPERATURE_HI_RES_INVALID; } else
                    if (iVal32 >  TEMPERATURE_HI_RES_INVALID) { iVal32 =  TEMPERATURE_HI_RES_INVALID; }
                }
                binFmtPrintf(bf, "%*i", len, iVal32);
                break;
#endif

#ifdef EVENT_INCL_GPS_STATS
            case FIELD_GPS_DGPS_UPDATE  :
                binFmtPrintf(bf, "%*u", len, (UInt32)er->gpsDgpsUpdate);
                break;
            case FIELD_GPS_HORZ_ACCURACY: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->gpsHorzAccuracy * 10.0) : (UInt32)ROUND(er->gpsHorzAccuracy);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_GPS_VERT_ACCURACY: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->gpsVertAccuracy * 10.0) : (UInt32)ROUND(er->gpsVertAccuracy);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_GPS_SATELLITES   :
                binFmtPrintf(bf, "%*u", len, (UInt32)er->gpsSatellites);
                break;
            case FIELD_GPS_MAG_VARIATION: // double +/-
                iVal32 = (Int32)ROUND(er->gpsMagVariation * 100.0);
                binFmtPrintf(bf, "%*i", len, iVal32);
                break;
            case FIELD_GPS_QUALITY      :
                binFmtPrintf(bf, "%*u", len, (UInt32)er->gpsQuality);
                break;
            case FIELD_GPS_TYPE         :
                binFmtPrintf(bf, "%*u", len, (UInt32)er->gps2D3D);
                break;
            case FIELD_GPS_GEOID_HEIGHT : // double +/-
                iVal32 = isHiRes? (Int32)ROUND(er->gpsGeoidHeight * 10.0) : (Int32)ROUND(er->gpsGeoidHeight);
                binFmtPrintf(bf, "%*i", len, iVal32);
                break;
            case FIELD_GPS_PDOP         : // double (values above 20.0 are considered poor)
                uVal32 = ((len == 1) && (er->gpsPDOP >= 25.5))? 255L : (UInt32)ROUND(er->gpsPDOP * 10.0);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_GPS_HDOP         : // double (values above 20.0 are considered poor)
                uVal32 = ((len == 1) && (er->gpsHDOP >= 25.5))? 255L : (UInt32)ROUND(er->gpsHDOP * 10.0);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_GPS_VDOP         : // double (values above 20.0 are considered poor)
                uVal32 = ((len == 1) && (er->gpsVDOP >= 25.5))? 255L : (UInt32)ROUND(er->gpsVDOP * 10.0);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
#endif

#ifdef EVENT_INCL_OBC
            case FIELD_OBC_VALUE: // EvOBCValue_t
                ndx = LIMIT_INDEX(ndx, sizeof(er->obcValue)/sizeof(er->obcValue[0]));
                if (len >= 4) {
                    EvOBCValue_t *J = &(er->obcValue[ndx]);
                    binFmtPrintf(bf, "%2u%2u", (UInt32)J->mid, (UInt32)J->pid);
                    len -= 4;
                    if (len <= J->dataLen) {
                        binFmtPrintf(bf, "%*b", len, J->data);
                    } else {
                        binFmtPrintf(bf, "%*b%*z", J->dataLen, J->data, len - J->dataLen);
                    }
                } else {
                    binFmtPrintf(bf, "%*z", len);
                }
                break;
            case FIELD_OBC_GENERIC: // UInt32
                ndx = LIMIT_INDEX(ndx, sizeof(er->obcGeneric)/sizeof(er->obcGeneric[0]));
                uVal32 = er->obcGeneric[ndx];
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_J1708_FAULT: // UInt32
                ndx = LIMIT_INDEX(ndx, sizeof(er->obcJ1708Fault)/sizeof(er->obcJ1708Fault[0]));
                uVal32 = er->obcJ1708Fault[ndx];
                binFmtPrintf(bf, "%*x", len, uVal32);
                break;
            case FIELD_OBC_DISTANCE   : // double
                uVal32 = isHiRes? (UInt32)ROUND(er->obcDistanceKM * 10.0) : (UInt32)ROUND(er->obcDistanceKM);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_ENGINE_HOURS: // double
                uVal32 = (UInt32)ROUND(er->obcEngineHours * 10.0);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_ENGINE_RPM: // UInt32
                uVal32 = er->obcEngineRPM;
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_COOLANT_TEMP: // double
                iVal32 = isHiRes? (UInt32)ROUND(er->obcCoolantTemp * 10.0) : (UInt32)ROUND(er->obcCoolantTemp);
                binFmtPrintf(bf, "%*i", len, iVal32);
                break;
            case FIELD_OBC_COOLANT_LEVEL: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->obcCoolantLevel * 1000.0) : (UInt32)ROUND(er->obcCoolantLevel * 100.0);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_OIL_LEVEL: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->obcOilLevel * 1000.0) : (UInt32)ROUND(er->obcOilLevel * 100.0);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_OIL_PRESSURE: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->obcOilPressure * 10.0) : (UInt32)ROUND(er->obcOilPressure);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_FUEL_LEVEL: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->obcFuelLevel * 1000.0) : (UInt32)ROUND(er->obcFuelLevel * 100.0);
                binFmtPrintf(bf, "%*i", len, uVal32);
                break;
            case FIELD_OBC_FUEL_ECONOMY: // double
                uVal32 = (UInt32)ROUND(er->obcAvgFuelEcon * 10.0); // try average first
                if (uVal32 == 0L) {
                    uVal32 = (UInt32)ROUND(er->obcFuelEconomy * 10.0); // fallback to 'instant'
                }
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
            case FIELD_OBC_FUEL_USED: // double
                uVal32 = isHiRes? (UInt32)ROUND(er->obcFuelUsed * 10.0) : (UInt32)ROUND(er->obcFuelUsed);
                binFmtPrintf(bf, "%*u", len, uVal32);
                break;
#endif

        }
    }

    /* set packet sequence */
    pkt->sequence = sequence; // will be 'SEQUENCE_ALL', if not specified as a field
    pkt->seqLen   = seqLen;   // # bytes (will be '0' if not specified as a field)
    pkt->seqPos   = seqPos;   // position of sequence field

    /* return full length */
    pkt->dataLen = (UInt8)BUFFER_DATA_LENGTH(bf);
    return pkt;

}

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

/* return the event queue */
PacketQueue_t *evGetEventQueue()
{
    return &eventQueue;
}

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

/* encode packet from event */
utBool evEncodePacket(Packet_t *pkt, PacketPriority_t pri, ClientPacketType_t pktType, UInt32 *evSeq, Event_t *er)
{
    if (pkt && er) {
        CustomDef_t *custDef = _evGetCustomDefinitionForType(pktType);
        if (custDef) {
            _evCreateEventPacket(pkt, pktType, custDef, evSeq, er);
            pkt->priority = (pri <= PRIORITY_NONE)? PRIORITY_NORMAL : pri;
            return utTrue;
        } else {
            logERROR(LOGSRC,"Custom format not found: 0x%04X", pktType);
        }
    }
    return utFalse;
}

/* add the specified event to the queue */
utBool evAddEventPacket(Packet_t *pkt, PacketPriority_t pri, ClientPacketType_t pktType, Event_t *er)
{
    if (pkt && er) {
        if (evEncodePacket(pkt, pri, pktType, &eventSequence, er)) {
            return evAddEncodedPacket(pkt);
        }
    } else {
        logERROR(LOGSRC,"NULL packet/event pointer!");
    }
    return utFalse;
}

/* add the specified event to the queue */
utBool evAddEncodedPacket(Packet_t *pkt)
{
    if (pkt) {
        totalPacketCount++;
        return pqueAddPacket(evGetEventQueue(), pkt);
    } else {
        logERROR(LOGSRC,"NULL packet/event pointer!");
        return utFalse;
    }
}

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

/* return the number of generated events */
Int32 evGetTotalPacketCount()
{
    // 'primary' transport events only
    return (Int32)totalPacketCount;
}

/* return the number of events found in the queue */
Int32 evGetPacketCount()
{
    // 'primary' transport events only
    return pqueGetPacketCount(evGetEventQueue());
}

/* return true if there are events in the queue (ie. non-empty) */
//utBool evHasPackets()
//{
//    return pqueHasPackets(evGetEventQueue());
//}

/* return an iterator on the event queue */
//PacketQueueIterator_t *evGetEventIterator(PacketQueueIterator_t *i)
//{
//    return pqueGetIterator(evGetEventQueue(), i);
//}

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

/* return the highest priority event in the queue */
//PacketPriority_t evGetHighestPriority()
//{
//    // 'primary' transport events only
//    return pqueGetHighestPriority(evGetEventQueue());
//}

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

/* delete the first event in the queue */
//void evFreeFirstEvent()
//{
//    pqueDeleteFirstEntry(evGetEventQueue());
//}

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

/* enable overwriting of the oldest event if the event queue fills up */
//void evEnableOverwrite(utBool overwrite)
//{
//    pqueEnableOverwrite(evGetEventQueue(), overwrite);
//}

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

/* acknowledge first sent event */
//utBool evAcknowledgeFirst()
//{
//    // 'primary' transport events only
//    UInt32 seq = pqueGetFirstSentSequence(evGetEventQueue()); // return 'SEQUENCE_ALL' if no first event
//    if (seq != SEQUENCE_ALL) {
//        return evAcknowledgeToSequence(seq);
//    } else {
//        return utFalse;
//    }
//}

/* acknowledge events up to and including the specified sequence */
//utBool evAcknowledgeToSequence(UInt32 sequence)
//{
//    // 'primary' transport events only
//    utBool didAck = utFalse;
//    utBool ackAll = (sequence == SEQUENCE_ALL)? utTrue : utFalse;
//    PacketQueue_t *eventQueue = evGetEventQueue();
//    if (ackAll || pqueHasSentPacketWithSequence(eventQueue,sequence)) {
//        PacketQueueIterator_t evi;
//        pqueGetIterator(eventQueue, &evi);
//        for (;;) {
//            // As we iterate through the event packets, we can assume the following:
//            // - If we get to a null packet, we are finished with the list
//            // - If we find a packet that hasn't been sent, then all following packets have 
//            //   also not been sent.
//            // - Once we find the 'first' matching sequence, we delete it then stop. This is
//            //   safer that deleting the last matching sequence.  (Note: multiple possible
//            //   matching sequence numbers can occur if the byte length of the sequence 
//            //   number is 1 (ie. 0 to 255), and more than 255 events are currently in the 
//            //   event packet queue.  Granted, an unlikely situation, but it can occur.)
//            // - No packet->sequence will ever match SEQUENCE_ALL (see 'ackAll').
//            Packet_t *pkt = pqueGetNextPacket((Packet_t*)0, &evi);
//            if (!pkt || !pkt->sent) {
//                //logWARNING(LOGSRC,"Stop at first non-sent packet");
//                break;  // stop at first null or non-sent packet
//            }
//            pqueDeleteFirstEntry(eventQueue);
//            didAck = utTrue;
//            if (ackAll) {
//                // ackowledge all sent packets
//                continue;
//            } else
//            if (pkt->sequence == SEQUENCE_ALL) {
//                // This condition can not (should not) occur.
//                // We don't know what the real sequence of the packet is.
//                // it's safer to stop here.
//                break;
//            } else
//            if (pkt->sequence != (sequence & SEQUENCE_MASK(pkt->seqLen))) {
//                // no match yet
//                continue;
//            }
//            break; // stop when sequence matches
//        }
//    } else {
//        logERROR(LOGSRC,"No packet with sequence: 0x%04lX", (UInt32)sequence);
//    }
//    return didAck;
//}

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

static utBool _evDidInit = utFalse;
void evInitialize()
{

    /* already initialized? */
    if (_evDidInit) {
        return;
    }
    _evDidInit = utTrue;

    /* init queue */
    PacketQueue_INIT(eventQueue,EVENT_QUEUE_SIZE);
    
    /* enable overwrite */
    pqueEnableOverwrite(&eventQueue, EVENT_QUEUE_OVERWRITE);

}

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