LibItsGeoNetworking_Functions.ttcn

/**
 *  @author     ETSI / STF405
 *  @version    $URL$
 *              $Id$
 *  @desc       Module containing functions for GeoNetworking
 *
 */
module LibItsGeoNetworking_Functions {
    
    // Libcommon
    import from LibCommon_BasicTypesAndValues all;
    import from LibCommon_VerdictControl {type FncRetCode;}
    import from LibCommon_Sync {altstep all};
    
    // LibIts
    import from LibIts_TestSystem all;
    import from LibIts_Interface all; 
    import from LibItsCommon_Functions all;
    import from LibItsGeoNetworking_TypesAndValues all;
    import from LibItsGeoNetworking_Templates all;
    import from LibItsGeoNetworking_Pixits all;
    
    /**
     * @desc    Create Facility component and connects GeoNetworking port
     * @remark  Only used when ItsFa is a PTC
     * @param   p_ptcDenm returned Facility component variable
     */    
    function f_ptcGeoNetworkingUp(out ItsNt p_ptcGeoNetworking) {
        
        // Create Facility component
        p_ptcGeoNetworking := ItsNt.create("GeoNetworking Tester");
        
        // map ports
        map(p_ptcGeoNetworking:geoNetworkingPort, system:geoNetworkingPort);
        
    } // end f_ptcGeoNetworkingUp       
    
    /**
     * @desc    Wait for component to finish and unmap GeoNetworking ports
     * @remark  Only used when ItsFa is a PTC
     * @param   p_camPtc Facility component variable
     */    
    function f_ptcGeoNetworkingDown(in ItsNt p_ptcGeoNetworking) runs on ItsMtc {    
        tc_guard.start;
        alt {
            [] p_ptcGeoNetworking.done {
                tc_guard.stop;
            }
            
            [] tc_guard.timeout {
                log("*** f_ptcGeoNetworkingDown: ERROR: Timeout while waiting for component ***");
                setverdict(inconc);   
            }
        }
        unmap(p_ptcGeoNetworking:geoNetworkingPort);
        
    } // end f_ptcGeoNetworkingDown
    
    group geoConfigurationFunctions {
        
        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - two ITS nodes (nodeA, nodeB)
         *       - Area1 which only includes NodeB and IUT
         *       - Area2 which only includes NodeB 
         *         NodeB being close to the area center    
         */
        function f_cf01Up() runs on ItsNt {

            // Variables
            var PositionTable v_positionTable := {};
 
            // Map
            map(self:geoNetworkingPort, system:geoNetworkingPort);
            
            // Position table
            f_addPosition(v_positionTable, c_compIut, f_getIutLongPosVector());
            f_addPosition(v_positionTable, c_compNodeA, f_computePosition());
            f_addPosition(v_positionTable, c_compNodeB, f_computePosition());
        
            f_initialiseComponent(v_positionTable, c_compNodeB);
            
        } // end f_cf01Up

        /**
         * @desc Deletes configuration cf01
         */
        function f_cf01Down() runs on ItsNt {

            // Map
            unmap(self:geoNetworkingPort, system:geoNetworkingPort);
            
        } // end f_cf01Down
        
        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - one ITS node (NodeB)
         *       - one ITS node (NodeD)
         *       - Area1 which only includes NodeB, NodeD and IUT
         *       - Area2 which only includes NodeB and NodeD 
         *         NodeB being close to the area center          
         *         
         * @param p_nodeB
         * @param p_nodeD
         */
        function f_cf02Up(out ItsNt p_nodeB, out ItsNt p_nodeD) runs on ItsMtc {
            
            // Variables
            var PositionTable v_positionTable := {};
            
            // Create
            p_nodeB := ItsNt.create(c_compNodeB) alive;
            p_nodeD := ItsNt.create(c_compNodeD) alive;

            // Map            
            map(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
            map(p_nodeD:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect            
            connect(p_nodeB:syncPort, self:syncPort);
            connect(p_nodeD:syncPort, self:syncPort);
        
            // Position table
            f_addPosition(v_positionTable, c_compIut, f_getIutLongPosVector());
            f_addPosition(v_positionTable, c_compNodeB, f_computePosition());
            f_addPosition(v_positionTable, c_compNodeD, f_computePosition());
            
            p_nodeB.start(f_initialiseComponent(v_positionTable, c_compNodeB));
            p_nodeD.start(f_initialiseComponent(v_positionTable, c_compNodeD));
            p_nodeD.done;
            p_nodeD.done;
        
        } // end f_cf02Up

        /**
         * @desc Deletes configuration cf02
         * @param p_nodeB
         * @param p_nodeD
         */
        function f_cf02Down(in ItsNt p_nodeB, in ItsNt p_nodeD) runs on ItsMtc {
            
            // Map
            unmap(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
            unmap(p_nodeD:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            disconnect(p_nodeB:syncPort, self:syncPort);
            disconnect(p_nodeD:syncPort, self:syncPort);
        
        } // end f_cf02Down
        
        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - one ITS node (NodeA)
         *       - one ITS node in direction of NodeA (NodeB)
         *       - one ITS node not in direction of NodeA (NodeC)       
         *       - Area1 which only includes NodeB and IUT
         *       - Area2 which only includes NodeB 
         *         NodeB being close to the area center   
         */
        function f_cf03Up(out ItsNt p_nodeB, out ItsNt p_nodeC) runs on ItsMtc {

            // Variables
            var PositionTable v_positionTable := {};
 
            // Create
            p_nodeB := ItsNt.create(c_compNodeB) alive;
            p_nodeC := ItsNt.create(c_compNodeC) alive;

            // Map
            map(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
            map(p_nodeC:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            connect(p_nodeB:syncPort, self:syncPort);
            connect(p_nodeC:syncPort, self:syncPort);

            // Position table
            f_addPosition(v_positionTable, c_compIut, f_getIutLongPosVector());
            f_addPosition(v_positionTable, c_compNodeA, f_computePosition());
            f_addPosition(v_positionTable, c_compNodeB, f_computePosition());
            f_addPosition(v_positionTable, c_compNodeC, f_computePosition());
            
            p_nodeB.start(f_initialiseComponent(v_positionTable, c_compNodeB));
            p_nodeC.start(f_initialiseComponent(v_positionTable, c_compNodeC));
            p_nodeB.done;
            p_nodeC.done;
                    
        } // end f_cf03Up

        /**
         * @desc Deletes configuration cf03
         * @param p_nodeA
         * @param p_nodeB
         * @param p_nodeC
         */
        function f_cf03Down(in ItsNt p_nodeB, in ItsNt p_nodeC) runs on ItsMtc {