inet::physicallayer::StateBasedCcEnergyConsumer Class Reference

This is a simple radio energy consumer model. More...

#include <StateBasedCcEnergyConsumer.h>

Inheritance diagram for inet::physicallayer::StateBasedCcEnergyConsumer:

Public Member Functions
virtual power::IEnergySource *	getEnergySource () const override
	Returns the energy source that provides energy for this energy consumer. More...
virtual A	getCurrentConsumption () const override
	Returns the current consumption in the range [0, +infinity). More...
virtual void	receiveSignal (cComponent *source, simsignal_t signal, intval_t value, cObject *details) override
virtual void	receiveSignal (cComponent *source, simsignal_t signal, double value, cObject *details) override
Public Member Functions inherited from inet::power::IEnergyConsumer
virtual	~IEnergyConsumer ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual A	computeCurrentConsumption () const

Protected Attributes
V	minSupplyVoltage = V(NaN)
V	maxSupplyVoltage = V(NaN)
A	offCurrentConsumption = A(NaN)
A	sleepCurrentConsumption = A(NaN)
A	switchingCurrentConsumption = A(NaN)
A	receiverIdleCurrentConsumption = A(NaN)
A	receiverBusyCurrentConsumption = A(NaN)
A	receiverReceivingCurrentConsumption = A(NaN)
A	receiverReceivingPreambleCurrentConsumption = A(NaN)
A	receiverReceivingHeaderCurrentConsumption = A(NaN)
A	receiverReceivingDataCurrentConsumption = A(NaN)
A	transmitterIdleCurrentConsumption = A(NaN)
A	transmitterTransmittingCurrentConsumption = A(NaN)
A	transmitterTransmittingPreambleCurrentConsumption = A(NaN)
A	transmitterTransmittingHeaderCurrentConsumption = A(NaN)
A	transmitterTransmittingDataCurrentConsumption = A(NaN)
IRadio *	radio = nullptr
power::ICcEnergySource *	energySource = nullptr
A	currentConsumption = A(NaN)

Additional Inherited Members
Static Public Attributes inherited from inet::power::ICcEnergyConsumer
static simsignal_t	currentConsumptionChangedSignal = cComponent::registerSignal("currentConsumptionChanged")
	The signal that is used to publish current consumption changes. More...

Detailed Description

This is a simple radio energy consumer model.

The current consumption is determined by the radio mode, the transmitter state and the receiver state using constant parameters.

Member Function Documentation

computeCurrentConsumption()

A inet::physicallayer::StateBasedCcEnergyConsumer::computeCurrentConsumption ( ) const

protectedvirtual

{
    IRadio::RadioMode radioMode = radio->getRadioMode();
    if (radioMode == IRadio::RADIO_MODE_OFF)
        return offCurrentConsumption;
    else if (radioMode == IRadio::RADIO_MODE_SLEEP)
        return sleepCurrentConsumption;
    else if (radioMode == IRadio::RADIO_MODE_SWITCHING)
        return switchingCurrentConsumption;
    A currentConsumption = A(0);
    IRadio::ReceptionState receptionState = radio->getReceptionState();
    IRadio::TransmissionState transmissionState = radio->getTransmissionState();
    if (radioMode == IRadio::RADIO_MODE_RECEIVER || radioMode == IRadio::RADIO_MODE_TRANSCEIVER) {
        if (receptionState == IRadio::RECEPTION_STATE_IDLE)
            currentConsumption += receiverIdleCurrentConsumption;
        else if (receptionState == IRadio::RECEPTION_STATE_BUSY)
            currentConsumption += receiverBusyCurrentConsumption;
        else if (receptionState == IRadio::RECEPTION_STATE_RECEIVING) {
            auto part = radio->getReceivedSignalPart();
            if (part == IRadioSignal::SIGNAL_PART_NONE)
                ;
            else if (part == IRadioSignal::SIGNAL_PART_WHOLE)
                currentConsumption += receiverReceivingCurrentConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_PREAMBLE)
                currentConsumption += receiverReceivingPreambleCurrentConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_HEADER)
                currentConsumption += receiverReceivingHeaderCurrentConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_DATA)
                currentConsumption += receiverReceivingDataCurrentConsumption;
            else
                throw cRuntimeError("Unknown received signal part");
        }
        else if (receptionState != IRadio::RECEPTION_STATE_UNDEFINED)
            throw cRuntimeError("Unknown radio reception state");
    }
    if (radioMode == IRadio::RADIO_MODE_TRANSMITTER || radioMode == IRadio::RADIO_MODE_TRANSCEIVER) {
        if (transmissionState == IRadio::TRANSMISSION_STATE_IDLE)
            currentConsumption += transmitterIdleCurrentConsumption;
        else if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING) {
            // TODO add transmission power?
            auto part = radio->getTransmittedSignalPart();
            if (part == IRadioSignal::SIGNAL_PART_NONE)
                ;
            else if (part == IRadioSignal::SIGNAL_PART_WHOLE)
                currentConsumption += transmitterTransmittingCurrentConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_PREAMBLE)
                currentConsumption += transmitterTransmittingPreambleCurrentConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_HEADER)
                currentConsumption += transmitterTransmittingHeaderCurrentConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_DATA)
                currentConsumption += transmitterTransmittingDataCurrentConsumption;
            else
                throw cRuntimeError("Unknown transmitted signal part");
        }
        else if (transmissionState != IRadio::TRANSMISSION_STATE_UNDEFINED)
            throw cRuntimeError("Unknown radio transmission state");
    }
    return currentConsumption;
}

getCurrentConsumption()

virtual A inet::physicallayer::StateBasedCcEnergyConsumer::getCurrentConsumption ( ) const

inlineoverridevirtual

Returns the current consumption in the range [0, +infinity).

Implements inet::power::ICcEnergyConsumer.

{ return currentConsumption; }

getEnergySource()

virtual power::IEnergySource* inet::physicallayer::StateBasedCcEnergyConsumer::getEnergySource ( ) const

inlineoverridevirtual

Returns the energy source that provides energy for this energy consumer.

This function never returns nullptr.

Implements inet::power::IEnergyConsumer.

{ return energySource; }

initialize()

void inet::physicallayer::StateBasedCcEnergyConsumer::initialize ( int  stage )

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        minSupplyVoltage = V(par("minSupplyVoltage"));
        maxSupplyVoltage = V(par("maxSupplyVoltage"));
        offCurrentConsumption = A(par("offCurrentConsumption"));
        sleepCurrentConsumption = A(par("sleepCurrentConsumption"));
        switchingCurrentConsumption = A(par("switchingCurrentConsumption"));
        receiverIdleCurrentConsumption = A(par("receiverIdleCurrentConsumption"));
        receiverBusyCurrentConsumption = A(par("receiverBusyCurrentConsumption"));
        receiverReceivingCurrentConsumption = A(par("receiverReceivingCurrentConsumption"));
        receiverReceivingPreambleCurrentConsumption = A(par("receiverReceivingPreambleCurrentConsumption"));
        receiverReceivingHeaderCurrentConsumption = A(par("receiverReceivingHeaderCurrentConsumption"));
        receiverReceivingDataCurrentConsumption = A(par("receiverReceivingDataCurrentConsumption"));
        transmitterIdleCurrentConsumption = A(par("transmitterIdleCurrentConsumption"));
        transmitterTransmittingCurrentConsumption = A(par("transmitterTransmittingCurrentConsumption"));
        transmitterTransmittingPreambleCurrentConsumption = A(par("transmitterTransmittingPreambleCurrentConsumption"));
        transmitterTransmittingHeaderCurrentConsumption = A(par("transmitterTransmittingHeaderCurrentConsumption"));
        transmitterTransmittingDataCurrentConsumption = A(par("transmitterTransmittingDataCurrentConsumption"));
        cModule *radioModule = getParentModule();
        radioModule->subscribe(IRadio::radioModeChangedSignal, this);
        radioModule->subscribe(IRadio::receptionStateChangedSignal, this);
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
        radioModule->subscribe(IRadio::receivedSignalPartChangedSignal, this);
        radioModule->subscribe(IRadio::transmittedSignalPartChangedSignal, this);
        radio = check_and_cast<IRadio *>(radioModule);
        const char *energySourceModule = par("energySourceModule");
        energySource = check_and_cast<ICcEnergySource *>(getModuleByPath(energySourceModule));
        check_and_cast<cModule *>(energySource)->subscribe(ICcEnergySource::currentConsumptionChangedSignal, this);
        currentConsumption = A(0);
        WATCH(currentConsumption);
    }
    else if (stage == INITSTAGE_POWER)
        energySource->addEnergyConsumer(this);
}

numInitStages()

virtual int inet::physicallayer::StateBasedCcEnergyConsumer::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

receiveSignal() [1/2]

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

overridevirtual

{
    Enter_Method("%s", cComponent::getSignalName(signal));
 
    if (signal == ICcEnergySource::currentConsumptionChangedSignal) {
        if (energySource->getOutputVoltage() < minSupplyVoltage)
            radio->setRadioMode(IRadio::RADIO_MODE_OFF);
    }
    else
        throw cRuntimeError("Unknown signal");
}

receiveSignal() [2/2]

void inet::physicallayer::StateBasedCcEnergyConsumer::receiveSignal ( cComponent *  source, simsignal_t  signal, intval_t  value, cObject *  details  )

overridevirtual

{
    Enter_Method("%s", cComponent::getSignalName(signal));
 
    if (signal == IRadio::radioModeChangedSignal ||
        signal == IRadio::receptionStateChangedSignal ||
        signal == IRadio::transmissionStateChangedSignal ||
        signal == IRadio::receivedSignalPartChangedSignal ||
        signal == IRadio::transmittedSignalPartChangedSignal)
    {
        currentConsumption = computeCurrentConsumption();
        emit(currentConsumptionChangedSignal, currentConsumption.get());
    }
    else
        throw cRuntimeError("Unknown signal");
}

Member Data Documentation

currentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::currentConsumption = A(NaN)

protected

energySource

power::ICcEnergySource* inet::physicallayer::StateBasedCcEnergyConsumer::energySource = nullptr

protected

maxSupplyVoltage

V inet::physicallayer::StateBasedCcEnergyConsumer::maxSupplyVoltage = V(NaN)

protected

minSupplyVoltage

V inet::physicallayer::StateBasedCcEnergyConsumer::minSupplyVoltage = V(NaN)

protected

offCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::offCurrentConsumption = A(NaN)

protected

radio

IRadio* inet::physicallayer::StateBasedCcEnergyConsumer::radio = nullptr

protected

receiverBusyCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::receiverBusyCurrentConsumption = A(NaN)

protected

receiverIdleCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::receiverIdleCurrentConsumption = A(NaN)

protected

receiverReceivingCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::receiverReceivingCurrentConsumption = A(NaN)

protected

receiverReceivingDataCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::receiverReceivingDataCurrentConsumption = A(NaN)

protected

receiverReceivingHeaderCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::receiverReceivingHeaderCurrentConsumption = A(NaN)

protected

receiverReceivingPreambleCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::receiverReceivingPreambleCurrentConsumption = A(NaN)

protected

sleepCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::sleepCurrentConsumption = A(NaN)

protected

switchingCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::switchingCurrentConsumption = A(NaN)

protected

transmitterIdleCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::transmitterIdleCurrentConsumption = A(NaN)

protected

transmitterTransmittingCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::transmitterTransmittingCurrentConsumption = A(NaN)

protected

transmitterTransmittingDataCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::transmitterTransmittingDataCurrentConsumption = A(NaN)

protected

transmitterTransmittingHeaderCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::transmitterTransmittingHeaderCurrentConsumption = A(NaN)

protected

transmitterTransmittingPreambleCurrentConsumption

A inet::physicallayer::StateBasedCcEnergyConsumer::transmitterTransmittingPreambleCurrentConsumption = A(NaN)

protected

---

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

• StateBasedCcEnergyConsumer.h
• StateBasedCcEnergyConsumer.cc