apiDenBasicService.cpp

Go to the documentation of this file.

#include <apiDenBasicService.h>

quint64 calculate_T_O_Validity(quint64 detectionTime, quint32 validityDuration)
{
    return detectionTime + validityDuration * 1000;
}

quint64 calculate_T_O_Validity(AppDenmTriggerData data)
{
    return calculate_T_O_Validity(data.eventDetectionTime(), data.validityDuration() ? *data.validityDuration() : DefaultValidity);
}

quint64 calculate_T_O_Validity(AppDenmUpdateData data, quint32 *validityDuration)
{
    if(data.validityDuration())
        *validityDuration = *data.validityDuration();
    else
        *validityDuration = DefaultValidity;
    return calculate_T_O_Validity(data.eventUpdateDetectionTime(), *validityDuration);
}

quint64 calculate_T_O_Validity(AppDenmTerminationData data)
{
    return calculate_T_O_Validity(data.eventTerminationDetectionTime(), data.validityDuration() ? *data.validityDuration() : DefaultValidity);
}

ActionID_t defaultActionID(ParameterApplication *appli, SequenceNumber_t sequenceNumber)
{
    ActionID_t ret;

    ret.originatingStationID = appli->stationID();
    ret.sequenceNumber = sequenceNumber;

    return ret;
}

ActionID_t assignUnusedActionID(ParameterApplication *appli, ActionID_t currentActionID)
{
    ActionID_t ret;

    ret.originatingStationID = appli->stationID();
    ret.sequenceNumber = (currentActionID.sequenceNumber + 1) % 65536;

    return ret;
}

ItsPduHeader_t fill_ItsPduHeader(StationID_t stationID)
{
    ItsPduHeader_t ret;

    ret.protocolVersion = protocolVersion_currentVersion;
    ret.messageID = messageID_denm;
    ret.stationID = stationID;

    return ret;
}

bool fill_ManagementContainer(AppDenmTriggerData data, ManagementContainer_t *management, ParameterApplication *appli, ParameterGPS gps)
{
    asn_ulong2INTEGER((INTEGER_t*)&management->detectionTime, data.eventDetectionTime());
    management->termination = 0;
    management->eventPosition = isReferencePositionAvailable(data.eventPosition().toASN()) ? data.eventPosition().toASN() : gps.referencePosition();


    if(data.relevanceDistance())
    {
        management->relevanceDistance = (RelevanceDistance_t*)calloc(1, sizeof *management->relevanceDistance);
        *management->relevanceDistance = *data.relevanceDistance();
    }
    else
        management->relevanceDistance = 0;
    if(data.relevanceTrafficDirection())
    {
        management->relevanceTrafficDirection = (RelevanceTrafficDirection_t*)calloc(1, sizeof *management->relevanceTrafficDirection);
        *management->relevanceTrafficDirection = *data.relevanceTrafficDirection();
    }
    else
        management->relevanceTrafficDirection = 0;

    if(data.validityDuration() && *data.validityDuration() != DefaultValidity)
    {
        management->validityDuration = (ValidityDuration_t*)calloc(1, sizeof *management->validityDuration);
        *management->validityDuration = *data.validityDuration();
    }
    else
        management->validityDuration = 0;
    management->stationType = appli->stationType();

    return true;
}

bool fill_ManagementContainer(AppDenmUpdateData data, ManagementContainer_t *management, ManagementContainer_t origin, ActionID_t actionID, ParameterApplication *appli)
{
    asn_ulong2INTEGER((INTEGER_t*)&management->detectionTime, data.eventUpdateDetectionTime());
    management->termination = 0;
    management->eventPosition = data.eventPosition().toASN();
    management->actionID = actionID;

    if(data.relevanceDistance())
    {
        management->relevanceDistance = (RelevanceDistance_t*)calloc(1, sizeof *management->relevanceDistance);
        *management->relevanceDistance = *data.relevanceDistance();
    }
    else if(origin.relevanceDistance)
    {
        management->relevanceDistance = (RelevanceDistance_t*)calloc(1, sizeof *management->relevanceDistance);
        *management->relevanceDistance = *origin.relevanceDistance;
    }
    else
        management->relevanceDistance = 0;
    if(data.relevanceTrafficDirection())
    {
        management->relevanceTrafficDirection = (RelevanceTrafficDirection_t*)calloc(1, sizeof *management->relevanceTrafficDirection);
        *management->relevanceTrafficDirection = *data.relevanceTrafficDirection();
    }
    else if(origin.relevanceTrafficDirection)
    {
        management->relevanceTrafficDirection = (RelevanceTrafficDirection_t*)calloc(1, sizeof *management->relevanceTrafficDirection);
        *management->relevanceTrafficDirection = *origin.relevanceTrafficDirection;
    }
    else
        management->relevanceTrafficDirection = 0;

    if(data.validityDuration() && *data.validityDuration() != DefaultValidity)
    {
        management->validityDuration = (ValidityDuration_t*)calloc(1, sizeof *management->validityDuration);
        *management->validityDuration = *data.validityDuration();
    }
    else if(origin.validityDuration)
    {
        management->validityDuration = (ValidityDuration_t*)calloc(1, sizeof *management->validityDuration);
        *management->validityDuration = *origin.validityDuration;
    }
    else
        management->validityDuration = 0;
    management->stationType = appli->stationType();

    return true;
}

bool fill_ManagementContainer(TimestampIts_t detectionTime, ManagementContainer_t *management, Termination_t termination,
                              FakeGPSProvider *gps, ParameterApplication *appli)
{
    management->detectionTime = setTimestampIts(detectionTime);
    management->termination = (Termination_t*)calloc(1, sizeof *management->termination);
    *management->termination = termination;
    management->stationType = appli->stationType();
    memset(&management->referenceTime, 0, sizeof management->referenceTime);
    asn_ulong2INTEGER((INTEGER_t*)&management->referenceTime, gps->timestamp());
    return true;
}

bool fill_ManagementContainer(TimestampIts_t detectionTime, TimestampIts_t referenceTime, ManagementContainer_t *management, Termination_t termination,
                              FakeGPSProvider *gps, ParameterApplication *appli)
{
    Q_UNUSED(gps);
    management->detectionTime = setTimestampIts(detectionTime);
    management->termination = (Termination_t*)calloc(1, sizeof *management->termination);
    *management->termination = termination;
    management->stationType = appli->stationType();
    //asn_ulong2INTEGER((INTEGER_t*)&management->referenceTime, gps->timestamp());
    management->referenceTime = setTimestampIts(referenceTime);
    return true;
}

ManagementContainer_t fill_ManagementContainer(ActionID originatingActionID, ParameterGPS *gps, ParameterApplication *appli)
{
    ManagementContainer_t ret;

    memset(&ret, 0, sizeof ret);
    asn_long2INTEGER((INTEGER_t*)&ret.detectionTime, gps->timestamp());
    ret.actionID = originatingActionID;
    ret.eventPosition = gps->referencePosition();
    ret.stationType = appli->stationType();

    return ret;
}

bool fill_SituationContainer(AppDenmTriggerData data, SituationContainer_t *situation)
{
    asn_dec_rval_t rval;

    rval = uper_decode_complete(NULL, &asn_DEF_SituationContainer, (void**)&situation, data.situation()->data(), data.situation()->length());

    return rval.code == RC_OK;
}

bool fill_SituationContainer(AppDenmUpdateData data, SituationContainer_t *situation)
{
    asn_dec_rval_t rval;
    rval = uper_decode_complete(NULL, &asn_DEF_SituationContainer, (void**)&situation, data.situation()->data(), data.situation()->length());

    return rval.code == RC_OK;
}

bool fill_LocationContainer(AppDenmTriggerData data, LocationContainer_t *location)
{
    asn_dec_rval_t rval;

    rval = uper_decode_complete(NULL, &asn_DEF_LocationContainer, (void**)&location, data.location()->data(), data.location()->length());

    /* 6.1.3.2. A DENM shall include at least one trace. */
    if(rval.code == RC_OK && location->traces.list.count < 1)
    {
        location->traces.list.array = (PathHistory_t**)calloc(1, sizeof *location->traces.list.array);
        PathHistory_t *p = (PathHistory_t*)calloc(1, sizeof *p);
        location->traces.list.array[0] = (PathHistory_t*)calloc(1, sizeof *location->traces.list.array[0]);
        ASN_SEQUENCE_ADD(&location->traces, p);
    }

    return rval.code == RC_OK;
}

bool fill_LocationContainer(AppDenmUpdateData data, LocationContainer_t *location)
{
    asn_dec_rval_t rval;

    rval = uper_decode_complete(NULL, &asn_DEF_LocationContainer, (void**)&location, data.location()->data(), data.location()->length());

    /* 6.1.3.2. A DENM shall include at least one trace. */
    if(rval.code == RC_OK && location->traces.list.count < 1)
    {
        location->traces.list.array = (PathHistory_t**)calloc(1, sizeof *location->traces.list.array);
        PathHistory_t *p = (PathHistory_t*)calloc(1, sizeof *p);
        location->traces.list.array[0] = (PathHistory_t*)calloc(1, sizeof *location->traces.list.array[0]);
        ASN_SEQUENCE_ADD(&location->traces, p);
    }

    return rval.code == RC_OK;
}

bool fill_AlacarteContainer(AppDenmTriggerData data, AlacarteContainer_t *alacarte)
{
    asn_dec_rval_t rval;

    rval = uper_decode_complete(NULL, &asn_DEF_AlacarteContainer, (void**)&alacarte, data.alacarte()->data(), data.alacarte()->length());

    return rval.code == RC_OK;
}

bool fill_AlacarteContainer(AppDenmUpdateData data, AlacarteContainer_t *alacarte)
{
    asn_dec_rval_t rval;

    rval = uper_decode_complete(NULL, &asn_DEF_AlacarteContainer, (void**)&alacarte, data.alacarte()->data(), data.alacarte()->length());

    return rval.code == RC_OK;
}

AlacarteContainer_t fill_AlacarteContainer(ParameterConfiguration *conf, ParameterCAN *can)
{
    AlacarteContainer_t ret;

    memset(&ret, 0, sizeof ret);

    ret.impactReduction = (ImpactReductionContainer_t*)calloc(1, sizeof *ret.impactReduction);
    ret.impactReduction->heightLonCarrLeft = conf->heightLonCarrLeft();
    ret.impactReduction->heightLonCarrRight = conf->heightLonCarrRight();
    ret.impactReduction->posLonCarrLeft = conf->posLonCarrLeft();
    ret.impactReduction->posLonCarrRight = conf->posLonCarrRight();
    ret.impactReduction->posCentMass = conf->posCentMass();
    ret.impactReduction->positionOfPillars = conf->positionOfPillars();
    ret.impactReduction->wheelBaseVehicle = conf->wheelBaseVehicle();
    ret.impactReduction->turningRadius = conf->turningRadius();
    ret.impactReduction->posFrontAx = conf->posFrontAx();
    ret.impactReduction->positionOfOccupants = can->positionOfOccupants();
    ret.impactReduction->vehicleMass = conf->vehicleMass();
    ret.impactReduction->requestResponseIndication = RequestResponseIndication_response;
    for(int i = 0 ; i < conf->positionOfPillars().list.count ; i++)
        *ret.impactReduction->positionOfPillars.list.array[i] = *conf->positionOfPillars().list.array[i];

    return ret;
}

int haveDENM(ActionID_t actionID, QVector<denMessageTableSource*> table)
{
    int found = -1;
    int i;

    for(i = 0 ; i < table.size() && found == -1 ; i++)
        if(isEqual_ActionID(actionID, table[i]->actionID()))
            found = i;

    return found;
}

int haveDENM(ActionID_t actionID, QVector<denMessageTableReception*> table)
{
    int found = -1;
    int i;

    for(i = 0 ; i < table.size() && found == -1 ; i++)
        if(isEqual_ActionID(actionID, table[i]->actionID()))
            found = i;

    return found;
}

int haveDENM(ActionID_t actionID, QVector<denMessageTableForwarding*> table)
{
    int found = -1;
    int i;

    for(i = 0 ; i < table.size() && found == -1 ; i++)
        if(isEqual_ActionID(actionID, table[i]->actionID()))
            found = i;

    return found;
}

gnDataRequest_t gnDataRequestFromAppDenmTriggerData(AppDenmTriggerData data, ParameterGPS gps)
{
    gnDataRequest_t dr;

    dr.destinationAddress = gnDataRequestFromDestinationArea(data.destinationArea(), gps);
    if(data.repetitionInterval())
    {
        dr.repetitionInterval = (quint16*)calloc(1, sizeof *dr.repetitionInterval);
        *dr.repetitionInterval = *data.repetitionInterval();
    }
    else
        dr.repetitionInterval = 0;
    if(data.transmissionInterval())
    {
        dr.maximumRepetitionTime = (quint16*)calloc(1, sizeof *dr.maximumRepetitionTime);
        *dr.maximumRepetitionTime = *data.transmissionInterval();
    }
    else
        dr.maximumRepetitionTime = 0;
    dr.upperProtocolEntity = CommonHeader::e_upperProtocolEntity::nextHeaderType_BTP_B;
    dr.destinationPort = btpPort_DENM;
    dr.destinationPortInfo = 0;
    dr.packetTransportType = CommonHeader::e_headerType::headerType_geoBroadcast;
    switch (data.destinationArea().shape()) {
    case DestinationAreaData::shape_circle:
        dr.packetTransportSubType = CommonHeader::e_headerSubTypeGeoBroadcast::headerSubTypeGeoBroadcast_circle;
        break;
    case DestinationAreaData::shape_rectangle:
        dr.packetTransportSubType = CommonHeader::e_headerSubTypeGeoBroadcast::headerSubTypeGeoBroadcast_rectangle;
        break;
    case DestinationAreaData::shape_ellipse:
        dr.packetTransportSubType = CommonHeader::e_headerSubTypeGeoBroadcast::headerSubTypeGeoBroadcast_ellipse;
        break;
    default:
        dr.packetTransportSubType = CommonHeader::e_headerSubTypeGeoBroadcast::headerSubTypeGeoBroadcast_circle;
        break;
    }
    dr.gnCommunicationProfile = gnCommunicationProfile_ITS_G5A;
    dr.trafficClass = gnDataRequestFromTrafficClass(data.trafficClass());
    if(data.lifeTime())
    {
        dr.maximumPacketLifeTime = (LifeTime*)calloc(1, sizeof *dr.maximumPacketLifeTime);
        *dr.maximumPacketLifeTime = gnDataRequestFromLifeTime(*data.lifeTime());
    }
    else
        dr.maximumPacketLifeTime = 0;
    if(data.maximumHopLimit())
    {
        dr.maximumHopLimit = (quint8*)calloc(1, sizeof *dr.maximumHopLimit);
        *dr.maximumHopLimit = *data.maximumHopLimit();
    }
    else
        dr.maximumHopLimit = 0;


    return dr;
}

destinationAddress_t gnDataRequestFromDestinationArea(DestinationAreaData data, ParameterGPS gps)
{
    destinationAddress_t dest;

    dest.present = destinationAddress_PR_DestinationArea;
    dest.choice.destinationArea.geoAreaPosLatitude = data.geoAreaPosLatitude();
    dest.choice.destinationArea.geoAreaPosLongitude = data.geoAreaPosLongitude();
    dest.choice.destinationArea.distanceA = data.distanceA();
    dest.choice.destinationArea.distanceB = data.distanceB();
    dest.choice.destinationArea.angle = data.angle();
    dest.choice.destinationArea.reserved = 0;

    if(!isDestinationAreaAvailable(data))
    {
        dest.choice.destinationArea.geoAreaPosLatitude = gps.referencePosition().latitude;
        dest.choice.destinationArea.geoAreaPosLongitude = gps.referencePosition().longitude;
    }

    return dest;
}

TrafficClass gnDataRequestFromTrafficClass(TrafficClassData data)
{
    return TrafficClass(data.storeCarryForward(), data.channelOffload(), data.trafficClassID());
}

LifeTime gnDataRequestFromLifeTime(LifeTimeData data)
{
    return LifeTime(data.multiplier(), (LifeTime::e_base)data.base());
}

bool isReferencePositionAvailable(ReferencePosition_t pos)
{
    return pos.latitude != Latitude_unavailable && pos.longitude != Longitude_unavailable;
}

bool isDestinationAreaAvailable(DestinationAreaData pos)
{
    return pos.geoAreaPosLatitude() != Latitude_unavailable && pos.geoAreaPosLongitude() != Longitude_unavailable;
}