NetSim Source Code Help v14.4
All 13 Components
 
Loading...
Searching...
No Matches
Mobility.c
1/************************************************************************************
2* Copyright (C) 2023 *
3* TETCOS, Bangalore. India *
4* *
5* Tetcos owns the intellectual property rights in the Product and its content. *
6* The copying, redistribution, reselling or publication of any or all of the *
7* Product or its content without express prior written consent of Tetcos is *
8* prohibited. Ownership and / or any other right relating to the software and all *
9* intellectual property rights therein shall remain at all times with Tetcos. *
10* *
11* Author: Shashi Kant Suman *
12* *
13* ---------------------------------------------------------------------------------*/
14#include "main.h"
15#include "Mobility.h"
16#include "Animation.h"
17
18unsigned int nCallBackCount = 0;
19_fnMobilityCallBack* fnMobilityCallBack;
20
21int fn_NetSim_Mobility_configure_NodeJoinProfile(void* xmlNode, NETSIM_ID nDeviceId);
22int fn_NetSim_Mobility_NodeJoinInit(NETSIM_ID nDevIndex);
23int fn_NetSim_Mobility_NodeJoined();
24int fn_NetSim_Mobility_NodeLeaved();
25
26ANIM_HANDLE animHandle;
27static void init_mobility_animation()
28{
29 animHandle = anim_add_new_menu(NULL,
30 "Node Movement",
31 false,
32 false,
33 true,
34 256,
35 ANIMFILETYPE_GENERIC);
36}
37
38void add_mobility_animation(NETSIM_ID d,
39 double t,
40 double x,
41 double y,
42 double z)
43{
44 MOVENODE mn;
45 mn.d = DEVICE_CONFIGID(d);
46 mn.time = t;
47 mn.x = x;
48 mn.y = y;
49 mn.z = z;
50 log_mobility(mn);
51 animation_add_new_entry(animHandle, ANIM_MOVENODE, &mn);
52}
53
54/** Function to configure the mobility model for all the devices */
55_declspec(dllexport) int fn_NetSim_Mobility_Configure(void** var)
56{
57 char* tagname = (char*)var[0];
58 void* xmlNetSimNode = var[2];
59 NETSIM_ID nDeviceId = var[3] ? *((NETSIM_ID*)var[3]) : 0;
60 NETSIM_ID nInterfaceId = var[4] ? *((NETSIM_ID*)var[4]) : 0;
61 LAYER_TYPE nLayerType = var[5] ? *((LAYER_TYPE*)var[5]) : LAYER_NULL;
62 char* szVal;
63 if (!_stricmp(tagname, "MOBILITY"))
64 {
65 MOBILITY_VAR* pstruMobilityVar = (MOBILITY_VAR*)calloc(1, sizeof * pstruMobilityVar);
66 NETWORK = (struct stru_NetSim_Network*)var[1];
67 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->pstruMobVar = pstruMobilityVar;
68 //Configure the Model
69 getXmlVar(&szVal, MODEL, xmlNetSimNode, 1, _STRING, Mobility);
70
71 if (!_stricmp(szVal, "NO_MOBILITY"))
72 {
73 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_NOMOBILITY;
74 return 0;
75 }
76 else if (!_stricmp(szVal, "RANDOM_WALK"))
77 {
78 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_RANDOMWALK;
79 }
80 else if (!_stricmp(szVal, "RANDOM_WAY_POINT"))
81 {
82 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_RANDOMWAYPOINT;
83 }
84 else if (!_stricmp(szVal, "FILE_BASED_MOBILITY"))
85 {
86 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_FILEBASEDMOBILITY;
87 }
88 else if (!_stricmp(szVal, "GROUP_MOBILITY"))
89 {
90 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_GROUP;
91 }
92 else if (!_stricmp(szVal, "SUMO")) {
93 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_SUMO;
94 }
95 else if (!_stricmp(szVal, "PEDESTRIAN_MOBILITY")) {
96 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_PEDESTRAIN;
97 }
98 else
99 {
100 NetSimxmlError("Unknown mobility model", szVal, xmlNetSimNode);
101 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType = MobilityModel_NOMOBILITY;
102 return -1;
103 }
104 free(szVal);
105
106 if (NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType == MobilityModel_FILEBASEDMOBILITY)
107 {
108 //IF node has FileBasedMobility
109 pstruMobilityVar->dLastTime = 0;
110 //return 1;
111 }
112 //Get the velocity
113 szVal = fn_NetSim_xmlConfig_GetVal(xmlNetSimNode,"VELOCITY",
114 NETWORK->ppstruDeviceList[nDeviceId-1]->pstruDeviceMobility->nMobilityType!=MobilityModel_SUMO&&
115 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType != MobilityModel_PEDESTRAIN &&
116 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType != MobilityModel_FILEBASEDMOBILITY);
117 if(szVal)
118 {
119 pstruMobilityVar->dVelocity = atof(szVal);
120 NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->dAvgSpeed = atof(szVal);
121 free(szVal);
122 }
123
124 getXmlVar(&pstruMobilityVar->dCalculationInterval, CALCULATION_INTERVAL, xmlNetSimNode, 0, _DOUBLE, Mobility);
125 pstruMobilityVar->dCalculationInterval *= SECOND;
126 if (pstruMobilityVar->dCalculationInterval == 0.0)
127 {
128 fnNetSimError("Calculation_interval can't be 0. Leads infinite loop. Assigning 1 us");
129 pstruMobilityVar->dCalculationInterval = 1;
130 }
131
132 switch (NETWORK->ppstruDeviceList[nDeviceId - 1]->pstruDeviceMobility->nMobilityType)
133 {
134 case MobilityModel_RANDOMWAYPOINT:
135 {
136 //Get the pause time
137 szVal = fn_NetSim_xmlConfig_GetVal(xmlNetSimNode, "PAUSE_TIME", 1);
138 if (szVal)
139 {
140 pstruMobilityVar->dPauseTime = atof(szVal);
141 pstruMobilityVar->dLastTime = -1000000 * atof(szVal);
142 free(szVal);
143 }
144 }
145 break;
146 case MobilityModel_GROUP:
147 {
148 getXmlVar(&pstruMobilityVar->nGroupId, GROUP_ID, xmlNetSimNode, 1, _INT, Mobility);
149 add_to_group(pstruMobilityVar->nGroupId, nDeviceId);
150 }
151 break;
152 case MobilityModel_SUMO:
153 {
154 extern char* sumoname;
155 extern double step_size;
156 getXmlVar(&pstruMobilityVar->sumoFileName, FILE_NAME, xmlNetSimNode, 1, _STRING, Mobility);
157 sumoname = pstruMobilityVar->sumoFileName;
158 getXmlVar(&pstruMobilityVar->step_size, STEP_SIZE, xmlNetSimNode, 1, _DOUBLE, Mobility);
159 step_size = pstruMobilityVar->step_size;
160 }
161 break;
162 case MobilityModel_PEDESTRAIN:
163 {
164 getXmlVar(&pstruMobilityVar->Max_Speed, MAX_SPEED_M_S, xmlNetSimNode, 1, _DOUBLE, Mobility);
165 getXmlVar(&pstruMobilityVar->Min_Speed, MIN_SPEED_M_S, xmlNetSimNode, 1, _DOUBLE, Mobility);
166 getXmlVar(&pstruMobilityVar->Stop_Probability, STOP_PROBABILITY, xmlNetSimNode, 1, _DOUBLE, Mobility);
167 getXmlVar(&pstruMobilityVar->Stop_Duration, STOP_DURATION_S, xmlNetSimNode, 1, _DOUBLE, Mobility);
168 pstruMobilityVar->Stop_Duration *= SECOND;
169 pstruMobilityVar->Pedestrain_Speed = NETSIM_RAND_RN(pstruMobilityVar->Max_Speed, pstruMobilityVar->Min_Speed);
170 pstruMobilityVar->angel = 0;
171 }
172 break;
173 case MobilityModel_FILEBASEDMOBILITY:
174 {
175 extern char* mobilityfile;
176 if (!mobilityfile)
177 {
178 getXmlVar(&pstruMobilityVar->mobilityFileName, OPEN_MOBILITY_FILE, xmlNetSimNode, 1, _STRING, Mobility);
179 mobilityfile = pstruMobilityVar->mobilityFileName;
180 }
181 }
182 break;
183 }
184
185 //Save the seed value
186 pstruMobilityVar->ulSeed1 = DEVICE(nDeviceId)->ulSeed[0];
187 pstruMobilityVar->ulSeed2 = DEVICE(nDeviceId)->ulSeed[1];
188 }
189 else if (!_stricmp(tagname, "NODE_JOIN_PROFILE"))
190 {
191 fn_NetSim_Mobility_configure_NodeJoinProfile(xmlNetSimNode, nDeviceId);
192 }
193 else if (!_stricmp(tagname, "PROTOCOL"))
194 {
195 fn_NetSim_MObility_configureOffice(xmlNetSimNode);
196 }
197 return 1;
198}
199/** Function to initialize the parameters of positions for all nodes*/
200_declspec(dllexport) int fn_NetSim_Mobility_Init(struct stru_NetSim_Network* NETWORK_Formal,
201 NetSim_EVENTDETAILS* pstruEventDetails_Formal,
202 char* pszAppPath_Formal,
203 char* pszWritePath_Formal,
204 int nVersion_Type,
205 void** fnPointer)
206{
207 NETSIM_ID nLoop;
208 NETWORK = NETWORK_Formal; //Get the Network structure from NetworkStack
209 pstruEventDetails = pstruEventDetails_Formal; //Get the Eventdetails from NetworkStack
210 pszAppPath = pszAppPath_Formal; //Get the application path from NetworkStack
211 pszIOPath = pszWritePath_Formal; //Get the write path from NetworkStack
212 nVersion_Type = nVersion_Type; //Get the version type from NetworkStack
213
214 srand(1); //Initialize seed as 1 for same result for every run
215 init_mobility_log();
216 init_mobility_animation();
217
218 if (nVersion_Type / 10 != VERSION)
219 {
220 printf("Mobility---Version number mismatch\nDll Version=%d\nNetSim Version=%d\nFileName=%s\nLine=%d\n", VERSION, nVersion_Type / 10, __FILE__, __LINE__);
221 exit(0);
222 }
223
224 {
225 char* temp = NULL;
226 temp = getenv("GRID_WIDTH");
227 if (temp)
228 {
229 if (atof(temp))
230 dGridWidth = atof(temp);
231 else
232 dGridWidth = 0xFFFFFFFF;
233 }
234 else
235 dGridWidth = 0xFFFFFFFF;
236
237 temp = NULL;
238 temp = getenv("GRID_LENGTH");
239 if (temp)
240 {
241 if (atof(temp))
242 dGridLength = atof(temp);
243 else
244 dGridLength = 0xFFFFFFFF;
245 }
246 else
247 dGridLength = 0xFFFFFFFF;
248
249 temp = getenv("ORIGIN_X");
250 if (temp)
251 {
252 if (atof(temp))
253 dOrigin_X = atof(temp);
254 else
255 dOrigin_X = 0;
256 }
257 else
258 dOrigin_X = 0;
259
260 temp = getenv("ORIGIN_Y");
261 if (temp)
262 {
263 if (atof(temp))
264 dOrigin_Y = atof(temp);
265 else
266 dOrigin_Y = 0;
267 }
268 else
269 dGridWidth = 0;
270
271 dGridMax_x = dOrigin_X + dGridWidth;
272 dGridMax_y = dOrigin_Y + dGridLength;
273 }
274 for (nLoop = 0; nLoop < NETWORK->nDeviceCount; nLoop++)
275 {
276 fn_NetSim_Mobility_NodeJoinInit(nLoop);
277 if (NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility)
278 {
279 MOBILITY_VAR* var = (MOBILITY_VAR*)NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruMobVar;
280 var->ulSeed1 = NETWORK->ppstruDeviceList[nLoop]->ulSeed[0];
281 var->ulSeed2 = NETWORK->ppstruDeviceList[nLoop]->ulSeed[1];
282 switch (NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->nMobilityType)
283 {
284 case MobilityModel_NOMOBILITY:
285 //No action
286 break;
287 case MobilityModel_FILEBASEDMOBILITY:
288 {
289 //IF node has FileBasedMobility
290 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
291 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
292 FileBasedMobilityReadingFile();
293 }
294 break;
295 case MobilityModel_RANDOMWALK:
296 case MobilityModel_RANDOMWAYPOINT:
297 case MobilityModel_PEDESTRAIN:
298 {
299 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
300 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
301 memcpy(NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition, NETWORK->ppstruDeviceList[nLoop]->pstruDevicePosition, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
302 memcpy(NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition, NETWORK->ppstruDeviceList[nLoop]->pstruDevicePosition, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
303 pstruEventDetails->dEventTime = 0;
304 pstruEventDetails->dPacketSize = 0;
305 pstruEventDetails->nApplicationId = 0;
306 pstruEventDetails->nDeviceId = nLoop + 1;
307 pstruEventDetails->nDeviceType = NETWORK->ppstruDeviceList[nLoop]->nDeviceType;
308 pstruEventDetails->nEventType = TIMER_EVENT;
309 pstruEventDetails->nInterfaceId = 0;
310 pstruEventDetails->nPacketId = 0;
311 pstruEventDetails->nProtocolId = PROTOCOL_MOBILITY;
312 pstruEventDetails->nSubEventType = 0;
313 pstruEventDetails->pPacket = NULL;
314 fnpAddEvent(pstruEventDetails);
315 }
316 break;
317 case MobilityModel_GROUP:
318 {
319 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
320 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
321 memcpy(NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition, NETWORK->ppstruDeviceList[nLoop]->pstruDevicePosition, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
322 memcpy(NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition, NETWORK->ppstruDeviceList[nLoop]->pstruDevicePosition, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
323 }
324 break;
325 case MobilityModel_SUMO:
326 {
327 init_sumo();
328 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
329 NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition = calloc(1, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
330 memcpy(NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition, NETWORK->ppstruDeviceList[nLoop]->pstruDevicePosition, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruCurrentPosition);
331 memcpy(NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition, NETWORK->ppstruDeviceList[nLoop]->pstruDevicePosition, sizeof * NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->pstruNextPosition);
332
333 pstruEventDetails->dEventTime = 0;
334 pstruEventDetails->dPacketSize = 0;
335 pstruEventDetails->nApplicationId = 0;
336 pstruEventDetails->nDeviceId = nLoop + 1;
337 pstruEventDetails->nDeviceType = NETWORK->ppstruDeviceList[nLoop]->nDeviceType;
338 pstruEventDetails->nEventType = TIMER_EVENT;
339 pstruEventDetails->nInterfaceId = 0;
340 pstruEventDetails->nPacketId = 0;
341 pstruEventDetails->nProtocolId = PROTOCOL_MOBILITY;
342 pstruEventDetails->nSubEventType = 0;
343 pstruEventDetails->pPacket = NULL;
344 fnpAddEvent(pstruEventDetails);
345 }
346 break;
347 default:
348 {
349 fnNetSimError("Unknown mobility model %d in fn_NetSim_Mobility_Init\n", NETWORK->ppstruDeviceList[nLoop]->pstruDeviceMobility->nMobilityType);
350 }
351 break;
352 } //End switch(mobility_type)
353 }// End if(device_mobility)
354 }// End for(loop_all_device)
355
356 fn_NetSim_Mobility_Group_init();
357 return 1;
358}
359/** This function is to free the memory space allocated for the variables that are used in mobily */
360_declspec(dllexport) int fn_NetSim_Mobility_Finish()
361{
362 NETSIM_ID loop;
363
364 for (loop = 0; loop < NETWORK->nDeviceCount; loop++)
365 {
366 if (NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility)
367 {
368 if (NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruMobVar)
369 {
370 free(((MOBILITY_VAR*)NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruMobVar)->sumoFileName);
371 free(((MOBILITY_VAR*)NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruMobVar)->mobilityFileName);
372 free((MOBILITY_VAR*)NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruMobVar);
373 }
374 if (NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruCurrentPosition)
375 free(NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruCurrentPosition);
376 if (NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruNextPosition)
377 free(NETWORK->ppstruDeviceList[loop]->pstruDeviceMobility->pstruNextPosition);
378 }
379 }
380 close_mobility_logs();
381 FileBasedMobilityPointersFree();
382 free(fnMobilityCallBack);
383 return 1;
384}
385
386void mobility_pass_position_to_animation(NETSIM_ID devId, double time, NetSim_COORDINATES* coor)
387{
388 if (coor->corrType == CORRTYPE_MAP)
389 {
390 fn_NetSim_Coordinate_ConvertCartesianToMap(coor);
391 add_mobility_animation(devId, time,
392 coor->lat, coor->lon, 0);
393 }
394 else if (coor->corrType == CORRTYPE_GEO)
395 {
396 fnNetSimError("change to appropriate function..\n");
397 assert(false);
398 fn_NetSim_Coordinate_ConvertCartesianToMap(coor);
399 add_mobility_animation(devId, time,
400 coor->lat, coor->lon, coor->altitude);
401 }
402 else
403 {
404 add_mobility_animation(devId, time,
405 coor->X, coor->Y, coor->Z);
406 }
407}
408
409/** This function is used to change the positions of the devices over simulation. At the end of this function cummulativereceivedpower[][] will be updated. */
410_declspec(dllexport) int fn_NetSim_Mobility_Run()
411{
412 switch (pstruEventDetails->nSubEventType)
413 {
414 case MOVE_GROUP:
415 fn_NetSim_MoveGroup();
416 break;
417 case NODE_JOIN:
418 fn_NetSim_Mobility_NodeJoined();
419 break;
420 case NODE_LEAVE:
421 fn_NetSim_Mobility_NodeLeaved();
422 break;
423 default:
424 {
425 unsigned int nLoop;
426 double X = NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->pstruCurrentPosition->X;
427 double Y = NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->pstruCurrentPosition->Y;
428 double vel = NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->dAvgSpeed;
429 MOBILITY_VAR* pstruMobilityVar = (MOBILITY_VAR*)NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->pstruMobVar;
430 double dPresentTime = pstruMobilityVar->dLastTime;
431 if (NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility
432 && NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->nMobilityType == MobilityModel_FILEBASEDMOBILITY)
433 {
434 //IF node has FileBasedMobility
435 process_filebased_mobility_event();
436 }
437 else if (NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility
438 && NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->nMobilityType == MobilityModel_SUMO)
439 {
440 sumo_run();
441 }
442 else if (NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility
443 && NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility->nMobilityType == MobilityModel_PEDESTRAIN) {
444 NetSim_MOBILITY* mob = NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility;
445 NetSim_COORDINATES* pos = DEVICE_POSITION(pstruEventDetails->nDeviceId);
446 NetSim_COORDINATES* cor = mob->pstruCurrentPosition;
447 NetSim_COORDINATES* ncor = mob->pstruNextPosition;
448 bool isStop = false;
449 memcpy(cor, ncor, sizeof * cor);
450
451 double probability = NETSIM_RAND_01();
452 if (probability < pstruMobilityVar->Stop_Probability) {
453 pstruMobilityVar->Pedestrain_Speed = NETSIM_RAND_RN(pstruMobilityVar->Max_Speed, pstruMobilityVar->Min_Speed);
454 pstruMobilityVar->angel = NETSIM_RAND_RN(360, 0);
455 isStop = true;
456 }
457 X = pstruMobilityVar->Pedestrain_Speed * cos(pstruMobilityVar->angel) * (pstruMobilityVar->dCalculationInterval / SECOND) + cor->X;
458 Y = pstruMobilityVar->Pedestrain_Speed * sin(pstruMobilityVar->angel) * (pstruMobilityVar->dCalculationInterval / SECOND) + cor->Y;
459 while (cor->corrType == CORRTYPE_CARTESIAN &&
460 (X > dGridMax_x || X < dOrigin_X || Y < dOrigin_Y || Y > dGridMax_y)) {
461 pstruMobilityVar->Pedestrain_Speed = NETSIM_RAND_RN(pstruMobilityVar->Max_Speed, pstruMobilityVar->Min_Speed);
462 pstruMobilityVar->angel = NETSIM_RAND_RN(360, 0);
463 X = pstruMobilityVar->Pedestrain_Speed * cos(pstruMobilityVar->angel) * (pstruMobilityVar->dCalculationInterval / SECOND) + cor->X;
464 Y = pstruMobilityVar->Pedestrain_Speed * sin(pstruMobilityVar->angel) * (pstruMobilityVar->dCalculationInterval / SECOND) + cor->Y;
465 }
466 if (!isStop) {
467 ncor->X = X;
468 ncor->Y = Y;
469 }
470 else {
471 ncor->X = cor->X;
472 ncor->Y = cor->Y;
473 }
474 //store the last time
475 if (isStop)
476 pstruMobilityVar->dLastTime = pstruEventDetails->dEventTime + pstruMobilityVar->dCalculationInterval + pstruMobilityVar->Stop_Duration;
477 else
478 pstruMobilityVar->dLastTime = pstruEventDetails->dEventTime + pstruMobilityVar->dCalculationInterval;
479
480 //update the device position
481 memcpy(pos, cor, sizeof * pos);
482
483 mobility_pass_position_to_animation(pstruEventDetails->nDeviceId,
484 pstruEventDetails->dEventTime,
485 pos);
486
487 //Add event for next point
488 if (isStop) {
489 pstruEventDetails->dEventTime = pstruEventDetails->dEventTime + pstruMobilityVar->Stop_Duration + pstruMobilityVar->dCalculationInterval;
490 fnpAddEvent(pstruEventDetails);
491 pstruEventDetails->dEventTime = pstruEventDetails->dEventTime - pstruMobilityVar->Stop_Duration - pstruMobilityVar->dCalculationInterval;
492 }
493 else {
494 pstruEventDetails->dEventTime += pstruMobilityVar->dCalculationInterval;
495 fnpAddEvent(pstruEventDetails);
496 pstruEventDetails->dEventTime -= pstruMobilityVar->dCalculationInterval;
497 }
498 }
499 else
500 {
501 NetSim_MOBILITY* mob = NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->pstruDeviceMobility;
502 NetSim_COORDINATES* pos = DEVICE_POSITION(pstruEventDetails->nDeviceId);
503 NetSim_COORDINATES* cor = mob->pstruCurrentPosition;
504 NetSim_COORDINATES* ncor = mob->pstruNextPosition;
505
506 memcpy(cor, ncor, sizeof * cor);
507 if (pstruMobilityVar->dLastTime + pstruMobilityVar->dPauseTime * SECOND < pstruEventDetails->dEventTime + pstruMobilityVar->dCalculationInterval)
508 {
509 fn_NMo_RandomPoint(&X, &Y, vel, pstruMobilityVar->dCalculationInterval, &pstruMobilityVar->ulSeed1, &pstruMobilityVar->ulSeed2);
510 while (cor->corrType == CORRTYPE_CARTESIAN &&
511 (X > dGridMax_x || X < dOrigin_X || Y < dOrigin_Y || Y > dGridMax_y))
512 {
513 X = cor->X;
514 Y = cor->Y;
515 fn_NMo_RandomPoint(&X, &Y, vel, pstruMobilityVar->dCalculationInterval, &pstruMobilityVar->ulSeed1, &pstruMobilityVar->ulSeed2);
516 }
517 ncor->X = X;
518 ncor->Y = Y;
519 //store the last time
520 pstruMobilityVar->dLastTime = pstruEventDetails->dEventTime + pstruMobilityVar->dCalculationInterval;
521 }
522 //update the device position
523 memcpy(pos, cor, sizeof * pos);
524
525 mobility_pass_position_to_animation(pstruEventDetails->nDeviceId,
526 pstruEventDetails->dEventTime,
527 pos);
528
529 //Add event for next point
530 pstruEventDetails->dEventTime += pstruMobilityVar->dCalculationInterval;
531 fnpAddEvent(pstruEventDetails);
532 pstruEventDetails->dEventTime -= pstruMobilityVar->dCalculationInterval;
533 }
534
535 //call all the callback function
536 for (nLoop = 0; nLoop < nCallBackCount; nLoop++)
537 {
538 fnMobilityCallBack[nLoop](pstruEventDetails->nDeviceId);
539 }
540 }
541 break;
542 }
543 return 1;
544};
545
546_declspec(dllexport) char* fn_NetSim_Mobility_Trace(NETSIM_ID id)
547{
548 switch (id)
549 {
550 case MOVE_GROUP:
551 return "MOVE_GROUP";
552 break;
553 case NODE_JOIN:
554 return "NODE_JOIN";
555 case NODE_LEAVE:
556 return "NODE_LEAVE";
557 }
558 return "";
559};
560_declspec(dllexport) int fn_NetSim_Mobility_FreePacket()
561{
562 return 1;
563};
564_declspec(dllexport) int fn_NetSim_Mobility_CopyPacket()
565{
566 return 1;
567};
568_declspec(dllexport) int fn_NetSim_Mobility_Metrics()
569{
570 return 1;
571};
572_declspec(dllexport) int fn_NetSim_Mobility_ConfigurePrimitives()
573{
574 return 1;
575};
576_declspec(dllexport) char* fn_NetSim_Mobility_ConfigPacketTrace()
577{
578 return "";
579};
580_declspec(dllexport) char* fn_NetSim_Mobility_WritePacketTrace()
581{
582 return "";
583};
584/** This function is used to generate the random point */
585int fn_NMo_RandomPoint(double* X, double* Y, double velocity, double interval, unsigned long* pulSeed1, unsigned long* pulSeed2)
586{
587 int min;
588 int max;
589 int ldRandNo;
590
591 ldRandNo = (unsigned int)fn_NetSim_Utilities_GenerateRandomNo(pulSeed1, pulSeed2);
592
593 min = (int)(*X - ldRandNo % ((int)(velocity * interval / SECOND) + 1));
594
595 ldRandNo = (unsigned int)fn_NetSim_Utilities_GenerateRandomNo(pulSeed1, pulSeed2);
596
597 max = (int)(*X + ldRandNo % ((int)(velocity * interval / SECOND) + 1));
598
599 if (min > max)
600 {
601 *X = max + (int)((min - max + 1) * NETSIM_RAND_01());
602 }
603 else
604 {
605 *X = min + (int)((min - max + 1) * NETSIM_RAND_01());
606 }
607
608 ldRandNo = (unsigned int)fn_NetSim_Utilities_GenerateRandomNo(pulSeed1, pulSeed2);
609
610 min = (int)(*Y - ldRandNo % ((int)(velocity * interval / SECOND) + 1));
611
612 ldRandNo = (unsigned int)fn_NetSim_Utilities_GenerateRandomNo(pulSeed1, pulSeed2);
613
614 max = (int)(*Y + ldRandNo % ((int)(velocity * interval / SECOND) + 1));
615
616 if (min > max)
617 {
618 *Y = max + (int)((min - max + 1) * NETSIM_RAND_01());
619 }
620 else
621 {
622 *Y = min + (int)((min - max + 1) * NETSIM_RAND_01());
623 }
624 return 1;
625}
626
627_declspec(dllexport) int fnMobilityRegisterCallBackFunction(_fnMobilityCallBack fnCallBack)
628{
629 if (!nCallBackCount)
630 {
631 fnMobilityCallBack = (_fnMobilityCallBack*)calloc(1, sizeof * fnMobilityCallBack);
632 }
633 else
634 {
635 fnMobilityCallBack = (_fnMobilityCallBack*)realloc(fnMobilityCallBack, (nCallBackCount + 1) * sizeof * fnMobilityCallBack);
636 }
637 fnMobilityCallBack[nCallBackCount] = fnCallBack;
638 nCallBackCount++;
639 return 0;
640}
stru_NetSim_MobilityVar::dPauseTime
double dPauseTime
To store the pause time.
Definition Mobility.h:80
stru_NetSim_MobilityVar::dLastTime
double dLastTime
Represent the devices last move time.
Definition Mobility.h:84
stru_NetSim_MobilityVar::ulSeed1
unsigned long ulSeed1
Used to generate random point.
Definition Mobility.h:82
stru_NetSim_MobilityVar::nGroupId
NETSIM_ID nGroupId
To store group id of device.
Definition Mobility.h:85
stru_NetSim_MobilityVar::ulSeed2
unsigned long ulSeed2
Used to generate random point.
Definition Mobility.h:83
stru_NetSim_MobilityVar::dVelocity
double dVelocity
To store the velocity.
Definition Mobility.h:81
stru_NetSim_Network
Definition Stack.h:735