inet::physicallayer::StateBasedEpEnergyConsumer Class Reference

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

#include <StateBasedEpEnergyConsumer.h>

Inheritance diagram for inet::physicallayer::StateBasedEpEnergyConsumer:

Public Member Functions
virtual IEnergySource *	getEnergySource () const override
	Returns the energy source that provides energy for this energy consumer. More...
virtual W	getPowerConsumption () const override
	Returns the power consumption in the range [0, +infinity). More...
virtual void	receiveSignal (cComponent *source, simsignal_t signal, long 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 W	computePowerConsumption () const

Protected Attributes
W	offPowerConsumption = W(NaN)
W	sleepPowerConsumption = W(NaN)
W	switchingPowerConsumption = W(NaN)
W	receiverIdlePowerConsumption = W(NaN)
W	receiverBusyPowerConsumption = W(NaN)
W	receiverReceivingPowerConsumption = W(NaN)
W	receiverReceivingPreamblePowerConsumption = W(NaN)
W	receiverReceivingHeaderPowerConsumption = W(NaN)
W	receiverReceivingDataPowerConsumption = W(NaN)
W	transmitterIdlePowerConsumption = W(NaN)
W	transmitterTransmittingPowerConsumption = W(NaN)
W	transmitterTransmittingPreamblePowerConsumption = W(NaN)
W	transmitterTransmittingHeaderPowerConsumption = W(NaN)
W	transmitterTransmittingDataPowerConsumption = W(NaN)
IRadio *	radio = nullptr
IEpEnergySource *	energySource = nullptr
W	powerConsumption = W(NaN)

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

Detailed Description

This is a simple radio power consumer model.

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

Author

Levente Meszaros

Member Function Documentation

W inet::physicallayer::StateBasedEpEnergyConsumer::computePowerConsumption ( ) const

protectedvirtual

Referenced by receiveSignal().

{
    IRadio::RadioMode radioMode = radio->getRadioMode();
    if (radioMode == IRadio::RADIO_MODE_OFF)
        return offPowerConsumption;
    else if (radioMode == IRadio::RADIO_MODE_SLEEP)
        return sleepPowerConsumption;
    else if (radioMode == IRadio::RADIO_MODE_SWITCHING)
        return switchingPowerConsumption;
    W powerConsumption = W(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)
            powerConsumption += receiverIdlePowerConsumption;
        else if (receptionState == IRadio::RECEPTION_STATE_BUSY)
            powerConsumption += receiverBusyPowerConsumption;
        else if (receptionState == IRadio::RECEPTION_STATE_RECEIVING) {
            auto part = radio->getReceivedSignalPart();
            if (part == IRadioSignal::SIGNAL_PART_NONE)
                ;
            else if (part == IRadioSignal::SIGNAL_PART_WHOLE)
                powerConsumption += receiverReceivingPowerConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_PREAMBLE)
                powerConsumption += receiverReceivingPreamblePowerConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_HEADER)
                powerConsumption += receiverReceivingHeaderPowerConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_DATA)
                powerConsumption += receiverReceivingDataPowerConsumption;
            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)
            powerConsumption += transmitterIdlePowerConsumption;
        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)
                powerConsumption += transmitterTransmittingPowerConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_PREAMBLE)
                powerConsumption += transmitterTransmittingPreamblePowerConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_HEADER)
                powerConsumption += transmitterTransmittingHeaderPowerConsumption;
            else if (part == IRadioSignal::SIGNAL_PART_DATA)
                powerConsumption += transmitterTransmittingDataPowerConsumption;
            else
                throw cRuntimeError("Unknown transmitted signal part");
        }
        else if (transmissionState != IRadio::TRANSMISSION_STATE_UNDEFINED)
            throw cRuntimeError("Unknown radio transmission state");
    }
    return powerConsumption;
}

virtual IEnergySource* inet::physicallayer::StateBasedEpEnergyConsumer::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; }

virtual W inet::physicallayer::StateBasedEpEnergyConsumer::getPowerConsumption ( ) const

inlineoverridevirtual

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

Implements inet::power::IEpEnergyConsumer.

{ return powerConsumption; }

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        offPowerConsumption = W(par("offPowerConsumption"));
        sleepPowerConsumption = W(par("sleepPowerConsumption"));
        switchingPowerConsumption = W(par("switchingPowerConsumption"));
        receiverIdlePowerConsumption = W(par("receiverIdlePowerConsumption"));
        receiverBusyPowerConsumption = W(par("receiverBusyPowerConsumption"));
        receiverReceivingPowerConsumption = W(par("receiverReceivingPowerConsumption"));
        receiverReceivingPreamblePowerConsumption = W(par("receiverReceivingPreamblePowerConsumption"));
        receiverReceivingHeaderPowerConsumption = W(par("receiverReceivingHeaderPowerConsumption"));
        receiverReceivingDataPowerConsumption = W(par("receiverReceivingDataPowerConsumption"));
        transmitterIdlePowerConsumption = W(par("transmitterIdlePowerConsumption"));
        transmitterTransmittingPowerConsumption = W(par("transmitterTransmittingPowerConsumption"));
        transmitterTransmittingPreamblePowerConsumption = W(par("transmitterTransmittingPreamblePowerConsumption"));
        transmitterTransmittingHeaderPowerConsumption = W(par("transmitterTransmittingHeaderPowerConsumption"));
        transmitterTransmittingDataPowerConsumption = W(par("transmitterTransmittingDataPowerConsumption"));
        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);
        powerConsumption = W(0);
        energySource = getModuleFromPar<IEpEnergySource>(par("energySourceModule"), this);
        energySource->addEnergyConsumer(this);
        WATCH(powerConsumption);
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

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

overridevirtual

{
    if (signal == IRadio::radioModeChangedSignal ||
        signal == IRadio::receptionStateChangedSignal ||
        signal == IRadio::transmissionStateChangedSignal ||
        signal == IRadio::receivedSignalPartChangedSignal ||
        signal == IRadio::transmittedSignalPartChangedSignal)
    {
        powerConsumption = computePowerConsumption();
        emit(powerConsumptionChangedSignal, powerConsumption.get());
    }
    else
        throw cRuntimeError("Unknown signal");
}

Member Data Documentation

IEpEnergySource* inet::physicallayer::StateBasedEpEnergyConsumer::energySource = nullptr

protected

Referenced by initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::offPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::powerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), initialize(), and receiveSignal().

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

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::receiverBusyPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::receiverIdlePowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::receiverReceivingDataPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::receiverReceivingHeaderPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::receiverReceivingPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::receiverReceivingPreamblePowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::sleepPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::switchingPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::transmitterIdlePowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::transmitterTransmittingDataPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::transmitterTransmittingHeaderPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::transmitterTransmittingPowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

W inet::physicallayer::StateBasedEpEnergyConsumer::transmitterTransmittingPreamblePowerConsumption = W(NaN)

protected

Referenced by computePowerConsumption(), and initialize().

---

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

• StateBasedEpEnergyConsumer.h
• StateBasedEpEnergyConsumer.cc