#include <Ieee80211LayeredOFDMTransmitter.h>

Inheritance diagram for inet::physicallayer::Ieee80211LayeredOFDMTransmitter:

Public Types
enum	LevelOfDetail { PACKET_DOMAIN, BIT_DOMAIN, SYMBOL_DOMAIN, SAMPLE_DOMAIN }

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 }

Public Member Functions
virtual	~Ieee80211LayeredOFDMTransmitter ()

virtual const ITransmission *	createTransmission (const IRadio radio, const cPacket packet, const simtime_t startTime) const override
	Returns a transmission which describes the radio signal corresponding to the provided mac frame. More...

virtual const IEncoder *	getEncoder () const

virtual const IModulator *	getModulator () const

virtual const IPulseShaper *	getPulseShaper () const

virtual const IDigitalAnalogConverter *	getDigitalAnalogConverter () const

virtual W	getMaxPower () const override
	Returns the maximum transmission power above which no transmission is ever transmitted. More...

virtual m	getMaxCommunicationRange () const override
	Returns the maximum transmission range. More...

virtual m	getMaxInterferenceRange () const override
	Returns the maximum interference range. More...

const Hz	getBandwidth () const

const Hz	getCarrierFrequency () const

const Hz	getCarrierSpacing () const

virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...

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

Protected Member Functions
virtual void	initialize (int stage) override

const ITransmissionPacketModel *	createSignalFieldPacketModel (const ITransmissionPacketModel *completePacketModel) const

const ITransmissionPacketModel *	createDataFieldPacketModel (const ITransmissionPacketModel *completePacketModel) const

virtual const ITransmissionPacketModel *	createPacketModel (const cPacket *macFrame) const

const ITransmissionSymbolModel *	createSymbolModel (const ITransmissionSymbolModel signalFieldSymbolModel, const ITransmissionSymbolModel dataFieldSymbolModel) const

const ITransmissionBitModel *	createBitModel (const ITransmissionBitModel signalFieldBitModel, const ITransmissionBitModel dataFieldBitModel, const ITransmissionPacketModel *packetModel) const

void	encodeAndModulate (const ITransmissionPacketModel packetModel, const ITransmissionBitModel &fieldBitModel, const ITransmissionSymbolModel &fieldSymbolModel, const IEncoder encoder, const IModulator *modulator, bool isSignalField) const

const ITransmissionSampleModel *	createSampleModel (const ITransmissionSymbolModel *symbolModel) const

const ITransmissionAnalogModel *	createAnalogModel (const ITransmissionPacketModel packetModel, const ITransmissionBitModel bitModel, const ITransmissionSymbolModel symbolModel, const ITransmissionSampleModel sampleModel) const

const ITransmissionAnalogModel *	createScalarAnalogModel (const ITransmissionPacketModel packetModel, const ITransmissionBitModel bitModel) const

BitVector *	serialize (const cPacket *packet) const

void	appendPadding (BitVector *serializedPacket, unsigned int length) const

const Ieee80211OFDMMode *	computeMode (Hz bandwidth) const

Protected Member Functions inherited from inet::physicallayer::TransmitterBase
virtual int	numInitStages () const override

Protected Attributes
LevelOfDetail	levelOfDetail

const Ieee80211OFDMMode *	mode = nullptr

const IEncoder *	signalEncoder = nullptr

const IEncoder *	dataEncoder = nullptr

const IModulator *	signalModulator = nullptr

const IModulator *	dataModulator = nullptr

const IPulseShaper *	pulseShaper = nullptr

const IDigitalAnalogConverter *	digitalAnalogConverter = nullptr

bool	isCompliant

Hz	bandwidth

Hz	channelSpacing

Hz	carrierFrequency

W	power

Member Enumeration Documentation

enum inet::physicallayer::Ieee80211LayeredOFDMTransmitter::LevelOfDetail

Enumerator
PACKET_DOMAIN
BIT_DOMAIN
SYMBOL_DOMAIN
SAMPLE_DOMAIN

                        {
         PACKET_DOMAIN,
         BIT_DOMAIN,
         SYMBOL_DOMAIN,
         SAMPLE_DOMAIN,
     };

Constructor & Destructor Documentation

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::~Ieee80211LayeredOFDMTransmitter ( )

virtual

 {
     if (!isCompliant) {
         delete mode->getDataMode()->getModulation();
         delete mode->getSignalMode()->getModulation();
         delete mode->getPreambleMode();
         delete mode->getSignalMode();
         delete mode->getDataMode();
         delete mode;
     }
 }

Member Function Documentation

void inet::physicallayer::Ieee80211LayeredOFDMTransmitter::appendPadding	(	BitVector *	serializedPacket,
		unsigned int	length
	)		const

protected

 {
     // 18.3.5.4 Pad bits (PAD), 1597p.
     // TODO: in non-compliant mode: header padding.
     unsigned int codedBitsPerOFDMSymbol = mode->getDataMode()->getModulation()->getSubcarrierModulation()->getCodeWordSize() * NUMBER_OF_OFDM_DATA_SUBCARRIERS;
     const Ieee80211OFDMCode *code = mode->getDataMode()->getCode();
     unsigned int dataBitsPerOFDMSymbol = codedBitsPerOFDMSymbol; // N_DBPS
     if (code->getConvolutionalCode()) {
         const ConvolutionalCode *convolutionalCode = code->getConvolutionalCode();
         dataBitsPerOFDMSymbol = convolutionalCode->getDecodedLength(codedBitsPerOFDMSymbol);
     }
     unsigned int dataBitsLength = 6 + length * 8 + 16;
     unsigned int numberOfOFDMSymbols = lrint(ceil(1.0*dataBitsLength / dataBitsPerOFDMSymbol));
     unsigned int numberOfBitsInTheDataField = dataBitsPerOFDMSymbol * numberOfOFDMSymbols; // N_DATA
     unsigned int numberOfPadBits = numberOfBitsInTheDataField - dataBitsLength; // N_PAD
     serializedPacket->appendBit(0, numberOfPadBits);
 }

const Ieee80211OFDMMode * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::computeMode ( Hz bandwidth ) const

protected

 {
     const Ieee80211OFDMEncoderModule *ofdmSignalEncoderModule = check_and_cast<const Ieee80211OFDMEncoderModule *>(signalEncoder);
     const Ieee80211OFDMEncoderModule *ofdmDataEncoderModule = check_and_cast<const Ieee80211OFDMEncoderModule *>(dataEncoder);
     const Ieee80211OFDMModulatorModule *ofdmSignalModulatorModule = check_and_cast<const Ieee80211OFDMModulatorModule *>(signalModulator);
     const Ieee80211OFDMModulatorModule *ofdmDataModulatorModule = check_and_cast<const Ieee80211OFDMModulatorModule *>(dataModulator);
     const Ieee80211OFDMSignalMode *signalMode = new Ieee80211OFDMSignalMode(ofdmSignalEncoderModule->getCode(), ofdmSignalModulatorModule->getModulation(), channelSpacing, bandwidth, 0);
     const Ieee80211OFDMDataMode *dataMode = new Ieee80211OFDMDataMode(ofdmDataEncoderModule->getCode(), ofdmDataModulatorModule->getModulation(), channelSpacing, bandwidth);
     return new Ieee80211OFDMMode("", new Ieee80211OFDMPreambleMode(channelSpacing), signalMode, dataMode, channelSpacing, bandwidth);
 }

const ITransmissionAnalogModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createAnalogModel	(	const ITransmissionPacketModel *	packetModel,
		const ITransmissionBitModel *	bitModel,
		const ITransmissionSymbolModel *	symbolModel,
		const ITransmissionSampleModel *	sampleModel
	)		const

protected

 {
     const ITransmissionAnalogModel *analogModel = nullptr;
     if (digitalAnalogConverter) {
         if (!sampleModel)
             analogModel = digitalAnalogConverter->convertDigitalToAnalog(sampleModel);
         else
             throw cRuntimeError("Digital/analog converter needs sample representation");
     }
     else // TODO: Analog model is obligatory, currently we use scalar analog model as default analog model
         analogModel = createScalarAnalogModel(packetModel, bitModel);
     return analogModel;
 }

const ITransmissionBitModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createBitModel	(	const ITransmissionBitModel *	signalFieldBitModel,
		const ITransmissionBitModel *	dataFieldBitModel,
		const ITransmissionPacketModel *	packetModel
	)		const

protected

 {
     if (levelOfDetail >= BIT_DOMAIN) {
         BitVector *encodedBits = new BitVector(*signalFieldBitModel->getBits());
         unsigned int signalBitLength = signalFieldBitModel->getBits()->getSize();
         const BitVector *dataFieldBits = dataFieldBitModel->getBits();
         unsigned int dataBitLength = dataFieldBits->getSize();
         for (unsigned int i = 0; i < dataFieldBits->getSize(); i++)
             encodedBits->appendBit(dataFieldBits->getBit(i));
         const TransmissionBitModel *transmissionBitModel = new TransmissionBitModel(signalBitLength, mode->getSignalMode()->getGrossBitrate(), dataBitLength, mode->getDataMode()->getGrossBitrate(), encodedBits, dataFieldBitModel->getForwardErrorCorrection(), dataFieldBitModel->getScrambling(), dataFieldBitModel->getInterleaving());
         delete signalFieldBitModel;
         delete dataFieldBitModel;
         return transmissionBitModel;
     }
     // TODO
     return new TransmissionBitModel(-1, mode->getSignalMode()->getGrossBitrate(), -1, mode->getDataMode()->getGrossBitrate(), nullptr, nullptr, nullptr, nullptr);
 }

const ITransmissionPacketModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createDataFieldPacketModel ( const ITransmissionPacketModel * completePacketModel ) const

protected

 {
     BitVector *dataField = new BitVector();
     const BitVector *serializedPacket = completePacketModel->getSerializedPacket();
     for (unsigned int i = NUMBER_OF_OFDM_DATA_SUBCARRIERS / 2; i < serializedPacket->getSize(); i++)
         dataField->appendBit(serializedPacket->getBit(i));
     return new TransmissionPacketModel(nullptr, dataField, bps(NaN));
 }

const ITransmissionPacketModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createPacketModel ( const cPacket * macFrame ) const

protectedvirtual

 {
     // The PLCP header is composed of RATE (4), Reserved (1), LENGTH (12), Parity (1),
     // Tail (6) and SERVICE (16) fields.
     int plcpHeaderLength = 4 + 1 + 12 + 1 + 6 + 16;
     Ieee80211OFDMPLCPFrame *phyFrame = new Ieee80211OFDMPLCPFrame();
     phyFrame->setName(macFrame->getName());
     phyFrame->setRate(mode->getSignalMode()->getRate());
     phyFrame->setLength(macFrame->getByteLength());
     phyFrame->encapsulate(const_cast<cPacket *>(macFrame));
     phyFrame->setBitLength(phyFrame->getLength() * 8 + plcpHeaderLength);
     BitVector *serializedPacket = serialize(phyFrame);
     return new TransmissionPacketModel(phyFrame, serializedPacket, mode->getDataMode()->getNetBitrate());
 }

const ITransmissionSampleModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createSampleModel ( const ITransmissionSymbolModel * symbolModel ) const

protected

 {
     if (levelOfDetail >= SAMPLE_DOMAIN) {
         throw cRuntimeError("This level of detail is unimplemented.");
 //        if (symbolModel)
 //        {
 //            if (pulseShaper) // non-compliant mode
 //                sampleModel = pulseShaper->shape(symbolModel);
 //            else // compliant mode
 //            {
 //            }
 //        }
 //        else
 //            throw cRuntimeError("Pulse shaper needs symbol representation");
     }
     else
         return nullptr;
 }

const ITransmissionAnalogModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createScalarAnalogModel	(	const ITransmissionPacketModel *	packetModel,
		const ITransmissionBitModel *	bitModel
	)		const

protected

 {
     int headerBitLength = -1;
     int dataBitLength = -1;
     if (levelOfDetail > PACKET_DOMAIN) {
         headerBitLength = bitModel->getHeaderBitLength();
         dataBitLength = bitModel->getPayloadBitLength();
     }
     else {
         if (isCompliant) {
             const ConvolutionalCode *convolutionalCode = mode->getDataMode()->getCode()->getConvolutionalCode();
             headerBitLength = ENCODED_SIGNAL_FIELD_LENGTH;
             dataBitLength = convolutionalCode->getEncodedLength((packetModel->getSerializedPacket()->getSize() - DECODED_SIGNAL_FIELD_LENGTH));
         }
         else {
             throw cRuntimeError("Unimplemented");
         }
     }
     simtime_t preambleDuration = mode->getPreambleMode()->getDuration();
     simtime_t headerDuration = 0;
     if (!isCompliant) {
         unsigned int headerCodeWordSize = mode->getSignalMode()->getModulation()->getSubcarrierModulation()->getCodeWordSize();
         ASSERT(headerBitLength % headerCodeWordSize == 0);
         unsigned int numberOfSignalAPSKSymbols = headerBitLength / headerCodeWordSize;
         unsigned int numberOfSignalOFDMSymbols = numberOfSignalAPSKSymbols / NUMBER_OF_OFDM_DATA_SUBCARRIERS;
         headerDuration = numberOfSignalOFDMSymbols * mode->getSymbolInterval();
     }
     else
         headerDuration = mode->getSignalMode()->getDuration();
     unsigned int dataCodeWordSize = mode->getDataMode()->getModulation()->getSubcarrierModulation()->getCodeWordSize();
     ASSERT(dataBitLength % dataCodeWordSize == 0);
     unsigned int numberOfDataAPSKSymbols = dataBitLength / dataCodeWordSize;
     unsigned int numberOfDataOFDMSymbols = numberOfDataAPSKSymbols / NUMBER_OF_OFDM_DATA_SUBCARRIERS;
     simtime_t dataDuration = numberOfDataOFDMSymbols * mode->getSymbolInterval();
     simtime_t duration = preambleDuration + headerDuration + dataDuration;
     return new ScalarTransmissionSignalAnalogModel(duration, carrierFrequency, mode->getDataMode()->getBandwidth(), power);
 }

const ITransmissionPacketModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createSignalFieldPacketModel ( const ITransmissionPacketModel * completePacketModel ) const

protected

 {
     // The SIGNAL field is composed of RATE (4), Reserved (1), LENGTH (12), Parity (1), Tail (6),
     // fields, so the SIGNAL field is 24 bits (OFDM_SYMBOL_SIZE / 2) long.
     BitVector *signalField = new BitVector();
     const BitVector *serializedPacket = completePacketModel->getSerializedPacket();
     for (unsigned int i = 0; i < NUMBER_OF_OFDM_DATA_SUBCARRIERS / 2; i++)
         signalField->appendBit(serializedPacket->getBit(i));
     return new TransmissionPacketModel(nullptr, signalField, bps(NaN));
 }

const ITransmissionSymbolModel * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createSymbolModel	(	const ITransmissionSymbolModel *	signalFieldSymbolModel,
		const ITransmissionSymbolModel *	dataFieldSymbolModel
	)		const

protected

 {
     if (levelOfDetail >= SYMBOL_DOMAIN) {
         const std::vector<const ISymbol *> *signalSymbols = signalFieldSymbolModel->getSymbols();
         std::vector<const ISymbol *> *mergedSymbols = new std::vector<const ISymbol *>();
         const Ieee80211OFDMSymbol *ofdmSymbol = nullptr;
         for (auto & signalSymbol : *signalSymbols) {
             ofdmSymbol = check_and_cast<const Ieee80211OFDMSymbol *>(signalSymbol);
             mergedSymbols->push_back(new Ieee80211OFDMSymbol(*ofdmSymbol));
         }
         const std::vector<const ISymbol *> *dataSymbols = dataFieldSymbolModel->getSymbols();
         for (auto & dataSymbol : *dataSymbols) {
             ofdmSymbol = dynamic_cast<const Ieee80211OFDMSymbol *>(dataSymbol);
             mergedSymbols->push_back(new Ieee80211OFDMSymbol(*ofdmSymbol));
         }
         const Ieee80211OFDMTransmissionSymbolModel *transmissionSymbolModel = new Ieee80211OFDMTransmissionSymbolModel(1, 1.0 / mode->getSignalMode()->getDuration(), mergedSymbols->size() - 1, 1.0 / mode->getSymbolInterval(), mergedSymbols, signalFieldSymbolModel->getHeaderModulation(), dataFieldSymbolModel->getPayloadModulation());
         delete signalFieldSymbolModel;
         delete dataFieldSymbolModel;
         return transmissionSymbolModel;
     }
     return new Ieee80211OFDMTransmissionSymbolModel(-1, NaN, -1, NaN, nullptr, mode->getSignalMode()->getModulation()->getSubcarrierModulation(), mode->getDataMode()->getModulation()->getSubcarrierModulation());
 }

const ITransmission * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::createTransmission	(	const IRadio *	transmitter,
		const cPacket *	macFrame,
		const simtime_t	startTime
	)		const

overridevirtual

Returns a transmission which describes the radio signal corresponding to the provided mac frame.

This function never returns nullptr.

Implements inet::physicallayer::ITransmitter.

 {
     TransmissionRequest *transmissionRequest = dynamic_cast<TransmissionRequest *>(macFrame->getControlInfo());
     Ieee80211TransmissionRequest *ieee80211TransmissionRequest = dynamic_cast<Ieee80211TransmissionRequest *>(transmissionRequest);
     if (isCompliant)
         mode = ieee80211TransmissionRequest != nullptr ? check_and_cast<const Ieee80211OFDMMode *>(ieee80211TransmissionRequest->getMode()) : &Ieee80211OFDMCompliantModes::getCompliantMode(11, MHz(20));
     else if (!mode)
         mode = computeMode(bandwidth);
     const ITransmissionBitModel *bitModel = nullptr;
     const ITransmissionBitModel *signalFieldBitModel = nullptr;
     const ITransmissionBitModel *dataFieldBitModel = nullptr;
     const ITransmissionSymbolModel *symbolModel = nullptr;
     const ITransmissionSymbolModel *signalFieldSymbolModel = nullptr;
     const ITransmissionSymbolModel *dataFieldSymbolModel = nullptr;
     const ITransmissionSampleModel *sampleModel = nullptr;
     const ITransmissionAnalogModel *analogModel = nullptr;
     const ITransmissionPacketModel *packetModel = createPacketModel(macFrame);
     encodeAndModulate(packetModel, signalFieldBitModel, signalFieldSymbolModel, signalEncoder, signalModulator, true);
     encodeAndModulate(packetModel, dataFieldBitModel, dataFieldSymbolModel, dataEncoder, dataModulator, false);
     bitModel = createBitModel(signalFieldBitModel, dataFieldBitModel, packetModel);
     symbolModel = createSymbolModel(signalFieldSymbolModel, dataFieldSymbolModel);
     sampleModel = createSampleModel(symbolModel);
     analogModel = createAnalogModel(packetModel, bitModel, symbolModel, sampleModel);
     IMobility *mobility = transmitter->getAntenna()->getMobility();
     // assuming movement and rotation during transmission is negligible
     const simtime_t endTime = startTime + analogModel->getDuration();
     const Coord startPosition = mobility->getCurrentPosition();
     const Coord endPosition = mobility->getCurrentPosition();
     const EulerAngles startOrientation = mobility->getCurrentAngularPosition();
     const EulerAngles endOrientation = mobility->getCurrentAngularPosition();
     return new LayeredTransmission(packetModel, bitModel, symbolModel, sampleModel, analogModel, transmitter, macFrame, startTime, endTime, -1, -1, -1, startPosition, endPosition, startOrientation, endOrientation);
 }

void inet::physicallayer::Ieee80211LayeredOFDMTransmitter::encodeAndModulate	(	const ITransmissionPacketModel *	packetModel,
		const ITransmissionBitModel *&	fieldBitModel,
		const ITransmissionSymbolModel *&	fieldSymbolModel,
		const IEncoder *	encoder,
		const IModulator *	modulator,
		bool	isSignalField
	)		const

protected

 {
     const ITransmissionPacketModel *fieldPacketModel = nullptr;
     if (isSignalField)
         fieldPacketModel = createSignalFieldPacketModel(packetModel);
     else
         fieldPacketModel = createDataFieldPacketModel(packetModel);
     if (levelOfDetail >= BIT_DOMAIN) {
         if (fieldPacketModel) {
             if (encoder) // non-compliant mode
                 fieldBitModel = encoder->encode(fieldPacketModel);
             else { // compliant mode
                 const Ieee80211OFDMCode *code = isSignalField ? mode->getSignalMode()->getCode() : mode->getDataMode()->getCode();
                 const Ieee80211OFDMEncoder encoder(code);
                 fieldBitModel = encoder.encode(fieldPacketModel);
             }
         }
         else
             throw cRuntimeError("Encoder needs packet representation");
     }
     if (levelOfDetail >= SYMBOL_DOMAIN) {
         if (fieldBitModel) {
             if (modulator) // non-compliant mode
                 fieldSymbolModel = modulator->modulate(fieldBitModel);
             else { // compliant mode
                 const Ieee80211OFDMModulation *ofdmModulation = isSignalField ? mode->getSignalMode()->getModulation() : mode->getDataMode()->getModulation();
                 Ieee80211OFDMModulator modulator(ofdmModulation, isSignalField ? 0 : 1);
                 fieldSymbolModel = modulator.modulate(fieldBitModel);
             }
         }
         else
             throw cRuntimeError("Modulator needs bit representation");
     }
     delete fieldPacketModel;
 }

const Hz inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getBandwidth ( ) const

inline

97 { return mode->getDataMode()->getBandwidth(); }

inet::physicallayer::Ieee80211OFDMMode::getDataMode

virtual const Ieee80211OFDMDataMode * getDataMode() const override

Definition: Ieee80211OFDMMode.h:152

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::mode

const Ieee80211OFDMMode * mode

Definition: Ieee80211LayeredOFDMTransmitter.h:48

inet::physicallayer::Ieee80211OFDMModeBase::getBandwidth

Hz getBandwidth() const

Definition: Ieee80211OFDMMode.h:68

const Hz inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getCarrierFrequency ( ) const

inline

98 { return carrierFrequency; }

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::carrierFrequency

Hz carrierFrequency

Definition: Ieee80211LayeredOFDMTransmitter.h:59

const Hz inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getCarrierSpacing ( ) const

inline

99 { return mode->getChannelSpacing(); }

inet::physicallayer::Ieee80211OFDMTimingRelatedParametersBase::getChannelSpacing

const Hz getChannelSpacing() const

Definition: Ieee80211OFDMMode.h:42

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::mode

const Ieee80211OFDMMode * mode

Definition: Ieee80211LayeredOFDMTransmitter.h:48

virtual const IDigitalAnalogConverter* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getDigitalAnalogConverter ( ) const

inlinevirtual

93 { return digitalAnalogConverter; }

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::digitalAnalogConverter

const IDigitalAnalogConverter * digitalAnalogConverter

Definition: Ieee80211LayeredOFDMTransmitter.h:54

virtual const IEncoder* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getEncoder ( ) const

inlinevirtual

90 { return dataEncoder; }

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::dataEncoder

const IEncoder * dataEncoder

Definition: Ieee80211LayeredOFDMTransmitter.h:50

virtual m inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getMaxCommunicationRange ( ) const

inlineoverridevirtual

Returns the maximum transmission range.

Returns a value in the range [0, +infinity] or NaN if unspecified.

Reimplemented from inet::physicallayer::TransmitterBase.

95 { return m(NaN); }

NaN

#define NaN

Definition: INETMath.h:103

inet::units::values::m

value< double, units::m > m

Definition: Units.h:1047

virtual m inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getMaxInterferenceRange ( ) const

inlineoverridevirtual

Returns the maximum interference range.

Returns a value in the range [0, +infinity] or NaN if unspecified.

Reimplemented from inet::physicallayer::TransmitterBase.

96 { return m(NaN); }

NaN

#define NaN

Definition: INETMath.h:103

inet::units::values::m

value< double, units::m > m

Definition: Units.h:1047

virtual W inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getMaxPower ( ) const

inlineoverridevirtual

Returns the maximum transmission power above which no transmission is ever transmitted.

Returns a value in the range [0, +infinity] or NaN if unspecified.

Reimplemented from inet::physicallayer::TransmitterBase.

94 { return power; }

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::power

W power

Definition: Ieee80211LayeredOFDMTransmitter.h:60

virtual const IModulator* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getModulator ( ) const

inlinevirtual

91 { return dataModulator; }

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::dataModulator

const IModulator * dataModulator

Definition: Ieee80211LayeredOFDMTransmitter.h:52

virtual const IPulseShaper* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::getPulseShaper ( ) const

inlinevirtual

92 { return pulseShaper; }

inet::physicallayer::Ieee80211LayeredOFDMTransmitter::pulseShaper

const IPulseShaper * pulseShaper

Definition: Ieee80211LayeredOFDMTransmitter.h:53

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         isCompliant = par("isCompliant").boolValue();
         dataEncoder = dynamic_cast<const IEncoder *>(getSubmodule("dataEncoder"));
         signalEncoder = dynamic_cast<const IEncoder *>(getSubmodule("signalEncoder"));
         dataModulator = dynamic_cast<const IModulator *>(getSubmodule("dataModulator"));
         signalModulator = dynamic_cast<const IModulator *>(getSubmodule("signalModulator"));
         pulseShaper = dynamic_cast<const IPulseShaper *>(getSubmodule("pulseShaper"));
         digitalAnalogConverter = dynamic_cast<const IDigitalAnalogConverter *>(getSubmodule("digitalAnalogConverter"));
         channelSpacing = Hz(par("channelSpacing"));
         power = W(par("power"));
         carrierFrequency = Hz(par("carrierFrequency"));
         bandwidth = Hz(par("bandwidth"));
         if (isCompliant && (dataEncoder || signalEncoder || dataModulator || signalModulator
                             || pulseShaper || digitalAnalogConverter || !std::isnan(channelSpacing.get()))) // TODO: check modulations
         {
             throw cRuntimeError("In compliant mode it is forbidden to set the following parameters: dataEncoder, signalEncoder, modulator, signalModulator, pulseShaper, digitalAnalogConverter, bandwidth, channelSpacing");
         }
         const char *levelOfDetailStr = par("levelOfDetail").stringValue();
         if (strcmp("bit", levelOfDetailStr) == 0)
             levelOfDetail = BIT_DOMAIN;
         else if (strcmp("symbol", levelOfDetailStr) == 0)
             levelOfDetail = SYMBOL_DOMAIN;
         else if (strcmp("sample", levelOfDetailStr) == 0)
             levelOfDetail = SAMPLE_DOMAIN;
         else if (strcmp("packet", levelOfDetailStr) == 0)
             levelOfDetail = PACKET_DOMAIN;
         else
             throw cRuntimeError("Unknown level of detail='%s'", levelOfDetailStr);
     }
 }

std::ostream & inet::physicallayer::Ieee80211LayeredOFDMTransmitter::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 << "Ieee80211LayeredOFDMTransmitter";
     if (level <= PRINT_LEVEL_TRACE)
         stream << ", levelOfDetail = " << levelOfDetail
                << ", mode = " << printObjectToString(mode, level + 1)
                << ", signalEncoder = " << printObjectToString(signalEncoder, level + 1)
                << ", dataEncoder = " << printObjectToString(dataEncoder, level + 1)
                << ", signalModulator = " << printObjectToString(signalModulator, level + 1)
                << ", dataModulator = " << printObjectToString(dataModulator, level + 1)
                << ", pulseShaper = " << printObjectToString(pulseShaper, level + 1)
                << ", digitalAnalogConverter = " << printObjectToString(digitalAnalogConverter, level + 1)
                << ", isCompliant = " << isCompliant
                << ", bandwidth = " << bandwidth
                << ", channelSpacing = " << channelSpacing
                << ", carrierFrequency = " << carrierFrequency
                << ", power = " << power;
     return stream;
 }

BitVector * inet::physicallayer::Ieee80211LayeredOFDMTransmitter::serialize ( const cPacket * packet ) const

protected

 {
     Ieee80211PhySerializer phySerializer;
     BitVector *serializedPacket = new BitVector();
     const Ieee80211OFDMPLCPFrame *phyFrame = check_and_cast<const Ieee80211OFDMPLCPFrame *>(packet);
     phySerializer.serialize(phyFrame, serializedPacket);
     unsigned int byteLength = phyFrame->getLength();
     appendPadding(serializedPacket, byteLength);
     return serializedPacket;
 }

Member Data Documentation

Hz inet::physicallayer::Ieee80211LayeredOFDMTransmitter::bandwidth

protected

Hz inet::physicallayer::Ieee80211LayeredOFDMTransmitter::carrierFrequency

protected

Hz inet::physicallayer::Ieee80211LayeredOFDMTransmitter::channelSpacing

protected

const IEncoder* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::dataEncoder = nullptr

protected

const IModulator* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::dataModulator = nullptr

protected

const IDigitalAnalogConverter* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::digitalAnalogConverter = nullptr

protected

bool inet::physicallayer::Ieee80211LayeredOFDMTransmitter::isCompliant

protected

LevelOfDetail inet::physicallayer::Ieee80211LayeredOFDMTransmitter::levelOfDetail

protected

const Ieee80211OFDMMode* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::mode = nullptr

mutableprotected

W inet::physicallayer::Ieee80211LayeredOFDMTransmitter::power

protected

const IPulseShaper* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::pulseShaper = nullptr

protected

const IEncoder* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::signalEncoder = nullptr

protected

const IModulator* inet::physicallayer::Ieee80211LayeredOFDMTransmitter::signalModulator = nullptr

protected

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation