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 power::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, intval_t 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)
opp_component_ptr< IRadio >	radio
ModuleRefByPar< power::IEpEnergySource >	energySource
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.

Member Function Documentation

computePowerConsumption()

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

protectedvirtual

{
    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) {
        switch (receptionState) {
            case IRadio::RECEPTION_STATE_IDLE:
                powerConsumption += receiverIdlePowerConsumption;
                break;
            case IRadio::RECEPTION_STATE_BUSY:
                powerConsumption += receiverBusyPowerConsumption;
                break;
            case IRadio::RECEPTION_STATE_RECEIVING: {
                auto part = radio->getReceivedSignalPart();
                switch (part) {
                    case IRadioSignal::SIGNAL_PART_NONE:
                        break;
                    case IRadioSignal::SIGNAL_PART_WHOLE:
                        powerConsumption += receiverReceivingPowerConsumption;
                        break;
                    case IRadioSignal::SIGNAL_PART_PREAMBLE:
                        powerConsumption += receiverReceivingPreamblePowerConsumption;
                        break;
                    case IRadioSignal::SIGNAL_PART_HEADER:
                        powerConsumption += receiverReceivingHeaderPowerConsumption;
                        break;
                    case IRadioSignal::SIGNAL_PART_DATA:
                        powerConsumption += receiverReceivingDataPowerConsumption;
                        break;
                    default:
                        throw cRuntimeError("Unknown received signal part");
                }
                break;
            }
            case IRadio::RECEPTION_STATE_UNDEFINED:
                break;
            default:
                throw cRuntimeError("Unknown radio reception state");
        }
    }
    if (radioMode == IRadio::RADIO_MODE_TRANSMITTER || radioMode == IRadio::RADIO_MODE_TRANSCEIVER) {
        switch (transmissionState) {
            case IRadio::TRANSMISSION_STATE_IDLE:
                powerConsumption += transmitterIdlePowerConsumption;
                break;
            case IRadio::TRANSMISSION_STATE_TRANSMITTING: {
                auto part = radio->getTransmittedSignalPart();
                switch (part) {
                    case IRadioSignal::SIGNAL_PART_NONE:
                        break;
                    case IRadioSignal::SIGNAL_PART_WHOLE:
                        powerConsumption += transmitterTransmittingPowerConsumption;
                        break;
                    case IRadioSignal::SIGNAL_PART_PREAMBLE:
                        powerConsumption += transmitterTransmittingPreamblePowerConsumption;
                        break;
                    case IRadioSignal::SIGNAL_PART_HEADER:
                        powerConsumption += transmitterTransmittingHeaderPowerConsumption;
                        break;
                    case IRadioSignal::SIGNAL_PART_DATA:
                        powerConsumption += transmitterTransmittingDataPowerConsumption;
                        break;
                    default:
                        throw cRuntimeError("Unknown transmitted signal part");
                }
                break;
            }
            case IRadio::TRANSMISSION_STATE_UNDEFINED:
                break;
            default:
                throw cRuntimeError("Unknown radio transmission state");
        }
    }
    return powerConsumption;
}

getEnergySource()

virtual power::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; }

getPowerConsumption()

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

inlineoverridevirtual

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

Implements inet::power::IEpEnergyConsumer.

{ return powerConsumption; }

initialize()

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.reference(this, "energySourceModule", true);
        WATCH(powerConsumption);
    }
    else if (stage == INITSTAGE_POWER)
        energySource->addEnergyConsumer(this);
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

receiveSignal()

void inet::physicallayer::StateBasedEpEnergyConsumer::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)
    {
        powerConsumption = computePowerConsumption();
        emit(powerConsumptionChangedSignal, powerConsumption.get());
    }
    else
        throw cRuntimeError("Unknown signal");
}

Member Data Documentation

energySource

ModuleRefByPar<power::IEpEnergySource> inet::physicallayer::StateBasedEpEnergyConsumer::energySource

protected

offPowerConsumption

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

protected

powerConsumption

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

protected

radio

opp_component_ptr<IRadio> inet::physicallayer::StateBasedEpEnergyConsumer::radio

protected

receiverBusyPowerConsumption

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

protected

receiverIdlePowerConsumption

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

protected

receiverReceivingDataPowerConsumption

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

protected

receiverReceivingHeaderPowerConsumption

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

protected

receiverReceivingPowerConsumption

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

protected

receiverReceivingPreamblePowerConsumption

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

protected

sleepPowerConsumption

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

protected

switchingPowerConsumption

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

protected

transmitterIdlePowerConsumption

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

protected

transmitterTransmittingDataPowerConsumption

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

protected

transmitterTransmittingHeaderPowerConsumption

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

protected

transmitterTransmittingPowerConsumption

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

protected

transmitterTransmittingPreamblePowerConsumption

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

protected

---

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

• StateBasedEpEnergyConsumer.h
• StateBasedEpEnergyConsumer.cc