Newer
Older
* @author ETSI / STF405 / STF449
* @version $URL$
* $Id$
* @desc Module containing functions for GeoNetworking
// Libcommon
import from LibCommon_BasicTypesAndValues all;
import from LibCommon_DataStrings all;
import from LibCommon_VerdictControl {type FncRetCode;}
import from LibCommon_Sync all;
import from LibItsGeoNetworking_Functions all;
import from LibItsGeoNetworking_TestSystem all;
import from LibItsGeoNetworking_Pics all;
import from LibItsExternal_TypesAndValues {type MacAddress};
/**
* @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 {
utPort.send(p_init);
tc_wait.start;
alt {
[] utPort.receive(UtResult: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);
}
[else] { // Shortcut defaults
*/
function f_utChangePosition() runs on ItsBaseGeoNetworking {
tc_wait.start;
alt {
[] utPort.receive(UtResult: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);
}
[else] { // Shortcut defaults
}
/**
* @desc Triggers event from the application layer
* @param p_event The event to trigger.
*/
function f_utTriggerEvent(template (value) UtGnTrigger p_event) runs on ItsGeoNetworking return boolean {
// Variables
var boolean v_return := true;
alt {
[] utPort.receive(UtResult:true) {
tc_wait.stop;
}
[] utPort.receive {
tc_wait.stop;
}
[] tc_wait.timeout {
group geoConfigurationFunctions {
/**
* @desc This configuration features:
* - one ITS node (IUT)
* - two ITS nodes (nodeA, nodeB)
* - Area1 which only includes NodeB and IUT
// Variables
var PositionTable v_positionTable := {};
var GeoAreaTable v_areaTable := {};
map(self:acPort, system:acPort);
map(self:utPort, system:utPort);
map(self:geoNetworkingPort, system:geoNetworkingPort);
// Connect
f_connect4SelfOrClientSync();
//Initialze the IUT
f_initialState();
// Positions & Areas
f_preparePositionsAndAreas(v_positionTable, v_areaTable);
f_initialiseComponent(v_positionTable, v_areaTable, c_compNodeB);
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) runs on ItsMtc {
// Variables
var PositionTable v_positionTable := {};
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
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());
if(p_mainUtComponent == c_compMTC) {
f_initialState();
}
else {
v_component := f_getComponent(p_mainUtComponent);
v_component.start(f_initialState());
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;
}
function f_cf02Down() runs on ItsMtc {
var integer i;
// 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);
} // end f_cf02Down
/**
* @desc This configuration features:
* - one ITS node (IUT)
* - one ITS node (NodeA)
* - one ITS node in direction of NodeA (NodeB)
* - 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) runs on ItsMtc {
// Variables
var PositionTable v_positionTable := {};
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
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());
if(p_mainUtComponent == c_compMTC) {
// MTC intializes IUT
f_initialState();
}
else {
v_component := f_getComponent(p_mainUtComponent);
v_component.start(f_initialState());
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 cf03
* @param p_nodeB Component for NodeB
* @param p_nodeC Component for NodeC
function f_cf03Down() runs on ItsMtc {
var integer i;
// 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);
/**
* @desc This configuration features:
* - one ITS node (IUT)
* - one ITS node (NodeA)
* 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) runs on ItsMtc {
// Variables
var PositionTable v_positionTable := {};
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
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());
if(p_mainUtComponent == c_compMTC) {
// MTC intializes IUT
f_initialState();
}
else {
v_component := f_getComponent(p_mainUtComponent);
v_component.start(f_initialState());
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 cf04
* @param p_nodeB Component for NodeB
* @param p_nodeC Component for NodeC
function f_cf04Down() runs on ItsMtc {
var integer i;
// 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);
}
/**
* @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,
vc_positionTable := p_positionTable;
* @desc Makes the simulated ITS node behave as a neighbour of IUT
function f_startBeingNeighbour() runs on ItsGeoNetworking {
vc_neighbourDefault := activate(a_neighbourDefault());
tepelmann
committed
f_acTriggerEvent(m_startBeaconing(m_beaconHeader(f_getPosition(vc_componentName)).beaconHeader));
f_sleepIgnoreDef(PX_NEIGHBOUR_DISCOVERY_DELAY);
* @desc Makes the simulated ITS node behave as not being a neighbour of IUT
function f_stopBeingNeighbour() runs on ItsGeoNetworking {
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 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;
}
}
}
}
/**
* @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
var LongPosVector v_longPosVectorIut, v_longPosVectorNodeA, v_longPosVectorNodeB, v_longPosVectorNodeC, v_longPosVectorNodeD;
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);
// 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);
// 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);
// Area table
f_addArea(p_areaTable, c_area1,
f_computeCircularArea(v_longPosVectorNodeD, float2int(1.1 * f_distance(v_longPosVectorNodeB, v_longPosVectorNodeD))));
f_addArea(p_areaTable, c_area2,
f_computeCircularArea(v_longPosVectorNodeB, float2int(1.1 * 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
in LongPosVector p_positionValue
) {
key := p_positionKey,
position := p_positionValue
};
* @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
in charstring p_positionKey
tepelmann
committed
var LongPosVector v_return := null;
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;
}
}
tepelmann
committed
if((v_return != null) and (v_return.timestamp == 0)) {
v_return.timestamp := f_computeGnTimestamp();
return v_return;
}
/**
* @desc Compute a position based on reference point and distance factors
* @param p_refPosition Reference point
* @param p_longitudeFactor Number of PX_DISTANCE_UNIT applied for computing longitude
* @param p_latitudeFactor Number of PX_DISTANCE_UNIT applied for computing latitude
* @return LongPosVector - Computed position
* @see PX_DISTANCE_UNIT
in LongPosVector p_refPosition,
in integer p_longitudeFactor,
in integer p_latitudeFactor
) return LongPosVector {
var LongPosVector v_return := p_refPosition;
v_return.latitude := v_return.latitude + p_latitudeFactor * PX_DISTANCE_UNIT;
v_return.longitude := v_return.longitude + p_longitudeFactor * PX_DISTANCE_UNIT;
/**
* @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
};
}
* @param p_areaName Reference key of the searched geoArea
* @return GeoArea - The serached 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;
* @param p_areaName Reference key of the searched geoBroadcastArea
* @return GeoBroadcastArea - The serached geoBroadcastArea
*/
function f_getGeoBroadcastArea(in charstring p_areaName) runs on ItsGeoNetworking
return GeoBroadcastArea {
return f_geoArea2GeoBroadcastArea(f_getArea(p_areaName));
* @param p_areaName Reference key of the searched GeoAnycastArea
* @return GeoAnycastArea - The serached GeoAnycastArea
*/
function f_getGeoAnycastArea(in charstring p_areaName) runs on ItsGeoNetworking
return GeoAnycastArea {
return f_geoArea2GeoAnycastArea(f_getArea(p_areaName));
/**
* @desc Convert GeoArea type to GeoBroadcastArea
* @param p_area GeoArea to be converted
* @return GeoBroadcastArea
return GeoBroadcastArea {
var GeoBroadcastArea v_broadcastArea;
log(p_area);
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;
/**
* @desc Convert GeoArea type to GeoAnycastArea
* @param p_area GeoArea to be converted
* @return GeoAnycastArea
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;
}
/**
* @desc Compute a square geoArea
* @param p_centerLongPosVector Center point of the square area
* @param p_distanceA Width of the square area in meters
* @return GeoArea - Computed geoArea
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,
/**
* @desc Compute a circular geoArea
* @param p_centerLongPosVector Center point of the square area
* @param p_distanceA Radius of the square area in meters
* @return GeoArea - Computed geoArea
*/
function f_computeCircularArea(
in UInt16 p_distanceA
) return GeoArea {
var GeoArea v_geoArea;
v_geoArea := {
shape := e_geoCircle,
area := {
geoAreaPosLatitude := p_centerLongPosVector.latitude,
geoAreaPosLongitude := p_centerLongPosVector.longitude,
distanceA := p_distanceA,
distanceB := 0,
/**
* @desc Compute radius of an circular area
* @param p_squareMeters Square meters of an circular area
* @return Computed radius in meters
* @see fx_computeRadiusFromCircularArea
*/
function f_radiusFromCircularArea(
in float p_squareMeters
) return float {
log("*** f_distance: INFO: calling fx_computeRadiusFromCircularArea() ***");
return fx_computeRadiusFromCircularArea(p_squareMeters);
}
/**
* @desc Compute distance between two points
* @param p_pointA First point
* @param p_pointB Second point
* @return Computed distance in meters
* @see fx_computeDistance
function f_distance(
in LongPosVector p_pointA,
in LongPosVector p_pointB
) return float {
log("*** f_distance: INFO: calling fx_computeDistance() ***");
return fx_computeDistance(p_pointA.latitude, p_pointA.longitude, p_pointB.latitude, p_pointB.longitude);
* @desc The base default.
*/
var LongPosVector v_longPosVectorIut;
[] geoNetworkingPort.receive {
log("*** a_default: ERROR: Received an unexpected message ***");
f_selfOrClientSyncAndVerdict("error", e_error);
log("*** a_default: ERROR: Timeout while awaiting reaction of the IUT prior to Upper Tester action ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
log("*** a_default: ERROR: Timeout while awaiting the reception of a message ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
[] a_shutdown() {
log("*** a_default: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
altstep a_neighbourDefault() runs on ItsGeoNetworking {
?, f_getPosition(vc_componentName).gnAddr.mid,
f_getPosition(vc_componentName),
[vc_componentName == c_compNodeB] a_receiveLsRequestAndReply(
?, f_getPosition(c_compNodeA).gnAddr.mid,
f_getPosition(c_compNodeA),
f_getPosition(vc_componentName)
repeat;
[] a_default() {
/**
* @desc The default for handling upper tester messages.
*/
altstep a_utDefault() runs on ItsGeoNetworking {
var UtGnEventInd v_ind;
[] utPort.receive(UtGnEventInd:?) -> value v_ind {
//store every upper tester indication received
vc_utInds[lengthof(vc_utInds)] := v_ind;
repeat;
}
[] utPort.receive {
tc_wait.stop;
log("*** " & __SCOPE__ & ": INFO: Received unexpected UT message from IUT ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] tc_wait.timeout {
log("*** " & __SCOPE__ & ": INFO: Could not receive expected UT message from IUT in time ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
[else] { // Shortcut defaults
repeat;
}
}
/**
* @desc Default handling cf01 de-initialisation.
*/
altstep a_cf01Down() runs on ItsGeoNetworking {
[] a_shutdown() {
f_poDefault();
f_cf01Down();
log("*** a_cf01Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
}
}
/**
* @desc Default handling cf02 de-initialisation.
*/
altstep a_cf02Down() runs on ItsMtc {
f_cf02Down();
log("*** a_cf02Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
stop;
}
}
/**
* @desc Default handling cf03 de-initialisation.
*/
altstep a_cf03Down() runs on ItsMtc {
f_cf03Down();
log("*** a_cf03Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
stop;
}
}
/**
* @desc Default handling cf04 de-initialisation.
*/
altstep a_cf04Down() runs on ItsMtc {
f_cf04Down();
log("*** a_cf04Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
stop;
}
}
/**
* @desc Receive GeoUnicast packet
* @param p_sourceLongPosVec Expected source position vector
* @param p_destinationShortPosVec Expected destination position vector
* @param p_seqNumber Expected sequence number
altstep a_receiveGeoUnicast(
in template (present) ShortPosVector p_destinationShortPosVec,
in template (present) UInt16 p_seqNumber
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwUnicastPacket(
* @desc Receive GeoUnicast packet for specific destination
* @param p_destinationShortPosVec Expected destination position vector
altstep a_receiveGeoUnicastWithDestination(in template (present) ShortPosVector p_destinationShortPosVec) runs on ItsGeoNetworking {
[] a_receiveGeoUnicast(p_destinationShortPosVec, ?) {}
/**
* @desc Receive any GeoUnicast packet
*/
altstep a_receiveAnyGeoUnicast() runs on ItsGeoNetworking {
group geoGeoBroadcastAltsteps {
/**
* @desc Receive GeoBroadcast packet
* @param p_srcLongPosVec Expected source position vector
* @param p_seqNumber Expected sequence number
in template (present) LongPosVector p_srcLongPosVec,
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacket(
p_srcLongPosVec,
p_seqNumber
)))) {
}
}
/**
* @desc Receive GeoBroadcast packet with specific Area and HopLimit
* @param p_srcLongPosVec Expected source position vector
* @param p_seqNumber Expected sequence number
* @param p_broadcastArea Expected geoBroadcastArea
tepelmann
committed
* @param p_routerHopLimit Expected router hop limit
* @param p_maxHopLimit Expected max hop limit (Default: ?)
*/
altstep a_receiveGeoBroadcastWithAreaWithHopLimit(
in template (present) LongPosVector p_srcLongPosVec,
in template (present) GeoBroadcastArea p_broadcastArea,
tepelmann
committed
in template (present) UInt8 p_routerHopLimit,
in template (present) UInt8 p_maxHopLimit := ?
tepelmann
committed
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithAreaAndHl(
tepelmann
committed
p_broadcastArea,
p_maxHopLimit
tepelmann
committed
p_routerHopLimit
/**
* @desc Receive GeoBroadcast packet for specific Geobroadcast Area
* @param p_srcLongPosVec Expected source position vector
* @param p_seqNumber Expected sequence number
* @param p_broadcastArea Expected geoBroadcastArea
in template (present) LongPosVector p_srcLongPosVec,
in template (present) UInt16 p_seqNumber,
in template (present) GeoBroadcastArea p_broadcastArea
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
p_srcLongPosVec,
p_seqNumber,
p_broadcastArea
)))) {
}
group geoGeoAnycastAltsteps {
/**
* @desc Receive GeoAnycast packet
* @param p_srcLongPosVec Expected source position vector
* @param p_senderLongPosVec Expected sender position vector
* @param p_seqNumber Expected sequence number
in template (present) LongPosVector p_srcLongPosVec,
in template (present) LongPosVector p_senderLongPosVec,
in template (present) UInt16 p_seqNumber
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwAnycastPacket(
p_srcLongPosVec,
p_seqNumber
)))) {
}
}
/**
* @desc Receive GeoAnycast packet with specific Area and HopLimit
* @param p_srcLongPosVec Expected source position vector
* @param p_senderLongPosVec Expected sender position vector
* @param p_seqNumber Expected sequence number
* @param p_anycastArea Expected geoAnycastArea
* @param p_hopLimit Expected hop limit
tepelmann
committed
* @param p_maxHopLimit Expected max hop limit (Default: ?)
*/
altstep a_receiveGeoAnycastWithAreaWithHopLimit(
in template (present) LongPosVector p_srcLongPosVec,
in template (present) GeoAnycastArea p_anycastArea,
tepelmann
committed
in template (present) UInt8 p_hopLimit,
in template (present) UInt8 p_maxHopLimit := ?
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwAnycastPacketWithArea(
p_anycastArea
),
-,
p_hopLimit
))) {
/**
* @desc Receive GeoAnycast packet for specific GeoAnycast Area
* @param p_srcLongPosVec Expected source position vector
* @param p_senderLongPosVec Expected sender position vector
* @param p_seqNumber Expected sequence number
* @param p_anycastArea Expected geoAnycastArea
in template (present) LongPosVector p_srcLongPosVec,
in template (present) UInt16 p_seqNumber,
in template (present) GeoAnycastArea p_anycastArea
[] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwAnycastPacketWithArea(
p_srcLongPosVec,
p_seqNumber,
p_anycastArea
)))) {
}
* @desc Receive Location Service Request
* @param p_seqNumber Expected sequence number of the received LS Request
* @param p_gnAddress GN address expected in received LS Request
* @param p_reqSrcPosVector Expected source position vector of the received LS Request
in template (present) UInt16 p_seqNumber,
berge
committed
in template (present) GN_Address.mid p_mid,
var GeoNetworkingInd v_msg;
[] geoNetworkingPort.receive(
mw_geoNwInd(
mw_geoNwPdu(
p_seqNumber,
)
)
)
) -> value v_msg {
p_reqSrcPosVector := valueof(v_msg.msgIn.gnPacket.packet.extendedHeader.lsRequestHeader.srcPosVector);
}
/**
* @desc Receive any Location Service Request
*/
altstep a_receiveAnyLsRequest() runs on ItsGeoNetworking {
var LongPosVector v_reqSrcPosVector;
[] a_receiveLsRequest(?, ?, v_reqSrcPosVector) {}
/**
* @desc Receive any Location Service Reply
*/
altstep a_receiveAnyLsReply() runs on ItsGeoNetworking {
[] geoNetworkingPort.receive( mw_geoNwInd( mw_geoNwPdu( mw_geoNwLsReplyPacket(?, ?) ))) {
//ignore and repeat
repeat;
}
}
* @desc Receive Location Service Request and send Location Service Reply
* @param p_reqSeqNumber Expected sequence number of the received LS Request
* @param p_gnAddress GN address expected in received LS Request
* @param p_repSrcPosVector Source position vector of the sent LS Response
* @param p_repSenderPosVector Sender position vector of the sent LS Response
berge
committed
in template (value) GN_Address.mid p_mid,
in template (value) LongPosVector p_repSenderPosVector
var LongPosVector v_repDstPosVector;
berge
committed
[] a_receiveLsRequest(p_reqSeqNumber, p_mid, v_repDstPosVector) {
f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(m_geoNwPdu(
m_geoNwLsReplyPacket(
p_repSrcPosVector,
f_longPosVector2ShortPosVector(v_repDstPosVector),
vc_localSeqNumber
}
}
} // end geoLocationServiceAltsteps
} // end geoAltsteps
group preambles {
/**
* @desc The default preamble.
*/
activate(a_default());
}
/**
* @desc Preamble for non-neighbour nodes
function f_prNonNeighbour() runs on ItsGeoNetworking {
/**
* @desc Preamble for neighbour nodes
f_startBeingNeighbour();
/**
* @desc Brings the IUT into an initial state.
*/
function f_initialState() runs on ItsBaseGeoNetworking {
/**
* @desc Receive and reply to LS Requests
* @param p_reqSeqNumber Expected sequence number of the received LS Request
* @param p_gnAddress GN address expected in received LS Request
* @param p_repSrcPosVector Source position vector of the sent LS Response
* @param p_repSenderPosVector Sender position vector of the sent LS Response
function f_handleLocationService(
in template (present) UInt16 p_reqSeqNumber,
berge
committed
in template (value) GN_Address.mid p_mid,
in template (value) LongPosVector p_repSrcPosVector,
in template (value) LongPosVector p_repSenderPosVector
tc_ac.start;
alt {
berge
committed
[] a_receiveLsRequestAndReply(p_reqSeqNumber, p_mid, p_repSrcPosVector, p_repSenderPosVector) {
tc_ac.stop;
}
}
}
/**
* @desc Send LS request and receive LS Reply
* @param p_reqSrcPosVector Source position vector of the sent LS Request
* @param p_reqSeqNumber Sequence number of the sent LS Request
* @param p_gnAddress GN address for which the LS Request is sent
* @param p_repSrcPosVector Expected source position vector in received LS Response
* @return FncRetCode
function f_processLocationService(
in template (value) LongPosVector p_reqSrcPosVector,
in template (value) UInt16 p_reqSeqNumber,
in template (value) GN_Address p_gnAddress,
var FncRetCode v_ret := e_error;
var GeoNetworkingInd v_msg;
f_sendGeoNetMessage(
p_reqSrcPosVector,
p_reqSeqNumber,
p_gnAddress
)
)
)
);
tc_ac.start;
alt {
[] geoNetworkingPort.receive(
mw_geoNwInd(
mw_geoNwPdu(
mw_shortPosVectorPosition(f_longPosVector2ShortPosVector(valueof(p_reqSrcPosVector)))
)
)
)
tc_ac.stop;
p_repSrcPosVector := valueof(v_msg.msgIn.gnPacket.packet.extendedHeader.lsReplyHeader.srcPosVector);
v_ret := e_success;
}
}
return v_ret;
}
} // end preambles
group postambles {
/**
* @desc The default postamble.
*/
/**
* @desc Postamble for neighbour nodes
* @desc Triggers event in the test system adaptation.
* @param p_event The event to trigger
* @return FncRetCode
function f_acTriggerEvent(template (value) AcGnPrimitive p_event) runs on ItsBaseGeoNetworking return FncRetCode {
var FncRetCode v_ret := e_success;
}
* @desc Get the position vector corresponding to a specific GN address
* @param p_gnAddress GN address for which the search is performed
* @return LongPosVector - IUT's position
function f_acGetLongPosVector(GN_Address p_gnAddress) runs on ItsBaseGeoNetworking return LongPosVector {
f_acTriggerEvent(m_getLongPosVector(p_gnAddress));
tc_ac.start;
alt {
[] acPort.receive(mw_getLongPosVectorAny(p_gnAddress)) -> value v_result {
tc_ac.stop;
}
[] acPort.receive {
tc_ac.stop;
log("*** f_acGetLongPosVector: ERROR: Received unexpected message ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] tc_ac.timeout {
log("*** f_acGetLongPosVector: ERROR: Timeout while waiting for adapter control event result ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
return v_result.getLongPosVector;
}
* @desc Triggers test adapter to send beacons for multiple neighbours
* @param p_numberOfNeighbour Number of neighbours to simulate
* @return FncRetCode
function f_acStartBeaconingMultipleNeighbour(in integer p_numberOfNeighbour) runs on ItsGeoNetworking return FncRetCode {
return f_acTriggerEvent(m_startBeaconingMultipleNeighbour(m_beaconHeader(f_getPosition(vc_componentName)).beaconHeader, p_numberOfNeighbour));
}
group commonFunctions {
/**
* @desc Gets the value of the lifetime in seconds.
* @param p_lifetime Lifetime to be converted
* @return Lifetime in seconds
function f_getLifetimeValue(in Lifetime p_lifetime) runs on ItsGeoNetworking return float {
var float v_lifetime := 0.0;
select (p_lifetime.ltBase) {
case (e_50ms) {
v_lifetime := int2float(p_lifetime.multiplier) * 0.5;
}
case (e_1s) {
v_lifetime := int2float(p_lifetime.multiplier) * 1.0;
}
case (e_10s) {
v_lifetime := int2float(p_lifetime.multiplier) * 10.0;
}
case (e_100s) {
v_lifetime := int2float(p_lifetime.multiplier) * 100.0;
}
}
return v_lifetime;
}
/**
* @desc Computes GN timestamp based on current time
* @return Unix-Epoch-Time mod 2^32
*/
function f_computeGnTimestamp() return UInt32 {
// Timestamp is 1s older than current time to avoid sending beacons coming from the future (time sync between nodes)
var UInt32 v_timestamp := fx_computeGnTimestamp() - 1000;
} // end commonFunctions
* @desc Gets the tester GN local address for a specific node
* @param p_node Simulated node
* @return GN address of simulated node
*/
function f_getTsGnLocalAddress(in charstring p_node) return GN_Address {
var GN_Address v_gnAddr := valueof(m_dummyGnAddr);
select (p_node) {
case (c_compNodeA) {
v_gnAddr := PX_TS_NODE_A_LOCAL_GN_ADDR;
}
case (c_compNodeB) {
v_gnAddr := PX_TS_NODE_B_LOCAL_GN_ADDR;
}
case (c_compNodeC) {
v_gnAddr := PX_TS_NODE_C_LOCAL_GN_ADDR;
}
case (c_compNodeD) {
v_gnAddr := PX_TS_NODE_D_LOCAL_GN_ADDR;
}
case else {
log("*** f_getTsGnLocalAddress: INFO: Unknown component " & p_node & " ***");
}
}
return v_gnAddr;
}
* @desc Sends a GeoNetworking message and in case of an included sequence number in the message the
* local sequence number will be increased by one.
* @param p_geoNetReq The message to send.
function f_sendGeoNetMessage(in template (value) GeoNetworkingReq p_geoNetReq) runs on ItsGeoNetworking {
if (not (ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.shbHeader)
or ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.beaconHeader))) {
f_setLocalSequenceNumber();
}
}
/**
* @desc Sends a GeoNetworking message with a payload and in case of an included sequence number in the message the
* local sequence number will be increased by one.
* @param p_geoNetReq The message to send.
* @param p_payload The payload to include.
*/
function f_sendGeoNetMessageWithPayload(
in template (value) GeoNetworkingReq p_geoNetReq,
in template (value) Payload p_payload
) runs on ItsGeoNetworking {
p_geoNetReq.msgOut.gnPacket.packet.payload := p_payload;
geoNetworkingPort.send(p_geoNetReq);
if (not (ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.shbHeader)
or ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.beaconHeader))) {
* @desc Receive a GeoNetworking message with a payload and in case of an included sequence number in the message the
* local sequence number will be increased by one.
* @param p_geoNetInd The message to receive.
* @param p_payload The payload to include.
*/
function f_receiveGeoNetMessageWithPayload(
in template (present) GeoNetworkingInd p_geoNetInd,
in template (present) Payload p_payload
) return template (present) GeoNetworkingInd {
var template (present) GeoNetworkingInd v_geoNetInd := p_geoNetInd;
v_geoNetInd.msgIn.gnPacket.packet.payload := p_payload;
return v_geoNetInd;
}
* @desc Sets the value of the sequence number for the next event.
function f_setLocalSequenceNumber() runs on ItsGeoNetworking {
}
* @return Time based initial sequence number (increasing with time)
*/
function f_getInitialSequenceNumber() return UInt16 {
return (f_computeGnTimestamp() / 1000) mod c_uInt16Max;
}
function f_getMessageCount() return integer {
} // end testerFunctions
group iutFunctions {
* @desc Gets the IUT GN local address
* @return IUT's GN_Address
* @see PICS_GN_LOCAL_GN_ADDR
function f_getIutGnLocalAddress() return GN_Address {
return PICS_GN_LOCAL_GN_ADDR;
* @desc Gets the IUT GN local address configuration method
* @return TypeOfAddress - IUT's GN local address configuration method
* @see PICS_GN_LOCAL_ADDR_CONF_METHOD
*/
function f_getIutGnLocalAddressConfigurationMethod() return TypeOfAddress {
return PICS_GN_LOCAL_ADDR_CONF_METHOD;
}
/**
* @desc Gets the IUT MAc address
* @return MacAddress - IUT's MAc Address
* @see PICS_IUT_MAC_ADDRESS
*/
function f_getIutMacAddress() return MacAddress {
* @desc Gets the GeoUnicast forwarding algorithm
* @return IUT's GeoUnicast forwarding algorithm
* @see PICS_GN_GEOUNICAST_FORWARDING_ALGORITHM
*/
function f_getGeoUnicastForwardingAlgorithm() return GeoUnicastForwardingAlgorithm {
return PICS_GN_GEOUNICAST_FORWARDING_ALGORITHM;
}
/**
* @desc Gets the GeoBroadcast forwarding algorithm
* @return IUT's GeoBroadcast forwarding algorithm
* @see PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM
*/
function f_getGeoBroadcastForwardingAlgorithm() return GeoBroadcastForwardingAlgorithm {
return PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM;
}
* @desc Gets the IUT default hop limit
* @return IUT's default hop limit
* @see PICS_GN_DEFAULT_HOP_LIMIT
*/
function f_getDefaultHopLimit() return UInt8 {
return PICS_GN_DEFAULT_HOP_LIMIT;
}
/**
* @desc Is the ITS-S mobile or stationary?
* @return Flags indicating whether the ITS-S is mobile or stationary.
* @see PICS_GN_IS_MOBILE
*/
function f_isMobile() return Bit8 {
if (PICS_GN_IS_MOBILE) {
return '10000000'B;
}
return '00000000'B;
}
* @desc Gets the LS retransmission timer.. Valid for NetRepInterval = default (cong. ctrl).
* @return LS retransmission timer in seconds
* @see PICS_GN_LOCATION_SERVICE_RETRANSMIT_TIMER
function f_getLsRetransmitTimer() return float {
var float v_itsGnLocationServiceRetransmitTimer := int2float(PICS_GN_LOCATION_SERVICE_RETRANSMIT_TIMER/1000);
return v_itsGnLocationServiceRetransmitTimer;
}
* @desc Gets the LS retransmission timer for NetRepInterval = medium (cong. ctrl).
* @return LS retransmission timer (medium) in seconds
* @see PX_GN_LOCATION_SERVICE_TIMER_MEDIUM
function f_getLsRetransmitTimerMedium() return float {
var float v_itsGnLocationServiceRetransmitTimerMedium := int2float(PX_GN_LOCATION_SERVICE_TIMER_MEDIUM/1000);
* @desc Gets the LS retransmission timer for NetRepInterval = maximum (cong. ctrl).
* @return LS retransmission timer (maximum) in seconds
* @see PX_GN_LOCATION_SERVICE_TIMER_MAXIMUM
function f_getLsRetransmitTimerMaximum() return float {
var float v_itsGnLocationServiceRetransmitTimerMaximum := int2float(PX_GN_LOCATION_SERVICE_TIMER_MAXIMUM/1000);
* @desc Gets the App retransmission timer. Valid for AppRepInterval = default (cong. ctrl).
* @return App retransmission timer in seconds
* @see PX_GN_APPLICATION_RETRANSMIT_TIMER
var float v_itsGnLocationApplicationRetransmitTimer := int2float(PX_GN_APPLICATION_RETRANSMIT_TIMER/1000);
* @desc Gets the App retransmission timer for AppRepInterval = medium (cong. ctrl).
* @return App retransmission timer (medium) in seconds
* @see PX_GN_APPLICATION_RETRANSMIT_TIMER_MEDIUM
*/
function f_getAppRetransmitTimerMedium() return float {
var float v_itsGnLocationApplicationRetransmitTimerMedium := int2float(PX_GN_APPLICATION_RETRANSMIT_TIMER_MEDIUM/1000);
return v_itsGnLocationApplicationRetransmitTimerMedium;
* @desc Gets the App retransmission timer for AppRepInterval = maximum (cong. ctrl).
* @return App retransmission timer (maximum) in seconds
* @see PX_GN_APPLICATION_RETRANSMIT_TIMER_MAXIMUM
*/
function f_getAppRetransmitTimerMaximum() return float {
var float v_itsGnLocationApplicationRetransmitTimerMaximum := int2float(PX_GN_APPLICATION_RETRANSMIT_TIMER_MAXIMUM/1000);
return v_itsGnLocationApplicationRetransmitTimerMaximum;
* @desc Gets the LS maximum retransmission number.
* @return LS maximum retransmission number
* @see PICS_GN_LOCATION_SERVICE_MAX_RETRANS
function f_getLsMaxRetrans() return integer {
var integer v_itsGnLocationServiceMaxRetrans := PICS_GN_LOCATION_SERVICE_MAX_RETRANS;
return v_itsGnLocationServiceMaxRetrans;
}
* @desc Gets the Application maximum retransmission number.
* @return Application maximum retransmission number
* @see PX_GN_APPLICATION_MAX_RETRANS
var integer v_itsGnApplicationMaxRetrans := PX_GN_APPLICATION_MAX_RETRANS;
return v_itsGnApplicationMaxRetrans;
* @desc Gets the Location Service packet buffer size.
* @return Location Service packet buffer size in Kbytes
* @see PICS_GN_LOCATION_SERVICE_PACKET_BUFFER_SIZE
function f_getLsPacketBufferSize() return integer {
var integer v_itsGnLocationServicePacketBufferSize := PICS_GN_LOCATION_SERVICE_PACKET_BUFFER_SIZE;
return v_itsGnLocationServicePacketBufferSize;
* @desc Gets the UC forwarding packet buffer size.
* @return UC forwarding packet buffer size in Kbytes
* @see PICS_GN_UC_FORWARDING_PACKET_BUFFER_SIZE
function f_getUcForwardingPacketBufferSize() return integer {
var integer v_itsGnUcForwardingPacketBufferSize := PICS_GN_UC_FORWARDING_PACKET_BUFFER_SIZE;
return v_itsGnUcForwardingPacketBufferSize;
} // end f_getUcForwardingPacketBufferSize
* @desc Gets the BC forwarding packet buffer size.
* @return BC forwarding packet buffer size in Kbytes
* @see PICS_GN_BC_FORWARDING_PACKET_BUFFER_SIZE
function f_getBcForwardingPacketBufferSize() return integer {
var integer v_itsGnBcForwardingPacketBufferSize := PICS_GN_BC_FORWARDING_PACKET_BUFFER_SIZE;
* @desc Gets the maximum lifetime of a packet.
* @return Maximum lifetime of a packet in seconds
* @see PICS_GN_MAX_PACKET_LIFETIME
*/
function f_getMaxPacketLifeTime() return float {
var float v_itsGnMaxPacketLifetime := int2float(PICS_GN_MAX_PACKET_LIFETIME);
return v_itsGnMaxPacketLifetime;
}
/**
* @desc Gets delta for timers.
* @return Delta for timers in seconds
* @see PX_T_DELTA
*/
function f_getDeltaTimer() return float {
return v_deltaTimer;
}
/**
* @desc Gets the beacon service retransmit timer.
*/
function f_getBsRetransmitTimer() return float {
var float v_itsGnBeaconServiceRetransmitTimer;
v_itsGnBeaconServiceRetransmitTimer := int2float(
(PICS_GN_BEACON_SERVICE_RETRANSMIT_TIMER/1000));
return v_itsGnBeaconServiceRetransmitTimer;
}
* @desc Gets the beacon service retransmit timer for NetBeaconInterval = medium (cong. ctrl).
* @return Beacon service retransmit timer (medium)
function f_getBsRetransmitTimerMedium() return float {
var float v_itsGnBeaconServiceRetransmitTimerMedium; // timer value increased (medium)
(PX_GN_BEACON_SERVICE_TIMER_MEDIUM+float2int((f_getBsMaxJitter() - 0.0 +1.0)*rnd()) + 0)/1000);
* @desc Gets the beacon service retransmit timer for NetBeaconInterval = maximum (cong. ctrl).
* @return Beacon service retransmit timer (maximum)
function f_getBsRetransmitTimerMaximum() return float {
var float v_itsGnBeaconServiceRetransmitTimerMaximum; // timer value increased (maximum)
(PX_GN_BEACON_SERVICE_TIMER_MAXIMUM+float2int((f_getBsMaxJitter() - 0.0 +1.0)*rnd()) + 0)/1000);
/**
* @desc Gets the maximum beacon service jitter.
* @return Maximum beacon service jitter
*/
function f_getBsMaxJitter() return float {
reinaortega
committed
var float v_itsGnBeaconServiceMaxJitter := int2float(PICS_GN_BEACON_SERVICE_MAX_JITTER)/1000.0;
return v_itsGnBeaconServiceMaxJitter;
}
* @desc Gets the Lifetime of a Location Table Entry.
* @return Lifetime of a Location Table Entry in seconds
* @see PICS_GN_LIFETIME_LOC_TE
function f_getLifetimeLocTableEntry() return float {
var float v_itsGnLifetimeLocTableEntry := int2float(PICS_GN_LIFETIME_LOC_TE);
return v_itsGnLifetimeLocTableEntry;
} // end f_getLifetimeLocTableEntry
* @desc Gets the maximum communication range for CBF algorithm
* @return Maximum communication range for CBF algorithm in meters
* @see PICS_GN_DEFAULT_MAX_COMMUNICATION_RANGE
*/
function f_getCbfMaxCommunicationRange() return integer {
var integer v_maxCommunicationRange := PICS_GN_DEFAULT_MAX_COMMUNICATION_RANGE;
return v_maxCommunicationRange;
} // end f_getCbfMaxCommunicationRange
function f_getGeoUnicastCbfMaxTime() return integer {
var integer v_cbfMaxTime := PICS_GN_GEOUNICAST_CBF_MAX_TIME;
function f_getGeoUnicastCbfMinTime() return integer {
var integer v_cbfMinTime := PICS_GN_GEOUNICAST_CBF_MIN_TIME;
return v_cbfMinTime;
} // end f_getGeoUnicastCbfMinTime
function f_getGnMaxAreaSize() return float {
var float v_maxAreaSize := PICS_GN_MAX_GEO_AREA_SIZE;
return v_maxAreaSize;
} // end f_getGnMaxAreaSize
* @desc Set the number of neighbour in the Location Table.
* @see PX_MIN_NR_NEIGHBOUR
function f_setNrNeighbourLocTableDefault() runs on ItsGeoNetworking {
var integer v_nrNeighbour := f_random (0, PX_MIN_NR_NEIGHBOUR);
f_acStartBeaconingMultipleNeighbour(v_nrNeighbour);
} // end f_setNrNeighbourLocTableDefault
* @desc Set the number of neighbour in the Location Table (medium).
* @see PX_MIN_NR_NEIGHBOUR
* @see PX_MAX_NR_NEIGHBOUR
function f_setNrNeighbourLocTableMedium() runs on ItsGeoNetworking {
var integer v_nrNeighbour := f_random (PX_MIN_NR_NEIGHBOUR, PX_MAX_NR_NEIGHBOUR);
f_acStartBeaconingMultipleNeighbour(v_nrNeighbour);
} // end f_setNrNeighbourLocTableMedium
* @desc Set the number of neighbour in the Location Table (maximum).
* @see PX_MAX_NR_NEIGHBOUR
* @see PX_MIN_NR_NEIGHBOUR
function f_setNrNeighbourLocTableMaximum() runs on ItsGeoNetworking {
var integer v_nrNeighbour := f_random (PX_MAX_NR_NEIGHBOUR, (2*PX_MIN_NR_NEIGHBOUR));
f_acStartBeaconingMultipleNeighbour(v_nrNeighbour);
} // end f_setNrNeighbourLocTableMaximum
} // end iutFunctions
* @desc Convert long position vector to short position vector
* @param p_longPosVector Long position vector to be converted
* @return Short position vector
function f_longPosVector2ShortPosVector(in LongPosVector p_longPosVector) return ShortPosVector {
var ShortPosVector v_shortPosVector;
v_shortPosVector := {
gnAddr := p_longPosVector.gnAddr,
timestamp := p_longPosVector.timestamp,
latitude := p_longPosVector.latitude,
longitude := p_longPosVector.longitude
};
/**
* @desc Get IUT's long position vector
* @return IUT's long position vector
function f_getIutLongPosVector() runs on ItsBaseGeoNetworking return LongPosVector {
}
/**
* @desc Get IUT's short position vector
* @return IUT's short position vector
tepelmann
committed
function f_getIutShortPosVector() runs on ItsGeoNetworking return ShortPosVector {
var LongPosVector v_longPosVectorIut := f_getPosition(c_compIut);
if (v_longPosVectorIut == null) {
v_longPosVectorIut := f_getIutLongPosVector();
}
return f_longPosVector2ShortPosVector(v_longPosVectorIut);
* @desc Compute a position using a reference position, a distance and an orientation
* @param p_iutLongPosVector Reference position
* @param p_distance Distance to the reference position (in meter)
* @param p_orientation direction of the computed position (0 to 359; 0 means North)
* @return LongPosVector
function f_computePositionUsingDistance(in LongPosVector p_iutLongPosVector, in integer p_distance, in integer p_orientation)
return LongPosVector {
var LongPosVector v_result := p_iutLongPosVector;
log("*** f_computePositionUsingDistance: INFO: calling fx_computePositionUsingDistance() ***");
fx_computePositionUsingDistance(p_iutLongPosVector.latitude, p_iutLongPosVector.longitude, p_distance, p_orientation, v_result.latitude, v_result.longitude);
/**
* @desc External function to compute timestamp based on current time
* @return Unix-Epoch-Time mod 2^32
external function fx_computeGnTimestamp() return UInt32;