inet::physicallayer::Radio Class Reference

This class is the default implementation of the IRadio interface. More...

#include <Radio.h>

Inheritance diagram for inet::physicallayer::Radio:

Protected Attributes
const int	id = nextId++
	An identifier which is globally unique for the whole lifetime of the simulation among all radios. More...
Parameters that determine the behavior of the radio.
const IAntenna *	antenna = nullptr
	The radio antenna model is never nullptr. More...
const ITransmitter *	transmitter = nullptr
	The transmitter model is never nullptr. More...
const IReceiver *	receiver = nullptr
	The receiver model is never nullptr. More...
ModuleRefByPar< IRadioMedium >	medium
	The radio medium model is never nullptr. More...
int	mediumModuleId = -1
	The module id of the medim model. More...
simtime_t	switchingTimes [RADIO_MODE_SWITCHING][RADIO_MODE_SWITCHING]
	Simulation time required to switch from one radio mode to another. More...
bool	sendRawBytes = false
	When true packets are serialized into a sequence of bytes before sending out. More...
bool	separateTransmissionParts = false
	Determines whether the transmission of the preamble, header and data part are simulated separately or not. More...
bool	separateReceptionParts = false
	Determines whether the reception of the preamble, header and data part are simulated separately or not. More...
cGate *	upperLayerOut = nullptr
	Gates. More...
cGate *	upperLayerIn = nullptr
cGate *	radioIn = nullptr
RadioMode	radioMode = RADIO_MODE_OFF
	State. More...
RadioMode	nextRadioMode = RADIO_MODE_OFF
	The radio is switching to this radio radio mode if a switch is in progress, otherwise this is the same as the current radio mode. More...
RadioMode	previousRadioMode = RADIO_MODE_OFF
	The radio is switching from this radio mode to another if a switch is in progress, otherwise this is the same as the current radio mode. More...
ReceptionState	receptionState = RECEPTION_STATE_UNDEFINED
	The current reception state. More...
TransmissionState	transmissionState = TRANSMISSION_STATE_UNDEFINED
	The current transmission state. More...
IRadioSignal::SignalPart	receivedSignalPart = IRadioSignal::SIGNAL_PART_NONE
	The current received signal part. More...
IRadioSignal::SignalPart	transmittedSignalPart = IRadioSignal::SIGNAL_PART_NONE
	The current transmitted signal part. More...
Protected Attributes inherited from inet::physicallayer::PhysicalLayerBase
int	upperLayerInGateId = -1
int	upperLayerOutGateId = -1
int	radioInGateId = -1
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Timer
cMessage *	transmissionTimer = nullptr
	The timer that is scheduled to the end of the current transmission. More...
cMessage *	receptionTimer = nullptr
	The timer that is scheduled to the end of the current reception. More...
cMessage *	switchTimer = nullptr
	The timer that is scheduled to the end of the radio mode switch. More...
void	parseRadioModeSwitchingTimes ()
void	startRadioModeSwitch (RadioMode newRadioMode, simtime_t switchingTime)
void	completeRadioModeSwitch (RadioMode newRadioMode)
virtual void	initialize (int stage) override
virtual void	initializeRadioMode ()
virtual void	handleMessageWhenDown (cMessage *message) override
virtual void	handleSelfMessage (cMessage *message) override
virtual void	handleSwitchTimer (cMessage *message)
virtual void	handleTransmissionTimer (cMessage *message)
virtual void	handleReceptionTimer (cMessage *message)
virtual void	handleUpperCommand (cMessage *command) override
virtual void	handleLowerCommand (cMessage *command) override
virtual void	handleUpperPacket (Packet *packet) override
virtual void	handleSignal (WirelessSignal *signal) override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	startTransmission (Packet *macFrame, IRadioSignal::SignalPart part)
virtual void	continueTransmission ()
virtual void	endTransmission ()
virtual void	abortTransmission ()
virtual WirelessSignal *	createSignal (Packet *packet) const
virtual void	startReception (cMessage *timer, IRadioSignal::SignalPart part)
virtual void	continueReception (cMessage *timer)
virtual void	endReception (cMessage *timer)
virtual void	abortReception (cMessage *timer)
virtual void	captureReception (cMessage *timer)
virtual void	sendUp (Packet *macFrame)
virtual cMessage *	createReceptionTimer (WirelessSignal *signal) const
virtual bool	isReceptionTimer (const cMessage *message) const
virtual bool	isReceiverMode (IRadio::RadioMode radioMode) const
virtual bool	isTransmitterMode (IRadio::RadioMode radioMode) const
virtual bool	isListeningPossible () const
virtual void	updateTransceiverState ()
virtual void	updateTransceiverPart ()
	Radio ()
virtual	~Radio ()
virtual int	getId () const override
	Returns an identifier for this radio which is globally unique for the whole lifetime of the simulation among all radios. More...
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const override
	Prints this object to the provided output stream. More...
virtual const IAntenna *	getAntenna () const override
	Returns the antenna used by the transceiver of this radio. More...
virtual const ITransmitter *	getTransmitter () const override
	Returns the transmitter part of this radio. More...
virtual const IReceiver *	getReceiver () const override
	Returns the receiver part of this radio. More...
virtual const IRadioMedium *	getMedium () const override
	Returns the radio medium where this radio is transmitting and receiving radio signals. More...
virtual const cGate *	getRadioGate () const override
	Returns the gate of the radio that receives incoming signals. More...
virtual RadioMode	getRadioMode () const override
	Returns the current radio mode, This is the same mode as the one emitted with the last radioModeChangedSignal. More...
virtual void	setRadioMode (RadioMode newRadioMode) override
	Changes the current radio mode. More...
virtual ReceptionState	getReceptionState () const override
	Returns the current radio reception state. More...
virtual TransmissionState	getTransmissionState () const override
	Returns the current radio transmission state. More...
virtual const ITransmission *	getTransmissionInProgress () const override
	Returns the ongoing transmission that the transmitter is currently transmitting or nullptr. More...
virtual const ITransmission *	getReceptionInProgress () const override
	Returns the ongoing reception that the receiver is currently receiving or nullptr. More...
virtual IRadioSignal::SignalPart	getTransmittedSignalPart () const override
	Returns the signal part of the ongoing transmission that the transmitter is currently transmitting or -1 if no transmission is in progress. More...
virtual IRadioSignal::SignalPart	getReceivedSignalPart () const override
	Returns the signal part of the ongoing reception that the receiver is currently receiving or -1 if no reception is in progress. More...
virtual void	encapsulate (Packet *packet) const
virtual void	decapsulate (Packet *packet) const

Additional Inherited Members
Public Types inherited from inet::physicallayer::IRadio
enum	RadioMode {   RADIO_MODE_OFF, RADIO_MODE_SLEEP, RADIO_MODE_RECEIVER, RADIO_MODE_TRANSMITTER,   RADIO_MODE_TRANSCEIVER, RADIO_MODE_SWITCHING }
	This enumeration specifies the requested operational mode of the radio. More...
enum	ReceptionState { RECEPTION_STATE_UNDEFINED, RECEPTION_STATE_IDLE, RECEPTION_STATE_BUSY, RECEPTION_STATE_RECEIVING }
	This enumeration specifies the reception state of the radio. More...
enum	TransmissionState { TRANSMISSION_STATE_UNDEFINED, TRANSMISSION_STATE_IDLE, TRANSMISSION_STATE_TRANSMITTING }
	This enumeration specifies the transmission state of the radio. More...
Public Types inherited from inet::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }
enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IPhysicalLayer
virtual	~IPhysicalLayer ()
Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	printToString () const
virtual std::string	printToString (int level, int evFlags=0) const
virtual std::string	getInfoStringRepresentation (int evFlags=0) const
virtual std::string	getDetailStringRepresentation (int evFlags=0) const
virtual std::string	getDebugStringRepresentation (int evFlags=0) const
virtual std::string	getTraceStringRepresentation (int evFlags=0) const
virtual std::string	getCompleteStringRepresentation (int evFlags=0) const
Static Public Member Functions inherited from inet::physicallayer::IRadio
static const char *	getRadioModeName (RadioMode radioMode)
	Returns the name of the provided radio mode. More...
static const char *	getRadioReceptionStateName (ReceptionState receptionState)
	Returns the name of the provided radio reception state. More...
static const char *	getRadioTransmissionStateName (TransmissionState transmissionState)
	Returns the name of the provided radio transmission state. More...
Static Public Attributes inherited from inet::physicallayer::IRadio
static simsignal_t	radioModeChangedSignal = cComponent::registerSignal("radioModeChanged")
	This signal is emitted when the radio mode of the radio is changed. More...
static simsignal_t	listeningChangedSignal = cComponent::registerSignal("listeningChanged")
	This signal is emitted when the radio listening of the radio is changed. More...
static simsignal_t	receptionStateChangedSignal = cComponent::registerSignal("receptionStateChanged")
	This signal is emitted when the radio reception state of the radio is changed. More...
static simsignal_t	transmissionStateChangedSignal = cComponent::registerSignal("transmissionStateChanged")
	This signal is emitted when the radio transmission state of the radio is changed. More...
static simsignal_t	receivedSignalPartChangedSignal = cComponent::registerSignal("receivedSignalPartChanged")
	This signal is emitted when the received part is changed by the radio. More...
static simsignal_t	transmittedSignalPartChangedSignal = cComponent::registerSignal("transmittedSignalPartChanged")
	This signal is emitted when the transmitted part is changed by the radio. More...
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
Protected Member Functions inherited from inet::physicallayer::PhysicalLayerBase
virtual void	handleLowerMessage (cMessage *message) override
virtual void	sendUp (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerPacket (Packet *packet)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()
Static Protected Attributes inherited from inet::physicallayer::IRadio
static int	nextId = 0
static cEnum *	radioModeEnum = nullptr
	The enumeration registered for radio mode. More...
static cEnum *	receptionStateEnum = nullptr
	The enumeration registered for radio reception state. More...
static cEnum *	transmissionStateEnum = nullptr
	The enumeration registered for radio transmission state. More...

Detailed Description

This class is the default implementation of the IRadio interface.

The transmission process starts when the radio module receives a packet from the higher layer. The radio must be in transmitter or transceiver mode before receiving a packet, otherwise it throws an exception. The radio changes its transmitter state to transmitting, and emits a transmitter state changed signal. Finally, it schedules a timer to the end of the transmission.

The transmission process ends when the above timer expires. The radio changes its transmitter state back to idle, and emits a transmitter state changed signal.

The reception process starts when the radio module receives a packet. The radio must be in receiver or transceiver mode before the packet arrives, otherwise it just ignores the packet. The radio changes its receiver state to the appropriate value, and emits a receiver state changed signal. Finally, it schedules a timer to the end of the reception.

The reception process ends when one of the above timer expires. If the timer corresponds to an attempted reception, then the radio determines the reception decision. Independently of whether the reception is successful or not, the encapsulated packet is sent up to the higher layer. Finally, the radio changes its receiver state to the appropriate value, and emits a receiver state changed signal.

Constructor & Destructor Documentation

Radio()

inet::physicallayer::Radio::Radio ( )

inline

{}

~Radio()

inet::physicallayer::Radio::~Radio ( )

virtual

{
    // NOTE: can't use the medium module here, because it may have been already deleted
    cModule *medium = getSimulation()->getModule(mediumModuleId);
    if (medium != nullptr)
        check_and_cast<IRadioMedium *>(medium)->removeRadio(this);
    cancelAndDelete(transmissionTimer);
    cancelAndDelete(switchTimer);
}

Member Function Documentation

abortReception()

void inet::physicallayer::Radio::abortReception ( cMessage *  timer )

protectedvirtual

{
    auto signal = static_cast<WirelessSignal *>(timer->getControlInfo());
    auto part = (IRadioSignal::SignalPart)timer->getKind();
    auto reception = signal->getReception();
    EV_INFO << "Reception \x1b[1maborted\x1b[0m: for " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
    if (timer == receptionTimer)
        receptionTimer = nullptr;
    updateTransceiverState();
    updateTransceiverPart();
}

Referenced by completeRadioModeSwitch().

abortTransmission()

void inet::physicallayer::Radio::abortTransmission ( )

protectedvirtual

{
    auto part = (IRadioSignal::SignalPart)transmissionTimer->getKind();
    auto signal = static_cast<WirelessSignal *>(transmissionTimer->getContextPointer());
    auto transmission = signal->getTransmission();
    transmissionTimer->setContextPointer(nullptr);
    EV_INFO << "Transmission aborted: " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << transmission << endl;
    EV_WARN << "Aborting ongoing transmissions is not supported" << endl;
    cancelEvent(transmissionTimer);
    updateTransceiverState();
    updateTransceiverPart();
}

Referenced by completeRadioModeSwitch(), handleCrashOperation(), and handleStopOperation().

captureReception()

void inet::physicallayer::Radio::captureReception ( cMessage *  timer )

protectedvirtual

{
    // TODO this would be called when the receiver switches to a stronger signal while receiving a weaker one
    throw cRuntimeError("Not yet implemented");
}

completeRadioModeSwitch()

void inet::physicallayer::Radio::completeRadioModeSwitch ( RadioMode  newRadioMode )

private

{
    EV_INFO << "Radio mode changed from \x1b[1m" << getRadioModeName(previousRadioMode) << "\x1b[0m to \x1b[1m" << getRadioModeName(newRadioMode) << "\x1b[0m." << endl;
    if (!isReceiverMode(newRadioMode) && receptionTimer != nullptr)
        abortReception(receptionTimer);
    if (!isTransmitterMode(newRadioMode) && transmissionTimer->isScheduled())
        abortTransmission();
    radioMode = previousRadioMode = nextRadioMode = newRadioMode;
    emit(radioModeChangedSignal, newRadioMode);
    updateTransceiverState();
    updateTransceiverPart();
}

Referenced by handleCrashOperation(), handleStopOperation(), handleSwitchTimer(), initializeRadioMode(), and setRadioMode().

continueReception()

void inet::physicallayer::Radio::continueReception ( cMessage *  timer )

protectedvirtual

{
    auto previousPart = (IRadioSignal::SignalPart)timer->getKind();
    auto nextPart = (IRadioSignal::SignalPart)(previousPart + 1);
    auto signal = static_cast<WirelessSignal *>(timer->getControlInfo());
    auto arrival = signal->getArrival();
    auto reception = signal->getReception();
    if (timer == receptionTimer && isReceiverMode(radioMode) && arrival->getEndTime(previousPart) == simTime()) {
        auto transmission = signal->getTransmission();
        bool isReceptionSuccessful = medium->isReceptionSuccessful(this, transmission, previousPart);
        EV_INFO << "Reception ended: " << (isReceptionSuccessful ? "\x1b[1msuccessfully\x1b[0m" : "\x1b[1munsuccessfully\x1b[0m") << " for " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(previousPart) << " as " << reception << endl;
        if (!isReceptionSuccessful)
            receptionTimer = nullptr;
        auto isReceptionAttempted = medium->isReceptionAttempted(this, transmission, nextPart);
        EV_INFO << "Reception started: " << (isReceptionAttempted ? "\x1b[1mattempting\x1b[0m" : "\x1b[1mnot attempting\x1b[0m") << " " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(nextPart) << " as " << reception << endl;
        if (!isReceptionAttempted)
            receptionTimer = nullptr;
        // FIXME see handling packets with incorrect PHY headers in the TODO file
    }
    else {
        EV_INFO << "Reception ended: \x1b[1mignoring\x1b[0m " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(previousPart) << " as " << reception << endl;
        EV_INFO << "Reception started: \x1b[1mignoring\x1b[0m " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(nextPart) << " as " << reception << endl;
    }
    timer->setKind(nextPart);
    scheduleAt(arrival->getEndTime(nextPart), timer);
    updateTransceiverState();
    updateTransceiverPart();
}

Referenced by handleReceptionTimer().

continueTransmission()

void inet::physicallayer::Radio::continueTransmission ( )

protectedvirtual

{
    auto previousPart = (IRadioSignal::SignalPart)transmissionTimer->getKind();
    auto nextPart = (IRadioSignal::SignalPart)(previousPart + 1);
    auto signal = static_cast<WirelessSignal *>(transmissionTimer->getContextPointer());
    auto transmission = signal->getTransmission();
    EV_INFO << "Transmission ended: " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(previousPart) << " as " << signal->getTransmission() << endl;
    transmissionTimer->setKind(nextPart);
    scheduleAt(transmission->getEndTime(nextPart), transmissionTimer);
    EV_INFO << "Transmission started: " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(nextPart) << " as " << transmission << endl;
    updateTransceiverState();
    updateTransceiverPart();
}

Referenced by handleTransmissionTimer().

createReceptionTimer()

cMessage * inet::physicallayer::Radio::createReceptionTimer ( WirelessSignal *  signal ) const

protectedvirtual

{
    cMessage *timer = new cMessage("receptionTimer");
    timer->setControlInfo(signal);
    return timer;
}

Referenced by handleSignal().

createSignal()

WirelessSignal * inet::physicallayer::Radio::createSignal ( Packet *  packet ) const

protectedvirtual

{
    encapsulate(packet);
    if (sendRawBytes) {
        // TODO this doesn't always work, because the packet length may not be divisible by 8
        auto bytes = packet->peekDataAsBytes();
        packet->eraseAll();
        packet->insertAtFront(bytes);
    }
    WirelessSignal *signal = check_and_cast<WirelessSignal *>(medium->transmitPacket(this, packet));
    ASSERT(signal->getDuration() != 0);
    return signal;
}

Referenced by startTransmission().

decapsulate()

virtual void inet::physicallayer::Radio::decapsulate ( Packet *  packet ) const

inlinevirtual

Reimplemented in inet::physicallayer::Ieee80211Radio, inet::physicallayer::ApskRadio, inet::physicallayer::Ieee80211OfdmRadio, and inet::physicallayer::UnitDiskRadio.

{}

Referenced by endReception().

encapsulate()

virtual void inet::physicallayer::Radio::encapsulate ( Packet *  packet ) const

inlinevirtual

Reimplemented in inet::physicallayer::Ieee80211Radio, inet::physicallayer::ApskRadio, inet::physicallayer::Ieee80211OfdmRadio, and inet::physicallayer::UnitDiskRadio.

{}

Referenced by createSignal().

endReception()

void inet::physicallayer::Radio::endReception ( cMessage *  timer )

protectedvirtual

{
    auto part = (IRadioSignal::SignalPart)timer->getKind();
    auto signal = static_cast<WirelessSignal *>(timer->getControlInfo());
    auto arrival = signal->getArrival();
    auto reception = signal->getReception();
    if (timer == receptionTimer && isReceiverMode(radioMode) && arrival->getEndTime() == simTime()) {
        auto transmission = signal->getTransmission();
        // TODO this would draw twice from the random number generator in isReceptionSuccessful: auto isReceptionSuccessful = medium->isReceptionSuccessful(this, transmission, part);
        auto isReceptionSuccessful = medium->getReceptionDecision(this, signal->getListening(), transmission, part)->isReceptionSuccessful();
        EV_INFO << "Reception ended: " << (isReceptionSuccessful ? "\x1b[1msuccessfully\x1b[0m" : "\x1b[1munsuccessfully\x1b[0m") << " for " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
        auto macFrame = medium->receivePacket(this, signal);
        take(macFrame);
        // FIXME see handling packets with incorrect PHY headers in the TODO file
        decapsulate(macFrame);
        sendUp(macFrame);
        emit(receptionEndedSignal, check_and_cast<const cObject *>(reception));
    }
    else
        EV_INFO << "Reception ended: \x1b[1mignoring\x1b[0m " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
    updateTransceiverState();
    updateTransceiverPart();
    if (timer == receptionTimer)
        receptionTimer = nullptr;
    delete timer;
    // TODO move to radio medium
    check_and_cast<RadioMedium *>(medium.get())->emit(IRadioMedium::signalArrivalEndedSignal, check_and_cast<const cObject *>(reception));
}

Referenced by handleReceptionTimer().

endTransmission()

void inet::physicallayer::Radio::endTransmission ( )

protectedvirtual

{
    auto part = (IRadioSignal::SignalPart)transmissionTimer->getKind();
    auto signal = static_cast<WirelessSignal *>(transmissionTimer->getContextPointer());
    auto transmission = signal->getTransmission();
    transmissionTimer->setContextPointer(nullptr);
    EV_INFO << "Transmission ended: " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << transmission << endl;
    updateTransceiverState();
    updateTransceiverPart();
    emit(transmissionEndedSignal, check_and_cast<const cObject *>(transmission));
    // TODO move to radio medium
    check_and_cast<RadioMedium *>(medium.get())->emit(IRadioMedium::signalDepartureEndedSignal, check_and_cast<const cObject *>(transmission));
}

Referenced by handleTransmissionTimer().

getAntenna()

virtual const IAntenna* inet::physicallayer::Radio::getAntenna ( ) const

inlineoverridevirtual

Returns the antenna used by the transceiver of this radio.

This function never returns nullptr.

Implements inet::physicallayer::IRadio.

{ return antenna; }

getId()

virtual int inet::physicallayer::Radio::getId ( ) const

inlineoverridevirtual

Returns an identifier for this radio which is globally unique for the whole lifetime of the simulation among all radios.

Implements inet::physicallayer::IRadio.

{ return id; }

Referenced by inet::physicallayer::Ieee80211Radio::peekIeee80211PhyHeaderAtFront(), inet::physicallayer::Ieee80211Radio::popIeee80211PhyHeaderAtFront(), startTransmission(), and inet::physicallayer::CommunicationLog::writeTransmission().

getMedium()

virtual const IRadioMedium* inet::physicallayer::Radio::getMedium ( ) const

inlineoverridevirtual

Returns the radio medium where this radio is transmitting and receiving radio signals.

This function never returns nullptr.

Implements inet::physicallayer::IRadio.

{ return medium; }

getRadioGate()

virtual const cGate* inet::physicallayer::Radio::getRadioGate ( ) const

inlineoverridevirtual

Returns the gate of the radio that receives incoming signals.

Implements inet::physicallayer::IRadio.

{ return radioIn; }

getRadioMode()

virtual RadioMode inet::physicallayer::Radio::getRadioMode ( ) const

inlineoverridevirtual

Returns the current radio mode, This is the same mode as the one emitted with the last radioModeChangedSignal.

Implements inet::physicallayer::IRadio.

{ return radioMode; }

Referenced by inet::physicallayer::RadioMedium::isPotentialReceiver().

getReceivedSignalPart()

IRadioSignal::SignalPart inet::physicallayer::Radio::getReceivedSignalPart ( ) const

overridevirtual

Returns the signal part of the ongoing reception that the receiver is currently receiving or -1 if no reception is in progress.

This is the same part as the one emitted with the last receivedPartChangedSignal.

Implements inet::physicallayer::IRadio.

{
    return receivedSignalPart;
}

getReceiver()

virtual const IReceiver* inet::physicallayer::Radio::getReceiver ( ) const

inlineoverridevirtual

Returns the receiver part of this radio.

This function never returns nullptr.

Implements inet::physicallayer::IRadio.

{ return receiver; }

getReceptionInProgress()

const ITransmission * inet::physicallayer::Radio::getReceptionInProgress ( ) const

overridevirtual

Returns the ongoing reception that the receiver is currently receiving or nullptr.

Implements inet::physicallayer::IRadio.

{
    if (receptionTimer == nullptr)
        return nullptr;
    else
        return static_cast<WirelessSignal *>(receptionTimer->getControlInfo())->getTransmission();
}

getReceptionState()

virtual ReceptionState inet::physicallayer::Radio::getReceptionState ( ) const

inlineoverridevirtual

Returns the current radio reception state.

This is the same state as the one emitted with the last receptionStateChangedSignal.

Implements inet::physicallayer::IRadio.

{ return receptionState; }

getTransmissionInProgress()

const ITransmission * inet::physicallayer::Radio::getTransmissionInProgress ( ) const

overridevirtual

Returns the ongoing transmission that the transmitter is currently transmitting or nullptr.

Implements inet::physicallayer::IRadio.

{
    if (!transmissionTimer->isScheduled())
        return nullptr;
    else
        return static_cast<WirelessSignal *>(transmissionTimer->getContextPointer())->getTransmission();
}

getTransmissionState()

virtual TransmissionState inet::physicallayer::Radio::getTransmissionState ( ) const

inlineoverridevirtual

Returns the current radio transmission state.

This is the same state as the one emitted with the last transmissionStateChangedSignal.

Implements inet::physicallayer::IRadio.

{ return transmissionState; }

getTransmittedSignalPart()

IRadioSignal::SignalPart inet::physicallayer::Radio::getTransmittedSignalPart ( ) const

overridevirtual

Returns the signal part of the ongoing transmission that the transmitter is currently transmitting or -1 if no transmission is in progress.

This is the same part as the one emitted with the last transmittedPartChangedSignal.

Implements inet::physicallayer::IRadio.

{
    return transmittedSignalPart;
}

getTransmitter()

virtual const ITransmitter* inet::physicallayer::Radio::getTransmitter ( ) const

inlineoverridevirtual

Returns the transmitter part of this radio.

This function never returns nullptr.

Implements inet::physicallayer::IRadio.

{ return transmitter; }

handleCrashOperation()

void inet::physicallayer::Radio::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    cancelEvent(switchTimer);
    if (transmissionTimer->isScheduled())
        abortTransmission();
    completeRadioModeSwitch(RADIO_MODE_OFF);
}

handleLowerCommand()

void inet::physicallayer::Radio::handleLowerCommand ( cMessage *  command )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    throw cRuntimeError("Unsupported command");
}

handleMessageWhenDown()

void inet::physicallayer::Radio::handleMessageWhenDown ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    if (message->getArrivalGate() == radioIn || isReceptionTimer(message))
        delete message;
    else
        PhysicalLayerBase::handleMessageWhenDown(message);
}

handleReceptionTimer()

void inet::physicallayer::Radio::handleReceptionTimer ( cMessage *  message )

protectedvirtual

{
    if (message->getKind() == IRadioSignal::SIGNAL_PART_WHOLE)
        endReception(message);
    else if (message->getKind() == IRadioSignal::SIGNAL_PART_PREAMBLE)
        continueReception(message);
    else if (message->getKind() == IRadioSignal::SIGNAL_PART_HEADER)
        continueReception(message);
    else if (message->getKind() == IRadioSignal::SIGNAL_PART_DATA)
        endReception(message);
    else
        throw cRuntimeError("Unknown self message");
}

Referenced by handleSelfMessage().

handleSelfMessage()

void inet::physicallayer::Radio::handleSelfMessage ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    if (message == switchTimer)
        handleSwitchTimer(message);
    else if (message == transmissionTimer)
        handleTransmissionTimer(message);
    else if (isReceptionTimer(message))
        handleReceptionTimer(message);
    else
        throw cRuntimeError("Unknown self message");
}

handleSignal()

void inet::physicallayer::Radio::handleSignal ( WirelessSignal *  signal )

overrideprotectedvirtual

Reimplemented from inet::physicallayer::PhysicalLayerBase.

{
    auto receptionTimer = createReceptionTimer(signal);
    if (separateReceptionParts)
        startReception(receptionTimer, IRadioSignal::SIGNAL_PART_PREAMBLE);
    else
        startReception(receptionTimer, IRadioSignal::SIGNAL_PART_WHOLE);
}

handleStartOperation()

void inet::physicallayer::Radio::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // NOTE: we ignore radio mode switching during start
    initializeRadioMode();
}

handleStopOperation()

void inet::physicallayer::Radio::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // NOTE: we ignore radio mode switching and ongoing transmission during shutdown
    cancelEvent(switchTimer);
    if (transmissionTimer->isScheduled())
        abortTransmission();
    completeRadioModeSwitch(RADIO_MODE_OFF);
}

handleSwitchTimer()

void inet::physicallayer::Radio::handleSwitchTimer ( cMessage *  message )

protectedvirtual

{
    completeRadioModeSwitch(nextRadioMode);
}

Referenced by handleSelfMessage().

handleTransmissionTimer()

void inet::physicallayer::Radio::handleTransmissionTimer ( cMessage *  message )

protectedvirtual

{
    if (message->getKind() == IRadioSignal::SIGNAL_PART_WHOLE)
        endTransmission();
    else if (message->getKind() == IRadioSignal::SIGNAL_PART_PREAMBLE)
        continueTransmission();
    else if (message->getKind() == IRadioSignal::SIGNAL_PART_HEADER)
        continueTransmission();
    else if (message->getKind() == IRadioSignal::SIGNAL_PART_DATA)
        endTransmission();
    else
        throw cRuntimeError("Unknown self message");
}

Referenced by handleSelfMessage().

handleUpperCommand()

void inet::physicallayer::Radio::handleUpperCommand ( cMessage *  command )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

Reimplemented in inet::physicallayer::Ieee80211Radio, inet::physicallayer::NarrowbandRadioBase, and inet::physicallayer::FlatRadioBase.

{
    if (message->getKind() == RADIO_C_CONFIGURE) {
        ConfigureRadioCommand *configureCommand = check_and_cast<ConfigureRadioCommand *>(message->getControlInfo());
        if (configureCommand->getRadioMode() != -1)
            setRadioMode((RadioMode)configureCommand->getRadioMode());
        delete message;
    }
    else
        throw cRuntimeError("Unsupported command");
}

Referenced by inet::physicallayer::NarrowbandRadioBase::handleUpperCommand().

handleUpperPacket()

void inet::physicallayer::Radio::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

Reimplemented in inet::physicallayer::ApskRadio.

{
    emit(packetReceivedFromUpperSignal, packet);
    if (isTransmitterMode(radioMode)) {
        if (transmissionTimer->isScheduled())
            throw cRuntimeError("Received frame from upper layer while already transmitting.");
        if (separateTransmissionParts)
            startTransmission(packet, IRadioSignal::SIGNAL_PART_PREAMBLE);
        else
            startTransmission(packet, IRadioSignal::SIGNAL_PART_WHOLE);
    }
    else {
        EV_ERROR << "Radio is not in transmitter or transceiver mode, dropping frame." << endl;
        delete packet;
    }
}

Referenced by inet::physicallayer::ApskRadio::handleUpperPacket().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::physicallayer::PhysicalLayerBase.

Reimplemented in inet::physicallayer::Ieee80211Radio, and inet::physicallayer::ApskRadio.

{
    PhysicalLayerBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        switchTimer = new cMessage("switchTimer");
        transmissionTimer = new cMessage("transmissionTimer");
        antenna = check_and_cast<IAntenna *>(getSubmodule("antenna"));
        transmitter = check_and_cast<ITransmitter *>(getSubmodule("transmitter"));
        receiver = check_and_cast<IReceiver *>(getSubmodule("receiver"));
        medium.reference(this, "radioMediumModule", true);
        mediumModuleId = check_and_cast<cModule *>(medium.get())->getId();
        upperLayerIn = gate("upperLayerIn");
        upperLayerOut = gate("upperLayerOut");
        radioIn = gate("radioIn");
        radioIn->setDeliverImmediately(true);
        sendRawBytes = par("sendRawBytes");
        separateTransmissionParts = par("separateTransmissionParts");
        separateReceptionParts = par("separateReceptionParts");
        WATCH(radioMode);
        WATCH(receptionState);
        WATCH(transmissionState);
        WATCH(receivedSignalPart);
        WATCH(transmittedSignalPart);
    }
    else if (stage == INITSTAGE_PHYSICAL_LAYER) {
        medium->addRadio(this);
        if (medium->getCommunicationCache()->getNumTransmissions() == 0 && isListeningPossible())
            throw cRuntimeError("Receiver is busy without any ongoing transmission, probably energy detection level is too low or background noise level is too high");
        initializeRadioMode();
        parseRadioModeSwitchingTimes();
    }
    else if (stage == INITSTAGE_LAST) {
        EV_INFO << "Initialized " << getCompleteStringRepresentation() << endl;
    }
}

Referenced by inet::physicallayer::ApskRadio::initialize(), and inet::physicallayer::Ieee80211Radio::initialize().

initializeRadioMode()

void inet::physicallayer::Radio::initializeRadioMode ( )

protectedvirtual

                                {
    const char *initialRadioMode = par("initialRadioMode");
    if (!strcmp(initialRadioMode, "off"))
        completeRadioModeSwitch(IRadio::RADIO_MODE_OFF);
    else if (!strcmp(initialRadioMode, "sleep"))
        completeRadioModeSwitch(IRadio::RADIO_MODE_SLEEP);
    else if (!strcmp(initialRadioMode, "receiver"))
        completeRadioModeSwitch(IRadio::RADIO_MODE_RECEIVER);
    else if (!strcmp(initialRadioMode, "transmitter"))
        completeRadioModeSwitch(IRadio::RADIO_MODE_TRANSMITTER);
    else if (!strcmp(initialRadioMode, "transceiver"))
        completeRadioModeSwitch(IRadio::RADIO_MODE_TRANSCEIVER);
    else
        throw cRuntimeError("Unknown initialRadioMode");
}

Referenced by handleStartOperation(), and initialize().

isListeningPossible()

bool inet::physicallayer::Radio::isListeningPossible ( ) const

protectedvirtual

{
    const simtime_t now = simTime();
    const Coord& position = antenna->getMobility()->getCurrentPosition();
    // TODO use 2 * minInterferenceTime for lookahead? or maybe simply use 0 duration listening?
    const IListening *listening = receiver->createListening(this, now, now + 1E-12, position, position);
    const IListeningDecision *listeningDecision = medium->listenOnMedium(this, listening);
    bool isListeningPossible = listeningDecision->isListeningPossible();
    delete listening;
    delete listeningDecision;
    return isListeningPossible;
}

Referenced by initialize(), and updateTransceiverState().

isReceiverMode()

bool inet::physicallayer::Radio::isReceiverMode ( IRadio::RadioMode  radioMode ) const

protectedvirtual

{
    return radioMode == RADIO_MODE_RECEIVER || radioMode == RADIO_MODE_TRANSCEIVER;
}

Referenced by completeRadioModeSwitch(), continueReception(), endReception(), and startReception().

isReceptionTimer()

bool inet::physicallayer::Radio::isReceptionTimer ( const cMessage *  message ) const

protectedvirtual

{
    return !strcmp(message->getName(), "receptionTimer");
}

Referenced by handleMessageWhenDown(), and handleSelfMessage().

isTransmitterMode()

bool inet::physicallayer::Radio::isTransmitterMode ( IRadio::RadioMode  radioMode ) const

protectedvirtual

{
    return radioMode == RADIO_MODE_TRANSMITTER || radioMode == RADIO_MODE_TRANSCEIVER;
}

Referenced by completeRadioModeSwitch(), and handleUpperPacket().

parseRadioModeSwitchingTimes()

void inet::physicallayer::Radio::parseRadioModeSwitchingTimes ( )

private

{
    const char *times = par("switchingTimes");
 
    char prefix[3];
    unsigned int count = sscanf(times, "%s", prefix);
 
    if (count > 2)
        throw cRuntimeError("Metric prefix should be no more than two characters long");
 
    double metric = 1;
 
    if (strcmp("s", prefix) == 0)
        metric = 1;
    else if (strcmp("ms", prefix) == 0)
        metric = 0.001;
    else if (strcmp("ns", prefix) == 0)
        metric = 0.000000001;
    else
        throw cRuntimeError("Undefined or missed metric prefix for switchingTimes parameter");
 
    cStringTokenizer tok(times + count + 1);
    unsigned int idx = 0;
    while (tok.hasMoreTokens()) {
        switchingTimes[idx / RADIO_MODE_SWITCHING][idx % RADIO_MODE_SWITCHING] = atof(tok.nextToken()) * metric;
        idx++;
    }
    if (idx != RADIO_MODE_SWITCHING * RADIO_MODE_SWITCHING)
        throw cRuntimeError("Check your switchingTimes parameter! Some parameters may be missed");
}

Referenced by initialize().

printToStream()

std::ostream & inet::physicallayer::Radio::printToStream ( std::ostream &  stream, int  level, int  evFlags = 0  ) const

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

{
    stream << static_cast<const cSimpleModule *>(this);
    if (level <= PRINT_LEVEL_TRACE)
        stream << EV_FIELD(antenna, printFieldToString(antenna, level + 1, evFlags))
               << EV_FIELD(transmitter, printFieldToString(transmitter, level + 1, evFlags))
               << EV_FIELD(receiver, printFieldToString(receiver, level + 1, evFlags));
    return stream;
}

sendUp()

void inet::physicallayer::Radio::sendUp ( Packet *  macFrame )

protectedvirtual

Reimplemented in inet::physicallayer::ApskRadio.

{
    EV_INFO << "Sending up " << macFrame << endl;
    emit(packetSentToUpperSignal, macFrame);
    send(macFrame, upperLayerOut);
}

Referenced by endReception(), and inet::physicallayer::ApskRadio::sendUp().

setRadioMode()

void inet::physicallayer::Radio::setRadioMode ( RadioMode  radioMode )

overridevirtual

Changes the current radio mode.

The actual change may take zero or more time. The new radio mode will be emitted with a radioModeChangedSignal.

Implements inet::physicallayer::IRadio.

{
    Enter_Method("setRadioMode");
    if (newRadioMode < RADIO_MODE_OFF || newRadioMode > RADIO_MODE_SWITCHING)
        throw cRuntimeError("Unknown radio mode: %d", newRadioMode);
    else if (newRadioMode == RADIO_MODE_SWITCHING)
        throw cRuntimeError("Cannot switch manually to RADIO_MODE_SWITCHING");
    else if (radioMode == RADIO_MODE_SWITCHING || switchTimer->isScheduled())
        throw cRuntimeError("Cannot switch to a new radio mode while another switch is in progress");
    else if (newRadioMode != radioMode && newRadioMode != nextRadioMode) {
        simtime_t switchingTime = switchingTimes[radioMode][newRadioMode];
        if (switchingTime != 0)
            startRadioModeSwitch(newRadioMode, switchingTime);
        else
            completeRadioModeSwitch(newRadioMode);
    }
}

Referenced by handleUpperCommand().

startRadioModeSwitch()

void inet::physicallayer::Radio::startRadioModeSwitch ( RadioMode  newRadioMode, simtime_t  switchingTime  )

private

{
    EV_DETAIL << "Starting to change radio mode from \x1b[1m" << getRadioModeName(radioMode) << "\x1b[0m to \x1b[1m" << getRadioModeName(newRadioMode) << "\x1b[0m." << endl;
    previousRadioMode = radioMode;
    radioMode = RADIO_MODE_SWITCHING;
    nextRadioMode = newRadioMode;
    emit(radioModeChangedSignal, radioMode);
    scheduleAfter(switchingTime, switchTimer);
}

Referenced by setRadioMode().

startReception()

void inet::physicallayer::Radio::startReception ( cMessage *  timer, IRadioSignal::SignalPart  part  )

protectedvirtual

{
    auto signal = static_cast<WirelessSignal *>(timer->getControlInfo());
    auto arrival = signal->getArrival();
    auto reception = signal->getReception();
    // TODO should be this, but it breaks fingerprints: if (receptionTimer == nullptr && isReceiverMode(radioMode) && arrival->getStartTime(part) == simTime()) {
    if (isReceiverMode(radioMode) && arrival->getStartTime(part) == simTime()) {
        auto transmission = signal->getTransmission();
        auto isReceptionAttempted = medium->isReceptionAttempted(this, transmission, part);
        EV_INFO << "Reception started: " << (isReceptionAttempted ? "\x1b[1mattempting\x1b[0m" : "\x1b[1mnot attempting\x1b[0m") << " " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
        if (isReceptionAttempted) {
            receptionTimer = timer;
            emit(receptionStartedSignal, check_and_cast<const cObject *>(reception));
        }
    }
    else
        EV_INFO << "Reception started: \x1b[1mignoring\x1b[0m " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
    timer->setKind(part);
    scheduleAt(arrival->getEndTime(part), timer);
    updateTransceiverState();
    updateTransceiverPart();
    // TODO move to radio medium
    check_and_cast<RadioMedium *>(medium.get())->emit(IRadioMedium::signalArrivalStartedSignal, check_and_cast<const cObject *>(reception));
}

Referenced by handleSignal().

startTransmission()

void inet::physicallayer::Radio::startTransmission ( Packet *  macFrame, IRadioSignal::SignalPart  part  )

protectedvirtual

{
    auto signal = createSignal(macFrame);
    auto transmission = signal->getTransmission();
    transmissionTimer->setKind(part);
    transmissionTimer->setContextPointer(const_cast<WirelessSignal *>(signal));
 
#ifdef NS3_VALIDATION
    auto *df = dynamic_cast<inet::ieee80211::Ieee80211DataHeader *>(macFrame);
    const char *ac = "NA";
    if (df != nullptr && df->getType() == inet::ieee80211::ST_DATA_WITH_QOS) {
        switch (df->getTid()) {
            case 1: case 2: ac = "AC_BK"; break;
            case 0: case 3: ac = "AC_BE"; break;
            case 4: case 5: ac = "AC_VI"; break;
            case 6: case 7: ac = "AC_VO"; break;
            default: ac = "???"; break;
        }
    }
    const char *lastSeq = strchr(macFrame->getName(), '-');
    if (lastSeq == nullptr)
        lastSeq = "-1";
    else
        lastSeq++;
    std::cout << "TX: node = " << getId() << ", ac = " << ac << ", seq = " << lastSeq << ", start = " << simTime().inUnit(SIMTIME_PS) << ", duration = " << signal->getDuration().inUnit(SIMTIME_PS) << std::endl;
#endif
 
    scheduleAt(transmission->getEndTime(part), transmissionTimer);
    EV_INFO << "Transmission started: " << (IWirelessSignal *)signal << " " << IRadioSignal::getSignalPartName(part) << " as " << transmission << endl;
    updateTransceiverState();
    updateTransceiverPart();
    emit(transmissionStartedSignal, check_and_cast<const cObject *>(transmission));
    // TODO move to radio medium
    check_and_cast<RadioMedium *>(medium.get())->emit(IRadioMedium::signalDepartureStartedSignal, check_and_cast<const cObject *>(transmission));
}

Referenced by handleUpperPacket().

updateTransceiverPart()

void inet::physicallayer::Radio::updateTransceiverPart ( )

protectedvirtual

{
    IRadioSignal::SignalPart newReceivedPart = receptionTimer == nullptr ? IRadioSignal::SIGNAL_PART_NONE : (IRadioSignal::SignalPart)receptionTimer->getKind();
    if (receivedSignalPart != newReceivedPart) {
        EV_INFO << "Changing radio received signal part from \x1b[1m" << IRadioSignal::getSignalPartName(receivedSignalPart) << "\x1b[0m to \x1b[1m" << IRadioSignal::getSignalPartName(newReceivedPart) << "\x1b[0m." << endl;
        receivedSignalPart = newReceivedPart;
        emit(receivedSignalPartChangedSignal, receivedSignalPart);
    }
    IRadioSignal::SignalPart newTransmittedPart = !transmissionTimer->isScheduled() ? IRadioSignal::SIGNAL_PART_NONE : (IRadioSignal::SignalPart)transmissionTimer->getKind();
    if (transmittedSignalPart != newTransmittedPart) {
        EV_INFO << "Changing radio transmitted signal part from \x1b[1m" << IRadioSignal::getSignalPartName(transmittedSignalPart) << "\x1b[0m to \x1b[1m" << IRadioSignal::getSignalPartName(newTransmittedPart) << "\x1b[0m." << endl;
        transmittedSignalPart = newTransmittedPart;
        emit(transmittedSignalPartChangedSignal, transmittedSignalPart);
    }
}

Referenced by abortReception(), abortTransmission(), completeRadioModeSwitch(), continueReception(), continueTransmission(), endReception(), endTransmission(), startReception(), and startTransmission().

updateTransceiverState()

void inet::physicallayer::Radio::updateTransceiverState ( )

protectedvirtual

{
    // reception state
    ReceptionState newRadioReceptionState;
    if (radioMode == RADIO_MODE_OFF || radioMode == RADIO_MODE_SWITCHING || radioMode == RADIO_MODE_SLEEP || radioMode == RADIO_MODE_TRANSMITTER)
        newRadioReceptionState = RECEPTION_STATE_UNDEFINED;
    else if (receptionTimer && receptionTimer->isScheduled())
        newRadioReceptionState = RECEPTION_STATE_RECEIVING;
    else if (isListeningPossible())
        newRadioReceptionState = RECEPTION_STATE_BUSY;
    else
        newRadioReceptionState = RECEPTION_STATE_IDLE;
    if (receptionState != newRadioReceptionState) {
        EV_INFO << "Changing radio reception state from \x1b[1m" << getRadioReceptionStateName(receptionState) << "\x1b[0m to \x1b[1m" << getRadioReceptionStateName(newRadioReceptionState) << "\x1b[0m." << endl;
        receptionState = newRadioReceptionState;
        emit(receptionStateChangedSignal, newRadioReceptionState);
    }
    // transmission state
    TransmissionState newRadioTransmissionState;
    if (radioMode == RADIO_MODE_OFF || radioMode == RADIO_MODE_SWITCHING || radioMode == RADIO_MODE_SLEEP || radioMode == RADIO_MODE_RECEIVER)
        newRadioTransmissionState = TRANSMISSION_STATE_UNDEFINED;
    else if (transmissionTimer->isScheduled())
        newRadioTransmissionState = TRANSMISSION_STATE_TRANSMITTING;
    else
        newRadioTransmissionState = TRANSMISSION_STATE_IDLE;
    if (transmissionState != newRadioTransmissionState) {
        EV_INFO << "Changing radio transmission state from \x1b[1m" << getRadioTransmissionStateName(transmissionState) << "\x1b[0m to \x1b[1m" << getRadioTransmissionStateName(newRadioTransmissionState) << "\x1b[0m." << endl;
        transmissionState = newRadioTransmissionState;
        emit(transmissionStateChangedSignal, newRadioTransmissionState);
    }
}

Referenced by abortReception(), abortTransmission(), completeRadioModeSwitch(), continueReception(), continueTransmission(), endReception(), endTransmission(), startReception(), and startTransmission().

Member Data Documentation

antenna

const IAntenna* inet::physicallayer::Radio::antenna = nullptr

protected

The radio antenna model is never nullptr.

Referenced by initialize(), isListeningPossible(), and printToStream().

id

const int inet::physicallayer::Radio::id = nextId++

protected

An identifier which is globally unique for the whole lifetime of the simulation among all radios.

medium

ModuleRefByPar<IRadioMedium> inet::physicallayer::Radio::medium

protected

The radio medium model is never nullptr.

Referenced by continueReception(), createSignal(), endReception(), endTransmission(), initialize(), isListeningPossible(), startReception(), startTransmission(), and ~Radio().

mediumModuleId

int inet::physicallayer::Radio::mediumModuleId = -1

protected

The module id of the medim model.

Referenced by initialize(), and ~Radio().

nextRadioMode

RadioMode inet::physicallayer::Radio::nextRadioMode = RADIO_MODE_OFF

protected

The radio is switching to this radio radio mode if a switch is in progress, otherwise this is the same as the current radio mode.

Referenced by completeRadioModeSwitch(), handleSwitchTimer(), setRadioMode(), and startRadioModeSwitch().

previousRadioMode

RadioMode inet::physicallayer::Radio::previousRadioMode = RADIO_MODE_OFF

protected

The radio is switching from this radio mode to another if a switch is in progress, otherwise this is the same as the current radio mode.

Referenced by completeRadioModeSwitch(), and startRadioModeSwitch().

radioIn

cGate* inet::physicallayer::Radio::radioIn = nullptr

protected

Referenced by handleMessageWhenDown(), and initialize().

radioMode

RadioMode inet::physicallayer::Radio::radioMode = RADIO_MODE_OFF

protected

State.

The current radio mode.

Referenced by completeRadioModeSwitch(), continueReception(), endReception(), handleUpperPacket(), initialize(), isReceiverMode(), isTransmitterMode(), setRadioMode(), startRadioModeSwitch(), startReception(), and updateTransceiverState().

receivedSignalPart

IRadioSignal::SignalPart inet::physicallayer::Radio::receivedSignalPart = IRadioSignal::SIGNAL_PART_NONE

protected

The current received signal part.

Referenced by getReceivedSignalPart(), initialize(), and updateTransceiverPart().

receiver

const IReceiver* inet::physicallayer::Radio::receiver = nullptr

protected

The receiver model is never nullptr.

Referenced by inet::physicallayer::Ieee80211OfdmRadio::decapsulate(), initialize(), isListeningPossible(), printToStream(), inet::physicallayer::Ieee80211Radio::setBand(), inet::physicallayer::NarrowbandRadioBase::setBandwidth(), inet::physicallayer::NarrowbandRadioBase::setCenterFrequency(), inet::physicallayer::Ieee80211Radio::setChannel(), inet::physicallayer::Ieee80211Radio::setChannelNumber(), inet::physicallayer::Ieee80211Radio::setModeSet(), and inet::physicallayer::NarrowbandRadioBase::setModulation().

receptionState

ReceptionState inet::physicallayer::Radio::receptionState = RECEPTION_STATE_UNDEFINED

protected

The current reception state.

Referenced by initialize(), and updateTransceiverState().

receptionTimer

cMessage* inet::physicallayer::Radio::receptionTimer = nullptr

protected

The timer that is scheduled to the end of the current reception.

If this timer is nullptr then no attempted reception is in progress but there still may be incoming receptions which are not attempted.

Referenced by abortReception(), completeRadioModeSwitch(), continueReception(), endReception(), getReceptionInProgress(), handleSignal(), inet::physicallayer::Ieee80211Radio::setBand(), inet::physicallayer::NarrowbandRadioBase::setBandwidth(), inet::physicallayer::FlatRadioBase::setBitrate(), inet::physicallayer::Ieee80211Radio::setChannel(), inet::physicallayer::Ieee80211Radio::setChannelNumber(), inet::physicallayer::Ieee80211Radio::setMode(), inet::physicallayer::Ieee80211Radio::setModeSet(), startReception(), updateTransceiverPart(), and updateTransceiverState().

sendRawBytes

bool inet::physicallayer::Radio::sendRawBytes = false

protected

When true packets are serialized into a sequence of bytes before sending out.

Referenced by createSignal(), and initialize().

separateReceptionParts

bool inet::physicallayer::Radio::separateReceptionParts = false

protected

Determines whether the reception of the preamble, header and data part are simulated separately or not.

Referenced by handleSignal(), and initialize().

separateTransmissionParts

bool inet::physicallayer::Radio::separateTransmissionParts = false

protected

Determines whether the transmission of the preamble, header and data part are simulated separately or not.

Referenced by handleUpperPacket(), and initialize().

switchingTimes

simtime_t inet::physicallayer::Radio::switchingTimes[RADIO_MODE_SWITCHING][RADIO_MODE_SWITCHING]

protected

Simulation time required to switch from one radio mode to another.

Referenced by parseRadioModeSwitchingTimes(), and setRadioMode().

switchTimer

cMessage* inet::physicallayer::Radio::switchTimer = nullptr

protected

The timer that is scheduled to the end of the radio mode switch.

Referenced by handleCrashOperation(), handleSelfMessage(), handleStopOperation(), initialize(), setRadioMode(), startRadioModeSwitch(), and ~Radio().

transmissionState

TransmissionState inet::physicallayer::Radio::transmissionState = TRANSMISSION_STATE_UNDEFINED

protected

The current transmission state.

Referenced by initialize(), and updateTransceiverState().

transmissionTimer

cMessage* inet::physicallayer::Radio::transmissionTimer = nullptr

protected

The timer that is scheduled to the end of the current transmission.

If this timer is not scheduled then no transmission is in progress.

Referenced by abortTransmission(), completeRadioModeSwitch(), continueTransmission(), endTransmission(), getTransmissionInProgress(), handleCrashOperation(), handleSelfMessage(), handleStopOperation(), handleUpperPacket(), initialize(), startTransmission(), updateTransceiverPart(), updateTransceiverState(), and ~Radio().

transmittedSignalPart

IRadioSignal::SignalPart inet::physicallayer::Radio::transmittedSignalPart = IRadioSignal::SIGNAL_PART_NONE

protected

The current transmitted signal part.

Referenced by getTransmittedSignalPart(), initialize(), and updateTransceiverPart().

transmitter

const ITransmitter* inet::physicallayer::Radio::transmitter = nullptr

protected

The transmitter model is never nullptr.

Referenced by inet::physicallayer::ApskRadio::decapsulate(), inet::physicallayer::UnitDiskRadio::encapsulate(), inet::physicallayer::Ieee80211OfdmRadio::encapsulate(), inet::physicallayer::ApskRadio::encapsulate(), inet::physicallayer::Ieee80211Radio::encapsulate(), inet::physicallayer::ApskRadio::getModulation(), initialize(), printToStream(), inet::physicallayer::Ieee80211Radio::setBand(), inet::physicallayer::NarrowbandRadioBase::setBandwidth(), inet::physicallayer::FlatRadioBase::setBitrate(), inet::physicallayer::NarrowbandRadioBase::setCenterFrequency(), inet::physicallayer::Ieee80211Radio::setChannel(), inet::physicallayer::Ieee80211Radio::setChannelNumber(), inet::physicallayer::Ieee80211Radio::setMode(), inet::physicallayer::Ieee80211Radio::setModeSet(), inet::physicallayer::NarrowbandRadioBase::setModulation(), and inet::physicallayer::FlatRadioBase::setPower().

upperLayerIn

cGate* inet::physicallayer::Radio::upperLayerIn = nullptr

protected

Referenced by initialize().

upperLayerOut

cGate* inet::physicallayer::Radio::upperLayerOut = nullptr

protected

Gates.

Referenced by initialize(), and sendUp().

---

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

• Radio.h
• Radio.cc