LibItsDenm_Templates.ttcn

/**
 *	@author 	ETSI / STF449
 *  @version 	$URL$
 *				$Id$
 *	@desc		Module containing base template definitions for DENM
 *
 */
module LibItsDenm_Templates {
    
    //LibIts
    import from LibItsCommon_TypesAndValues all;
    import from LibItsCommon_Functions all;
    import from LibItsCommon_Pixits all;
    import from LibItsDenm_TestSystem all;
    import from LibItsDenm_TypesAndValues all;
    import from DENM_PDU_Descriptions language "ASN.1:1997" all;
    import from ITS_Container language "ASN.1:1997" all;
    
    group asn1Constants {
        
        const integer HeadingValue_wgs84North   := 0;
        const integer HeadingValue_wgs84East    := 900;
        const integer HeadingValue_wgs84South   := 1800;
        const integer HeadingValue_wgs84West    := 2700;
        const integer HeadingValue_unavailable  := 3600;
        
        const integer HeadingConfidence_withinZeroPointOneDegree    := 1;
        const integer HeadingConfidence_withinOneDegree             := 10;
        const integer HeadingConfidence_outOfRange                  := 126;
        const integer HeadingConfidence_unavailable                 := 127;
        
    } // End of group asn1Constants 
    
    group primitivesTemplates {
        
        /**
         * @desc    Send template for DEN Message (DenmPort Primitive)
         * @param   p_denMsg    The DEN Message to be sent
         */
        template (value) DenmReq m_denmReq(
            template (value) DENM p_denMsg
        ) := {
            msgOut := p_denMsg
        }
        
        /**
         * @desc    Receive template for DEN Message (DenmPort Primitive)
         * @param   p_denMsg    The expected DEN Message
         */
        template (present) DenmInd mw_denmInd(
            template (present) DENM p_denMsg
        ) := {
            msgIn := p_denMsg,
            receptionTime := *
        }
        
        group utPrimitives {
            
            /**
             * @desc    Send template for Upper Tester event initialization
             */
            template (value) UtInitialize m_denmInitialize := {
            }
            
            /**
             * @desc    Send template for Upper Tester Trigger event
             * @param   p_situation                     The Situation Container
             * @param   p_location                      The Location Container
             * @param   p_validityDuration              The validity duration (Default: omit)
             * @param   p_transmissionInterval          The transmission interval (Default: omit)
             * @param   p_repetitionDuration            The repetition duration (Default: omit)
             * @param   p_keepAliveForwardingRequest    The keep alive forwarding request flag (Default: omit)
             * @param   p_alacarte                      The Alacarte container (Default: omit)
             */
            template (value) UtDenmTrigger m_utTriggerEvent(
                template (value) SituationContainer p_situation,
                template (value) LocationContainer p_location,
                template (omit) ValidityDuration p_validityDuration := omit,
                template (omit) TransmissionInterval p_transmissionInterval := omit,
                template (omit) ValidityDuration p_repetitionDuration := omit,
                template (value) boolean p_keepAliveForwardingRequest := false,
                template (omit) AlacarteContainer p_alacarte := omit
            ) := {
                detectionTime := f_getCurrentTime(),
                validityDuration := c_validityDuration_2sec,
                repetitionDuration := p_repetitionDuration,
                situtation := p_situation,
                location := p_location,
                alacarte := p_alacarte,
                relevanceDistance := lessThan50m,
                relevanceTrafficDirection := allTrafficDirection,
                trafficClass := 0,
                transmissionInterval := p_transmissionInterval,
                keepAliveForwardingRequest := p_keepAliveForwardingRequest
            }
            
            /**
             * @desc Send template for Upper Tester event update
             * @param p_actionId                    The action id
             * @param p_situation                   The Situation Container (Default: omit)
             * @param p_location                    The Location Container (Default: omit)
             * @param p_validityDuration            The validity duration (Default: omit)
             * @param p_relevanceDistance           The relevance distance (Default: omit)
             * @param p_relevanceTrafficDirection   The relevance traffic direction (Default: omit)
             * @param p_trafficClass                The traffic class (Default: omit)
             * @param p_transmissionInterval        The transmission interval (Default: omit)
             * @param p_keepAliveForwardingRequest  The keep alive forwarding request flag (Default: omit)
             * @param p_alacarte                    The Alacarte Container (Default: omit)
             */
            template (value) UtDenmUpdate m_utUpdateEvent(
                template (value) ActionID p_actionId,
                template (omit) SituationContainer p_situation := omit,
                template (omit) LocationContainer p_location := omit,
                template (omit) ValidityDuration p_validityDuration := omit,
                template (omit) RelevanceDistance p_relevanceDistance := omit,
                template (omit) RelevanceTrafficDirection p_relevanceTrafficDirection := omit,
                template (omit) integer p_trafficClass := omit,
                template (omit) TransmissionInterval p_transmissionInterval := omit,
                template (value) boolean p_keepAliveForwardingRequest := false,
                template (omit) AlacarteContainer p_alacarte := omit
            ) := {
                actionId := p_actionId,
                detectionTime := f_getCurrentTime(),
                validityDuration := p_validityDuration,
                situation := p_situation,
                location := p_location,
                alacarte := p_alacarte,
                relevanceDistance := p_relevanceDistance,
                relevanceTrafficDirection := p_relevanceTrafficDirection,
                trafficClass := p_trafficClass,
                transmissionInterval := p_transmissionInterval,
                keepAliveForwardingRequest := p_keepAliveForwardingRequest
            }
            
            /**
             * @desc    Send template for Upper Tester event cancellation
             * @param   p_actionId  The action id
             */
            template (value) UtDenmTermination m_utEventCancellation(
                template (value) ActionID p_actionId
            ) := {
                actionId := p_actionId
            }
            
            /**
             * @desc Send template for Upper Tester event change position
             * @param p_latitude    The new latitude
             * @param p_longitude   The new longitude
             * @param p_elevation   The new elevation (Default: 0)
             */
            template (value) UtChangePosition m_utChangePosition(
                template (value) integer p_latitude,
                template (value) integer p_longitude,
                template (value) integer p_elevation := 0
            ) := {
                latitude := p_latitude,
                longitude := p_longitude,
                elevation := p_elevation
            }
            
        } // end utPrimitives
      
    } // end primitives
    
    group denmPduTemplates {
        
        /**
         * @desc    Send template for DENM PDU
         * @param   p_denm  The DEN Message
         */
        template (value) DENM m_denmPdu(
            template (value) DecentralizedEnvironmentalNotificationMessage p_denm
        ) := {
            header := m_itsPduHeader,
            denm := p_denm
        }
        
        /**
         * @desc    Default receive template for DENM PDU
         * @param   p_itsPduHeader  The expected ITS PDU header (Default: any)
         * @param   p_denm          The expected DEN Message (Default: any)
         */
        template DENM mw_anyDenmPdu(
            template (present) ItsPduHeader p_itsPduHeader := ?,
            template (present) DecentralizedEnvironmentalNotificationMessage p_denm := ?
        ) := {
            header := p_itsPduHeader,
            denm := p_denm
        }
        
        /**
         * @desc    Receive template for DENM PDU
         * @param   p_denm              The expected DEN Message 
         * @param   p_stationID         The expected station id (Default: any)
         * @param   p_protocolVersion   The expected protocol version (Default: current DEN protocol version)
         * @param   p_messageID         The expected message id (Default: DEN message id)
         */
        template (present) DENM mw_denmPdu(
            template (present) DecentralizedEnvironmentalNotificationMessage p_denm,
            template (present) StationID p_stationID := ?,
            template (present) ItsPduHeader.protocolVersion p_protocolVersion := c_protocolVersionDenm,
            template (present) ItsPduHeader.messageID p_messageID := c_messageId
        ) := {
            header := mw_itsPduHeader(p_stationID, p_protocolVersion, p_messageID),
            denm := p_denm
        }
        
    } // end denmPduTemplates
    
    group headerTemplates {
        
        /**
         * @desc    Default send template for ITS PDU header
         * @param   p_stationID         The source station ID (Default: test system station id)
         * @param   p_protocolVersion   The protocol version (Default: current DEN protocol version)
         * @param   p_messageID         The message Id (Default: DEN message id)
         */
        template (value) ItsPduHeader m_itsPduHeader(
            template (value) StationID p_stationID := f_getTsStationId(),
            template (value) ItsPduHeader.protocolVersion p_protocolVersion := c_protocolVersionDenm,
            template (value) ItsPduHeader.messageID p_messageID := c_messageId
        ) := {
            protocolVersion := p_protocolVersion,
            messageID := p_messageID,
            stationID := p_stationID
        }
        
        /**
         * @desc    Default receive template for ITS PDU header
         * @param   p_stationID         The expected station id (Default: any)
         * @param   p_protocolVersion   The expected protocol version (Default: current DEN protocol version)
         * @param   p_messageID         The expected message id (Default: DEN message id)
         */
        template ItsPduHeader mw_itsPduHeader(
            template (present) StationID p_stationID := ?,
            template (present) ItsPduHeader.protocolVersion p_protocolVersion := c_protocolVersionDenm,
            template (present) ItsPduHeader.messageID p_messageID := c_messageId
        ) := {
            protocolVersion := p_protocolVersion,
            messageID := p_messageID,
            stationID := p_stationID
        }
        
        /**
         * @desc    Default receive template for the station id
         */
        template (present) StationID mw_anyStationId := ?;
        
    } // end headerTemplates
    
    group timeTemplates {
        
        /**
         * @desc    Receive template for TimestampIts check with delta
         * @param   p_time The expected timestamp
         */
        template TimestampIts mw_timestampIts_withDelta(
            in template (value) TimestampIts p_time
        )  := (valueof(p_time)-PX_TIME_DELTA .. valueof(p_time)+PX_TIME_DELTA);
        
    } // end timeTemplates
    
    group positionTemplates {
        
        /**
         * @desc    Send template for the test system position
         * @param   p_longitude The longitude (Default: Test system's longitude)
         * @param   p_latitude  The latitude (Default: Test system's latitude)
         * @see     m_posConfidenceEllipse
         * @see     m_elevation
         */
        template (value) ReferencePosition m_tsPosition(
            template (value) Longitude p_longitude := f_getTsLongitude(),
            template (value) Latitude p_latitude := f_getTsLatitude()
        ) := {
            longitude := p_longitude,
            latitude := p_latitude,
            positionConfidenceEllipse := m_posConfidenceEllipse,
            altitude := m_altitude
        }
        
        /**
         * @desc    Send template for the position confidence
         * @param   p_semiMajorConfidence   The major confidence (Default: 1cm)
         * @param   p_semiMinorConfidence   The minor confidence (Default: 1cm)
         * @param   p_semiMajorOrientation  The major orientation (Default: m_direction)
         * @see     m_direction
         */
        template (value) PosConfidenceEllipse m_posConfidenceEllipse(
            template (value) SemiAxisLength p_semiMajorConfidence := c_semiAxisLengthOneCentimeter,
            template (value) SemiAxisLength p_semiMinorConfidence := c_semiAxisLengthOneCentimeter,
            template (value) Heading p_semiMajorOrientation := m_direction
        ) := {
            semiMajorConfidence := p_semiMajorConfidence,
            semiMinorConfidence := p_semiMinorConfidence,
            semiMajorOrientation := p_semiMajorOrientation
        }
        
        /**
         * @desc    Send template for north direction with 0.1 confidence
         */
        template (value) Heading m_direction := {
            headingValue := HeadingValue_wgs84North,
            headingConfidence := HeadingConfidence_withinZeroPointOneDegree
        }
          
        /**
         * @desc    Send template for altitude
         * @param   p_altitudeValue        The altitude (Default: Sea level)
         * @param   p_altitudeConfidence   The confidence of the elevation (Default: within one meter)
         */
        template (value) Altitude m_altitude(
            template (value) AltitudeValue p_altitudeValue := c_seaLevel,
            template (value) AltitudeConfidence p_altitudeConfidence := alt_000_01
        ) := {
            altitudeValue := p_altitudeValue,
            altitudeConfidence := p_altitudeConfidence
        }
        
    } // end positionTemplates
    
    group decentralizedEnvironmentalNotificationMessageTemplates {
        
        /**
         * @desc    Send template for DEN Message
         * @param   p_management    The Management Container
         * @param   p_situation     The Situation Container
         * @param   p_location      The Location Container
         * @param   p_alacarte      The Alacarte Container (Default: omit)
         */
        template (value) DecentralizedEnvironmentalNotificationMessage m_denm(
            template (value) ManagementContainer p_management,
            template (omit) SituationContainer p_situation,
            template (omit) LocationContainer p_location,
            template (omit) AlacarteContainer p_alacarte := omit
        ) := {
            management := p_management, 
            situation := p_situation, 
            location := p_location,
            alacarte := p_alacarte
        }
        
        /**
         * @desc    Default receive template for DEN Message
         */
        template (present) DecentralizedEnvironmentalNotificationMessage mw_anyDenm := {
            management := ?, 
            situation := *, 
            location := *,
            alacarte := *
        }
        
        /**
         * @desc    Receive template for DEN Message
         * @param   p_management    The expected Management Container (Default: any)
         * @param   p_situation     The expected Situation Container (Default: any or omit)
         * @param   p_location      The expected location Container (Default: any or omit)
         * @param   p_alacarte      The expected Alacarte Container (Default: any or omit)
         */
        template (present) DecentralizedEnvironmentalNotificationMessage mw_denm(
            template (present) ManagementContainer p_management := ?,
            template SituationContainer p_situation := *,
            template LocationContainer p_location := *,
            template AlacarteContainer p_alacarte := *
        ) modifies mw_anyDenm := {
            management := p_management, 
            situation := p_situation, 
            location := p_location,
            alacarte := p_alacarte
        }
        
        /**
         * @desc    Send template for DEN Message for event termination.
         * @param   p_actionID  The action id
         */
        template (value) DecentralizedEnvironmentalNotificationMessage m_denmCancellation(
            template (value) ActionID p_actionID
        ) := {
            management := m_denmMgmtCon(p_actionID, -, true), 
            situation := omit, 
            location := omit,
            alacarte := omit
        }
        
    } // end group decentralizedEnvironmentalNotificationMessageTemplates
    
    group decentralizedManagementTemplates {
        
        /**
         * @desc    Send template for Management Container
         * @param   p_actionID              The action id
         * @param   p_isNegation            The negation flag (Default: false)
         * @param   p_isCancellation        The cancellation flag (Default: false)
         * @param   p_validityDuration      The validity duration (Default: omit)
         * @param   p_transmissionInterval  The transmission interval (Default: omit)
         * @param   p_detectionTime         The detection time (Default: current time)
         * @param   p_referenceTime         The reference time (Default: current time)
         */
        template (value) ManagementContainer m_denmMgmtCon(
            template (value) ActionID p_actionID,
            template (value) boolean p_isNegation := false,
            template (value) boolean p_isCancellation := false,
            template (omit) ValidityDuration p_validityDuration := omit,
            template (omit) TransmissionInterval p_transmissionInterval := omit,
            template (value) TimestampIts p_detectionTime := f_getCurrentTime(),
            template (value) TimestampIts p_referenceTime := f_getCurrentTime()
        ) := {
            actionID := p_actionID,
            detectionTime := p_detectionTime,
            referenceTime := p_referenceTime,
            isNegation := p_isNegation,
            isCancellation := p_isCancellation,
            eventPosition := m_tsPosition,
            relevanceDistance := lessThan50m,
            relevanceTrafficDirection := allTrafficDirection,
            validityDuration := p_validityDuration,
            transmissionInterval := p_transmissionInterval
        }
        
        /**
         * @desc    Receive template for Management Container
         * @param   p_actionID              The expected action id
         * @param   p_referenceTime         The reference time (Default: any)
         * @param   p_isNegation            The expected negation flag (Default: false)
         * @param   p_isCancellation        The expected cancellation flag (Default: false)
         * @param   p_validityDuration      The expected validity duration (Default: any or omit)
         * @param   p_transmissionInterval  The expected transmission interval (Default: any or omit)
         */
        template (present) ManagementContainer mw_denmMgmtCon(
            template (present) ActionID p_actionID,
            template (present) TimestampIts p_referenceTime := ?,
            template (present) boolean p_isNegation := false,
            template (present) boolean p_isCancellation := false,
            template ValidityDuration p_validityDuration := *,
            template TransmissionInterval p_transmissionInterval := *
        ) := {
            actionID := p_actionID,
            detectionTime := ?,
            referenceTime := p_referenceTime,
            isNegation := p_isNegation,
            isCancellation := p_isCancellation,
            eventPosition := ?,
            relevanceDistance := ?,
            relevanceTrafficDirection := ?,
            validityDuration := p_validityDuration,
            transmissionInterval := p_transmissionInterval
        }
        
        /**
         * @desc    Send template for Test system ActionID
         * @param   p_sequenceNumber    The sequence number (Default: 0)
         */
        template (value) ActionID m_tsActionId(
            template (value) SequenceNumber p_sequenceNumber := 0
        ) := {
        	originatorStationID := f_getTsStationId(),
            sequenceNumber := p_sequenceNumber
        }
        
        /**
         * @desc    Default receive template for Management Container
         */
        template (present) ManagementContainer mw_anyDenmMgmtCon := {
            actionID := ?,
            detectionTime := ?,
            referenceTime := ?,
            isNegation := ?,
            isCancellation := ?,
            eventPosition := ?,
            relevanceDistance := ?,
            relevanceTrafficDirection := ?,
            validityDuration := *,
            transmissionInterval := *
        }
        
        /**
         * @desc    Receive template for Management Container with the given action id
         * @param   p_actionId  The expected action id (Default: any)
         */
        template (present) ManagementContainer mw_denmMgmtConWithActionID(
            template (present) ActionID p_actionId := ?
        ) modifies mw_anyDenmMgmtCon := {
            actionID := p_actionId
        }
        
        /**
         * @desc    Receive template for Management Container with the given data version
         * @param   p_referenceTime   The expected reference time (Default: any)
         */
        template (present) ManagementContainer mw_denmMgmtConWithReferenceTime(
            template (present) TimestampIts p_referenceTime := ?
        ) modifies mw_anyDenmMgmtCon := {
            referenceTime := p_referenceTime
        }
        
        /**
         * @desc    Send template for ActionID
         * @param   p_sequenceNumber        The sequence number
         * @param   p_originatorStationID   The originator station id (Default: IUT's station id)
         */
        template (value) ActionID m_actionId(
            template (value) SequenceNumber p_sequenceNumber,
            template (value) ITS_Container.StationID p_originatorStationID := f_getIutStationId()
        ) := {
            originatorStationID := p_originatorStationID,
            sequenceNumber := p_sequenceNumber
        }
        
        /**
         * @desc    Receive template for ActionID
         * @param   p_originatorStationID   The expected originator station id (Default: any)
         * @param   p_sequenceNumber        The expected sequence number (Default: any)
         */
        template (present) ActionID mw_actionId(
            template (present) ITS_Container.StationID p_originatorStationID := ?,
            template (present) SequenceNumber p_sequenceNumber := ?
        ) := {
            originatorStationID := p_originatorStationID,
            sequenceNumber := p_sequenceNumber
        }
        
        /**
         * @desc    Default receive template for any ActionID
         */
        template (present) ActionID mw_anyActionId := ?;
        
    } // end group decentralizedManagementTemplates
    
    group decentralizedSituationTemplates {
        
        group situationTemplates {
            
            /**
             * @desc    Send template for Situation Container
             * @param   p_cause                 The cause code
             * @param   p_subCause              The sub-cause code
             * @param   p_informationQuality    The information quality (Default: 0)
             */
            template (value) SituationContainer m_situation(
                template (value) CauseCodeType p_cause, 
                template (value) SubCauseCodeType p_subCause,
                template (value) InformationQuality p_informationQuality := 0
            ) := {
                informationQuality := p_informationQuality,
                eventType := {
                    causeCode := p_cause,
                    subCauseCode := p_subCause
                },
                linkedCause := omit
            }
            
            /**
             * @desc    Receive template for Situation Container
             * @param   p_cause                 The expected cause code
             * @param   p_subCause              The expected sub-cause code
             * @param   p_informationQuality    The expected information quality (Default: any)
             */
            template (present) SituationContainer mw_situation(
                template (present) CauseCodeType p_cause, 
                template (present) SubCauseCodeType p_subCause,
                template (present) InformationQuality p_informationQuality := ?
            ) := {
                informationQuality := p_informationQuality,
                eventType := {
                    causeCode := p_cause,
                    subCauseCode := p_subCause
                },
                linkedCause := *
            }
            
            /**
             * @desc    Default receive template for Situation Container
             */
            template (present) SituationContainer mw_anySitutation := ?;
            
        } // end group situationTemplates
        
    } // end group decentralizedSituationTemplates
    
    group decentralizedLocationTemplates {
        
        /**
         * @desc    Send template for Location Container where no delta is given
         */
        template (value) LocationContainer m_denmLocation_zeroDelta := {
            eventSpeed := omit,
            eventPositionHeading := omit,
            traces := {
                {
                    {
                        pathPosition := {
                            deltaLatitude := 0,
                            deltaLongitude := 0,
                            deltaAltitude := 0
                        },
                        pathDeltaTime := 0
                    }
                }
            },
            roadType := omit 
        }
        
        /**
         * @desc    Default receive template for Location Container
         */
        template (present) LocationContainer mw_anyDenmLocation := {
            eventSpeed := *,
            eventPositionHeading := *,
            traces := ?,
            roadType := *
        }
        
        /**
         * @desc    Receive template for Location Container with the given traces
         * @param   p_traces    The expected traces.
         */
        template (present) LocationContainer mw_denmLocationWithTrace(
            template (present) Traces p_traces
        ) := {
            eventSpeed := *,
            eventPositionHeading := *,
            traces := p_traces,
            roadType := *
        }
        
    } // end group decentralizedLocationTemplates
    
    group alacarteTemplates {
        
        /**
         * @desc    Send template for Alacarte Container including lane count
         */
        template (value) AlacarteContainer m_alacarteConLaneCount := {
            laneNumber := 2,
            impactReduction := omit,
            externalTemperature := omit,
            roadWorks := omit,
            positioningSolution := omit,
            stationaryVehicle := omit
        }
        
    } // end alacarteTemplates
    
} // end LibItsDenmTemplates