#include <SimpleEpEnergyManagement.h>

Inheritance diagram for inet::power::SimpleEpEnergyManagement:

Public Member Functions
virtual	~SimpleEpEnergyManagement ()

virtual IEnergyStorage *	getEnergyStorage () const override
	Returns the energy storage that is managed by this energy management. More...

virtual J	getEstimatedEnergyCapacity () const override
	Returns the estimated energy capacity in the range [0, +infinity). More...

virtual void	receiveSignal (cComponent source, simsignal_t signal, double value, cObject details) override

Public Member Functions inherited from inet::power::IEnergyManagement
virtual	~IEnergyManagement ()

Public Member Functions inherited from inet::LifecycleController
	LifecycleController ()

virtual	~LifecycleController ()

virtual bool	initiateOperation (LifecycleOperation operation, IDoneCallback completionCallback=nullptr)
	Initiate an operation. More...

Protected Member Functions
virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *message) override

virtual void	refreshDisplay () const override

virtual void	executeNodeOperation (J estimatedEnergyCapacity)

virtual void	scheduleLifecycleOperationTimer ()

Protected Member Functions inherited from inet::LifecycleController
virtual bool	resumeOperation (LifecycleOperation *operation)

virtual void	doOneStage (LifecycleOperation operation, cModule submodule)

virtual void	moduleOperationStageCompleted (Callback *callback)

Protected Attributes
J	nodeShutdownCapacity = J(NaN)

J	nodeStartCapacity = J(NaN)

IEpEnergyStorage *	energyStorage = nullptr

cModule *	networkNode = nullptr

NodeStatus *	nodeStatus = nullptr

cMessage *	lifecycleOperationTimer = nullptr

J	targetCapacity = J(NaN)

Protected Attributes inherited from inet::LifecycleController
Callback *	spareCallback = nullptr

Constructor & Destructor Documentation

◆ ~SimpleEpEnergyManagement()

inet::power::SimpleEpEnergyManagement::~SimpleEpEnergyManagement ( )

virtual

 {
     cancelAndDelete(lifecycleOperationTimer);
 }

Member Function Documentation

◆ executeNodeOperation()

void inet::power::SimpleEpEnergyManagement::executeNodeOperation ( J estimatedEnergyCapacity )

protectedvirtual

 {
     if (!std::isnan(nodeShutdownCapacity.get()) && estimatedEnergyCapacity <= nodeShutdownCapacity && nodeStatus->getState() == NodeStatus::UP) {
         EV_WARN << "Capacity reached node shutdown threshold" << endl;
         LifecycleOperation::StringMap params;
         ModuleStopOperation *operation = new ModuleStopOperation();
         operation->initialize(networkNode, params);
         initiateOperation(operation);
     }
     else if (!std::isnan(nodeStartCapacity.get()) && estimatedEnergyCapacity >= nodeStartCapacity && nodeStatus->getState() == NodeStatus::DOWN) {
         EV_INFO << "Capacity reached node start threshold" << endl;
         LifecycleOperation::StringMap params;
         ModuleStartOperation *operation = new ModuleStartOperation();
         operation->initialize(networkNode, params);
         initiateOperation(operation);
     }
 }

Referenced by handleMessage(), and receiveSignal().

◆ getEnergyStorage()

virtual IEnergyStorage* inet::power::SimpleEpEnergyManagement::getEnergyStorage ( ) const

inlineoverridevirtual

Returns the energy storage that is managed by this energy management.

This function never returns nullptr.

Implements inet::power::IEnergyManagement.

45 { return energyStorage; }

◆ getEstimatedEnergyCapacity()

J inet::power::SimpleEpEnergyManagement::getEstimatedEnergyCapacity ( ) const

overridevirtual

Returns the estimated energy capacity in the range [0, +infinity).

It specifies the amount of energy that the energy storage contains at the moment according to the estimation of the management.

Implements inet::power::IEpEnergyManagement.

 {
     // NOTE: cheat with estimation and return the actual energy capacity known by the energy storage
     return energyStorage->getResidualEnergyCapacity();
 }

Referenced by handleMessage(), receiveSignal(), and scheduleLifecycleOperationTimer().

◆ handleMessage()

void inet::power::SimpleEpEnergyManagement::handleMessage ( cMessage * message )

overrideprotectedvirtual

 {
     if (message == lifecycleOperationTimer) {
         executeNodeOperation(getEstimatedEnergyCapacity());
         scheduleLifecycleOperationTimer();
     }
     else
         throw cRuntimeError("Unknown message");
 }

◆ initialize()

void inet::power::SimpleEpEnergyManagement::initialize ( int stage )

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         nodeShutdownCapacity = J(par("nodeShutdownCapacity"));
         nodeStartCapacity = J(par("nodeStartCapacity"));
         networkNode = findContainingNode(this);
         energyStorage = check_and_cast<IEpEnergyStorage *>(networkNode->getSubmodule("energyStorage"));
         auto energyStorageModule = check_and_cast<cModule *>(energyStorage);
         energyStorageModule->subscribe(IEpEnergySource::powerConsumptionChangedSignal, this);
         energyStorageModule->subscribe(IEpEnergySink::powerGenerationChangedSignal, this);
         nodeStatus = dynamic_cast<NodeStatus *>(networkNode->getSubmodule("status"));
         if (!nodeStatus)
             throw cRuntimeError("Cannot find node status");
         lifecycleOperationTimer = new cMessage("lifecycleOperation");
     }
 }

◆ receiveSignal()

void inet::power::SimpleEpEnergyManagement::receiveSignal	(	cComponent *	source,
		simsignal_t	signal,
		double	value,
		cObject *	details
	)

overridevirtual

 {
     Enter_Method("%s", cComponent::getSignalName(signal));
  
     if (signal == IEpEnergySource::powerConsumptionChangedSignal || signal == IEpEnergySink::powerGenerationChangedSignal) {
         executeNodeOperation(getEstimatedEnergyCapacity());
         scheduleLifecycleOperationTimer();
     }
 }

◆ refreshDisplay()

void inet::power::SimpleEpEnergyManagement::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     std::string text;
     if (std::isnan(targetCapacity.get()))
         text = "";
     else if (targetCapacity == nodeShutdownCapacity)
         text = "shutdown";
     else if (targetCapacity == nodeStartCapacity)
         text = "start";
     else
         throw cRuntimeError("Invalid state");
     if (text.length() != 0)
         text += " in " + (lifecycleOperationTimer->getArrivalTime() - simTime()).str() + " s";
     getDisplayString().setTagArg("t", 0, text.c_str());
 }

◆ scheduleLifecycleOperationTimer()

void inet::power::SimpleEpEnergyManagement::scheduleLifecycleOperationTimer ( )

protectedvirtual

 {
     targetCapacity = J(NaN);
     J estimatedResidualCapacity = getEstimatedEnergyCapacity();
     W totalPower = energyStorage->getTotalPowerGeneration() - energyStorage->getTotalPowerConsumption();
     if (totalPower > W(0)) {
         // override target capacity if start is needed
         if (!std::isnan(nodeStartCapacity.get()) && nodeStatus->getState() == NodeStatus::DOWN && estimatedResidualCapacity < nodeStartCapacity)
             targetCapacity = nodeStartCapacity;
     }
     else if (totalPower < W(0)) {
         // override target capacity if shutdown is needed
         if (!std::isnan(nodeShutdownCapacity.get()) && nodeStatus->getState() == NodeStatus::UP && estimatedResidualCapacity > nodeShutdownCapacity)
             targetCapacity = nodeShutdownCapacity;
     }
     if (lifecycleOperationTimer->isScheduled())
         cancelEvent(lifecycleOperationTimer);
     if (totalPower != W(0)) {
         // enforce target capacity to be in range
         simtime_t remainingTime = unit((targetCapacity - estimatedResidualCapacity) / totalPower / s(1)).get();
         // make sure the targetCapacity is reached despite floating point arithmetic
         remainingTime.setRaw(remainingTime.raw() + 1);
         // don't schedule if there's no progress
         if (remainingTime > 0)
             scheduleAfter(remainingTime, lifecycleOperationTimer);
     }
 }