inet::TurtleMobility Class Reference

LOGO-style movement model, with the script coming from XML. More...

#include <TurtleMobility.h>

Inheritance diagram for inet::TurtleMobility:

Public Member Functions
	TurtleMobility ()
virtual double	getMaxSpeed () const override
	Returns the maximum possible speed at any future time. More...
Public Member Functions inherited from inet::LineSegmentsMobilityBase
	LineSegmentsMobilityBase ()
Public Member Functions inherited from inet::MovingMobilityBase
virtual const Coord &	getCurrentPosition () override
	Returns the position at the current simulation time. More...
virtual const Coord &	getCurrentVelocity () override
	Returns the velocity at the current simulation time. More...
virtual const Coord &	getCurrentAcceleration () override
	Returns the acceleration at the current simulation time. More...
virtual const Quaternion &	getCurrentAngularPosition () override
	Returns the angular position at the current simulation time. More...
virtual const Quaternion &	getCurrentAngularVelocity () override
	Returns the angular velocity at the current simulation time. More...
virtual const Quaternion &	getCurrentAngularAcceleration () override
	Returns the angular acceleration at the current simulation time. More...
Public Member Functions inherited from inet::MobilityBase
virtual const Coord &	getConstraintAreaMax () const override
	Returns the maximum position along each axes for. More...
virtual const Coord &	getConstraintAreaMin () const override
	Returns the minimum position along each axes for. More...
Public Member Functions inherited from inet::IMobility
virtual	~IMobility ()

Protected Member Functions
virtual int	numInitStages () const override
	Returns the required number of initialize stages. More...
virtual void	initialize (int stage) override
	Initializes mobility model parameters. More...
virtual void	setInitialPosition () override
	Initializes the position according to the mobility model. More...
virtual void	setTargetPosition () override
	Overridden from LineSegmentsMobilityBase. More...
virtual void	move () override
	Overridden from LineSegmentsMobilityBase. More...
virtual void	resumeScript ()
	Process next statements from script. More...
virtual void	executeStatement (cXMLElement *nextStatement)
	Execute the given statement. More...
virtual double	getValue (const char *s)
	Parse attrs in the script – accepts things like "uniform(10,50) as well. More...
virtual void	gotoNextStatement ()
	Advance nextStatement pointer. More...
virtual void	computeMaxSpeed (cXMLElement *nodes)
Protected Member Functions inherited from inet::LineSegmentsMobilityBase
virtual void	initializePosition () override
	Initializes mobility position. More...
Protected Member Functions inherited from inet::MovingMobilityBase
	MovingMobilityBase ()
virtual	~MovingMobilityBase ()
virtual void	handleSelfMessage (cMessage *message) override
	Called upon arrival of a self messages, subclasses must override. More...
void	scheduleUpdate ()
	Schedules the move timer that will update the mobility state. More...
void	moveAndUpdate ()
	Moves and notifies listeners. More...
virtual void	orient ()
Protected Member Functions inherited from inet::MobilityBase
	MobilityBase ()
virtual int	getId () const override
virtual void	checkPosition ()
	Checks whether the position is valid or not. More...
virtual void	initializeOrientation ()
	Initializes the orientation from module parameters. More...
virtual void	refreshDisplay () const override
	Moves the visual representation module's icon to the new position on the screen. More...
virtual void	updateDisplayStringFromMobilityState () const
virtual void	handleParameterChange (const char *name) override
	Allows changing parameters from the GUI. More...
virtual void	handleMessage (cMessage *msg) override
	This modules should only receive self-messages. More...
virtual void	emitMobilityStateChangedSignal ()
	Emits a signal with the updated mobility state. More...
virtual Coord	getRandomPosition ()
	Returns a new random position satisfying the constraint area. More...
virtual cModule *	findSubjectModule ()
	Returns the module that represents the object moved by this mobility module. More...
virtual bool	isOutside ()
	Returns true if the mobility is outside of the constraint area. More...
virtual void	reflectIfOutside (Coord &targetPosition, Coord &velocity, rad &angle, rad &elevation, Quaternion &quaternion)
	Utility function to reflect the node if it goes outside the constraint area. More...
virtual void	wrapIfOutside (Coord &targetPosition)
	Utility function to wrap the node to the opposite edge (torus) if it goes outside the constraint area. More...
virtual void	placeRandomlyIfOutside (Coord &targetPosition)
	Utility function to place the node randomly if it goes outside the constraint area. More...
virtual void	raiseErrorIfOutside ()
	Utility function to raise an error if the node gets outside the constraint area. More...
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity)
	Invokes one of reflectIfOutside(), wrapIfOutside() and placeRandomlyIfOutside(), depending on the given border policy. More...
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity, rad &heading)
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity, rad &heading, rad &elevation)
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity, rad &heading, rad &elevation, Quaternion &quaternion)

Protected Attributes
cXMLElement *	turtleScript
cXMLElement *	nextStatement
double	speed
rad	heading
rad	elevation
BorderPolicy	borderPolicy
std::stack< long >	loopVars
double	maxSpeed
Protected Attributes inherited from inet::LineSegmentsMobilityBase
Coord	targetPosition
	End position of current linear movement. More...
Protected Attributes inherited from inet::MovingMobilityBase
cMessage *	moveTimer
	The message used for mobility state changes. More...
simtime_t	updateInterval
	The simulation time interval used to regularly signal mobility state changes. More...
bool	stationary
	A mobility model may decide to become stationary at any time. More...
Coord	lastVelocity
	The last velocity that was reported at lastUpdate. More...
Quaternion	lastAngularVelocity
	The last angular velocity that was reported at lastUpdate. More...
simtime_t	lastUpdate
	The simulation time when the mobility state was last updated. More...
simtime_t	nextChange
	The next simulation time when the mobility module needs to update its internal state. More...
bool	faceForward
Protected Attributes inherited from inet::MobilityBase
cModule *	subjectModule
	Pointer to visual representation module, to speed up repeated access. More...
const CanvasProjection *	canvasProjection
	The 2D projection used on the canvas. More...
Coord	constraintAreaMin
	3 dimensional position and size of the constraint area (in meters). More...
Coord	constraintAreaMax
Coord	lastPosition
	The last position that was reported. More...
Quaternion	lastOrientation
	The last orientation that was reported. More...
StringFormat	format

Additional Inherited Members
Public Types inherited from inet::MobilityBase
enum	BorderPolicy { REFLECT, WRAP, PLACERANDOMLY, RAISEERROR }
	Selects how a mobility module should behave if it reaches the edge of the constraint area. More...
Static Public Attributes inherited from inet::IMobility
static simsignal_t	mobilityStateChangedSignal = cComponent::registerSignal("mobilityStateChanged")
	A signal used to publish mobility state changes. More...

Detailed Description

LOGO-style movement model, with the script coming from XML.

See NED file for more info.

Constructor & Destructor Documentation

TurtleMobility()

inet::TurtleMobility::TurtleMobility

(

)

                               :
    turtleScript(nullptr),
    nextStatement(nullptr),
    speed(0),
    heading(deg(0)),
    elevation(deg(0)),
    borderPolicy(REFLECT),
    maxSpeed(0)
{
}

Member Function Documentation

computeMaxSpeed()

void inet::TurtleMobility::computeMaxSpeed ( cXMLElement *  nodes )

protectedvirtual

{
    // Recursively traverse the whole config file, looking for
    // speed attributes
    cXMLElementList childs = nodes->getChildren();
    for (auto& child : childs) {
        const char *speedAttr = child->getAttribute("speed");
        if (speedAttr) {
            double speed = atof(speedAttr);
            if (speed > maxSpeed)
                maxSpeed = speed;
        }
        computeMaxSpeed(child);
    }
}

Referenced by initialize().

executeStatement()

void inet::TurtleMobility::executeStatement ( cXMLElement *  nextStatement )

protectedvirtual

Execute the given statement.

{
    ASSERT(nextChange != -1);
    const char *tag = stmt->getTagName();
 
    EV_DEBUG << "doing <" << tag << ">\n";
 
    if (!strcmp(tag, "repeat")) {
        const char *nAttr = stmt->getAttribute("n");
        long n = -1; // infinity -- that's the default
 
        if (nAttr) {
            n = (long)getValue(nAttr);
 
            if (n < 0)
                throw cRuntimeError("<repeat>: negative repeat count at %s", stmt->getSourceLocation());
        }
 
        loopVars.push(n);
    }
    else if (!strcmp(tag, "set")) {
        const char *speedAttr = stmt->getAttribute("speed");
        const char *headingAttr = stmt->getAttribute("heading");
        if (headingAttr == nullptr)
            headingAttr = stmt->getAttribute("angle"); // for backward compatibility
        const char *elevationAttr = stmt->getAttribute("elevation");
        const char *xAttr = stmt->getAttribute("x");
        const char *yAttr = stmt->getAttribute("y");
        const char *zAttr = stmt->getAttribute("z");
        const char *bpAttr = stmt->getAttribute("borderPolicy");
 
        if (speedAttr)
            speed = getValue(speedAttr);
 
        if (headingAttr)
            heading = deg(getValue(headingAttr));
 
        if (elevationAttr)
            elevation = deg(getValue(elevationAttr));
 
        if (xAttr)
            targetPosition.x = lastPosition.x = getValue(xAttr);
 
        if (yAttr)
            targetPosition.y = lastPosition.y = getValue(yAttr);
 
        if (zAttr)
            targetPosition.z = lastPosition.z = getValue(zAttr);
 
        if (speed <= 0)
            throw cRuntimeError("<set>: speed is negative or zero at %s", stmt->getSourceLocation());
 
        if (bpAttr) {
            if (!strcmp(bpAttr, "reflect"))
                borderPolicy = REFLECT;
            else if (!strcmp(bpAttr, "wrap"))
                borderPolicy = WRAP;
            else if (!strcmp(bpAttr, "placerandomly"))
                borderPolicy = PLACERANDOMLY;
            else if (!strcmp(bpAttr, "error"))
                borderPolicy = RAISEERROR;
            else
                throw cRuntimeError("<set>: value for attribute borderPolicy is invalid, should be "
                                    "'reflect', 'wrap', 'placerandomly' or 'error' at %s",
                        stmt->getSourceLocation());
        }
    }
    else if (!strcmp(tag, "forward")) {
        const char *dAttr = stmt->getAttribute("d");
        const char *tAttr = stmt->getAttribute("t");
 
        if (!dAttr && !tAttr)
            throw cRuntimeError("<forward>: must have at least attribute 't' or 'd' (or both) at %s", stmt->getSourceLocation());
 
        double d, t;
 
        if (tAttr && dAttr) {
            // cover distance d in time t (current speed is ignored)
            d = getValue(dAttr);
            t = getValue(tAttr);
        }
        else if (dAttr) {
            // travel distance d at current speed
            d = getValue(dAttr);
            t = d / speed;
        }
        else {
            // tAttr only: travel for time t at current speed
            t = getValue(tAttr);
            d = speed * t;
        }
 
        if (t < 0)
            throw cRuntimeError("<forward>: time (attribute t) is negative at %s", stmt->getSourceLocation());
 
        if (d < 0)
            throw cRuntimeError("<forward>: distance (attribute d) is negative at %s", stmt->getSourceLocation());
 
        Coord direction = Quaternion(EulerAngles(heading, -elevation, rad(0))).rotate(Coord::X_AXIS);
 
        targetPosition += direction * d;
        nextChange += t;
    }
    else if (!strcmp(tag, "turn")) {
        const char *headingAttr = stmt->getAttribute("heading");
        if (headingAttr == nullptr)
            headingAttr = stmt->getAttribute("angle"); // for backward compatibility
        const char *elevationAttr = stmt->getAttribute("elevation");
 
        if (headingAttr)
            heading += deg(getValue(headingAttr));
 
        if (elevationAttr)
            elevation += deg(getValue(elevationAttr));
    }
    else if (!strcmp(tag, "wait")) {
        const char *tAttr = stmt->getAttribute("t");
 
        if (!tAttr)
            throw cRuntimeError("<wait>: required attribute 't' missing at %s", stmt->getSourceLocation());
 
        double t = getValue(tAttr);
 
        if (t < 0)
            throw cRuntimeError("<wait>: time (attribute t) is negative (%g) at %s", t, stmt->getSourceLocation());
 
        nextChange += t; // targetPosition is unchanged
    }
    else if (!strcmp(tag, "moveto")) {
        const char *xAttr = stmt->getAttribute("x");
        const char *yAttr = stmt->getAttribute("y");
        const char *zAttr = stmt->getAttribute("z");
        const char *tAttr = stmt->getAttribute("t");
 
        if (xAttr)
            targetPosition.x = getValue(xAttr);
 
        if (yAttr)
            targetPosition.y = getValue(yAttr);
 
        if (zAttr)
            targetPosition.z = getValue(zAttr);
 
        // travel to targetPosition at current speed, or get there in time t (ignoring current speed then)
        double t = tAttr ? getValue(tAttr) : lastPosition.distance(targetPosition) / speed;
 
        if (t < 0)
            throw cRuntimeError("<wait>: time (attribute t) is negative at %s", stmt->getSourceLocation());
 
        nextChange += t;
    }
    else if (!strcmp(tag, "moveby")) {
        const char *xAttr = stmt->getAttribute("x");
        const char *yAttr = stmt->getAttribute("y");
        const char *zAttr = stmt->getAttribute("z");
        const char *tAttr = stmt->getAttribute("t");
 
        if (xAttr)
            targetPosition.x += getValue(xAttr);
 
        if (yAttr)
            targetPosition.y += getValue(yAttr);
 
        if (zAttr)
            targetPosition.z += getValue(zAttr);
 
        // travel to targetPosition at current speed, or get there in time t (ignoring current speed then)
        double t = tAttr ? getValue(tAttr) : lastPosition.distance(targetPosition) / speed;
 
        if (t < 0)
            throw cRuntimeError("<wait>: time (attribute t) is negative at %s", stmt->getSourceLocation());
 
        nextChange += t;
    }
}

Referenced by resumeScript().

getMaxSpeed()

virtual double inet::TurtleMobility::getMaxSpeed ( ) const

inlineoverridevirtual

Returns the maximum possible speed at any future time.

Reimplemented from inet::MobilityBase.

{ return maxSpeed; }

getValue()

double inet::TurtleMobility::getValue ( const char *  s )

protectedvirtual

Parse attrs in the script – accepts things like "uniform(10,50) as well.

{
    // first, textually replace $MAXX and $MAXY with their actual values
    std::string str;
    if (strchr(s, '$')) {
        char strMinX[32], strMinY[32], strMinZ[32];
        char strMaxX[32], strMaxY[32], strMaxZ[32];
        sprintf(strMinX, "%g", constraintAreaMin.x);
        sprintf(strMinY, "%g", constraintAreaMin.y);
        sprintf(strMinZ, "%g", constraintAreaMin.z);
        sprintf(strMaxX, "%g", constraintAreaMax.x);
        sprintf(strMaxY, "%g", constraintAreaMax.y);
        sprintf(strMaxZ, "%g", constraintAreaMax.z);
 
        str = s;
        std::string::size_type pos;
 
        while ((pos = str.find("$MINX")) != std::string::npos)
            str.replace(pos, sizeof("$MINX") - 1, strMinX);
 
        while ((pos = str.find("$MINY")) != std::string::npos)
            str.replace(pos, sizeof("$MINY") - 1, strMinY);
 
        while ((pos = str.find("$MINZ")) != std::string::npos)
            str.replace(pos, sizeof("$MINZ") - 1, strMinZ);
 
        while ((pos = str.find("$MAXX")) != std::string::npos)
            str.replace(pos, sizeof("$MAXX") - 1, strMaxX);
 
        while ((pos = str.find("$MAXY")) != std::string::npos)
            str.replace(pos, sizeof("$MAXY") - 1, strMaxY);
 
        while ((pos = str.find("$MAXZ")) != std::string::npos)
            str.replace(pos, sizeof("$MAXZ") - 1, strMaxZ);
 
        s = str.c_str();
    }
 
    // then use cDynamicExpression to evaluate the string
    try {
        cDynamicExpression expr;
        expr.parse(s);
        return expr.doubleValue(this);
    }
    catch (std::exception& e) {
        throw cRuntimeError("Wrong value '%s' around %s: %s", s,
                nextStatement->getSourceLocation(), e.what());
    }
}

Referenced by executeStatement().

gotoNextStatement()

void inet::TurtleMobility::gotoNextStatement ( )

protectedvirtual

Advance nextStatement pointer.

{
    // "statement either doesn't have a child, or it's a <repeat> and loop count is already pushed on the stack"
    ASSERT(!nextStatement->getFirstChild() || (!strcmp(nextStatement->getTagName(), "repeat")
                                               && !loopVars.empty()));
 
    if (nextStatement->getFirstChild() && (loopVars.top() != 0 || (loopVars.pop(), false))) { // !=0: positive or -1
        // statement must be a <repeat> if it has children; repeat count>0 must be
        // on the stack; let's start doing the body.
        nextStatement = nextStatement->getFirstChild();
    }
    else if (!nextStatement->getNextSibling()) {
        // no sibling -- either end of <repeat> body, or end of script
        ASSERT(nextStatement->getParentNode() == turtleScript ? loopVars.empty() : !loopVars.empty());
 
        if (!loopVars.empty()) {
            // decrement and check loop counter
            if (loopVars.top() != -1) // -1 means infinity
                loopVars.top()--;
 
            if (loopVars.top() != 0) { // positive or -1
                // go to beginning of <repeat> block again
                nextStatement = nextStatement->getParentNode()->getFirstChild();
            }
            else {
                // end of loop -- locate next statement after the <repeat>
                nextStatement = nextStatement->getParentNode();
                gotoNextStatement();
            }
        }
        else {
            // end of script
            nextStatement = nullptr;
        }
    }
    else {
        // go to next statement (must exist -- see "if" above)
        nextStatement = nextStatement->getNextSibling();
    }
}

Referenced by resumeScript().

initialize()

void inet::TurtleMobility::initialize ( int  stage )

overrideprotectedvirtual

Initializes mobility model parameters.

Reimplemented from inet::MovingMobilityBase.

{
    LineSegmentsMobilityBase::initialize(stage);
 
    EV_TRACE << "initializing TurtleMobility stage " << stage << endl;
    if (stage == INITSTAGE_LOCAL) {
        WATCH(speed);
        WATCH(heading);
        WATCH(elevation);
        WATCH(borderPolicy);
        computeMaxSpeed(par("turtleScript"));
    }
}

move()

void inet::TurtleMobility::move ( )

overrideprotectedvirtual

Overridden from LineSegmentsMobilityBase.

Reimplemented from inet::LineSegmentsMobilityBase.

{
    LineSegmentsMobilityBase::move();
    Coord dummyCoord;
    handleIfOutside(borderPolicy, targetPosition, dummyCoord, heading, elevation);
}

numInitStages()

virtual int inet::TurtleMobility::numInitStages ( ) const

inlineoverrideprotectedvirtual

Returns the required number of initialize stages.

Reimplemented from inet::MobilityBase.

{ return NUM_INIT_STAGES; }

resumeScript()

void inet::TurtleMobility::resumeScript ( )

protectedvirtual

Process next statements from script.

Will set a new nextChange and targetPosition.

{
    simtime_t now = simTime();
 
    while (nextChange == now) {
        if (nextStatement != nullptr) {
            executeStatement(nextStatement);
            gotoNextStatement();
        }
        else {
            nextChange = -1;
            stationary = true;
            targetPosition = lastPosition;
        }
    }
}

Referenced by setInitialPosition(), and setTargetPosition().

setInitialPosition()

void inet::TurtleMobility::setInitialPosition ( )

overrideprotectedvirtual

Initializes the position according to the mobility model.

Reimplemented from inet::MobilityBase.

{
    LineSegmentsMobilityBase::setInitialPosition();
 
    turtleScript = par("turtleScript");
    nextStatement = turtleScript->getFirstChild();
 
    speed = 1;
    heading = deg(0);
    elevation = deg(0);
    borderPolicy = REFLECT;
 
    // a dirty trick to extract starting position out of the script
    // (start doing it, but then rewind to the beginning)
    nextChange = simTime();
    resumeScript();
    targetPosition = lastPosition;
    nextChange = simTime();
    nextStatement = turtleScript->getFirstChild();
 
    while (!loopVars.empty())
        loopVars.pop();
}

setTargetPosition()

void inet::TurtleMobility::setTargetPosition ( )

overrideprotectedvirtual

Overridden from LineSegmentsMobilityBase.

Invokes resumeScript().

Implements inet::LineSegmentsMobilityBase.

{
    resumeScript();
}

Member Data Documentation

borderPolicy

BorderPolicy inet::TurtleMobility::borderPolicy

protected

Referenced by executeStatement(), initialize(), move(), and setInitialPosition().

elevation

rad inet::TurtleMobility::elevation

protected

Referenced by executeStatement(), initialize(), move(), and setInitialPosition().

heading

rad inet::TurtleMobility::heading

protected

Referenced by executeStatement(), initialize(), move(), and setInitialPosition().

loopVars

std::stack<long> inet::TurtleMobility::loopVars

protected

Referenced by executeStatement(), gotoNextStatement(), and setInitialPosition().

maxSpeed

double inet::TurtleMobility::maxSpeed

protected

Referenced by computeMaxSpeed().

nextStatement

cXMLElement* inet::TurtleMobility::nextStatement

protected

Referenced by getValue(), gotoNextStatement(), resumeScript(), and setInitialPosition().

speed

double inet::TurtleMobility::speed

protected

Referenced by computeMaxSpeed(), executeStatement(), initialize(), and setInitialPosition().

turtleScript

cXMLElement* inet::TurtleMobility::turtleScript

protected

Referenced by gotoNextStatement(), and setInitialPosition().

---

The documentation for this class was generated from the following files:

• TurtleMobility.h
• TurtleMobility.cc