LibItsGeoNetworking_Functions.ttcn

/**
 *  @author     ETSI / STF405 / STF449
 *  @version    $URL$
 *              $Id$
 *  @desc       Module containing functions for GeoNetworking
 *
 */
module LibItsGeoNetworking_Functions {
    
    // Libcommon
    import from LibCommon_BasicTypesAndValues all;
    import from LibCommon_DataStrings all;
    import from LibCommon_VerdictControl {type FncRetCode;}
    import from LibCommon_Sync all;
    import from LibCommon_Time all;
    
    // LibItsCommon
    import from LibItsCommon_Functions all;
    import from LibItsCommon_Pixits all;
    import from LibItsCommon_Templates all;
    import from LibItsCommon_TestSystem all;
    import from LibItsCommon_TypesAndValues all;
    import from LibItsExternal_TypesAndValues {type MacAddress};
    
    // LibItsSecurity
    import from LibItsSecurity_TypesAndValues all;
    import from LibItsSecurity_Templates all;
    import from LibItsSecurity_Functions all;
    import from LibItsSecurity_Pixits all;
    
    // LibItsGeoNetworking
    import from LibItsGeoNetworking_TestSystem all;
    import from LibItsGeoNetworking_TypesAndValues all;
    import from LibItsGeoNetworking_Templates all;
    import from LibItsGeoNetworking_Pixits all;
    import from LibItsGeoNetworking_Pics all;
    
    group utFuntions {
        
        /**
         * @desc    Requests to bring the IUT in an initial state
         * @param   p_init The initialisation to trigger.
         */
        function f_utInitializeIut(template (value) UtInitialize p_init) runs on ItsBaseGeoNetworking {
            
            //deactivate gnPort default alts
            vc_gnDefaultActive := false;
            
            utPort.send(p_init);
            tc_wait.start;
            alt {
                [] utPort.receive(UtInitializeResult:true) {
                    tc_wait.stop;
                    log("*** f_utInitializeIut: INFO: IUT initialized ***");
                }
                [] utPort.receive {
                    tc_wait.stop;
                    log("*** f_utInitializeIut: INFO: IUT could not be initialized ***");
                    f_selfOrClientSyncAndVerdict("error", e_error);
                }
                [] tc_wait.timeout {
                    log("*** f_utInitializeIut: INFO: IUT could not be initialized in time ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
            }
            
            //activate gnPort default alts
            vc_gnDefaultActive := true;
            
        }
        
        /**
         * @desc    Requests to change the position of the IUT
         */
        function f_utChangePosition() runs on ItsBaseGeoNetworking {
            
            //deactivate gnPort default alts
            vc_gnDefaultActive := false;
            
            utPort.send(m_changePosition);
            tc_wait.start;
            alt {
                [] utPort.receive(UtChangePositionResult:true) {
                    tc_wait.stop;
                    log("*** f_utChangePosition: INFO: IUT position changed ***");
                }
                [] utPort.receive(UtChangePositionResult:false) {
                    tc_wait.stop;
                    log("*** f_utChangePosition: INFO: IUT position change was not successful ***");
                    f_selfOrClientSyncAndVerdict("error", e_error);
                }
                [] a_utDefault() {
                }
                [] tc_wait.timeout {
                    log("*** f_utChangePosition: INFO: IUT position not changed in time ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
            }
            
            //activate gnPort default alts
            vc_gnDefaultActive := true;
            
        }
        
        /**
         * @desc    Triggers event from the application layer
         * @param   p_event The event to trigger.
         */
        function f_utTriggerEvent(template (value) UtGnTrigger p_event) runs on ItsBaseGeoNetworking return boolean {
            
            // Variables
            var boolean v_return := true;

            //deactivate gnPort default alts
            vc_gnDefaultActive := false;
            
            utPort.send(p_event);
            tc_wait.start;
            alt {
                [] utPort.receive(UtGnTriggerResult:true) {
                    tc_wait.stop;
                }
                [] utPort.receive(UtGnTriggerResult:false) {
                    tc_wait.stop;
                    log("*** UtGnTriggerResult: INFO: UT trigger was not successful ***");
                    f_selfOrClientSyncAndVerdict("error", e_error);
                }
                [] a_utDefault() {
                }
                [] tc_wait.timeout {
                    v_return := false;
                }
            }
            
            //activate gnPort default alts
            vc_gnDefaultActive := true;
            
            return v_return;
        }
        
    } // End of group utFunctions
    
    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(Scenario p_scenario := e_staticPosition) runs on ItsGeoNetworking system ItsGeoNetworkingSystem {
            
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            
            // Map
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            map(self:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            f_connect4SelfOrClientSync();
            activate(a_cf01Down());
            
            // Initialise secured mode
            f_initialiseSecuredMode();
            
            //Initialze the IUT
            f_initialState(p_scenario);
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeB);
            
        } // end f_cf01Up
        
        function f_cf01Down() runs on ItsGeoNetworking system ItsGeoNetworkingSystem {
            
            f_uninitialiseSecuredMode();
            
            // Unmap
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            unmap(self:geoNetworkingPort, system:geoNetworkingPort);
            
            // Disconnect
            f_disconnect4SelfOrClientSync();
            
        } // 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_mainUtComponent Name of the component that will initialize IUT and handle default UT messages
         */
        function f_cf02Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var ItsGeoNetworking v_component;
            var integer i;
            
            // Select components
            vc_componentTable := {{c_compNodeB, omit}, {c_compNodeD, omit}};
            
            // Create components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent := ItsGeoNetworking.create(vc_componentTable[i].componentName) alive;
            }
            
            // Map & Connect
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            connect(self:syncPort, mtc:syncPort);
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                map(vc_componentTable[i].gnComponent:acPort, system:acPort);
                map(vc_componentTable[i].gnComponent:utPort, system:utPort);
                map(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                connect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            
            activate(a_cf02Down());
            
            //Initialze the IUT
            if(p_mainUtComponent == c_compMTC) {
                // Initialise secured mode
                f_initialiseSecuredMode();
                
                // MTC intializes IUT
                f_initialState(p_scenario);
            }
            else {
                v_component := f_getComponent(p_mainUtComponent);
                v_component.start(f_initialState(p_scenario));
                v_component.done;    
            }
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            // Initialize components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.start(f_initialiseComponent(v_positionTable, v_areaTable, vc_componentTable[i].componentName));
            }
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.done;
            }
            
        } // end f_cf02Up
        
        /**
         * @desc Deletes configuration cf02
         */
        function f_cf02Down() runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Local variables
            var integer i;
            
            f_uninitialiseSecuredMode();
            
            // Unmap & Disconnect
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) { 
                unmap(vc_componentTable[i].gnComponent:utPort, system:utPort);
                unmap(vc_componentTable[i].gnComponent:acPort, system:acPort);
                unmap(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                disconnect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            disconnect(self:syncPort, mtc: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
         * @param p_mainUtComponent Name of the component that will initialize IUT and handle default UT messages
         */
        function f_cf03Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var ItsGeoNetworking v_component;
            var integer i;
            
            // Select components
            vc_componentTable := {{c_compNodeB, omit}, {c_compNodeC, omit}};
            
            // Create components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent := ItsGeoNetworking.create(vc_componentTable[i].componentName) alive;
            }
            
            // Map & Connect
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            connect(self:syncPort, mtc:syncPort);
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                map(vc_componentTable[i].gnComponent:acPort, system:acPort);
                map(vc_componentTable[i].gnComponent:utPort, system:utPort);
                map(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                connect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            
            activate(a_cf03Down());
            
            //Initialze the IUT
            if(p_mainUtComponent == c_compMTC) {
                // Initialise secured mode
                f_initialiseSecuredMode();
                
                // MTC intializes IUT
                f_initialState(p_scenario);
            }
            else {
                v_component := f_getComponent(p_mainUtComponent);
                v_component.start(f_initialState(p_scenario));
                v_component.done;   
            }
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            // Initialize components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.start(f_initialiseComponent(v_positionTable, v_areaTable, vc_componentTable[i].componentName));
            }
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.done;
            }
            
        } // end f_cf03Up
        
        /**
         * @desc Deletes configuration cf03
         */
        function f_cf03Down() runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Local variables
            var integer i;
            
            f_uninitialiseSecuredMode();
            
            // Unmap & Disconnect
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) { 
                unmap(vc_componentTable[i].gnComponent:utPort, system:utPort);
                unmap(vc_componentTable[i].gnComponent:acPort, system:acPort);
                unmap(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                disconnect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            disconnect(self:syncPort, mtc:syncPort);
        
        } // end f_cf03Down
        
        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - one ITS node (NodeA)
         *       - one ITS node in direction of NodeA and having
         *         shortest distance to NodeA (NodeB)
         *       - one ITS node in direction of NodeA (NodeD)
         *       - one ITS node not in direction of NodeA (NodeC)
         *       - Area1 which only includes NodeB, NodeD and IUT
         *       - Area2 which only includes NodeA, NodeB and NodeD
         *         NodeB being close to the area center
         * @param p_mainUtComponent Name of the component that will initialize IUT and handle default UT messages
         */
        function f_cf04Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var ItsGeoNetworking v_component;
            var integer i;
            
            // Select components
            vc_componentTable := {{c_compNodeB, omit}, {c_compNodeC, omit}, {c_compNodeD, omit}};
            
            // Create components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent := ItsGeoNetworking.create(vc_componentTable[i].componentName) alive;
            }
            
            // Map & Connect
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            connect(self:syncPort, mtc:syncPort);
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                map(vc_componentTable[i].gnComponent:acPort, system:acPort);
                map(vc_componentTable[i].gnComponent:utPort, system:utPort);
                map(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                connect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            
            activate(a_cf04Down());
            
            //Initialze the IUT
            if(p_mainUtComponent == c_compMTC) {
                // Initialise secured mode
                f_initialiseSecuredMode();
                
                // MTC intializes IUT
                f_initialState(p_scenario);
            }
            else {
                v_component := f_getComponent(p_mainUtComponent);
                v_component.start(f_initialState(p_scenario));
                v_component.done;   
            }
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            // Initialize components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.start(f_initialiseComponent(v_positionTable, v_areaTable, vc_componentTable[i].componentName));
            }
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.done;
            }
            
        } // end f_cf04Up
        
        /**
         * @desc Deletes configuration cf04
         */
        function f_cf04Down() runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Local variables
            var integer i;
            
            f_uninitialiseSecuredMode();
            
            // Unmap & Disconnect
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) { 
                unmap(vc_componentTable[i].gnComponent:utPort, system:utPort);
                unmap(vc_componentTable[i].gnComponent:acPort, system:acPort);
                unmap(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                disconnect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            disconnect(self:syncPort, mtc:syncPort);
            
        } // end f_cf04Down

        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - one ITS node (NodeB)
         *       - one ITS node not in direction of NodeB and having
         *         longest distance to NodeB (NodeE)
         *       - Area1 which only includes NodeB, NodeD and IUT
         * @param p_mainUtComponent Name of the component that will initialize IUT and handle default UT messages
         */
        function f_cf05Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var ItsGeoNetworking v_component;
            var integer i;
            
            // Select components
            vc_componentTable := {{c_compNodeB, omit}, {c_compNodeE, omit}};
            
            // Create components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent := ItsGeoNetworking.create(vc_componentTable[i].componentName) alive;
            }
            
            // Map & Connect
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            connect(self:syncPort, mtc:syncPort);
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                map(vc_componentTable[i].gnComponent:acPort, system:acPort);
                map(vc_componentTable[i].gnComponent:utPort, system:utPort);
                map(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                connect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            
            activate(a_cf05Down());
            
            //Initialze the IUT
            if(p_mainUtComponent == c_compMTC) {
                // Initialise secured mode
                f_initialiseSecuredMode();
                
                // MTC intializes IUT
                f_initialState(p_scenario);
            }
            else {
                v_component := f_getComponent(p_mainUtComponent);
                v_component.start(f_initialState(p_scenario));
                v_component.done;   
            }
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            // Initialize components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.start(f_initialiseComponent(v_positionTable, v_areaTable, vc_componentTable[i].componentName));
            }
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.done;
            }
        }
        
        /**
         * @desc Deletes configuration cf05
         */
        function f_cf05Down() runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Local variables
            var integer i;
            
            f_uninitialiseSecuredMode();
            
            // Unmap & Disconnect
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) { 
                unmap(vc_componentTable[i].gnComponent:utPort, system:utPort);
                unmap(vc_componentTable[i].gnComponent:acPort, system:acPort);
                unmap(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                disconnect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            disconnect(self:syncPort, mtc:syncPort);
            
        } // end f_cf05Down
        
        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - one ITS node (NodeB)
         *       - one ITS node not in direction of NodeB and having
         *         shortest distance to NodeB (NodeF)
         *       - Area1 which only includes NodeB, NodeD and IUT
         *       - IUT not in sectorial area of NodeB-NodeF
         * @param p_mainUtComponent Name of the component that will initialize IUT and handle default UT messages
         */
        function f_cf06Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
                    
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var ItsGeoNetworking v_component;
            var integer i;
            
            // Select components
            vc_componentTable := {{c_compNodeB, omit}, {c_compNodeF, omit}};
            
            // Create components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent := ItsGeoNetworking.create(vc_componentTable[i].componentName) alive;
            }
            
            // Map & Connect
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            connect(self:syncPort, mtc:syncPort);
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                map(vc_componentTable[i].gnComponent:acPort, system:acPort);
                map(vc_componentTable[i].gnComponent:utPort, system:utPort);
                map(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                connect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            
            activate(a_cf06Down());
            
            //Initialze the IUT
            if(p_mainUtComponent == c_compMTC) {
                // Initialise secured mode
                f_initialiseSecuredMode();
                
                // MTC intializes IUT
                f_initialState(p_scenario);
            }
            else {
                v_component := f_getComponent(p_mainUtComponent);
                v_component.start(f_initialState(p_scenario));
                v_component.done;   
            }
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            // Initialize components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.start(f_initialiseComponent(v_positionTable, v_areaTable, vc_componentTable[i].componentName));
            }
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.done;
            }
        }
        
        /**
         * @desc Deletes configuration cf06
         */
        function f_cf06Down() runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Local variables
            var integer i;
            
            f_uninitialiseSecuredMode();
            
            // Unmap & Disconnect
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) { 
                unmap(vc_componentTable[i].gnComponent:utPort, system:utPort);
                unmap(vc_componentTable[i].gnComponent:acPort, system:acPort);
                unmap(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                disconnect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            disconnect(self:syncPort, mtc:syncPort);
            
        } // end f_cf06Down

        /**
         * @desc This configuration features:
         *       - one ITS node (IUT)
         *       - one ITS node (NodeB)
         *       - one ITS node in direction of NodeB and having
         *         shortest distance to NodeB (NodeD)
         *       - Area1 which only includes NodeB, NodeD and IUT
         * @param p_mainUtComponent Name of the component that will initialize IUT and handle default UT messages
         */
        function f_cf07Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
                    
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var ItsGeoNetworking v_component;
            var integer i;
            
            // Select components
            vc_componentTable := {{c_compNodeB, omit}, {c_compNodeD, omit}};
            
            // Create components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent := ItsGeoNetworking.create(vc_componentTable[i].componentName) alive;
            }
            
            // Map & Connect
            map(self:acPort, system:acPort);
            map(self:utPort, system:utPort);
            connect(self:syncPort, mtc:syncPort);
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                map(vc_componentTable[i].gnComponent:acPort, system:acPort);
                map(vc_componentTable[i].gnComponent:utPort, system:utPort);
                map(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                connect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            
            activate(a_cf07Down());
            
            //Initialze the IUT
            if(p_mainUtComponent == c_compMTC) {
                // Initialise secured mode
                f_initialiseSecuredMode();
                
                // MTC intializes IUT
                f_initialState(p_scenario);
            }
            else {
                v_component := f_getComponent(p_mainUtComponent);
                v_component.start(f_initialState(p_scenario));
                v_component.done;   
            }
            
            // Positions & Areas
            f_preparePositionsAndAreas(v_positionTable, v_areaTable);
            
            // Initialize components
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.start(f_initialiseComponent(v_positionTable, v_areaTable, vc_componentTable[i].componentName));
            }
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) {
                vc_componentTable[i].gnComponent.done;
            }
        }
        
        /**
         * @desc Deletes configuration cf06
         */
        function f_cf07Down() runs on ItsMtc mtc ItsMtc system ItsGeoNetworkingSystem {
            
            // Local variables
            var integer i;
            
            f_uninitialiseSecuredMode();
            
            // Unmap & Disconnect
            for(i:=0; i < lengthof(vc_componentTable); i:=i+1) { 
                unmap(vc_componentTable[i].gnComponent:utPort, system:utPort);
                unmap(vc_componentTable[i].gnComponent:acPort, system:acPort);
                unmap(vc_componentTable[i].gnComponent:geoNetworkingPort, system:geoNetworkingPort);
                disconnect(vc_componentTable[i].gnComponent:syncPort, self:syncPort);
            }
            unmap(self:acPort, system:acPort);
            unmap(self:utPort, system:utPort);
            disconnect(self:syncPort, mtc:syncPort);
            
        } // end f_cf0yDown
        
        /**
         * @desc    Behavior function for initializing component's variables and tables
         * @param   p_positionTable Table containing position vectors of all nodes
         * @param   p_areaTable     Table containing all defined geoAreas
         * @param   p_componentName Name of the component
         */
        function f_initialiseComponent(
            in PositionTable p_positionTable,
            in GeoAreaTable p_areaTable,
            in charstring p_componentName)
        runs on ItsGeoNetworking {
            
            vc_positionTable := p_positionTable;
            vc_areaTable := p_areaTable;
            vc_componentName := p_componentName;
            
            vc_localSeqNumber := f_getInitialSequenceNumber();
            vc_multipleMessagesCount := f_getMessageCount();
            
        } // end f_initialiseComponent
        
        /**
         * @desc    Makes the simulated ITS node behave as a neighbour of IUT
         */
        function f_startBeingNeighbour() runs on ItsGeoNetworking {
            
            vc_neighbourDefault := activate(a_neighbourDefault());
            f_acTriggerEvent(m_startBeaconing(m_beaconHeader(f_getPosition(vc_componentName)).beaconHeader));
            f_sleepIgnoreDef(PX_NEIGHBOUR_DISCOVERY_DELAY);
        } // end f_startBeingNeighbour
        
        /**
         * @desc    Makes the simulated ITS node behave as not being a neighbour of IUT
         */
        function f_stopBeingNeighbour() runs on ItsGeoNetworking {
            
            f_acTriggerEvent(m_stopBeaconing);
            if (PICS_GN_SECURITY == true) {
                deactivate(vc_neighbourDefault);
            }
        } // end f_stopBeingNeighbour
        
        /**
         * @desc Initialise secure mode if required
         */
        function f_initialiseSecuredMode() runs on ItsBaseGeoNetworking {
            if (PICS_GN_SECURITY == true) {
                if(e_success != f_acEnableSecurity()){
                    log("*** INFO: TEST CASE NOW STOPPING ITSELF! ***");
                    stop;
                }
            }
        } // End of function f_initialiseSecuredMode()
        
        function f_uninitialiseSecuredMode() runs on ItsBaseGeoNetworking {
            if (PICS_GN_SECURITY == true) {

                f_acDisableSecurity();
            }
        } // End of function f_initialiseSecuredMode()
        
    } // end geoConfigurationFunctions
    
    group componentFunctions {
        /**
         * @desc    Get the component  corresponding to a key
         * @param   p_componentName   Name searched component
         * @return  ItsGeoNetworking - The searched position vector
         */
        function f_getComponent(
            in charstring p_componentName
        ) runs on ItsMtc
        return ItsGeoNetworking {
            
            var ItsGeoNetworking v_return := null;
            var integer i := 0;
            
            for (i:=0; i<lengthof(vc_componentTable); i:=i+1) {
                if (vc_componentTable[i].componentName == p_componentName) {
                    v_return := vc_componentTable[i].gnComponent;
                }
            }
            
            return v_return;
        }
    }
    
    group geoPositionFunctions {
        
        /**
         * @desc   Prepare positions and areas tables according to general constellation 
         * @param p_positionTable  Position Table
         * @param p_areaTable      Area Table
         */
        function f_preparePositionsAndAreas(
            inout PositionTable p_positionTable,
            inout GeoAreaTable p_areaTable
        ) runs on ItsBaseGeoNetworking {
            
            var LongPosVector v_longPosVectorIut, v_longPosVectorNodeA, v_longPosVectorNodeB, v_longPosVectorNodeC, v_longPosVectorNodeD, v_longPosVectorNodeE, v_longPosVectorNodeF;
            
            // Get positions
            v_longPosVectorIut := f_getIutLongPosVector();
            v_longPosVectorNodeA := f_computePosition(v_longPosVectorIut, c_longitudeFactorNodeA, c_latitudeFactorNodeA);
            v_longPosVectorNodeB := f_computePosition(v_longPosVectorIut, c_longitudeFactorNodeB, c_latitudeFactorNodeB);
            v_longPosVectorNodeC := f_computePosition(v_longPosVectorIut, c_longitudeFactorNodeC, c_latitudeFactorNodeC);
            v_longPosVectorNodeD := f_computePosition(v_longPosVectorIut, c_longitudeFactorNodeD, c_latitudeFactorNodeD);
            v_longPosVectorNodeE := f_computePosition(v_longPosVectorIut, c_longitudeFactorNodeE, c_latitudeFactorNodeE);
            v_longPosVectorNodeF := f_computePosition(v_longPosVectorIut, c_longitudeFactorNodeF, c_latitudeFactorNodeF);
            
            // Propagate GN addresses
            v_longPosVectorNodeA.gnAddr := f_getTsGnLocalAddress(c_compNodeA);
            v_longPosVectorNodeB.gnAddr := f_getTsGnLocalAddress(c_compNodeB);
            v_longPosVectorNodeC.gnAddr := f_getTsGnLocalAddress(c_compNodeC);
            v_longPosVectorNodeD.gnAddr := f_getTsGnLocalAddress(c_compNodeD);
            v_longPosVectorNodeE.gnAddr := f_getTsGnLocalAddress(c_compNodeE);
            v_longPosVectorNodeF.gnAddr := f_getTsGnLocalAddress(c_compNodeF);
            
            // Position table
            f_addPosition(p_positionTable, c_compIut, v_longPosVectorIut);
            f_addPosition(p_positionTable, c_compNodeA, v_longPosVectorNodeA);
            f_addPosition(p_positionTable, c_compNodeB, v_longPosVectorNodeB);
            f_addPosition(p_positionTable, c_compNodeC, v_longPosVectorNodeC);
            f_addPosition(p_positionTable, c_compNodeD, v_longPosVectorNodeD);
            f_addPosition(p_positionTable, c_compNodeE, v_longPosVectorNodeE);
            f_addPosition(p_positionTable, c_compNodeF, v_longPosVectorNodeF);
            
            // Area table
            f_addArea(p_areaTable, c_area1,
                f_computeCircularArea(v_longPosVectorNodeD, float2int(5.0 * f_distance(v_longPosVectorNodeB, v_longPosVectorNodeD))));
            f_addArea(p_areaTable, c_area2,
                f_computeCircularArea(v_longPosVectorNodeB, float2int(1.5 * f_distance(v_longPosVectorNodeB, v_longPosVectorNodeD))));               
            
        }
        
        /**
         * @desc    Add a position vector in position table
         * @param   p_positionTable Position table to be updated
         * @param   p_positionKey   Reference key of the added position vector
         * @param   p_positionValue Added position vector
         */
        function f_addPosition(
            inout PositionTable p_positionTable,
            in charstring p_positionKey,
            in LongPosVector p_positionValue
        ) {
            
            p_positionTable[lengthof(p_positionTable)] := {
                key := p_positionKey,
                position := p_positionValue
            };
        }
        
        function @deterministic f_fillTimestamp(inout LongPosVector v_vector) 
        return LongPosVector {
            if (v_vector.timestamp_ == 0) {
                v_vector.timestamp_ := f_computeGnTimestamp();
            }
            return v_vector;
        }
        
        /**
         * @desc    Get the position vector corresponding to a key
         * @param   p_positionKey   Reference key of the searched position vector
         * @return  LongPosVector - The searched position vector
         */
        function f_getPosition(
            in charstring p_positionKey
        ) runs on ItsGeoNetworking
        return LongPosVector {
            
            var LongPosVector v_return;
            var integer i := 0;
            
            for (i:=0; i<lengthof(vc_positionTable); i:=i+1) {
                if (vc_positionTable[i].key == p_positionKey) {
                    v_return := f_fillTimestamp(vc_positionTable[i].position);
                }
            }
            
            if (isbound(v_return) and (v_return.timestamp_ == 0)) {
                v_return.timestamp_ := f_computeGnTimestamp();
            }
            return v_return;
        }
        /**
         * @desc    Set the position vector corresponding to a ComponentNode
         * @param   p_compNode  Reference to the Component to be changed
         * @param   p_longPosVector - The new position vector
         */

        function f_changePositon(
            in charstring p_compNode,
            in LongPosVector p_longPosVector
        ) runs on ItsGeoNetworking {
            
            var integer i := 0;

             for (i:=0; i<lengthof(vc_positionTable); i:=i+1) {
                if (vc_positionTable[i].key == p_compNode) {
                    vc_positionTable[i].position := p_longPosVector;
                    break;
                }
            }
        }
        
        /**
         * @desc    Compute a position based on reference point and distance factors
         * @param   p_refPosition       Reference point
         * @param   p_longitudeFactor   Number of DISTANCE_UNIT applied for computing longitude
         * @param   p_latitudeFactor    Number of DISTANCE_UNIT applied for computing latitude
         * @return  LongPosVector - Computed position
         * @see     PICS_GN_DEFAULT_MAX_COMMUNICATION_RANGE
         */
        function f_computePosition(
            in LongPosVector p_refPosition,
            in integer p_longitudeFactor,
            in integer p_latitudeFactor
        ) return LongPosVector {
            
            const integer c_distance2Gps := 100;
            var LongPosVector v_return := p_refPosition;                        
            var UInt32 v_distanceUnit := (c_distance2Gps * PICS_GN_DEFAULT_MAX_COMMUNICATION_RANGE) / 10;
            
            v_return.latitude := v_return.latitude + p_latitudeFactor * v_distanceUnit;
            v_return.longitude := v_return.longitude + p_longitudeFactor * v_distanceUnit;
            v_return.timestamp_ := f_computeGnTimestamp();
            v_return.pai := int2bit(1,1);
            
            return v_return;
        }
        
        /**
         * @desc    Add a geoArea in geoArea table
         * @param   p_geoAreaTable  GeoArea table to be updated
         * @param   p_areaKey       Reference key of the added geoArea
         * @param   p_geoArea       Added geoArea
         */
        function f_addArea(
            inout GeoAreaTable p_geoAreaTable,
            in charstring p_areaKey,
            in GeoArea p_geoArea
        ) {
            p_geoAreaTable[lengthof(p_geoAreaTable)] := {
                key := p_areaKey,
                geoArea := p_geoArea
            };
        }
        
        /**
         * @desc    Get the geoArea corresponding to a key
         * @param   p_areaName   Reference key of the searched geoArea
         * @return  GeoArea - The serached geoArea
         */
        function f_getArea(
            in charstring p_areaName
        ) runs on ItsGeoNetworking
        return GeoArea {
            var GeoArea v_return;
            var integer i := 0;
            
            for (i:=0; i<lengthof(vc_areaTable); i:=i+1) {
                if (vc_areaTable[i].key == p_areaName) {
                    v_return := vc_areaTable[i].geoArea;
                }
            }
            
            return v_return;
        }
        
        /**
         * @desc    Get the geoBroadcastArea corresponding to a key