FileBasedMobility.c

Go to the documentation of this file.

/************************************************************************************
* Copyright (C) 2021                                                                *
* TETCOS, Bangalore. India                                                          *
*                                                                                   *
* Tetcos owns the intellectual property rights in the Product and its content.      *
* The copying, redistribution, reselling or publication of any or all of the        *
* Product or its content without express prior written consent of Tetcos is         *
* prohibited. Ownership and / or any other right relating to the software and all   *
* intellectual property rights therein shall remain at all times with Tetcos.       *
*                                                                                   *
* This source code is licensed per the NetSim license agreement.                    *
*                                                                                   *
* No portion of this source code may be used as the basis for a derivative work,    *
* or used, for any purpose other than its intended use per the NetSim license       *
* agreement.                                                                        *
*                                                                                   *
* This source code and the algorithms contained within it are confidential trade    *
* secrets of TETCOS and may not be used as the basis for any other software,        *
* hardware, product or service.                                                     *
*                                                                                   *
* Author:    Shashi Kant Suman                                                      *
*                                                                                   *
* ----------------------------------------------------------------------------------*/
#include "main.h"
#include "Mobility.h"
#include "NetSim_utility.h"
 
typedef struct stru_filebasedmobilityinfo
{
    NETSIM_ID d;
    double time;
    double x;
    double y;
    double z;
    struct stru_filebasedmobilityinfo* next;
}INFO, * ptrINFO;
ptrINFO* mobilityInfo;
ptrINFO* lastInfo;
 
static void add_mobility_info(NETSIM_ID d,
    double time,
    double x,
    double y,
    double z)
{
    if (!mobilityInfo)
    {
        mobilityInfo = calloc(NETWORK->nDeviceCount, sizeof * mobilityInfo);
        lastInfo = calloc(NETWORK->nDeviceCount, sizeof * lastInfo);
    }
    ptrINFO info = mobilityInfo[d - 1];
 
    ptrINFO t = calloc(1, sizeof * t);
    t->d = d;
    t->time = time;
    t->x = x;
    t->y = y;
    t->z = z;
    if (info)
    {
        lastInfo[d - 1]->next = t;
        lastInfo[d - 1] = t;
    }
    else
    {
        mobilityInfo[d - 1] = t;
        lastInfo[d - 1] = t;
    }
    fprintf(stderr, "%d,%lf,%lf,%lf%lf\n",
        d, time, x, y, z);
}
 
static void add_mobility_event()
{
    NETSIM_ID d;
    if (!mobilityInfo)
        return;
    for (d = 0; d < NETWORK->nDeviceCount; d++)
    {
        if (!mobilityInfo[d])
            continue;
        NetSim_MOBILITY* mob = DEVICE_MOBILITY(d + 1);
        mob->pstruCurrentPosition = calloc(1, sizeof * mob->pstruCurrentPosition);
        mob->pstruNextPosition = calloc(1, sizeof * mob->pstruNextPosition);
        ptrINFO i = mobilityInfo[d];
        pstruEventDetails->dEventTime = i->time;
        pstruEventDetails->dPacketSize = 0;
        pstruEventDetails->nApplicationId = 0;
        pstruEventDetails->nDeviceId = d + 1;
        pstruEventDetails->nDeviceType = NETWORK->ppstruDeviceList[d]->nDeviceType;
        pstruEventDetails->nEventType = TIMER_EVENT;
        pstruEventDetails->nInterfaceId = 0;
        pstruEventDetails->nPacketId = 0;
        pstruEventDetails->nProtocolId = PROTOCOL_MOBILITY;
        pstruEventDetails->nSubEventType = 0;
        pstruEventDetails->pPacket = NULL;
        fnpAddEvent(pstruEventDetails);
    }
}
 
void process_filebased_mobility_event()
{
    if (!mobilityInfo)
        return;
    NETSIM_ID d = pstruEventDetails->nDeviceId;
    ptrINFO i = mobilityInfo[d - 1];
    if (!i)
        return;
    NetSim_MOBILITY* mob = DEVICE_MOBILITY(d);
    NetSim_COORDINATES* c = mob->pstruCurrentPosition;
    NetSim_COORDINATES* n = mob->pstruNextPosition;
    NetSim_COORDINATES* dc = DEVICE(d)->pstruDevicePosition;
    dc->X = i->x;
    dc->Y = i->y;
    dc->Z = i->z;
    c->X = i->x;
    c->Y = i->y;
    c->Z = i->z;
    if (i->next)
    {
        n->X = i->next->x;
        n->Y = i->next->y;
        n->Z = i->next->z;
    }
    mobilityInfo[d - 1] = i->next;
    free(i);
    mobility_pass_position_to_animation(pstruEventDetails->nDeviceId,
        pstruEventDetails->dEventTime,
        DEVICE_POSITION(pstruEventDetails->nDeviceId));
    if (mobilityInfo[d - 1])
    {
        pstruEventDetails->dEventTime = mobilityInfo[d - 1]->time;
        fnpAddEvent(pstruEventDetails);
    }
}
 
/** This function is to free the file pointers */
int FileBasedMobilityPointersFree()
{
    NETSIM_ID d;
    if (mobilityInfo)
    {
        for (d = 0; d < NETWORK->nDeviceCount; d++)
        {
            ptrINFO i = mobilityInfo[d];
            while (i)
            {
                mobilityInfo[d] = i->next;
                free(i);
                i = mobilityInfo[d];
            }
        }
        free(mobilityInfo);
    }
    return 0;
}
 
NETSIM_ID find_DeviceID_From_ConfigID(NETSIM_ID d) {
    NETSIM_ID i;
    for (i = 0; i < NETWORK->nDeviceCount; i++) {
        NETSIM_ID r = DEVICE_CONFIGID(i + 1);
        if (DEVICE_CONFIGID(i + 1) == d)
            return i;
    }
    return 0;
}
 
/** This function is to open the file, to define position pointers and to set the initial positions for all the nodes */
int FileBasedMobilityReadingFile()
{
    int lineno = 0;
    double time, x, y, z;
    NETSIM_ID d;
    FILE* fp;
    char str[BUFSIZ];
    if (!mobilityInfo)
    {
        sprintf(str, "%s/%s", pszIOPath, "mobility.txt");
        fp = fopen(str, "r");
        if (!fp)
        {
            fnSystemError("Unable to open %s file.\n", str);
            perror(str);
            return -1;
        }
    }
    else
    {
        return -1;
    }
 
    char data[BUFSIZ];
    while (fgets(data, BUFSIZ, fp))
    {
        lineno++;
        lskip(data);
        if (*data == '#' ||
            *data == 0)
            continue;
        if (*data != '$')
        {
            fprintf(stderr, "In mobility.txt, invalid data at line no %d\n", lineno);
            continue;
        }
        if (*(data + 1) == 'n')
            continue;
        if (*(data + 1) != 't')
        {
            fprintf(stderr, "In mobility.txt, invalid data at line no %d\n", lineno);
            continue;
        }
 
        if (sscanf(data, "$time %lf \"$node_(%d) %lf %lf %lf\"",
            &time, &d, &x, &y, &z));
        d = find_DeviceID_From_ConfigID(d + 1);
        add_mobility_info(d + 1, time * SECOND, x, y, z);
    }
    fclose(fp);
 
    add_mobility_event();
    return 0;
}