LibItsCam_Functions.ttcn

/**
 *	@author 	ETSI / STF405
 *  @version 	$URL$
 *				$Id$
 *	@desc		Module containing common functions for ITS
 *
 */
module LibItsCam_Functions {
    
    // LibIts
    import from LibIts_TestSystem all;
    import from LibIts_Interface all; 
	import from LibItsCam_Templates all;
	import from LibItsCam_Pixits all;
    import from LibItsCam_TypesAndValues all;
	import from CAM_PDU_Descriptions language "ASN.1:1997" all;
	import from DENM_PDU_Descriptions language "ASN.1:1997" all;	
 
    // LibCommon
    import from LibCommon_VerdictControl all;

 group defaults {

    /**
     * @desc 	basic default behaviour handling
     * @remark	none
     * @param	none
     */    
	altstep a_basicDefault() runs on ItsFa {

        [] camPort.receive(mw_camInd ( mw_camMsg_any )){ 
			setverdict(fail, "*** a_basicDefault: FAIL: CAM message received in default ***");
			stop;
		}
		[] camPort.receive {
			setverdict(fail, "*** a_basicDefault: FAIL: event received on CAM port in default ***");
			stop;
		}
       [] any timer.timeout { 
			setverdict(fail, "*** a_basicDefault: FAIL: a timer expired in default ***");
			stop;
		}
	}//end altstep a_basicDefault
     
     
     
 } // end of defaults  
 
 group preambles {
        
    /**
     * @desc 	Initialize the IUT
     * @remark	No specific actions specified in the base standard
     * @param	none
     */    
    function f_initialState() runs on ItsFa {
        
        // basic default altstep
        activate(a_basicDefault());
                  
    } // end f_initialState
 
 } // end of preambles

group postambles {
    
    /**
     * @desc 	Global postamble - stops the MTC
     * @remark	No specific actions required so far
     * @param	none
     */    
    function f_postamble()  runs on ItsFa {
        
 	log("*** f_postamble: INFO: postamble ***");
        
    } // end of function
    
} // end of upperTester

group upperTester {
    
    function f_upperTester () {
        
        // crash signal activated
        
        // crash signal deactivated
        
    } // end of function
    
} // end of upperTester

    
group configuration {
    
    /**
     * @desc 	Create Facility component and map CAM port
     * @remark	Only used when ItsFa is a PTC
     * @param	p_camPtc returned Facility component variable
     */    
    function f_ptcCamUp(out ItsFa p_ptcCam) {
        
        // Create Facility component
        p_ptcCam := ItsFa.create("CAM Tester");
        
        // map ports
        map(p_ptcCam:camPort, system:camPort);
        
    } // end f_ptcCamUp
    
    /**
     * @desc 	Wait for component to finish and unmap CAM ports
     * @remark	Only used when ItsFa is a PTC
     * @param	p_camPtc Facility component variable
     */    
    function f_ptcCamDown(in ItsFa p_ptcCam) runs on ItsMtc {
            
    	tc_guard.start;
        alt {
        	[] p_ptcCam.done {
            	tc_guard.stop;
            }
            
            [] tc_guard.timeout {
             	log("*** f_ptcCamDown: ERROR: Timeout while waiting for component ***");
             	setverdict(inconc);   
            }
        }
        unmap(p_ptcCam:camPort);
        
    } // end f_ptcCamDown
        
} // end of configuration

group otherFunctions {
        
	/** @desc	function to generate integer random values
	 *			
	 * @see		ttcn-3 - rnd()
	 *  @param 	p_lowerbound lowest number in range<br>
	 *  @param 	p_upperbound highest number in range<br>
	 *  @return 	integer<br>
	 *
	*/
	function f_random(	in integer p_lowerbound,
    					in integer p_upperbound )
	return integer {
		//Variables
		var integer v_random := 0;
        v_random := float2int(int2float(p_upperbound - p_lowerbound +1)*rnd()) + p_lowerbound;
		//  Here, upperbound and lowerbound denote highest and lowest number in range.
		log("**** f_random: INFO: OK - random value = " & int2str(v_random) & " ****");
        return v_random;

	} // end function f_random

	/** @desc	function to generate a random bitstring value 
	 * 			corrzesponding to 1 bit position set to 1 (eg '00010000', '01000000', ...)
	 *			
	 *  @see	f_random
	 *  @param 	p_length bitstring length - max 15<br>
	 *  @return bitstring<br>
	 *
	*/
	function f_bitPositionRandom( in integer p_length )
	return bitstring {
		//Variables
		var bitstring v_random := '00000000'B;
		
        v_random := '000000000000001'B << f_random (0, p_length);
		log("**** f_random: INFO: OK - random value = " & bit2str(v_random) & " ****");
        return v_random;

	} // end function f_random

} // end of otherFunctions

group upperTester {
    
	/** @desc	upper tester function to change current heading (absolute)
	*
	* @param 	p_heading<br>
	* @return 	FncRetCode<br>
	*/
	function f_changeHeading( Direction p_heading ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_changeHeading: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_changeHeading
    
	/** @desc	upper tester function to change current position (meter)
	*
	* @param 	p_position<br>
	* @return 	FncRetCode<br>
	*/
	function f_changePosition( integer p_position ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_changePosition: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_changePosition
    
	/** @desc	upper tester function to change speed (m/S)
	*
	* @param 	p_speed<br>
	* @return 	FncRetCode<br>
	*/
	function f_changeSpeed( Speed p_speed ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_changeSpeed: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_changeSpeed
    
	/** @desc	upper tester function to set the crash signal (activated/deactivated)
	*
	* @param 	p_crashStatus<br>
	* @return 	FncRetCode<br>
	*/
	function f_setCrashSignal( CrashStatus p_crashStatus ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setCrashSignal: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setCrashSignal
    
	/** @desc	upper tester function to set the dangerous goods status (Good type)
	*			p_goodType = 0 if no dangerous goods are transported
	* @param 	p_goodType<br>
	* @return 	FncRetCode<br>
	*/
	function f_setDangerousGoodsStatus( DangerousGoods p_goodType ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setDangerousGoodsStatus: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setDangerousGoodsStatus
    
	/** 
	*	@desc	upper tester function to set the doors status			
	* 	@param 	p_doorStatus<br>
	* 	@return 	FncRetCode<br>
	*/
	function f_setDoorStatus( DoorOpen p_doorStatus ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setDoorStatus: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setDoorStatus
    
	/** @desc	upper tester function to set the distance to stop line
	*			
	* @param 	p_distance<br>
	* @return 	FncRetCode<br>
	*/
	function f_setDistanceToStopLine( Distance p_distance ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setDistanceToStopLine: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setDistanceToStopLine
    
	/** @desc	upper tester function to set the turn advice
	*			
	* @param 	p_turnAdvice<br>
	* @return 	FncRetCode<br>
	*/
	function f_setTurnAdvice( TurnAdvice p_turnAdvice ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setTurnAdvice: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setTurnAdvice
    
	/** @desc	upper tester function to set the curvature change
	*			
	* @param 	p_curvature<br>
	* @return 	FncRetCode<br>
	*/
	function f_setCurvatureChange( Curvature p_curvature ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setCurvatureChange: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setCurvatureChange
    
	/** @desc	upper tester function to set the Occupancy
	*			
	* @param 	p_occupancy<br>
	* @return 	FncRetCode<br>
	*/
	function f_setOccupancy( Occupancy p_occupancy ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setOccupancy: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setOccupancy
    
	/** @desc	upper tester function to set the light bar status
	*			
	* @param 	p_status<br>
	* @return 	FncRetCode<br>
	*/
	function f_setLightBarStatus( SimpleSystemState p_status ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setLightBarStatus: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setLightBarStatus
    
	/** @desc	upper tester function to set the sirene status
	*			
	* @param 	p_status<br>
	* @return 	FncRetCode<br>
	*/
	function f_setSireneStatus( SimpleSystemState p_status ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setSireneStatus: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setSireneStatus
    
	/** @desc	upper tester function to set the traffic light priority
	*			
	* @param 	p_priority<br>
	* @return 	FncRetCode<br>
	*/
	function f_setTrafficLightPriority( Priority p_priority ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setTrafficLightPriority: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setTrafficLightPriority
    
    
	/** 
	*	@desc	upper tester function to set the Schedule Deviation			
	* 	@param 	p_scheduleDeviation<br>
	* 	@return 	FncRetCode<br>
	*/
	function f_setScheduleDeviation( ScheduleDeviation p_scheduleDeviation ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setScheduleDeviation: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setScheduleDeviation
    
	/** 
	*	@desc	upper tester function to set the PT Line Description			
	* 	@param 	p_pTLineDescription<br>
	* 	@return 	FncRetCode<br>
	*/
	function f_setPTLineDescription( PTLineDescription p_pTLineDescription ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setPTLineDescription: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setPTLineDescription
    
	/** 
	*	@desc	upper tester function to set the exterior lights status			
	* 	@param 	p_exteriorLightsStatus<br>
	* 	@return 	FncRetCode<br>
	*/
	function f_setExteriorLightsStatus( ExteriorLights p_exteriorLightsStatus ) runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_setExteriorLightsStatus: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_setExteriorLightsStatus
    
	/** 
	*	@desc	upper tester function to chnage the reference position (moving)			
	* 	@param 	none<br>
	* 	@return 	FncRetCode<br>
	*/
	function f_changeReferencePosition() runs on ItsFa return FncRetCode {

		//Variables
        var FncRetCode v_ret := e_success;
            
        //TODO define external function
		log("**** f_changeReferencePosition: INFO: OK  ****");
            
        return v_ret;
        
    } // end function f_changeReferencePosition
    
} // end of group upperTester
    
group externalFunctions {
    
	/**
	*	@desc 	Generate a timestamp of the cureent time to be used in a generationTime field
	* @return 	TimeStamp<br>
	*/
	external function fx_generateTime()
	return TimeStamp;

	/** @desc	Wrapper function for fx_generateTime
	 *			
	 * @see		xf_generateTime
	 *
	*/
	function f_generateTime()
	return TimeStamp {
		//Variables
		var TimeStamp v_generationTime:=0;
		
        v_generationTime := fx_generateTime();
        if (v_generationTime!=0)
        {
            return v_generationTime ;
			log("**** f_generateTime: INFO: OK - generationTime = " & int2str(v_generationTime) & " ****");
		}
		else {
			log("**** f_generateTime: ERROR: timestamp could not be generated ****");
			setverdict( inconc ) ;
            return v_generationTime ;
			stop;
		} 
	} // end function f_generateTime
	

	/** @desc	function to get the PT Line Description
	 *			currently return the PIXIT value
	 * @see		PX_PTLINE_COURSE, PX_PTLINE_REF, PX_PTLINE_ROUTE
	 *
	*/
	function f_getPTLineDescription()
	return PTLineDescription {
		//Variables
		var PTLineDescription v_pTLineDescription := { "a", "b", "c" };
		
        v_pTLineDescription :=  { PX_PTLINE_COURSE, PX_PTLINE_REF, PX_PTLINE_ROUTE };   // PIXIT used!
		log("**** f_getPTLineDescription: INFO: OK  ****");
        return v_pTLineDescription ;

	} // end function f_getPTLineDescription
	
	/** @desc	function to get the stationID
	 *			currently return the PIXIT value
	 * @see		PX_TESTER_STATION_ID
	 *
	*/
	function f_getStationID()
	return StationID {
		//Variables
		var StationID v_stationID := 0;
		
        v_stationID :=  PX_TESTER_STATION_ID;   // PIXIT used!
		log("**** f_getStationID: INFO: OK - stationID = " & int2str(v_stationID) & " ****");
        return v_stationID ;

	} // end function fx_getStationID
	
	/**
	*	@desc 	get the stationCharacteristics of the tester
	* @return 	CoopAwareness.stationCharacteristics<br>
	*/
	external function fx_getStationCharacteristics()
    return CoopAwareness.stationCharacteristics;

	/** @desc	Wrapper function for fx_getStationCharacteristics
	 *			
	 * @see		fx_getStationCharacteristics
	 *
	*/
	function f_getStationCharacteristics()
	return CoopAwareness.stationCharacteristics {
		//Variables
		var CoopAwareness.stationCharacteristics v_stationCharacteristics := { true, true, true };
		
        v_stationCharacteristics := fx_getStationCharacteristics();
		log("**** f_getStationCharacteristics: INFO: OK - stationCharacteristics received ****");
        return v_stationCharacteristics ;

	} // end function f_getStationCharacteristics
	

	/**
	*	@desc 	get the ReferencePosition of the tester
	* @return 	ReferencePosition<br>
	*/
	external function fx_getReferencePosition()
    return ReferencePosition;

	/** @desc	Wrapper function for fx_getReferencePosition
	 *			
	 * @see		fx_getReferencePosition
	 *
	*/
	function f_getReferencePosition()
	return ReferencePosition {
		//Variables
		var ReferencePosition v_referencePosition;
		
        v_referencePosition := fx_getReferencePosition();
		log("**** f_getReferencePosition: INFO: OK - referencePosition received ****");
        return v_referencePosition ;

	} // end function f_getReferencePosition
	
	

} // end of externalFunctions

} // end LibItsCam_Functions