LibItsGeoNetworking_Functions.ttcn

/**
 *  @author     ETSI / STF405 / STF449 / STF484 / STF517 / STF525
 *  @version    $URL$
*              $Id$
 *  @desc       Module containing functions for GeoNetworking
 *  @copyright   ETSI Copyright Notification
 *               No part may be reproduced except as authorized by written permission.
 *               The copyright and the foregoing restriction extend to reproduction in all media.
 *               All rights reserved.
 *
 */
module LibItsGeoNetworking_Functions {
    
  // Libcommon
  import from LibCommon_BasicTypesAndValues all;
  import from LibCommon_DataStrings all;
  import from LibCommon_VerdictControl all;
  import from LibCommon_Sync all;
  import from LibCommon_Time all;
    
  // LibIts
  import from IEEE1609dot2BaseTypes language "ASN.1:1997" all;
  import from IEEE1609dot2 language "ASN.1:1997" all;
  import from EtsiTs103097Module language "ASN.1:1997" all;
    
  // LibItsCommon
  import from LibItsCommon_TypesAndValues all;
  import from LibItsExternal_TypesAndValues all;
  import from LibItsCommon_Templates all;
  import from LibItsCommon_Functions all;
  import from LibItsCommon_Pixits all;
  //    import from LibItsCommon_TestSystem all;
    
  // 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;
  //    import from LibItsGeoNetworking_EncdecDeclarations 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) UtGnInitialize p_init) runs on ItsBaseGeoNetworking {
            
      //deactivate gnPort default alts
    vc_gnDefaultActive := false;
            
      utPort.send(p_init);
      tc_wait.start;
      alt {
	      [] utPort.receive(UtGnResults: { utGnInitializeResult := 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(UtGnResults: { utGnChangePositionResult := true} ) {
          tc_wait.stop;
          log("*** f_utChangePosition: INFO: IUT position changed ***");
        }
        [] utPort.receive(UtGnResults: { utGnChangePositionResult := 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(UtGnResults: { utGnTriggerResult := true }) {
          tc_wait.stop;
	      }
	      [] utPort.receive(UtGnResults: { 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
     */
    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf01Up(Scenario p_scenario := e_staticPosition) runs on ItsGeoNetworking /* TITAN TODO: 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
        
    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf01Down() runs on ItsGeoNetworking /* TITAN TODO: 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
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf02Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc /* TITAN TODO: 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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          vc_componentTable[i].gnComponent.done;
        }
      }
            
    } // end f_cf02Up
        
    /**
     * @desc Deletes configuration cf02
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf02Down() runs on ItsMtc /* TITAN TODO: 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
     */
    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf03Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc /* TITAN TODO: 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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          vc_componentTable[i].gnComponent.done;
        }
      }
            
    } // end f_cf03Up
        
    /**
     * @desc Deletes configuration cf03
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf03Down() runs on ItsMtc /* TITAN TODO: 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
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf04Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc /* TITAN TODO: 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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          vc_componentTable[i].gnComponent.done;
        }
      }
            
    } // end f_cf04Up
        
    /**
     * @desc Deletes configuration cf04
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf04Down() runs on ItsMtc /* TITAN TODO: 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
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf05Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc /* TITAN TODO: 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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          vc_componentTable[i].gnComponent.done;
        }
      }
    }
        
    /**
     * @desc Deletes configuration cf05
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf05Down() runs on ItsMtc /* TITAN TODO: 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
     */
    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf06Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc /* TITAN TODO: 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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          vc_componentTable[i].gnComponent.done;
        }
      }
    }
        
    /**
     * @desc Deletes configuration cf06
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf06Down() runs on ItsMtc /* TITAN TODO: 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
     */

    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf07Up(in charstring p_mainUtComponent := c_compMTC, Scenario p_scenario := e_staticPosition) runs on ItsMtc /* TITAN TODO 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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          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) {
        if (isvalue(vc_componentTable[i].gnComponent)) {
          vc_componentTable[i].gnComponent.done;
        }
      }
    }
        
    /**
     * @desc Deletes configuration cf06
     */
    //FIXME RGY Titan doesn't support mtc and system clauses yet
    function f_cf07Down() runs on ItsMtc /* TITAN TODO: 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) or (PICS_IS_IUT_SECURED == 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) or (PICS_IS_IUT_SECURED == true)) {
        f_acDisableSecurity();
      }
    } // End of function f_uninitialiseSecuredMode()
        
  } // 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) {
          if (isvalue(vc_componentTable[i].gnComponent)) {
          v_return := valueof(vc_componentTable[i].gnComponent);
          }
          else {
            testcase.stop(__SCOPE__ & " can not handle omitted GN components");
          }
        }
      }
            
      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
      };
    }
    //FIXME RGY Titan doesn't support @deterministic yet   
    //        function @deterministic f_fillTimestamp(inout LongPosVector v_vector) 
    function 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);
        }
      }
            
      /*Spirent removed*/            
      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