Newer
Older
* @author ETSI / STF405 / STF449
* @version $URL$
* $Id$
* @desc Module containing common functions for ITS CAM
import from LibCommon_Time all;
import from LibCommon_VerdictControl all;
import from LibCommon_Sync all;
import from LibItsCam_Templates all;
import from LibItsCommon_Pixits all;
import from LibItsCommon_Templates all;
import from LibItsCommon_Functions all;
import from LibItsCommon_TypesAndValues all;
import from ITS_Container language "ASN.1:1997" all;
import from CAM_PDU_Descriptions language "ASN.1:1997" all;
import from DENM_PDU_Descriptions language "ASN.1:1997" all;
group utFuntions {
/**
* @desc Requests to bring the IUT in an initial state
* @param p_init The initialisation to trigger.
*/
function f_utInitializeIut(template (value) UtInitialize p_init) runs on ItsCam {
utPort.send(p_init);
tc_wait.start;
alt {
[] utPort.receive(UtInitializeResult:true) {
tc_wait.stop;
log("*** f_utInitializeIut: INFO: IUT initialized ***");
}
[] utPort.receive {
tc_wait.stop;
log("*** f_utInitializeIut: INFO: IUT could not be initialized ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] tc_wait.timeout {
log("*** f_utInitializeIut: INFO: IUT could not be initialized in time ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
[else] { // Shortcut defaults
//f_sleep(0.050); // 50 ms
repeat;
}
}
}
/**
* @desc Triggers event from the application layer
* @param p_event The event to trigger.
*/
function f_utTriggerEvent(template (value) UtCamTrigger p_event) runs on ItsCam {
utPort.send(p_event);
[] utPort.receive(UtCamTriggerResult:true) {
tc_wait.stop;
}
[] utPort.receive {
tc_wait.stop;
}
[] tc_wait.timeout {
}
[else] { // Shortcut defaults
//f_sleep(0.050); // 50 ms
* @desc Changes the position of the IUT
* @param p_position
function f_utChangePosition(template (value) UtChangePosition p_position) runs on ItsCam {
utPort.send(p_position);
[] utPort.receive(UtChangePositionResult:?) {
[] utPort.receive {
tc_wait.stop;
}
log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
[else] { // Shortcut defaults
//f_sleep(0.050); // 50 ms
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
group adapterControl {
/**
* @desc Triggers event in the test system adaptation.
* @param p_event The event to trigger
* @return FncRetCode
*/
function f_acTriggerGnssEvent(template (value) AcGnssPrimitive p_event) runs on ItsCam return FncRetCode {
var FncRetCode v_ret := e_success;
acPort.send(p_event);
tc_ac.start;
alt {
[] acPort.receive(m_acGnssResponseSuccess) {
tc_ac.stop;
}
[] acPort.receive {
tc_ac.stop;
log("*** " & __SCOPE__ & ": ERROR: Received unexpected message ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] tc_ac.timeout {
log("*** " & __SCOPE__ & ": ERROR: Timeout while waiting for adapter control event result ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
return v_ret;
}
/**
* @desc Loads the given scenario
*
* @param p_scenario The scenario to load.
*/
function f_acLoadScenario(Scenario p_scenario) runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT==true) {
f_acTriggerGnssEvent(m_loadScenario(p_scenario));
}
} // end f_acLoadScenario
/**
* @desc Starts a loaded scenario
*/
function f_acStartScenario() runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT==true) {
f_acTriggerGnssEvent(m_startScenario);
vc_scenarioStarted := true;
}
} // end f_acStartScenario
/**
* @desc Stops a loaded scenario
*/
function f_acStopScenario() runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT==true and vc_scenarioStarted==true) {
f_acTriggerGnssEvent(m_stopScenario);
vc_scenarioStarted := false;
}
} // end f_acStopScenario
function f_acAwaitDistanceCovered(float p_distanceToCover) runs on ItsCam return FncRetCode {
var FncRetCode v_ret := e_success;
if (PICS_GNSS_SCENARIO_SUPPORT==true and vc_scenarioStarted==true) {
f_acTriggerGnssEvent(m_distanceToCover(p_distanceToCover));
tc_ac.start;
alt {
[] acPort.receive(m_acGnssDistanceCovered) {
tc_ac.stop;
}
[] acPort.receive {
tc_ac.stop;
log("*** " & __SCOPE__ & ": ERROR: Received unexpected message ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] tc_ac.timeout {
log("*** " & __SCOPE__ & ": ERROR: Timeout while waiting for covered distance indication ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
}
return v_ret;
} // end f_acAwaitDistanceCovered
function f_acChangeSpeed(SpeedValue p_deltaSpeedValue) runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT==true and vc_scenarioStarted==true) {
f_acTriggerGnssEvent(m_changeScenarioSpeed(p_deltaSpeedValue));
}
} // end f_acChangeSpeed
function f_acChangeHeading(HeadingValue p_deltaHeadingValue) runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT==true and vc_scenarioStarted==true) {
f_acTriggerGnssEvent(m_changeScenarioHeading(p_deltaHeadingValue));
}
} // end f_acChangeHeading
} // End of group adapterControl
group camConfigurationFunctions {
/**
* @desc Setups default configuration
*/
function f_cfUp() runs on ItsCam system ItsCamSystem {
map(self:utPort, system:utPort);
map(self:acPort, system:acPort);
map(self:camPort, system:camPort);
f_connect4SelfOrClientSync();
} // end f_cfUp
/**
* @desc Deletes default configuration
*/
function f_cfDown() runs on ItsCam system ItsCamSystem {
unmap(self:utPort, system:utPort);
unmap(self:acPort, system:acPort);
unmap(self:camPort, system:camPort);
f_disconnect4SelfOrClientSync();
} // end f_cfDown
} // end of camConfigurationFunctions
/**
* @desc basic default behaviour handling
*/
[] camPort.receive(mw_camInd ( mw_camMsg_any )){
log("*** a_default: INFO: CAM message received in default ***");
log("*** a_default: ERROR: event received on CAM port in default ***");
log("*** a_default: INCONC: a timer expired in default ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
[] a_shutdown() {
f_poDefault();
f_cfDown();
log("*** a_default: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
stop;
}
/**
* @desc The default for handling upper tester messages.
*/
altstep a_utDefault() runs on ItsCam {
var UtCamEventInd v_event;
[] utPort.receive(UtCamEventInd:?) -> value v_event {
//store every upper tester indication received
vc_utEvents[lengthof(vc_utEvents)] := v_event;
repeat;
}
[] utPort.receive {
log("*** " & testcasename() & ": INFO: Received unhandled/unknown UT message from IUT ***");
repeat;
/**
* @desc The default preamble.
*/
function f_prDefault() runs on ItsCam {
vc_default := activate(a_default());
activate(a_utDefault());
}
/**
* @desc Initialize the IUT
* @remark No specific actions specified in the base standard
*/
function f_prInitialState(Scenario p_scenario := e_staticPosition, boolean p_awaitInitialCAM := true) runs on ItsCam {
f_acLoadScenario(p_scenario);
//Allow burst mode at the beginning
f_sleep(1.0);
f_acStartScenario();
if (p_awaitInitialCAM) {
tc_ac.start;
alt {
[] camPort.receive(mw_camInd ( mw_camMsg_any )){
tc_ac.stop;
log("*** " & testcasename() & ": INFO: Received initial CAM ***");
}
[] tc_ac.timeout {
log("*** " & testcasename() & ": INCONC: Initial CAM not received ***");
f_selfOrClientSyncAndVerdictPreamble("error", e_timeout);
}
}
group camPositionFunctions {
* @desc Compute a position using a reference position, a distance
* and an orientation
*
* @param p_referencePosition The base reference position.
* @param p_offSet Distance to the reference position (in meter).
*
* @return The new reference position.
function f_computePositionUsingDistance(in ReferencePosition p_referencePosition, in float p_offSet) return ReferencePosition {
var ReferencePosition v_referencePosition := p_referencePosition;
log("*** f_computePositionUsingDistance: INFO: calling fx_computePositionUsingDistance() ***");
fx_computePositionUsingDistance(
p_referencePosition.latitude,
p_referencePosition.longitude,
p_offSet,
p_referencePosition.positionConfidenceEllipse.semiMajorOrientation,
v_referencePosition.latitude,
v_referencePosition.longitude
);
return v_referencePosition;
}
} // end group camPositionFunctions
group camAuxilaryFunctions {
function f_changeSpeed(SpeedValue p_deltaSpeedValue) runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT == false) {
f_utTriggerEvent(m_changeSpeed(p_deltaSpeedValue));
}
else {
f_acChangeSpeed(p_deltaSpeedValue);
}
}
function f_changeHeading(HeadingValue p_deltaHeadingValue) runs on ItsCam {
if (PICS_GNSS_SCENARIO_SUPPORT == false) {
f_utTriggerEvent(m_changeHeading(p_deltaHeadingValue));
}
else {
f_acChangeHeading(p_deltaHeadingValue);
}
}
} // end group camAuxilaryFunctions
group camGenerators {
function f_generateDefaultCam()
return octetstring {
return bit2oct(
encvalue(
m_camReq(
m_camMsg_vehicle(
f_getTsStationId(),
f_getCurrentTime() mod 65536, // See ETSI EN 302 637-2 V1.3.0 - Clause B.3 generationDelatTime
m_tsPosition
)
)
)
);
}
} // end of group camGenerators