LibItsGeoNetworking_Functions.ttcn 52.4 KB
Newer Older
berge's avatar
berge committed
/**
berge's avatar
berge committed
 *  @author     ETSI / STF405
 *  @version    $URL$
 *              $Id$
 *  @desc       Module containing functions for GeoNetworking
berge's avatar
berge committed
 *
 */
module LibItsGeoNetworking_Functions {
    
berge's avatar
berge committed
    // Libcommon
    import from LibCommon_BasicTypesAndValues all;
    import from LibCommon_VerdictControl {type FncRetCode;}
    import from LibCommon_Sync all;
berge's avatar
berge committed
    // LibIts
    import from LibIts_TestSystem all;
    import from LibIts_Interface all; 
fischer's avatar
fischer committed
    import from LibItsCommon_Functions all;
berge's avatar
berge committed
    import from LibItsGeoNetworking_TypesAndValues all;
berge's avatar
berge committed
    import from LibItsGeoNetworking_Templates all;
fischer's avatar
fischer committed
    import from LibItsGeoNetworking_Pixits all;
    import from LibItsGeoNetworking_Pics all;
berge's avatar
berge committed
    /**
berge's avatar
berge committed
     * @desc    Create Facility component and connects GeoNetworking port
     * @remark  Only used when ItsFa is a PTC
     * @param   p_ptcDenm returned Facility component variable
berge's avatar
berge committed
     */    
berge's avatar
berge committed
    function f_ptcGeoNetworkingUp(out ItsNt p_ptcGeoNetworking) {
berge's avatar
berge committed
        
        // Create Facility component
        p_ptcGeoNetworking := ItsNt.create("GeoNetworking Tester");
berge's avatar
berge committed
        
        // map ports
        map(p_ptcGeoNetworking:geoNetworkingPort, system:geoNetworkingPort);
        
berge's avatar
berge committed
    } // end f_ptcGeoNetworkingUp       
berge's avatar
berge committed
    
    /**
berge's avatar
berge committed
     * @desc    Wait for component to finish and unmap GeoNetworking ports
     * @remark  Only used when ItsFa is a PTC
     * @param   p_camPtc Facility component variable
berge's avatar
berge committed
     */    
berge's avatar
berge committed
    function f_ptcGeoNetworkingDown(in ItsNt p_ptcGeoNetworking) runs on ItsMtc {    
berge's avatar
berge committed
        tc_guard.start;
berge's avatar
berge committed
        alt {
berge's avatar
berge committed
            [] p_ptcGeoNetworking.done {
                tc_guard.stop;
berge's avatar
berge committed
            }
            
            [] tc_guard.timeout {
                f_selfOrClientSyncAndVerdict("error", e_timeout, "*** f_ptcGeoNetworkingDown: Timeout while waiting for component ***");
berge's avatar
berge committed
            }
        }
        unmap(p_ptcGeoNetworking:geoNetworkingPort);
        
berge's avatar
berge committed
    } // end f_ptcGeoNetworkingDown
berge's avatar
berge committed
    
    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 := {};
            var GeoAreaTable v_areaTable := {};
            var LongPosVector v_iutLongPosVector := f_getIutLongPosVector();
            var LongPosVector v_nodeALongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeA_longitudeFactor, c_compNodeA_latitudeFactor);
            var LongPosVector v_nodeBLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeB_longitudeFactor, c_compNodeB_latitudeFactor);
            var LongPosVector v_nodeDLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeD_longitudeFactor, c_compNodeD_latitudeFactor);
            
            map(self:utPort, system:utPort);
            map(self:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            f_connect4SelfOrClientSync();
            
            // Position table            
            f_addPosition(v_positionTable, c_compIut, v_iutLongPosVector);
            f_addPosition(v_positionTable, c_compNodeA, v_nodeALongPosVector);
            f_addPosition(v_positionTable, c_compNodeB, v_nodeBLongPosVector);
            // Area table
            f_addArea(v_areaTable, c_area1, 
                f_computeSquareArea(v_nodeDLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
            f_addArea(v_areaTable, c_area2, 
                f_computeSquareArea(v_nodeBLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
        
            f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeB);
            
        } // end f_cf01Up

berge's avatar
berge committed
        /**
         * @desc Deletes configuration cf01
         */
        function f_cf01Down() runs on ItsNt {

            // Unmap
            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)
berge's avatar
berge committed
         *       - 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          
berge's avatar
berge committed
         * @param p_nodeB
berge's avatar
berge committed
         * @param p_nodeD
berge's avatar
berge committed
        function f_cf02Up(out ItsNt p_nodeB, out ItsNt p_nodeD) runs on ItsMtc {
            
            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var LongPosVector v_iutLongPosVector := f_getIutLongPosVector();            
            var LongPosVector v_nodeBLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeB_longitudeFactor, c_compNodeB_latitudeFactor);
            var LongPosVector v_nodeCLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeC_longitudeFactor, c_compNodeC_latitudeFactor);
            var LongPosVector v_nodeDLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeD_longitudeFactor, c_compNodeD_latitudeFactor);
            
            // Create
            p_nodeB := ItsNt.create(c_compNodeB) alive;
berge's avatar
berge committed
            p_nodeD := ItsNt.create(c_compNodeD) alive;
            map(p_nodeB:utPort, system:utPort);
            map(p_nodeD:utPort, system:utPort);
            map(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
berge's avatar
berge committed
            map(p_nodeD:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect            
            connect(p_nodeB:syncPort, self:syncPort);
berge's avatar
berge committed
            connect(p_nodeD:syncPort, self:syncPort);
        
            // Position table
            f_addPosition(v_positionTable, c_compIut, v_iutLongPosVector);
            f_addPosition(v_positionTable, c_compNodeB, v_nodeBLongPosVector);
            f_addPosition(v_positionTable, c_compNodeD, v_nodeDLongPosVector);

            // Area table
            f_addArea(v_areaTable, c_area1, 
                f_computeSquareArea(v_nodeDLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
            f_addArea(v_areaTable, c_area2, 
                f_computeSquareArea(v_nodeBLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
            
            p_nodeB.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeB));
            p_nodeD.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeD));
berge's avatar
berge committed
            p_nodeD.done;
            p_nodeD.done;
        
        } // end f_cf02Up

berge's avatar
berge committed
        /**
         * @desc Deletes configuration cf02
         * @param p_nodeB
berge's avatar
berge committed
         * @param p_nodeD
berge's avatar
berge committed
        function f_cf02Down(in ItsNt p_nodeB, in ItsNt p_nodeD) runs on ItsMtc {
            // Unmap
            unmap(p_nodeB:utPort, system:utPort);
            unmap(p_nodeD:utPort, system:utPort);
            unmap(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
berge's avatar
berge committed
            unmap(p_nodeD:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            disconnect(p_nodeB:syncPort, self:syncPort);
berge's avatar
berge committed
            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   
berge's avatar
berge committed
        function f_cf03Up(out ItsNt p_nodeB, out ItsNt p_nodeC) runs on ItsMtc {

            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var LongPosVector v_iutLongPosVector := f_getIutLongPosVector();
            var LongPosVector v_nodeALongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeA_longitudeFactor, c_compNodeA_latitudeFactor);
            var LongPosVector v_nodeBLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeB_longitudeFactor, c_compNodeB_latitudeFactor);
            var LongPosVector v_nodeCLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeC_longitudeFactor, c_compNodeC_latitudeFactor);
            var LongPosVector v_nodeDLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeD_longitudeFactor, c_compNodeD_latitudeFactor);
            
            // Create
            p_nodeB := ItsNt.create(c_compNodeB) alive;
            p_nodeC := ItsNt.create(c_compNodeC) alive;

            // Map
            map(p_nodeB:utPort, system:utPort);
            map(p_nodeC:utPort, system:utPort);
            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, v_iutLongPosVector);
            f_addPosition(v_positionTable, c_compNodeA, v_nodeALongPosVector);
            f_addPosition(v_positionTable, c_compNodeB, v_nodeBLongPosVector);
            f_addPosition(v_positionTable, c_compNodeC, v_nodeCLongPosVector);
            
            // Area table
            f_addArea(v_areaTable, c_area1, 
                f_computeSquareArea(v_nodeDLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
            f_addArea(v_areaTable, c_area2, 
                f_computeSquareArea(v_nodeBLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
            
            p_nodeB.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeB));
            p_nodeC.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeC));
            p_nodeB.done;
            p_nodeC.done;
                    
        } // end f_cf03Up

        /**
         * @desc Deletes configuration cf03
         * @param p_nodeA
         * @param p_nodeB
         * @param p_nodeC
         */
berge's avatar
berge committed
        function f_cf03Down(in ItsNt p_nodeB, in ItsNt p_nodeC) runs on ItsMtc {
            // Unmap
            unmap(p_nodeB:utPort, system:utPort);
            unmap(p_nodeC:utPort, system:utPort);
            unmap(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
            unmap(p_nodeC:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            disconnect(p_nodeB:syncPort, self:syncPort);
            disconnect(p_nodeC:syncPort, self: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             
        function f_cf04Up(out ItsNt p_nodeB, out ItsNt p_nodeC, out ItsNt p_nodeD) runs on ItsMtc {

            // Variables
            var PositionTable v_positionTable := {};
            var GeoAreaTable v_areaTable := {};
            var LongPosVector v_iutLongPosVector := f_getIutLongPosVector();
            var LongPosVector v_nodeALongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeA_longitudeFactor, c_compNodeA_latitudeFactor);
            var LongPosVector v_nodeBLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeB_longitudeFactor, c_compNodeB_latitudeFactor);
            var LongPosVector v_nodeCLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeC_longitudeFactor, c_compNodeC_latitudeFactor);
            var LongPosVector v_nodeDLongPosVector := f_computePosition(v_iutLongPosVector, c_compNodeD_longitudeFactor, c_compNodeD_latitudeFactor);
            
            // Create
            p_nodeB := ItsNt.create(c_compNodeB) alive;
            p_nodeC := ItsNt.create(c_compNodeC) alive;
            p_nodeD := ItsNt.create(c_compNodeD) alive;

            // Map
            map(p_nodeB:utPort, system:utPort);
            map(p_nodeC:utPort, system:utPort);
            map(p_nodeD:utPort, system:utPort);
            map(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
            map(p_nodeC:geoNetworkingPort, system:geoNetworkingPort);
            map(p_nodeD:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            connect(p_nodeB:syncPort, self:syncPort);
            connect(p_nodeC:syncPort, self:syncPort);
            connect(p_nodeD:syncPort, self:syncPort);
            
            // Position table
            f_addPosition(v_positionTable, c_compIut, v_iutLongPosVector);
            f_addPosition(v_positionTable, c_compNodeA, v_nodeALongPosVector);
            f_addPosition(v_positionTable, c_compNodeB, v_nodeBLongPosVector);
            f_addPosition(v_positionTable, c_compNodeC, v_nodeCLongPosVector);
            f_addPosition(v_positionTable, c_compNodeD, v_nodeDLongPosVector);

            // Area table
            f_addArea(v_areaTable, c_area1, 
                f_computeSquareArea(v_nodeDLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
            f_addArea(v_areaTable, c_area2, 
                f_computeSquareArea(v_nodeBLongPosVector, float2int(1.1 * f_distance(v_nodeBLongPosVector, v_nodeDLongPosVector))));
                            
            p_nodeB.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeB));
            p_nodeC.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeC));
            p_nodeD.start(f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeD));
            p_nodeB.done;
            p_nodeC.done;
            p_nodeD.done;
                    
        } // end f_cf04Up

        /**
         * @desc Deletes configuration cf04
         * @param p_nodeB
         * @param p_nodeC
         * @param p_nodeD
         */
tepelmann's avatar
tepelmann committed
        function f_cf04Down(in ItsNt p_nodeB, in ItsNt p_nodeC, in ItsNt p_nodeD) runs on ItsMtc {
            // Unmap
            unmap(p_nodeB:utPort, system:utPort);
            unmap(p_nodeC:utPort, system:utPort);
            unmap(p_nodeD:utPort, system:utPort);
            unmap(p_nodeB:geoNetworkingPort, system:geoNetworkingPort);
            unmap(p_nodeC:geoNetworkingPort, system:geoNetworkingPort);
            unmap(p_nodeD:geoNetworkingPort, system:geoNetworkingPort);
            
            // Connect
            disconnect(p_nodeB:syncPort, self:syncPort);
            disconnect(p_nodeC:syncPort, self:syncPort);
            disconnect(p_nodeD:syncPort, self:syncPort);
        
        } // end f_cf04Down
        
        function f_initialiseComponent(
            in PositionTable p_positionTable,
            in GeoAreaTable p_areaTable,
            in charstring p_componentName) 
        runs on ItsNt {
            
            vc_positionTable := p_positionTable;
            vc_areaTable := p_areaTable;
            vc_componentName := p_componentName; 
            
        } // end f_initialiseComponent
        
berge's avatar
berge committed
        function f_startBeingNeighbour() runs on ItsNt {
            
            activate(a_neighbourDefault());
            f_acTriggerEvent(m_startBeaconing(m_beaconHeader(f_getPosition(vc_componentName)).beaconHeader));
berge's avatar
berge committed
            
        } // end f_startBeingNeighbour
        
        function f_stopBeingNeighbour() runs on ItsNt  {
            
            f_acTriggerEvent(m_stopBeaconing);
berge's avatar
berge committed
            deactivate; // FIXME: probably too brutal
            activate(a_default());
            
        } // end f_stopBeingNeighbour
        
    } // end geoConfigurationFunctions
    
    group geoPositionFunctions {
        
        function f_addPosition(
berge's avatar
berge committed
            inout PositionTable p_positionTable,
            in charstring p_positionKey,
            in LongPosVector p_positionValue
        ) {
berge's avatar
berge committed
            p_positionTable[lengthof(p_positionTable)] := {
                key := p_positionKey,
                position := p_positionValue
            };
        }
        
        function f_getPosition(
            in charstring p_positionKey
        ) runs on ItsNt 
        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 := vc_positionTable[i].position;
                }
            }
         * @desc Gives the IUT position within the minimum update frequency of local position vector (LPV) in ms	
         * @see  PICS_GN_MINIMUM_UPDATE_FREQUENCY_LPV
         */
        function f_getPositionWithinMinUpdateFreq(
            in PositionTable p_positionTable, 
            in charstring p_positionKey)
        return LongPosVector {
            
berge's avatar
berge committed
            var LongPosVector v_return := valueof(m_dummyLongPosVector);
            return v_return;
        }
        
        function f_computePosition(
            in LongPosVector p_refPosition, 
            in integer p_longitudeFactor, 
            in integer p_latitudeFactor
        ) return LongPosVector {
        
            var LongPosVector v_return := p_refPosition;
        
berge's avatar
berge committed
            v_return.latitude := v_return.latitude + p_latitudeFactor * PX_DISTANCE_UNIT;
            v_return.longitude := v_return.longitude + p_longitudeFactor * PX_DISTANCE_UNIT;
            return v_return;
        }
        
        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
            };
        }
        
berge's avatar
berge committed
        function f_getArea(
            in charstring p_areaName
        ) runs on ItsNt 
        return GeoArea {
            var GeoArea v_return;
            var integer i := 0;
            
berge's avatar
berge committed
            for (i:=0; i<lengthof(vc_areaTable); i:=i+1) {
                if (vc_areaTable[i].key == p_areaName) {
                    v_return := vc_areaTable[i].geoArea;
berge's avatar
berge committed
            
            return v_return;
        }
        
        function f_getGeoBroadcastArea(in charstring p_areaName) runs on ItsNt 
        return GeoBroadcastArea {         
berge's avatar
berge committed
            return f_geoArea2geoBroadcastArea(f_getArea(p_areaName));
berge's avatar
berge committed
        function f_getGeoAnycastArea(in charstring p_areaName) runs on ItsNt 
berge's avatar
berge committed
            return f_geoArea2geoAnycastArea(f_getArea(p_areaName));
        }
        
        function f_geoArea2geoBroadcastArea(GeoArea p_area) 
        return GeoBroadcastArea {
            var GeoBroadcastArea v_broadcastArea;
            if (p_area.shape == e_geoCircle) {
                v_broadcastArea.geoBroadcastSubType := e_geoBroadcastCircle;
            }
            else if (p_area.shape == e_geoRect) {
                v_broadcastArea.geoBroadcastSubType := e_geoBroadcastRect;
            }
            else if (p_area.shape == e_geoElip) {
                v_broadcastArea.geoBroadcastSubType := e_geoBroadcastElip;
            }
            else {
                v_broadcastArea.geoBroadcastSubType := e_reserved;
            }
            
            v_broadcastArea.geoBroadcastArea := p_area.area;
            
            return v_broadcastArea;
        function f_geoArea2geoAnycastArea(GeoArea p_area) 
        return GeoAnycastArea {
            var GeoAnycastArea v_anycastArea;
            
            if (p_area.shape == e_geoCircle) {
                v_anycastArea.geoAnycastSubType := e_geoAnycastCircle;
            }
            else if (p_area.shape == e_geoRect) {
                v_anycastArea.geoAnycastSubType := e_geoAnycastRect;
            }
            else if (p_area.shape == e_geoElip) {
                v_anycastArea.geoAnycastSubType := e_geoAnycastElip;
            }
            else {
                v_anycastArea.geoAnycastSubType := e_reserved;
            }
            
            v_anycastArea.geoAnycastArea := p_area.area;
            
            return v_anycastArea;
        }
        
        function f_computeSquareArea(
            in LongPosVector p_centerLongPosVector, 
            in UInt16 p_distanceA
        ) return GeoArea {
                
            var GeoArea v_geoArea;
            
            v_geoArea := {
                shape := e_geoRect,
                area := {
                    geoAreaPosLatitude := p_centerLongPosVector.latitude,
                    geoAreaPosLongitude := p_centerLongPosVector.longitude,
                    distanceA := p_distanceA,
                    distanceB := p_distanceA,
                    angle := 0 
                }
            }
            
            return v_geoArea;   
        }
        
        function f_distance(
            in LongPosVector p_pointA,
            in LongPosVector p_pointB
        ) return float {
         
            return fx_computeDistance(p_pointA.latitude, p_pointA.longitude, p_pointB.latitude, p_pointB.longitude);   
        }
        
    } // end geoPositionFunctions    
    
berge's avatar
berge committed
    group geoAltsteps {
berge's avatar
berge committed
        /**
         * @desc The base default.
         */
        altstep a_default() runs on ItsNt {
            
            var LongPosVector v_iutLongPosVector;
            
            [] a_receiveLsRequest(
                ?, ?, v_iutLongPosVector
            [] geoNetworkingPort.receive {
                f_selfOrClientSyncAndVerdict("error", e_error, "*** a_default: Received an unexpected message ***");
            }
            [] tc_wait.timeout {
                f_selfOrClientSyncAndVerdict("error", e_timeout, "*** a_default: Timeout while awaiting reaction of the IUT prior to Upper Tester action ***");
            }
            [] tc_ac.timeout {
                f_selfOrClientSyncAndVerdict("error", e_timeout, "*** a_default: Timeout while awaiting the reception of a message ***");
tepelmann's avatar
tepelmann committed
            [] a_shutdown() {
                f_poDefault();
                log("*** a_default: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;   
            }

        altstep a_neighbourDefault() runs on ItsNt {
      
            [] a_receiveLsRequestAndReply(
                ?, f_getPosition(vc_componentName).gnAddr, 
                f_getPosition(vc_componentName), 
                f_getPosition(vc_componentName)
tepelmann's avatar
tepelmann committed
            [] a_shutdown() {
                f_poNeighbour();
                log("*** a_neighbourDefault: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;   
            }            
            [] a_default() {                
            }
        }
berge's avatar
berge committed
        
        group geoGeoUnicastAltsteps {
            
            /**
             * @desc Receive GeoUnicast packet
             */
berge's avatar
berge committed
            altstep a_receiveGeoUnicast(
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) ShortPosVector p_destinationShortPosVec,
                in template (present) UInt16 p_seqNumber
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoUnicastHeader(
                    p_senderLongPosVec,
                    p_destinationShortPosVec,
                    p_seqNumber)))) {
                    }
            }     
            
            /**
berge's avatar
berge committed
             * @desc Receive GeoUnicast packet for specific destination
             */
berge's avatar
berge committed
            altstep a_receiveGeoUnicastWithDestination(in template (present) ShortPosVector p_destinationShortPosVec) runs on ItsNt {
                
                [] a_receiveGeoUnicast(?, p_destinationShortPosVec, ?) {}
berge's avatar
berge committed
            }     
berge's avatar
berge committed
            
            /**
             * @desc Receive any GeoUnicast packet
             */
berge's avatar
berge committed
            altstep a_receiveAnyGeoUnicast() runs on ItsNt {
                
                [] a_receiveGeoUnicast(?, ?, ?) {}
berge's avatar
berge committed
            }  
berge's avatar
berge committed
            
        } // end geoGeoUnicastAltsteps
        
berge's avatar
berge committed
        group geoGeoBroadcastAltsteps {
            
            /**
             * @desc Receive GeoBroadcast packet
             */
            altstep a_receiveGeoBroadcast(
berge's avatar
berge committed
                in template (present) LongPosVector p_srcLongPosVec,                
                in template (present) LongPosVector p_senderLongPosVec,
berge's avatar
berge committed
                in template (present) UInt16 p_seqNumber
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoBroadcastHeader(
                        p_srcLongPosVec,
berge's avatar
berge committed
                        p_senderLongPosVec,
berge's avatar
berge committed
                        p_seqNumber
                    )))) {
                }
            }
berge's avatar
berge committed
            
            /**
             * @desc Receive GeoBroadcast packet with specific Area and HopLimit
             */
            altstep a_receiveGeoBroadcastWithAreaWithHopLimit(
                in template (present) LongPosVector p_srcLongPosVec,                
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoBroadcastArea p_broadcastArea,
berge's avatar
berge committed
                in template (present) UInt8 p_hopLimit
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoBroadcastHeaderWithAreaWithHopLimit(
                        p_srcLongPosVec,
                        p_senderLongPosVec,
                        p_seqNumber,
                        p_broadcastArea,
                        p_hopLimit
                    )))) {
                }
            }            
berge's avatar
berge committed

            /**
             * @desc Receive GeoBroadcast packet for specific Geobroadcast Area
             */
            altstep a_receiveGeoBroadcastWithArea(                
                in template (present) LongPosVector p_srcLongPosVec,
berge's avatar
berge committed
                in template (present) LongPosVector p_senderLongPosVec,
berge's avatar
berge committed
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoBroadcastArea p_broadcastArea
berge's avatar
berge committed
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoBroadcastHeaderWithArea(
                        p_srcLongPosVec,
berge's avatar
berge committed
                        p_senderLongPosVec,
berge's avatar
berge committed
                        p_seqNumber,
                        p_broadcastArea
                    )))) {
                }
            }               
                        
        } // end geoGeoBroadcastAltsteps
berge's avatar
berge committed

        group geoGeoAnycastAltsteps {
            
            /**
             * @desc Receive GeoAnycast packet
             */
            altstep a_receiveGeoAnycast(
                in template (present) LongPosVector p_srcLongPosVec,                
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) UInt16 p_seqNumber
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoAnycastHeader(
                        p_srcLongPosVec,
                        p_senderLongPosVec,
                        p_seqNumber
                    )))) {
                }
            }
            
            /**
             * @desc Receive GeoAnycast packet with specific Area and HopLimit
             */
            altstep a_receiveGeoAnycastWithAreaWithHopLimit(
                in template (present) LongPosVector p_srcLongPosVec,                
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoAnycastArea p_anycastArea,
berge's avatar
berge committed
                in template (present) UInt8 p_hopLimit
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoAnycastHeaderWithAreaWithHopLimit(
                        p_srcLongPosVec,
                        p_senderLongPosVec,
                        p_seqNumber,
                        p_anycastArea,
                        p_hopLimit
                    )))) {
                }
            }            

            /**
             * @desc Receive GeoAnycast packet for specific GeoAnycast Area
             */
            altstep a_receiveGeoAnycastWithArea(                
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoAnycastArea p_anycastArea
berge's avatar
berge committed
            ) runs on ItsNt {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoAnycastHeaderWithArea(
                        p_srcLongPosVec,
                        p_senderLongPosVec,
                        p_seqNumber,
                        p_anycastArea
                    )))) {
                }
            }               
                        
        } // end geoGeoAnycastAltsteps
berge's avatar
berge committed
        group geoLocationServiceAltsteps {

            /**
             * @desc Receive Location Service Request
             */
            altstep a_receiveLsRequest(
                in template (present) UInt16 p_seqNumber,
                in template (present) GN_Address p_gnAddress,
berge's avatar
berge committed
                out LongPosVector p_reqSrcPosVector
berge's avatar
berge committed
            ) runs on ItsNt {
                var GeoNetworkingInd v_msg;
                
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwPdu(
                            mw_lsRequestHeader(
                                p_seqNumber,
                                p_gnAddress
                            )
                        )
                    )
                ) -> value v_msg {
berge's avatar
berge committed
                    p_reqSrcPosVector := valueof(v_msg.msgIn.header.lsRequestHeader.srcPosVector);
berge's avatar
berge committed
            }
            
            /**
             * @desc Receive any Location Service Request
             */
            altstep a_receiveAnyLsRequest() runs on ItsNt {
                var LongPosVector v_reqSrcPosVector;
                
                [] a_receiveLsRequest(?, ?, v_reqSrcPosVector) {}
berge's avatar
berge committed
            }
            
            /**
             * @desc Receive Location Service Request and send Location Service Reply  
             */
            altstep a_receiveLsRequestAndReply(
berge's avatar
berge committed
                in template (present) UInt16 p_reqSeqNumber,
                in template (value) GN_Address p_gnAddress,
                in template (value) LongPosVector p_repSrcPosVector,
                in template (value) LongPosVector p_repSenderPosVector
berge's avatar
berge committed
            ) runs on ItsNt {
                var LongPosVector v_repDstPosVector;
                [] a_receiveLsRequest(p_reqSeqNumber, p_gnAddress, v_repDstPosVector) {
                    f_sendGeoNetMessage(m_geoNwReq(m_geoNwPdu(
berge's avatar
berge committed
                        m_lsReplyHeader(
tepelmann's avatar
tepelmann committed
                        p_repSrcPosVector,
                        f_longPosVector2ShortPosVector(v_repDstPosVector),
berge's avatar
berge committed
                        p_repSenderPosVector,
                        vc_localSeqNumber   
berge's avatar
berge committed
                }
            }
          
        } // end geoLocationServiceAltsteps
        
        
    } // end geoAltsteps
    
    group preambles {
        
        /**
         * @desc The default preamble.
         */
        function f_prDefault() runs on ItsNt {
            activate(a_default());
        }
        
        function f_prNonNeighbour() runs on ItsNt {
            f_prDefault();
        }
        
        function f_prNeighbour() runs on ItsNt {
berge's avatar
berge committed
            f_startBeingNeighbour();        
        /**
         * @desc Brings the IUT into an initial state.
         * @return 
         */
berge's avatar
berge committed
        function f_prInitialState() {
berge's avatar
berge committed
            var ItsNt initComponent := ItsNt.create;
berge's avatar
berge committed
            
            initComponent.start(f_utInitializeIut());
            initComponent.done;
        function f_handleLocationService(
          in template (present) UInt16 p_reqSeqNumber,
          in template (value) GN_Address p_gnAddress,
          in template (value) LongPosVector p_repSrcPosVector,
          in template (value) LongPosVector p_repSenderPosVector
                [] a_receiveLsRequestAndReply(p_reqSeqNumber, p_gnAddress, p_repSrcPosVector, p_repSenderPosVector) {
                    tc_ac.stop;
                }
            }
            
        }
        
        function f_processLocationService(
          in template (value) LongPosVector p_reqSrcPosVector,
          in template (value) UInt16 p_reqSeqNumber,
          in template (value) GN_Address p_gnAddress,
berge's avatar
berge committed
          out LongPosVector p_repSrcPosVector
        ) runs on ItsNt return FncRetCode {
            var FncRetCode v_ret := e_error;
            var GeoNetworkingInd v_msg;
            
            f_sendGeoNetMessage(
                m_geoNwReq(
                    m_geoNwPdu(
                        m_lsRequestHeader(
                            p_reqSrcPosVector,
                            p_reqSrcPosVector,
                            p_reqSeqNumber,
                            p_gnAddress
                        )
                    )
                )
            );
            
            tc_ac.start;
            alt {
                [] geoNetworkingPort.receive(
                        mw_geoNwInd(
                            mw_geoNwPdu(
                                mw_lsReplyHeader(
                                    p_reqSeqNumber,
                                    ?,
                                    f_longPosVector2ShortPosVector(valueof(p_reqSrcPosVector))
berge's avatar
berge committed
                    p_repSrcPosVector := valueof(v_msg.msgIn.header.lsRequestHeader.srcPosVector);
    } // end preambles
    
    group postambles {
        
        /**
         * @desc The default postamble.
         */
        function f_poDefault() runs on ItsNt {
        
        function f_poNeighbour() runs on ItsNt {
berge's avatar
berge committed
            f_stopBeingNeighbour();
            f_poDefault();           
        }
        
        /**
         * @desc    Requests to bring the IUT in an initial state
         * @return 
         */
berge's avatar
berge committed
        function f_utInitializeIut() runs on ItsNt {
            
            utPort.send(UtGNInitialize:{});
            alt {
                [] utPort.receive(UtGNResult:true) {
                    log("*** f_utInitializeIut: IUT initialized ***");
                }
                [] utPort.receive {
                    f_selfOrClientSyncAndVerdict("error", e_error, "*** f_utInitializeIut: IUT could not be initialized ***");
                [] tc_wait.timeout {
                    f_selfOrClientSyncAndVerdict("error", e_timeout, "*** f_utInitializeIut: IUT could not be initialized in time ***");
        /**
         * @desc    Triggers event from the application layer
         * @param   p_event The event to trigger.
         * @return 
         */
        function f_utTriggerEvent(template (value) UtGNEvent p_event) runs on ItsNt return FncRetCode {
            var FncRetCode v_ret := e_success;
            var template (value) UtGNTrigger v_utMsg := { p_event };
            
            utPort.send(v_utMsg);
            
            return v_ret;
tepelmann's avatar
tepelmann committed
        }
        
        /**
         * @desc Checks that the event was indicated at the application layer
         * @param p_event The event to check.
         * @return 
         */
        function f_utCheckEvent(template (value) GeoNetworkingPacket p_event, boolean p_discard:=false) runs on ItsNt {
            var template (value) UtGNCheck v_utMsg := { p_event };
            utPort.send(v_utMsg);
            alt {
                [] utPort.receive(UtGNResult:true) {
                    if (p_discard == false) {
                        log("*** f_utCheckEvent: Event correctly indicated at application layer ***");
                    }
                    else {
                        f_selfOrClientSyncAndVerdict("error", e_error, "*** f_utCheckEvent: Event indicated at application layer where should not appear ***");
                    }
                }
                [] utPort.receive {
                    if (p_discard == false) {
                        f_selfOrClientSyncAndVerdict("error", e_error, "*** f_utCheckEvent: Event not correctly indicated at application layer ***");
                    }
                    else {
                        log("*** f_utCheckEvent: Another event indicated at application layer, repeating check ***");
                        repeat;
                    }
                [] tc_wait.timeout {
                    if (p_discard == false) {
                        f_selfOrClientSyncAndVerdict("error", e_timeout, "*** f_utCheckEvent: Timeout while waiting for event check result ***");
                    }
                    else {
                        log("*** f_utCheckEvent: Event not indicated at application layer ***");