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:

Public Member Functions
	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) 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 radio frames. 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...
Public Member Functions inherited from inet::PhysicalLayerBase
	PhysicalLayerBase ()
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IPhysicalLayer
virtual	~IPhysicalLayer ()
Public Member Functions inherited from inet::physicallayer::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	getInfoStringRepresentation () const
virtual std::string	getDetailStringRepresentation () const
virtual std::string	getDebugStringRepresentation () const
virtual std::string	getTraceStringRepresentation () const
virtual std::string	getCompleteStringRepresentation () const

Static Public Attributes
static simsignal_t	minSNIRSignal = cComponent::registerSignal("minSNIR")
static simsignal_t	packetErrorRateSignal = cComponent::registerSignal("packetErrorRate")
static simsignal_t	bitErrorRateSignal = cComponent::registerSignal("bitErrorRate")
static simsignal_t	symbolErrorRateSignal = cComponent::registerSignal("symbolErrorRate")
Static Public Attributes inherited from inet::physicallayer::IRadio
static simsignal_t	radioModeChangedSignal = cComponent::registerSignal("radioModeChanged")
	This signal is emitted every time the radio mode changes. More...
static simsignal_t	listeningChangedSignal = cComponent::registerSignal("listeningChanged")
	This signal is emitted every time the radio listening changes. More...
static simsignal_t	receptionStateChangedSignal = cComponent::registerSignal("receptionStateChanged")
	This signal is emitted every time the radio reception state changes. More...
static simsignal_t	transmissionStateChangedSignal = cComponent::registerSignal("transmissionStateChanged")
	This signal is emitted every time the radio transmission state changes. More...
static simsignal_t	receivedSignalPartChangedSignal = cComponent::registerSignal("receivedSignalPartChanged")
	This signal is emitted every time the received part changes. More...
static simsignal_t	transmittedSignalPartChangedSignal = cComponent::registerSignal("transmittedSignalPartChanged")
	This signal is emitted every time the transmitted part changes. More...

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	handleMessageWhenDown (cMessage *message) override
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleSelfMessage (cMessage *message)
virtual void	handleSwitchTimer (cMessage *message)
virtual void	handleTransmissionTimer (cMessage *message)
virtual void	handleReceptionTimer (cMessage *message)
virtual void	handleUpperCommand (cMessage *command)
virtual void	handleLowerCommand (cMessage *command)
virtual void	handleUpperPacket (cPacket *packet)
virtual void	handleLowerPacket (RadioFrame *packet)
virtual bool	handleNodeStart (IDoneCallback *doneCallback) override
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback) override
virtual void	handleNodeCrash () override
virtual void	startTransmission (cPacket *macFrame, IRadioSignal::SignalPart part)
virtual void	continueTransmission ()
virtual void	endTransmission ()
virtual void	abortTransmission ()
virtual RadioFrame *	createRadioFrame (cPacket *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 (cPacket *macFrame)
virtual cMessage *	createReceptionTimer (RadioFrame *radioFrame) 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 ()
Protected Member Functions inherited from inet::PhysicalLayerBase
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::OperationalBase
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	setOperational (bool isOperational)

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...
IRadioMedium *	medium = nullptr
	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	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...
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...
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Private Member Functions
void	parseRadioModeSwitchingTimes ()
void	startRadioModeSwitch (RadioMode newRadioMode, simtime_t switchingTime)
void	completeRadioModeSwitch (RadioMode newRadioMode)

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::physicallayer::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }
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 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 received packet can have a TransmissionRequest attached as a control info object. 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 radio frame. The radio must be in receiver or transceiver mode before the message arrives, otherwise it just ignores the message. 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. The radio also attaches a ReceptionIndication as a control info object. Finally, the radio changes its receiver state to the appropriate value, and emits a receiver state changed signal.

Constructor & Destructor Documentation

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

inline

{ }

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

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

protectedvirtual

Referenced by completeRadioModeSwitch().

{
    auto radioFrame = static_cast<RadioFrame *>(timer->getControlInfo());
    auto part = (IRadioSignal::SignalPart)timer->getKind();
    auto reception = radioFrame->getReception();
    EV_INFO << "Reception aborted: for " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
    if (timer == receptionTimer)
        receptionTimer = nullptr;
    updateTransceiverState();
    updateTransceiverPart();
}

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

protectedvirtual

Referenced by completeRadioModeSwitch(), handleNodeCrash(), and handleNodeShutdown().

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

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");
}

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

private

Referenced by handleNodeCrash(), handleNodeShutdown(), handleNodeStart(), handleSwitchTimer(), and setRadioMode().

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

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

protectedvirtual

Referenced by handleReceptionTimer().

{
    auto previousPart = (IRadioSignal::SignalPart)timer->getKind();
    auto nextPart = (IRadioSignal::SignalPart)(previousPart + 1);
    auto radioFrame = static_cast<RadioFrame *>(timer->getControlInfo());
    auto arrival = radioFrame->getArrival();
    auto reception = radioFrame->getReception();
    if (timer == receptionTimer && isReceiverMode(radioMode) && arrival->getEndTime(previousPart) == simTime()) {
        auto transmission = radioFrame->getTransmission();
        bool isReceptionSuccessful = medium->isReceptionSuccessful(this, transmission, previousPart);
        EV_INFO << "Reception ended: " << (isReceptionSuccessful ? "successfully" : "unsuccessfully") << " for " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(previousPart) << " as " << reception << endl;
        if (!isReceptionSuccessful)
            receptionTimer = nullptr;
        auto isReceptionAttempted = medium->isReceptionAttempted(this, transmission, nextPart);
        EV_INFO << "Reception started: " << (isReceptionAttempted ? "attempting" : "not attempting") << " " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(nextPart) << " as " << reception << endl;
        if (!isReceptionAttempted)
            receptionTimer = nullptr;
    }
    else {
        EV_INFO << "Reception ended: ignoring " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(previousPart) << " as " << reception << endl;
        EV_INFO << "Reception started: ignoring " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(nextPart) << " as " << reception << endl;
    }
    timer->setKind(nextPart);
    scheduleAt(arrival->getEndTime(nextPart), timer);
    updateTransceiverState();
    updateTransceiverPart();
}

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

protectedvirtual

Referenced by handleTransmissionTimer().

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

RadioFrame * inet::physicallayer::Radio::createRadioFrame ( cPacket *  packet ) const

protectedvirtual

Referenced by startTransmission().

{
    RadioFrame *radioFrame = check_and_cast<RadioFrame *>(medium->transmitPacket(this, packet));
    ASSERT(radioFrame->getDuration() != 0);
    return radioFrame;
}

cMessage * inet::physicallayer::Radio::createReceptionTimer ( RadioFrame *  radioFrame ) const

protectedvirtual

Referenced by handleLowerPacket().

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

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

protectedvirtual

Referenced by handleReceptionTimer().

{
    auto part = (IRadioSignal::SignalPart)timer->getKind();
    auto radioFrame = static_cast<RadioFrame *>(timer->getControlInfo());
    auto arrival = radioFrame->getArrival();
    auto reception = radioFrame->getReception();
    if (timer == receptionTimer && isReceiverMode(radioMode) && arrival->getEndTime() == simTime()) {
        auto transmission = radioFrame->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, radioFrame->getListening(), transmission, part)->isReceptionSuccessful();
        EV_INFO << "Reception ended: " << (isReceptionSuccessful ? "successfully" : "unsuccessfully") << " for " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
        auto macFrame = medium->receivePacket(this, radioFrame);
        emit(LayeredProtocolBase::packetSentToUpperSignal, macFrame);
        sendUp(macFrame);
        receptionTimer = nullptr;
    }
    else
        EV_INFO << "Reception ended: ignoring " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
    updateTransceiverState();
    updateTransceiverPart();
    check_and_cast<RadioMedium *>(medium)->emit(IRadioMedium::receptionEndedSignal, check_and_cast<const cObject *>(reception));
    delete timer;
}

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

protectedvirtual

Referenced by handleTransmissionTimer().

{
    auto part = (IRadioSignal::SignalPart)transmissionTimer->getKind();
    auto radioFrame = static_cast<RadioFrame *>(transmissionTimer->getContextPointer());
    auto transmission = radioFrame->getTransmission();
    transmissionTimer->setContextPointer(nullptr);
    EV_INFO << "Transmission ended: " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << transmission << endl;
    updateTransceiverState();
    updateTransceiverPart();
    check_and_cast<RadioMedium *>(medium)->emit(IRadioMedium::transmissionEndedSignal, check_and_cast<const cObject *>(transmission));
}

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; }

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.

Referenced by initialize(), startTransmission(), and inet::physicallayer::CommunicationLog::writeTransmission().

{ return id; }

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; }

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

inlineoverridevirtual

Returns the gate of the radio that receives incoming radio frames.

Implements inet::physicallayer::IRadio.

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

{ return radioIn; }

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.

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

{ return radioMode; }

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;
}

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.

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

{ return receiver; }

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<RadioFrame *>(receptionTimer->getControlInfo())->getTransmission();
}

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; }

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<RadioFrame *>(transmissionTimer->getContextPointer())->getTransmission();
}

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; }

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;
}

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; }

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

protectedvirtual

Referenced by handleMessageWhenUp().

{
    throw cRuntimeError("Unsupported command");
}

void inet::physicallayer::Radio::handleLowerPacket ( RadioFrame *  packet )

protectedvirtual

Referenced by handleMessageWhenUp().

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

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

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

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

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

overrideprotectedvirtual

Implements inet::OperationalBase.

{
    if (message->isSelfMessage())
        handleSelfMessage(message);
    else if (message->getArrivalGate() == upperLayerIn) {
        if (!message->isPacket()) {
            handleUpperCommand(message);
            delete message;
        }
        else
            handleUpperPacket(check_and_cast<cPacket *>(message));
    }
    else if (message->getArrivalGate() == radioIn) {
        if (!message->isPacket()) {
            handleLowerCommand(message);
            delete message;
        }
        else
            handleLowerPacket(check_and_cast<RadioFrame *>(message));
    }
    else
        throw cRuntimeError("Unknown arrival gate '%s'.", message->getArrivalGate()->getFullName());
}

void inet::physicallayer::Radio::handleNodeCrash ( )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

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

bool inet::physicallayer::Radio::handleNodeShutdown ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

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

bool inet::physicallayer::Radio::handleNodeStart ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    // NOTE: we ignore radio mode switching during start
    completeRadioModeSwitch(RADIO_MODE_OFF);
    return PhysicalLayerBase::handleNodeStart(doneCallback);
}

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

protectedvirtual

Referenced by handleSelfMessage().

{
    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");
}

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

protectedvirtual

Referenced by handleMessageWhenUp().

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

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

protectedvirtual

Referenced by handleSelfMessage().

{
    completeRadioModeSwitch(nextRadioMode);
}

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

protectedvirtual

Referenced by handleSelfMessage().

{
    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");
}

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

protectedvirtual

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

Referenced by handleMessageWhenUp(), and inet::physicallayer::NarrowbandRadioBase::handleUpperCommand().

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

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

protectedvirtual

Referenced by handleMessageWhenUp().

{
    emit(LayeredProtocolBase::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;
    }
}

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

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Reimplemented in inet::physicallayer::Ieee80211Radio.

Referenced by inet::physicallayer::Ieee80211Radio::initialize().

{
    PhysicalLayerBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        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 = getModuleFromPar<IRadioMedium>(par("radioMediumModule"), this);
        mediumModuleId = check_and_cast<cModule *>(medium)->getId();
        upperLayerIn = gate("upperLayerIn");
        upperLayerOut = gate("upperLayerOut");
        radioIn = gate("radioIn");
        radioIn->setDeliverOnReceptionStart(true);
        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);
        switchTimer = new cMessage("switchTimer");
        parseRadioModeSwitchingTimes();
    }
    else if (stage == INITSTAGE_LAST) {
        EV_INFO << "Initialized " << getCompleteStringRepresentation() << endl;
    }
}

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

protectedvirtual

Referenced by updateTransceiverState().

{
    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;
}

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

protectedvirtual

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

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

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

protectedvirtual

Referenced by handleMessageWhenDown(), and handleSelfMessage().

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

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

protectedvirtual

Referenced by completeRadioModeSwitch(), and handleUpperPacket().

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

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

private

Referenced by initialize().

{
    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");
}

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

overridevirtual

Prints this object to the provided output stream.

Function calls to operator<< with pointers or references either const or not are all forwarded to this function.

Reimplemented from inet::physicallayer::IPrintableObject.

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

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

protectedvirtual

Referenced by endReception().

{
    auto indication = check_and_cast<const ReceptionIndication *>(macFrame->getControlInfo());
    emit(minSNIRSignal, indication->getMinSNIR());
    if (!std::isnan(indication->getPacketErrorRate()))
        emit(packetErrorRateSignal, indication->getPacketErrorRate());
    if (!std::isnan(indication->getBitErrorRate()))
        emit(bitErrorRateSignal, indication->getBitErrorRate());
    if (!std::isnan(indication->getSymbolErrorRate()))
        emit(symbolErrorRateSignal, indication->getSymbolErrorRate());
    EV_INFO << "Sending up " << macFrame << endl;
    send(macFrame, upperLayerOut);
}

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.

Referenced by handleUpperCommand().

{
    Enter_Method_Silent();
    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);
    }
}

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

private

Referenced by setRadioMode().

{
    EV_DETAIL << "Starting to change radio mode from " << getRadioModeName(radioMode) << " to " << getRadioModeName(newRadioMode) << endl;
    previousRadioMode = radioMode;
    radioMode = RADIO_MODE_SWITCHING;
    nextRadioMode = newRadioMode;
    emit(radioModeChangedSignal, radioMode);
    scheduleAt(simTime() + switchingTime, switchTimer);
}

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

protectedvirtual

Referenced by handleLowerPacket().

{
    auto radioFrame = static_cast<RadioFrame *>(timer->getControlInfo());
    auto arrival = radioFrame->getArrival();
    auto reception = radioFrame->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 = radioFrame->getTransmission();
        auto isReceptionAttempted = medium->isReceptionAttempted(this, transmission, part);
        EV_INFO << "Reception started: " << (isReceptionAttempted ? "attempting" : "not attempting") << " " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
        if (isReceptionAttempted)
            receptionTimer = timer;
    }
    else
        EV_INFO << "Reception started: ignoring " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << reception << endl;
    timer->setKind(part);
    scheduleAt(arrival->getEndTime(part), timer);
    updateTransceiverState();
    updateTransceiverPart();
    check_and_cast<RadioMedium *>(medium)->emit(IRadioMedium::receptionStartedSignal, check_and_cast<const cObject *>(reception));
}

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

protectedvirtual

Referenced by handleUpperPacket().

{
    auto radioFrame = createRadioFrame(macFrame);
    auto transmission = radioFrame->getTransmission();
    transmissionTimer->setKind(part);
    transmissionTimer->setContextPointer(const_cast<RadioFrame *>(radioFrame));

#ifdef NS3_VALIDATION
    auto *df = dynamic_cast<inet::ieee80211::Ieee80211DataFrame *>(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 = " << radioFrame->getDuration().inUnit(SIMTIME_PS) << std::endl;
#endif

    scheduleAt(transmission->getEndTime(part), transmissionTimer);
    EV_INFO << "Transmission started: " << (IRadioFrame *)radioFrame << " " << IRadioSignal::getSignalPartName(part) << " as " << transmission << endl;
    updateTransceiverState();
    updateTransceiverPart();
    check_and_cast<RadioMedium *>(medium)->emit(IRadioMedium::transmissionStartedSignal, check_and_cast<const cObject *>(transmission));
}

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

protectedvirtual

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

{
    IRadioSignal::SignalPart newReceivedPart = receptionTimer == nullptr ? IRadioSignal::SIGNAL_PART_NONE : (IRadioSignal::SignalPart)receptionTimer->getKind();
    if (receivedSignalPart != newReceivedPart) {
        EV_INFO << "Changing radio received signal part from " << IRadioSignal::getSignalPartName(receivedSignalPart) << " to " << IRadioSignal::getSignalPartName(newReceivedPart) << "." << 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 " << IRadioSignal::getSignalPartName(transmittedSignalPart) << " to " << IRadioSignal::getSignalPartName(newTransmittedPart) << "." << endl;
        transmittedSignalPart = newTransmittedPart;
        emit(transmittedSignalPartChangedSignal, transmittedSignalPart);
    }
}

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

protectedvirtual

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

{
    // reception state
    ReceptionState newRadioReceptionState;
    if (radioMode == RADIO_MODE_OFF || 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 " << getRadioReceptionStateName(receptionState) << " to " << getRadioReceptionStateName(newRadioReceptionState) << "." << endl;
        receptionState = newRadioReceptionState;
        emit(receptionStateChangedSignal, newRadioReceptionState);
    }
    // transmission state
    TransmissionState newRadioTransmissionState;
    if (radioMode == RADIO_MODE_OFF || 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 " << getRadioTransmissionStateName(transmissionState) << " to " << getRadioTransmissionStateName(newRadioTransmissionState) << "." << endl;
        transmissionState = newRadioTransmissionState;
        emit(transmissionStateChangedSignal, newRadioTransmissionState);
    }
}

Member Data Documentation

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

protected

The radio antenna model is never nullptr.

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

simsignal_t inet::physicallayer::Radio::bitErrorRateSignal = cComponent::registerSignal("bitErrorRate")

static

Referenced by sendUp().

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

protected

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

IRadioMedium* inet::physicallayer::Radio::medium = nullptr

protected

The radio medium model is never nullptr.

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

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

protected

The module id of the medim model.

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

simsignal_t inet::physicallayer::Radio::minSNIRSignal = cComponent::registerSignal("minSNIR")

static

Referenced by sendUp().

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().

simsignal_t inet::physicallayer::Radio::packetErrorRateSignal = cComponent::registerSignal("packetErrorRate")

static

Referenced by sendUp().

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().

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

protected

Referenced by handleMessageWhenDown(), handleMessageWhenUp(), and initialize().

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

protected

State.

The current radio mode.

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

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

protected

The current received signal part.

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

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

protected

The receiver model is never nullptr.

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

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

protected

The current reception state.

Referenced by initialize(), and updateTransceiverState().

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(), handleLowerPacket(), 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().

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 handleLowerPacket(), and initialize().

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().

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().

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

protected

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

Referenced by handleNodeCrash(), handleNodeShutdown(), handleSelfMessage(), initialize(), setRadioMode(), startRadioModeSwitch(), and ~Radio().

simsignal_t inet::physicallayer::Radio::symbolErrorRateSignal = cComponent::registerSignal("symbolErrorRate")

static

Referenced by sendUp().

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

protected

The current transmission state.

Referenced by initialize(), and updateTransceiverState().

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(), handleNodeCrash(), handleNodeShutdown(), handleSelfMessage(), handleUpperPacket(), initialize(), startTransmission(), updateTransceiverPart(), updateTransceiverState(), and ~Radio().

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

protected

The current transmitted signal part.

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

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

protected

The transmitter model is never nullptr.

Referenced by initialize(), printToStream(), inet::physicallayer::Ieee80211Radio::setBand(), inet::physicallayer::NarrowbandRadioBase::setBandwidth(), inet::physicallayer::FlatRadioBase::setBitrate(), inet::physicallayer::NarrowbandRadioBase::setCarrierFrequency(), 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().

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

protected

Referenced by handleMessageWhenUp(), and initialize().

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