#include <Ieee80211LayeredOfdmReceiver.h>

Inheritance diagram for inet::physicallayer::Ieee80211LayeredOfdmReceiver:

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

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
virtual	~Ieee80211LayeredOfdmReceiver ()

virtual const Ieee80211OfdmMode *	getMode (const Packet *packet) const

virtual bool	computeIsReceptionPossible (const IListening listening, const IReception reception, IRadioSignal::SignalPart part) const override
	Returns whether the reception of the provided part is possible or not. More...

virtual const IListeningDecision *	computeListeningDecision (const IListening listening, const IInterference interference) const override
	Returns the result of the listening process specifying the reception state of the receiver. More...

virtual const IListening *	createListening (const IRadio *radio, const simtime_t startTime, const simtime_t endTime, const Coord &startPosition, const Coord &endPosition) const override
	Returns a description of how the receiver is listening on the medium. More...

virtual const IReceptionResult *	computeReceptionResult (const IListening listening, const IReception reception, const IInterference interference, const ISnir snir, const std::vector< const IReceptionDecision * > *decisions) const override
	Returns the complete result of the reception process for the provided reception. More...

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

Public Member Functions inherited from inet::physicallayer::SnirReceiverBase
virtual double	getSNIRThreshold () const

virtual bool	computeIsReceptionSuccessful (const IListening listening, const IReception reception, IRadioSignal::SignalPart part, const IInterference interference, const ISnir snir) const override
	Returns whether the reception of the provided part is actually successful or failed by the receiver. More...

Public Member Functions inherited from inet::physicallayer::ReceiverBase
	ReceiverBase ()

virtual W	getMinInterferencePower () const override
	Returns the minimum interference power below which receptions are to be ignored while computing the interference. More...

virtual W	getMinReceptionPower () const override
	Returns the minimum reception power below which successful reception is definitely not possible. More...

virtual bool	computeIsReceptionPossible (const IListening listening, const ITransmission transmission) const override
	Returns whether the reception of the provided transmission is possible or not independently of the reception conditions. More...

virtual bool	computeIsReceptionAttempted (const IListening listening, const IReception reception, IRadioSignal::SignalPart part, const IInterference *interference) const override
	Returns whether the reception of the provided part is actually attempted or ignored by the receiver. More...

virtual const IReceptionDecision *	computeReceptionDecision (const IListening listening, const IReception reception, IRadioSignal::SignalPart part, const IInterference interference, const ISnir snir) const override
	Returns the reception decision for the transmission part that specifies whether the reception is possible, attempted, and successful. More...

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

Protected Member Functions
virtual void	initialize (int stage) override

const IReceptionAnalogModel *	createAnalogModel (const LayeredTransmission transmission, const ISnir snir) const

const IReceptionSampleModel *	createSampleModel (const LayeredTransmission transmission, const ISnir snir) const

const IReceptionSymbolModel *	createSignalFieldSymbolModel (const IReceptionSymbolModel *symbolModel) const

const IReceptionSymbolModel *	createDataFieldSymbolModel (const IReceptionSymbolModel *symbolModel) const

const IReceptionSymbolModel *	createSymbolModel (const LayeredTransmission transmission, const ISnir snir) const

const IReceptionSymbolModel *	createCompleteSymbolModel (const IReceptionSymbolModel signalFieldSymbolModel, const IReceptionSymbolModel dataFieldSymbolModel) const

const IReceptionBitModel *	createSignalFieldBitModel (const IReceptionBitModel bitModel, const IReceptionSymbolModel symbolModel) const

const IReceptionBitModel *	createDataFieldBitModel (const IReceptionBitModel bitModel, const IReceptionSymbolModel symbolModel, const IReceptionPacketModel signalFieldPacketModel, const IReceptionBitModel signalFieldBitModel) const

const IReceptionBitModel *	createBitModel (const LayeredTransmission transmission, const ISnir snir) const

const IReceptionBitModel *	createCompleteBitModel (const IReceptionBitModel signalFieldBitModel, const IReceptionBitModel dataFieldBitModel) const

const IReceptionPacketModel *	createSignalFieldPacketModel (const IReceptionBitModel *signalFieldBitModel) const

const IReceptionPacketModel *	createDataFieldPacketModel (const IReceptionBitModel signalFieldBitModel, const IReceptionBitModel dataFieldBitModel, const IReceptionPacketModel *signalFieldPacketModel) const

const IReceptionPacketModel *	createPacketModel (const LayeredTransmission transmission, const ISnir snir) const

const IReceptionPacketModel *	createCompletePacketModel (const char name, const IReceptionPacketModel signalFieldPacketModel, const IReceptionPacketModel *dataFieldPacketModel) const

const Ieee80211OfdmMode *	computeMode (Hz bandwidth) const

unsigned int	getSignalFieldLength (const BitVector *signalField) const

unsigned int	calculatePadding (unsigned int dataFieldLengthInBits, const ApskModulationBase *modulation, double codeRate) const

double	getCodeRateFromDecoderModule (const IDecoder *decoder) const

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

virtual W	computeSignalPower (const IListening listening, const ISnir snir, const IInterference *interference) const

virtual Packet *	computeReceivedPacket (const ISnir *snir, bool isReceptionSuccessful) const

Protected Attributes
LevelOfDetail	levelOfDetail

const Ieee80211OfdmMode *	mode = nullptr

const ILayeredErrorModel *	errorModel = nullptr

const IDecoder *	dataDecoder = nullptr

const IDecoder *	signalDecoder = nullptr

const IDemodulator *	dataDemodulator = nullptr

const IDemodulator *	signalDemodulator = nullptr

const IPulseFilter *	pulseFilter = nullptr

const IAnalogDigitalConverter *	analogDigitalConverter = nullptr

W	energyDetection

W	sensitivity

Hz	centerFrequency

Hz	bandwidth

Hz	channelSpacing

double	snirThreshold

bool	isCompliant

Protected Attributes inherited from inet::physicallayer::SnirReceiverBase
double	snirThreshold = NaN

SnirThresholdMode	snirThresholdMode = SnirThresholdMode::STM_UNDEFINED

Additional Inherited Members
Protected Types inherited from inet::physicallayer::SnirReceiverBase
enum	SnirThresholdMode { SnirThresholdMode::STM_UNDEFINED = -1, SnirThresholdMode::STM_MIN, SnirThresholdMode::STM_MEAN }

Member Enumeration Documentation

◆ LevelOfDetail

enum inet::physicallayer::Ieee80211LayeredOfdmReceiver::LevelOfDetail

Enumerator
PACKET_DOMAIN
BIT_DOMAIN
SYMBOL_DOMAIN
SAMPLE_DOMAIN

                        {
         PACKET_DOMAIN,
         BIT_DOMAIN,
         SYMBOL_DOMAIN,
         SAMPLE_DOMAIN,
     };

Constructor & Destructor Documentation

◆ ~Ieee80211LayeredOfdmReceiver()

inet::physicallayer::Ieee80211LayeredOfdmReceiver::~Ieee80211LayeredOfdmReceiver ( )

virtual

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

Member Function Documentation

◆ calculatePadding()

unsigned int inet::physicallayer::Ieee80211LayeredOfdmReceiver::calculatePadding	(	unsigned int	dataFieldLengthInBits,
		const ApskModulationBase *	modulation,
		double	codeRate
	)		const

protected

 {
     ASSERT(modulation != nullptr);
     unsigned int codedBitsPerOFDMSymbol = modulation->getCodeWordSize() * NUMBER_OF_OFDM_DATA_SUBCARRIERS;
     unsigned int dataBitsPerOFDMSymbol = codedBitsPerOFDMSymbol * codeRate;
     return dataBitsPerOFDMSymbol - dataFieldLengthInBits % dataBitsPerOFDMSymbol;
 }

Referenced by createDataFieldBitModel().

◆ computeIsReceptionPossible()

bool inet::physicallayer::Ieee80211LayeredOfdmReceiver::computeIsReceptionPossible	(	const IListening *	listening,
		const IReception *	reception,
		IRadioSignal::SignalPart	part
	)		const

overridevirtual

Returns whether the reception of the provided part is possible or not.

For example, it might check if the reception power is above sensitivity.

This function may be called before the reception actually starts at the receiver, thus it must be purely functional and support optimistic parallel computation.

Reimplemented from inet::physicallayer::ReceiverBase.

 {
     const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
     const LayeredReception *scalarReception = check_and_cast<const LayeredReception *>(reception);
     // TODO scalar
     const ScalarReceptionSignalAnalogModel *analogModel = check_and_cast<const ScalarReceptionSignalAnalogModel *>(scalarReception->getAnalogModel());
     if (bandListening->getCenterFrequency() != analogModel->getCenterFrequency() || bandListening->getBandwidth() != analogModel->getBandwidth()) {
         EV_DEBUG << "Computing reception possible: listening and reception bands are different -> reception is impossible" << endl;
         return false;
     }
     else {
         const INarrowbandSignal *narrowbandSignalAnalogModel = check_and_cast<const INarrowbandSignal *>(reception->getAnalogModel());
         W minReceptionPower = narrowbandSignalAnalogModel->computeMinPower(reception->getStartTime(), reception->getEndTime());
         bool isReceptionPossible = minReceptionPower >= sensitivity;
         EV_DEBUG << "Computing reception possible" << EV_FIELD(minReceptionPower) << EV_FIELD(sensitivity) << " -> reception is " << (isReceptionPossible ? "possible" : "impossible") << endl;
         return isReceptionPossible;
     }
 }

◆ computeListeningDecision()

const IListeningDecision * inet::physicallayer::Ieee80211LayeredOfdmReceiver::computeListeningDecision	(	const IListening *	listening,
		const IInterference *	interference
	)		const

overridevirtual

Returns the result of the listening process specifying the reception state of the receiver.

This function must be purely functional and support optimistic parallel computation.

Implements inet::physicallayer::IReceiver.

 {
     const IRadio *receiver = listening->getReceiver();
     const IRadioMedium *radioMedium = receiver->getMedium();
     const IAnalogModel *analogModel = radioMedium->getAnalogModel();
     const INoise *noise = analogModel->computeNoise(listening, interference);
     const NarrowbandNoiseBase *flatNoise = check_and_cast<const NarrowbandNoiseBase *>(noise);
     W maxPower = flatNoise->computeMaxPower(listening->getStartTime(), listening->getEndTime());
     bool isListeningPossible = maxPower >= energyDetection;
     delete noise;
     EV_DEBUG << "Computing listening possible: maximum power = " << maxPower << ", energy detection = " << energyDetection << " -> listening is " << (isListeningPossible ? "possible" : "impossible") << endl;
     return new ListeningDecision(listening, isListeningPossible);
 }

◆ computeMode()

const Ieee80211OfdmMode * inet::physicallayer::Ieee80211LayeredOfdmReceiver::computeMode ( Hz bandwidth ) const

protected

 {
     const Ieee80211OfdmDecoderModule *ofdmSignalDecoderModule = check_and_cast<const Ieee80211OfdmDecoderModule *>(signalDecoder);
     const Ieee80211OfdmDecoderModule *ofdmDataDecoderModule = check_and_cast<const Ieee80211OfdmDecoderModule *>(dataDecoder);
     const Ieee80211OfdmDemodulatorModule *ofdmSignalDemodulatorModule = check_and_cast<const Ieee80211OfdmDemodulatorModule *>(signalDemodulator);
     const Ieee80211OfdmDemodulatorModule *ofdmDataDemodulatorModule = check_and_cast<const Ieee80211OfdmDemodulatorModule *>(dataDemodulator);
     const Ieee80211OfdmSignalMode *signalMode = new Ieee80211OfdmSignalMode(ofdmSignalDecoderModule->getCode(), ofdmSignalDemodulatorModule->getModulation(), channelSpacing, bandwidth, 0);
     const Ieee80211OfdmDataMode *dataMode = new Ieee80211OfdmDataMode(ofdmDataDecoderModule->getCode(), ofdmDataDemodulatorModule->getModulation(), channelSpacing, bandwidth);
     return new Ieee80211OfdmMode("", new Ieee80211OfdmPreambleMode(channelSpacing), signalMode, dataMode, channelSpacing, bandwidth);
 }

Referenced by computeReceptionResult().

◆ computeReceptionResult()

const IReceptionResult * inet::physicallayer::Ieee80211LayeredOfdmReceiver::computeReceptionResult	(	const IListening *	listening,
		const IReception *	reception,
		const IInterference *	interference,
		const ISnir *	snir,
		const std::vector< const IReceptionDecision * > *	decisions
	)		const

overridevirtual

Returns the complete result of the reception process for the provided reception.

This function may be called before the reception actually starts at the receiver, thus it must be purely functional and support optimistic parallel computation.

Reimplemented from inet::physicallayer::ReceiverBase.

 {
     const Ieee80211LayeredTransmission *transmission = dynamic_cast<const Ieee80211LayeredTransmission *>(reception->getTransmission());
     // corruted model
     const IReceptionAnalogModel *analogModel = createAnalogModel(transmission, snir);
     const IReceptionSampleModel *sampleModel = createSampleModel(transmission, snir);
     const IReceptionSymbolModel *symbolModel = createSymbolModel(transmission, snir);
     const IReceptionBitModel *bitModel = createBitModel(transmission, snir);
     const IReceptionPacketModel *packetModel = createPacketModel(transmission, snir);
     // signal field model
     const IReceptionSymbolModel *signalFieldSymbolModel = createSignalFieldSymbolModel(symbolModel);
     const IReceptionSymbolModel *dataFieldSymbolModel = createDataFieldSymbolModel(symbolModel);
     const IReceptionBitModel *signalFieldBitModel = createSignalFieldBitModel(bitModel, signalFieldSymbolModel);
     const IReceptionPacketModel *signalFieldPacketModel = createSignalFieldPacketModel(signalFieldBitModel);
     // determine mode
     if (isCompliant) {
         auto packet = signalFieldPacketModel != nullptr ? signalFieldPacketModel->getPacket() : packetModel->getPacket();
         const auto& signalFieldBytesChunk = packet->peekAllAsBytes();
         uint8_t rate = signalFieldBytesChunk->getByte(0) >> 4;
         mode = Ieee80211OfdmCompliantModes::findCompliantMode(rate, channelSpacing);
         if (mode == nullptr)
             const_cast<Packet *>(packet)->setBitError(true);
     }
     else if (!mode)
         mode = computeMode(bandwidth);
     // data field model
     const IReceptionBitModel *dataFieldBitModel = mode != nullptr ? createDataFieldBitModel(bitModel, dataFieldSymbolModel, signalFieldPacketModel, signalFieldBitModel) : nullptr;
     const IReceptionPacketModel *dataFieldPacketModel = mode != nullptr ? createDataFieldPacketModel(signalFieldBitModel, dataFieldBitModel, signalFieldPacketModel) : nullptr;
     // complete model
 //    if (!sampleModel)
 //        sampleModel = createCompleteSampleModel(signalFieldSampleModel, dataFieldSampleModel);
     if (!symbolModel)
         symbolModel = createCompleteSymbolModel(signalFieldSymbolModel, dataFieldSymbolModel);
     if (!bitModel)
         bitModel = createCompleteBitModel(signalFieldBitModel, dataFieldBitModel);
     if (!packetModel)
         packetModel = createCompletePacketModel(transmission->getPacket()->getName(), signalFieldPacketModel, dataFieldPacketModel);
     // delete signal and data field models
     delete signalFieldSymbolModel;
     delete dataFieldSymbolModel;
     delete signalFieldBitModel;
     delete dataFieldBitModel;
     if (signalFieldPacketModel != nullptr) {
         delete signalFieldPacketModel->getPacket();
         delete signalFieldPacketModel;
     }
     if (dataFieldPacketModel != nullptr) {
         delete dataFieldPacketModel->getPacket();
         delete dataFieldPacketModel;
     }
     // add indications
     auto packet = const_cast<Packet *>(packetModel->getPacket());
     auto snirInd = packet->addTagIfAbsent<SnirInd>();
     snirInd->setMinimumSnir(snir->getMin());
     snirInd->setMaximumSnir(snir->getMax());
     snirInd->setAverageSnir(snir->getMean());
     auto errorRateInd = packet->addTagIfAbsent<ErrorRateInd>();
     if (symbolModel != nullptr)
         errorRateInd->setSymbolErrorRate(symbolModel->getSymbolErrorRate());
     if (bitModel != nullptr)
         errorRateInd->setBitErrorRate(bitModel->getBitErrorRate());
     if (packetModel != nullptr)
         errorRateInd->setPacketErrorRate(packetModel->getPacketErrorRate());
     auto modeInd = packet->addTagIfAbsent<Ieee80211ModeInd>();
     modeInd->setMode(transmission->getMode());
     auto channelInd = packet->addTagIfAbsent<Ieee80211ChannelInd>();
     channelInd->setChannel(transmission->getChannel());
     return new LayeredReceptionResult(reception, decisions, packetModel, bitModel, symbolModel, sampleModel, analogModel);
 }

◆ createAnalogModel()

const IReceptionAnalogModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createAnalogModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir
	)		const

protected

 {
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createBitModel()

const IReceptionBitModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createBitModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir
	)		const

protected

 {
     if (levelOfDetail == BIT_DOMAIN)
         return errorModel->computeBitModel(transmission, snir);
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createCompleteBitModel()

const IReceptionBitModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createCompleteBitModel	(	const IReceptionBitModel *	signalFieldBitModel,
		const IReceptionBitModel *	dataFieldBitModel
	)		const

protected

 {
     if (levelOfDetail >= BIT_DOMAIN) {
         if (dataFieldBitModel == nullptr)
             return new ReceptionBitModel(signalFieldBitModel->getHeaderLength(), signalFieldBitModel->getHeaderBitRate(), b(-1), bps(NaN), new BitVector(*signalFieldBitModel->getBits()), NaN);
         else {
             BitVector *bits = new BitVector(*signalFieldBitModel->getBits());
             const BitVector *dataBits = dataFieldBitModel->getBits();
             for (unsigned int i = 0; i < dataBits->getSize(); i++)
                 bits->appendBit(dataBits->getBit(i));
             return new ReceptionBitModel(signalFieldBitModel->getHeaderLength(), signalFieldBitModel->getHeaderBitRate(), dataFieldBitModel->getDataLength(), dataFieldBitModel->getDataBitRate(), bits, NaN);
         }
     }
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createCompletePacketModel()

const IReceptionPacketModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createCompletePacketModel	(	const char *	name,
		const IReceptionPacketModel *	signalFieldPacketModel,
		const IReceptionPacketModel *	dataFieldPacketModel
	)		const

protected

 {
     if (dataFieldPacketModel == nullptr)
         return new ReceptionPacketModel(signalFieldPacketModel->getPacket()->dup(), bps(NaN), NaN);
     else {
         Packet *packet = new Packet(name);
         packet->insertAtBack(signalFieldPacketModel->getPacket()->peekAllAsBits());
         packet->insertAtBack(dataFieldPacketModel->getPacket()->peekAllAsBits());
         packet->setBitError(signalFieldPacketModel->getPacket()->hasBitError() | dataFieldPacketModel->getPacket()->hasBitError());
         return new ReceptionPacketModel(packet, bps(NaN), NaN);
     }
 }

Referenced by computeReceptionResult().

◆ createCompleteSymbolModel()

const IReceptionSymbolModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createCompleteSymbolModel	(	const IReceptionSymbolModel *	signalFieldSymbolModel,
		const IReceptionSymbolModel *	dataFieldSymbolModel
	)		const

protected

 {
     if (levelOfDetail >= SYMBOL_DOMAIN) {
         const std::vector<const ISymbol *> *symbols = signalFieldSymbolModel->getSymbols();
         std::vector<const ISymbol *> *completeSymbols = new std::vector<const ISymbol *>(*symbols);
         symbols = dataFieldSymbolModel->getSymbols();
         for (auto& symbol : *symbols)
             completeSymbols->push_back(new Ieee80211OfdmSymbol(*static_cast<const Ieee80211OfdmSymbol *>(symbol)));
         return new Ieee80211OfdmReceptionSymbolModel(signalFieldSymbolModel->getHeaderSymbolLength(), signalFieldSymbolModel->getHeaderSymbolRate(), dataFieldSymbolModel->getPayloadSymbolLength(), dataFieldSymbolModel->getPayloadSymbolRate(), completeSymbols);
     }
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createDataFieldBitModel()

const IReceptionBitModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createDataFieldBitModel	(	const IReceptionBitModel *	bitModel,
		const IReceptionSymbolModel *	symbolModel,
		const IReceptionPacketModel *	signalFieldPacketModel,
		const IReceptionBitModel *	signalFieldBitModel
	)		const

protected

 {
     const IReceptionBitModel *dataFieldBitModel = nullptr;
     if (levelOfDetail > BIT_DOMAIN) { // Create from symbol model
         if (dataDemodulator) // non-compliant
             dataFieldBitModel = dataDemodulator->demodulate(dataFieldSymbolModel);
         else { // compliant
             const Ieee80211OfdmDataMode *dataMode = mode->getDataMode();
             const Ieee80211OfdmDemodulator ofdmDemodulator(dataMode->getModulation());
             dataFieldBitModel = ofdmDemodulator.demodulate(dataFieldSymbolModel);
         }
     }
     else if (levelOfDetail == BIT_DOMAIN) { // Create from bit model (made by the error model)
         const ConvolutionalCode *convolutionalCode = nullptr;
         const ApskModulationBase *modulation = nullptr;
         double codeRate = NaN;
         const auto& bytesChunk = signalFieldPacketModel->getPacket()->peekAllAsBytes();
         unsigned int psduLengthInBits = getSignalFieldLength(new BitVector(bytesChunk->getBytes())) * 8;
         unsigned int dataFieldLengthInBits = psduLengthInBits + PPDU_SERVICE_FIELD_BITS_LENGTH + PPDU_TAIL_BITS_LENGTH;
         if (isCompliant) {
             const Ieee80211OfdmDataMode *dataMode = mode->getDataMode();
             modulation = dataMode->getModulation()->getSubcarrierModulation();
             const Ieee80211OfdmCode *code = dataMode->getCode();
             convolutionalCode = code->getConvolutionalCode();
             codeRate = convolutionalCode->getCodeRatePuncturingN() * 1.0 / convolutionalCode->getCodeRatePuncturingK();
         }
         else {
             const Ieee80211OfdmDecoderModule *decoderModule = check_and_cast<const Ieee80211OfdmDecoderModule *>(dataDecoder);
             const Ieee80211OfdmCode *code = decoderModule->getCode();
             convolutionalCode = code->getConvolutionalCode();
             modulation = mode->getDataMode()->getModulation()->getSubcarrierModulation();
             codeRate = getCodeRateFromDecoderModule(dataDecoder);
         }
         dataFieldLengthInBits += calculatePadding(dataFieldLengthInBits, modulation, 1.0 / codeRate);
 //        ASSERT(dataFieldLengthInBits % convolutionalCode->getCodeRatePuncturingK() == 0);
         unsigned int encodedDataFieldLengthInBits = dataFieldLengthInBits * codeRate;
         const BitVector *bits = bitModel->getBits();
         unsigned int encodedSignalFieldLength = b(signalFieldBitModel->getHeaderLength()).get();
         if (dataFieldLengthInBits + encodedSignalFieldLength > bits->getSize())
             throw cRuntimeError("The calculated data field length = %d is greater then the actual bitvector length = %d", dataFieldLengthInBits, bits->getSize());
         BitVector *dataBits = new BitVector();
         for (unsigned int i = 0; i < encodedDataFieldLengthInBits; i++)
             dataBits->appendBit(bits->getBit(encodedSignalFieldLength + i));
         dataFieldBitModel = new ReceptionBitModel(b(-1), bps(NaN), b(encodedDataFieldLengthInBits), bitModel->getDataBitRate(), dataBits, NaN);
     }
     return dataFieldBitModel;
 }

Referenced by computeReceptionResult().

◆ createDataFieldPacketModel()

const IReceptionPacketModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createDataFieldPacketModel	(	const IReceptionBitModel *	signalFieldBitModel,
		const IReceptionBitModel *	dataFieldBitModel,
		const IReceptionPacketModel *	signalFieldPacketModel
	)		const

protected

 {
     const IReceptionPacketModel *dataFieldPacketModel = nullptr;
     if (levelOfDetail > PACKET_DOMAIN) { // Create from the bit model
         if (dataDecoder)
             dataFieldPacketModel = dataDecoder->decode(dataFieldBitModel);
         else {
             const Ieee80211OfdmCode *code = mode->getDataMode()->getCode();
             const Ieee80211OfdmDecoder decoder(code);
             dataFieldPacketModel = decoder.decode(dataFieldBitModel);
         }
     }
     return dataFieldPacketModel;
 }

Referenced by computeReceptionResult().

◆ createDataFieldSymbolModel()

const IReceptionSymbolModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createDataFieldSymbolModel ( const IReceptionSymbolModel * symbolModel ) const

protected

 {
     const Ieee80211OfdmReceptionSymbolModel *dataFieldSymbolModel = nullptr;
     if (levelOfDetail > SYMBOL_DOMAIN)
         throw cRuntimeError("This level of detail is unimplemented!");
     else if (levelOfDetail == SYMBOL_DOMAIN) { // Create from symbol model (made by the error model)
         const std::vector<const ISymbol *> *symbols = receptionSymbolModel->getSymbols();
         std::vector<const ISymbol *> *dataSymbols = new std::vector<const ISymbol *>();
         const Ieee80211OfdmSymbol *ofdmSymbol = nullptr;
         for (unsigned int i = 1; i < symbols->size(); i++) {
             ofdmSymbol = check_and_cast<const Ieee80211OfdmSymbol *>(symbols->at(i));
             dataSymbols->push_back(new Ieee80211OfdmSymbol(*ofdmSymbol));
         }
         dataFieldSymbolModel = new Ieee80211OfdmReceptionSymbolModel(-1, NaN, symbols->size() - 1, receptionSymbolModel->getPayloadSymbolRate(), dataSymbols);
     }
     return dataFieldSymbolModel;
 }

Referenced by computeReceptionResult().

◆ createListening()

const IListening * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createListening	(	const IRadio *	radio,
		const simtime_t	startTime,
		const simtime_t	endTime,
		const Coord &	startPosition,
		const Coord &	endPosition
	)		const

overridevirtual

Returns a description of how the receiver is listening on the medium.

Implements inet::physicallayer::IReceiver.

 {
     // We assume that in compliant mode the bandwidth is always 20MHz.
     return new BandListening(radio, startTime, endTime, startPosition, endPosition, centerFrequency, isCompliant ? Hz(20000000) : bandwidth);
 }

◆ createPacketModel()

const IReceptionPacketModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createPacketModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir
	)		const

protected

 {
     if (levelOfDetail == PACKET_DOMAIN)
         return errorModel->computePacketModel(transmission, snir);
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createSampleModel()

const IReceptionSampleModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createSampleModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir
	)		const

protected

 {
     if (levelOfDetail == SAMPLE_DOMAIN)
         return errorModel->computeSampleModel(transmission, snir);
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createSignalFieldBitModel()

const IReceptionBitModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createSignalFieldBitModel	(	const IReceptionBitModel *	bitModel,
		const IReceptionSymbolModel *	symbolModel
	)		const

protected

 {
     const IReceptionBitModel *signalFieldBitModel = nullptr;
     if (levelOfDetail > BIT_DOMAIN) { // Create from symbol model
         if (signalDemodulator) // non-compliant
             signalFieldBitModel = signalDemodulator->demodulate(signalFieldSymbolModel);
         else { // compliant
                // In compliant mode, the signal field modulation is always BPSK
             const Ieee80211OfdmModulation *signalModulation = new Ieee80211OfdmModulation(&BpskModulation::singleton);
             const Ieee80211OfdmDemodulator demodulator(signalModulation);
             signalFieldBitModel = demodulator.demodulate(signalFieldSymbolModel);
             delete signalModulation;
         }
     }
     else if (levelOfDetail == BIT_DOMAIN) { // Create from bit model (made by the error model)
         unsigned int signalFieldLength = 0;
         if (isCompliant)
             signalFieldLength = ENCODED_SIGNAL_FIELD_LENGTH;
         else {
             double codeRate = getCodeRateFromDecoderModule(signalDecoder);
             signalFieldLength = DECODED_SIGNAL_FIELD_LENGTH * codeRate;
         }
         BitVector *signalFieldBits = new BitVector();
         const BitVector *bits = bitModel->getBits();
         for (unsigned int i = 0; i < signalFieldLength; i++)
             signalFieldBits->appendBit(bits->getBit(i));
         signalFieldBitModel = new ReceptionBitModel(b(signalFieldLength), bitModel->getHeaderBitRate(), b(-1), bps(NaN), signalFieldBits, NaN);
     }
     return signalFieldBitModel;
 }

Referenced by computeReceptionResult().

◆ createSignalFieldPacketModel()

const IReceptionPacketModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createSignalFieldPacketModel ( const IReceptionBitModel * signalFieldBitModel ) const

protected

 {
     const IReceptionPacketModel *signalFieldPacketModel = nullptr;
     if (levelOfDetail > PACKET_DOMAIN) { // Create from the bit model
         if (signalDecoder) // non-complaint
             signalFieldPacketModel = signalDecoder->decode(signalFieldBitModel);
         else { // complaint
                // In compliant mode the code for the signal field is always the following:
             const Ieee80211OfdmDecoder decoder(&Ieee80211OfdmCompliantCodes::ofdmCC1_2BPSKInterleavingWithoutScrambling);
             signalFieldPacketModel = decoder.decode(signalFieldBitModel);
         }
     }
     return signalFieldPacketModel;
 }

Referenced by computeReceptionResult().

◆ createSignalFieldSymbolModel()

const IReceptionSymbolModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createSignalFieldSymbolModel ( const IReceptionSymbolModel * symbolModel ) const

protected

 {
     const Ieee80211OfdmReceptionSymbolModel *signalFieldSymbolModel = nullptr;
     if (levelOfDetail > SYMBOL_DOMAIN)
         throw cRuntimeError("This level of detail is unimplemented!");
     else if (levelOfDetail == SYMBOL_DOMAIN) { // Create from symbol model (made by the error model)
         const std::vector<const ISymbol *> *symbols = receptionSymbolModel->getSymbols();
         std::vector<const ISymbol *> *signalSymbols = new std::vector<const ISymbol *>();
         const Ieee80211OfdmSymbol *signalSymbol = check_and_cast<const Ieee80211OfdmSymbol *>(symbols->at(0));
         signalSymbols->push_back(new Ieee80211OfdmSymbol(*signalSymbol)); // The first symbol is the signal field symbol
         signalFieldSymbolModel = new Ieee80211OfdmReceptionSymbolModel(1, receptionSymbolModel->getHeaderSymbolRate(), -1, NaN, signalSymbols);
     }
     return signalFieldSymbolModel;
 }

Referenced by computeReceptionResult().

◆ createSymbolModel()

const IReceptionSymbolModel * inet::physicallayer::Ieee80211LayeredOfdmReceiver::createSymbolModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir
	)		const

protected

 {
     if (levelOfDetail == SYMBOL_DOMAIN)
         return errorModel->computeSymbolModel(transmission, snir);
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ getCodeRateFromDecoderModule()

double inet::physicallayer::Ieee80211LayeredOfdmReceiver::getCodeRateFromDecoderModule ( const IDecoder * decoder ) const

protected

 {
     const Ieee80211OfdmDecoderModule *decoderModule = check_and_cast<const Ieee80211OfdmDecoderModule *>(decoder);
     const Ieee80211OfdmCode *code = decoderModule->getCode();
     const ConvolutionalCode *convolutionalCode = code->getConvolutionalCode();
     return convolutionalCode ? 1.0 * convolutionalCode->getCodeRatePuncturingN() / convolutionalCode->getCodeRatePuncturingK() : 1;
 }

Referenced by createDataFieldBitModel(), and createSignalFieldBitModel().

◆ getMode()

const Ieee80211OfdmMode * inet::physicallayer::Ieee80211LayeredOfdmReceiver::getMode ( const Packet * packet ) const

virtual

 {
     const auto& modeInd = const_cast<Packet *>(packet)->findTag<Ieee80211ModeInd>();
     if (isCompliant)
         return modeInd != nullptr ? check_and_cast<const Ieee80211OfdmMode *>(modeInd->getMode()) : &Ieee80211OfdmCompliantModes::getCompliantMode(11, MHz(20));
     else
         return mode;
 }

◆ getSignalFieldLength()

unsigned int inet::physicallayer::Ieee80211LayeredOfdmReceiver::getSignalFieldLength ( const BitVector * signalField ) const

protected

 {
     ShortBitVector length;
     for (int i = SIGNAL_LENGTH_FIELD_START; i <= SIGNAL_LENGTH_FIELD_END; i++)
         length.appendBit(signalField->getBit(i));
     return length.toDecimal();
 }

Referenced by createDataFieldBitModel().

◆ initialize()

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

overrideprotectedvirtual

Reimplemented from inet::physicallayer::SnirReceiverBase.

 {
     SnirReceiverBase::initialize(stage);
     if (stage == INITSTAGE_LOCAL) {
         errorModel = dynamic_cast<ILayeredErrorModel *>(getSubmodule("errorModel"));
         dataDecoder = dynamic_cast<IDecoder *>(getSubmodule("dataDecoder"));
         signalDecoder = dynamic_cast<IDecoder *>(getSubmodule("signalDecoder"));
         dataDemodulator = dynamic_cast<IDemodulator *>(getSubmodule("dataDemodulator"));
         signalDemodulator = dynamic_cast<IDemodulator *>(getSubmodule("signalDemodulator"));
         pulseFilter = dynamic_cast<IPulseFilter *>(getSubmodule("pulseFilter"));
         analogDigitalConverter = dynamic_cast<IAnalogDigitalConverter *>(getSubmodule("analogDigitalConverter"));
  
         energyDetection = mW(math::dBmW2mW(par("energyDetection")));
         sensitivity = mW(math::dBmW2mW(par("sensitivity")));
         centerFrequency = Hz(par("centerFrequency"));
         bandwidth = Hz(par("bandwidth"));
         channelSpacing = Hz(par("channelSpacing"));
         isCompliant = par("isCompliant");
         if (isCompliant && (dataDecoder || signalDecoder || dataDemodulator || signalDemodulator || pulseFilter || analogDigitalConverter)) {
             throw cRuntimeError("In compliant mode it is forbidden to the following parameters: dataDecoder, signalDecoder, dataDemodulator, signalDemodulator, pulseFilter, analogDigitalConverter.");
         }
         const char *levelOfDetailStr = par("levelOfDetail");
         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);
     }
 }

◆ printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::physicallayer::SnirReceiverBase.

 {
     stream << "Ieee80211LayeredOfdmReceiver";
     if (level <= PRINT_LEVEL_TRACE)
         stream << EV_FIELD(levelOfDetail)
                << EV_FIELD(mode, printFieldToString(mode, level + 1, evFlags))
                << EV_FIELD(errorModel, printFieldToString(errorModel, level + 1, evFlags))
                << EV_FIELD(dataDecoder, printFieldToString(dataDecoder, level + 1, evFlags))
                << EV_FIELD(signalDecoder, printFieldToString(signalDecoder, level + 1, evFlags))
                << EV_FIELD(dataDemodulator, printFieldToString(dataDemodulator, level + 1, evFlags))
                << EV_FIELD(signalDemodulator, printFieldToString(signalDemodulator, level + 1, evFlags))
                << EV_FIELD(pulseFilter, printFieldToString(pulseFilter, level + 1, evFlags))
                << EV_FIELD(analogDigitalConverter, printFieldToString(analogDigitalConverter, level + 1, evFlags))
                << EV_FIELD(energyDetection)
                << EV_FIELD(sensitivity)
                << EV_FIELD(centerFrequency)
                << EV_FIELD(bandwidth)
                << EV_FIELD(channelSpacing)
                << EV_FIELD(snirThreshold)
                << EV_FIELD(isCompliant);
     return stream;
 }

Member Data Documentation

◆ analogDigitalConverter

const IAnalogDigitalConverter* inet::physicallayer::Ieee80211LayeredOfdmReceiver::analogDigitalConverter = nullptr

protected

Referenced by initialize(), and printToStream().

◆ bandwidth

Hz inet::physicallayer::Ieee80211LayeredOfdmReceiver::bandwidth

protected

Referenced by computeMode(), computeReceptionResult(), createListening(), initialize(), and printToStream().

◆ centerFrequency

Hz inet::physicallayer::Ieee80211LayeredOfdmReceiver::centerFrequency

protected

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

◆ channelSpacing

Hz inet::physicallayer::Ieee80211LayeredOfdmReceiver::channelSpacing

protected

Referenced by computeMode(), computeReceptionResult(), initialize(), and printToStream().

◆ dataDecoder

const IDecoder* inet::physicallayer::Ieee80211LayeredOfdmReceiver::dataDecoder = nullptr

protected

Referenced by computeMode(), createDataFieldBitModel(), createDataFieldPacketModel(), initialize(), and printToStream().

◆ dataDemodulator

const IDemodulator* inet::physicallayer::Ieee80211LayeredOfdmReceiver::dataDemodulator = nullptr

protected

Referenced by computeMode(), createDataFieldBitModel(), initialize(), and printToStream().

◆ energyDetection

W inet::physicallayer::Ieee80211LayeredOfdmReceiver::energyDetection

protected

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

◆ errorModel

const ILayeredErrorModel* inet::physicallayer::Ieee80211LayeredOfdmReceiver::errorModel = nullptr

protected

Referenced by createBitModel(), createPacketModel(), createSampleModel(), createSymbolModel(), initialize(), and printToStream().

◆ isCompliant

bool inet::physicallayer::Ieee80211LayeredOfdmReceiver::isCompliant

protected

Referenced by computeReceptionResult(), createDataFieldBitModel(), createListening(), createSignalFieldBitModel(), getMode(), initialize(), printToStream(), and ~Ieee80211LayeredOfdmReceiver().

◆ levelOfDetail

LevelOfDetail inet::physicallayer::Ieee80211LayeredOfdmReceiver::levelOfDetail

protected

Referenced by createBitModel(), createCompleteBitModel(), createCompleteSymbolModel(), createDataFieldBitModel(), createDataFieldPacketModel(), createDataFieldSymbolModel(), createPacketModel(), createSampleModel(), createSignalFieldBitModel(), createSignalFieldPacketModel(), createSignalFieldSymbolModel(), createSymbolModel(), initialize(), and printToStream().

◆ mode

const Ieee80211OfdmMode* inet::physicallayer::Ieee80211LayeredOfdmReceiver::mode = nullptr

mutableprotected

Referenced by computeReceptionResult(), createDataFieldBitModel(), createDataFieldPacketModel(), getMode(), printToStream(), and ~Ieee80211LayeredOfdmReceiver().

◆ pulseFilter

const IPulseFilter* inet::physicallayer::Ieee80211LayeredOfdmReceiver::pulseFilter = nullptr

protected

Referenced by initialize(), and printToStream().

◆ sensitivity

W inet::physicallayer::Ieee80211LayeredOfdmReceiver::sensitivity

protected

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

◆ signalDecoder

const IDecoder* inet::physicallayer::Ieee80211LayeredOfdmReceiver::signalDecoder = nullptr

protected

Referenced by computeMode(), createSignalFieldBitModel(), createSignalFieldPacketModel(), initialize(), and printToStream().

◆ signalDemodulator

const IDemodulator* inet::physicallayer::Ieee80211LayeredOfdmReceiver::signalDemodulator = nullptr

protected

Referenced by computeMode(), createSignalFieldBitModel(), initialize(), and printToStream().

◆ snirThreshold

double inet::physicallayer::Ieee80211LayeredOfdmReceiver::snirThreshold

protected

Referenced by printToStream().

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Member Enumeration Documentation

◆ LevelOfDetail

Constructor & Destructor Documentation

◆ ~Ieee80211LayeredOfdmReceiver()

Member Function Documentation

◆ calculatePadding()

◆ computeIsReceptionPossible()

◆ computeListeningDecision()

◆ computeMode()

◆ computeReceptionResult()

◆ createAnalogModel()

◆ createBitModel()

◆ createCompleteBitModel()

◆ createCompletePacketModel()

◆ createCompleteSymbolModel()

◆ createDataFieldBitModel()

◆ createDataFieldPacketModel()

◆ createDataFieldSymbolModel()

◆ createListening()

◆ createPacketModel()

◆ createSampleModel()

◆ createSignalFieldBitModel()

◆ createSignalFieldPacketModel()

◆ createSignalFieldSymbolModel()

◆ createSymbolModel()

◆ getCodeRateFromDecoderModule()

◆ getMode()

◆ getSignalFieldLength()

◆ initialize()

◆ printToStream()

Member Data Documentation

◆ analogDigitalConverter

◆ bandwidth

◆ centerFrequency

◆ channelSpacing

◆ dataDecoder

◆ dataDemodulator

◆ energyDetection

◆ errorModel

◆ isCompliant

◆ levelOfDetail

◆ mode

◆ pulseFilter

◆ sensitivity

◆ signalDecoder

◆ signalDemodulator

◆ snirThreshold