#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::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	~Ieee80211LayeredOFDMReceiver ()

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 override
	Returns the complete result of the reception process for the provided reception. More...

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::SNIRReceiverBase
	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...

virtual ReceptionIndication *	createReceptionIndication () const
	Returns an empty reception indication (control info). 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 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 IReceptionPacketModel signalFieldPacketModel, const IReceptionPacketModel dataFieldPacketModel) const

const Ieee80211OFDMMode *	computeMode (Hz bandwidth) const

uint8_t	getRate (const BitVector *serializedPacket) 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::SNIRReceiverBase
virtual const ReceptionIndication *	computeReceptionIndication (const ISNIR *snir) const override
	Returns the physical properties of the reception including noise and signal related measures, error probabilities, actual error counts, etc. More...

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

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	carrierFrequency

Hz	bandwidth

Hz	channelSpacing

double	snirThreshold

bool	isCompliant

Protected Attributes inherited from inet::physicallayer::SNIRReceiverBase
double	snirThreshold

Member Enumeration Documentation

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

inet::physicallayer::Ieee80211LayeredOFDMReceiver::~Ieee80211LayeredOFDMReceiver ( )

virtual

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

Member Function Documentation

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

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->getCarrierFrequency() != analogModel->getCarrierFrequency() || 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: minimum reception power = " << minReceptionPower << ", sensitivity = " << sensitivity << " -> reception is " << (isReceptionPossible ? "possible" : "impossible") << endl;
         return isReceptionPossible;
     }
 }

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

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

const IReceptionResult * inet::physicallayer::Ieee80211LayeredOFDMReceiver::computeReceptionResult	(	const IListening *	listening,
		const IReception *	reception,
		const IInterference *	interference,
		const ISNIR *	snir
	)		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 LayeredTransmission *transmission = dynamic_cast<const LayeredTransmission *>(reception->getTransmission());
     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);
 
     const IReceptionSymbolModel *signalFieldSymbolModel = createSignalFieldSymbolModel(symbolModel);
     const IReceptionSymbolModel *dataFieldSymbolModel = createDataFieldSymbolModel(symbolModel);
     const IReceptionBitModel *signalFieldBitModel = createSignalFieldBitModel(bitModel, signalFieldSymbolModel);
     const IReceptionPacketModel *signalFieldPacketModel = createSignalFieldPacketModel(signalFieldBitModel);
     if (isCompliant) {
         uint8_t rate = getRate(signalFieldPacketModel->getSerializedPacket());
         // TODO: handle erroneous rate field
         mode = &Ieee80211OFDMCompliantModes::getCompliantMode(rate, channelSpacing);
     }
     else if (!mode)
         mode = computeMode(bandwidth);
     const IReceptionBitModel *dataFieldBitModel = createDataFieldBitModel(bitModel, dataFieldSymbolModel, signalFieldPacketModel, signalFieldBitModel);
     const IReceptionPacketModel *dataFieldPacketModel = createDataFieldPacketModel(signalFieldBitModel, dataFieldBitModel, signalFieldPacketModel);
 
 //    if (!sampleModel)
 //        sampleModel = createCompleteSampleModel(signalFieldSampleModel, dataFieldSampleModel);
     if (!symbolModel)
         symbolModel = createCompleteSymbolModel(signalFieldSymbolModel, dataFieldSymbolModel);
     if (!bitModel)
         bitModel = createCompleteBitModel(signalFieldBitModel, dataFieldBitModel);
     if (!packetModel)
         packetModel = createCompletePacketModel(signalFieldPacketModel, dataFieldPacketModel);
 
     delete signalFieldSymbolModel;
     delete dataFieldSymbolModel;
     delete signalFieldBitModel;
     delete dataFieldBitModel;
     delete signalFieldPacketModel;
     delete dataFieldPacketModel;
 
     ReceptionIndication *receptionIndication = new ReceptionIndication();
     receptionIndication->setMinSNIR(snir->getMin());
     receptionIndication->setPacketErrorRate(packetModel->getPER());
 // TODO: true, true, packetModel->isPacketErrorless()
     return new LayeredReceptionResult(reception, new std::vector<const IReceptionDecision *>(), receptionIndication, packetModel, bitModel, symbolModel, sampleModel, analogModel);
 }

const IReceptionAnalogModel * inet::physicallayer::Ieee80211LayeredOFDMReceiver::createAnalogModel	(	const LayeredTransmission *	transmission,
		const ISNIR *	snir
	)		const

protected

 {
     return nullptr;
 }

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

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

protected

 {
     if (levelOfDetail >= BIT_DOMAIN) {
         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->getHeaderBitLength(), signalFieldBitModel->getHeaderBitRate(), dataFieldBitModel->getPayloadBitLength(), dataFieldBitModel->getPayloadBitRate(), bits);
     }
     return nullptr;
 }

const IReceptionPacketModel * inet::physicallayer::Ieee80211LayeredOFDMReceiver::createCompletePacketModel	(	const IReceptionPacketModel *	signalFieldPacketModel,
		const IReceptionPacketModel *	dataFieldPacketModel
	)		const

protected

 {
     const BitVector *headerBits = signalFieldPacketModel->getSerializedPacket();
     BitVector *mergedBits = new BitVector(*headerBits);
     const BitVector *dataBits = dataFieldPacketModel->getSerializedPacket();
     for (unsigned int i = 0; i < dataBits->getSize(); i++)
         mergedBits->appendBit(dataBits->getBit(i));
     Ieee80211PhySerializer deserializer;
     cPacket *phyFrame = deserializer.deserialize(mergedBits);
     bool isReceptionSuccessful = true;
     cPacket *packet = phyFrame;
     while (packet != nullptr) {
         isReceptionSuccessful &= !packet->hasBitError();
         packet = packet->getEncapsulatedPacket();
     }
     return new ReceptionPacketModel(phyFrame, mergedBits, bps(NaN), 0, isReceptionSuccessful);
 }

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

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;
         unsigned int psduLengthInBits = getSignalFieldLength(signalFieldPacketModel->getSerializedPacket()) * 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 = signalFieldBitModel->getHeaderBitLength();
         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(-1, bps(NaN), encodedDataFieldLengthInBits, bitModel->getPayloadBitRate(), dataBits);
     }
     return dataFieldBitModel;
 }

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

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

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, carrierFrequency, isCompliant ? Hz(20000000) : bandwidth);
 }

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

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

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(signalFieldLength, bitModel->getHeaderBitRate(), -1, bps(NaN), signalFieldBits);
     }
     return signalFieldBitModel;
 }

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

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

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

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

uint8_t inet::physicallayer::Ieee80211LayeredOFDMReceiver::getRate ( const BitVector * serializedPacket ) const

protected

 {
     ShortBitVector rate;
     for (unsigned int i = 0; i < 4; i++)
         rate.appendBit(serializedPacket->getBit(i));
     return rate.toDecimal();
 }

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

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

overrideprotectedvirtual

Reimplemented from inet::physicallayer::SNIRReceiverBase.

 {
     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::dBm2mW(par("energyDetection")));
         sensitivity = mW(math::dBm2mW(par("sensitivity")));
         carrierFrequency = Hz(par("carrierFrequency"));
         bandwidth = Hz(par("bandwidth"));
         snirThreshold = math::dB2fraction(par("snirThreshold"));
         channelSpacing = Hz(par("channelSpacing"));
         isCompliant = par("isCompliant").boolValue();
         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").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::Ieee80211LayeredOFDMReceiver::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::SNIRReceiverBase.

 {
     stream << "Ieee80211LayeredOFDMReceiver";
     if (level <= PRINT_LEVEL_TRACE)
         stream << ", levelOfDetail = " << levelOfDetail
                << ", mode = " << printObjectToString(mode, level + 1)
                << ", errorModel = " << printObjectToString(errorModel, level + 1)
                << ", dataDecoder = " << printObjectToString(dataDecoder, level + 1)
                << ", signalDecoder = " << printObjectToString(signalDecoder, level + 1)
                << ", dataDemodulator = " << printObjectToString(dataDemodulator, level + 1)
                << ", signalDemodulator = " << printObjectToString(signalDemodulator, level + 1)
                << ", pulseFilter = " << printObjectToString(pulseFilter, level + 1)
                << ", analogDigitalConverter = " << printObjectToString(analogDigitalConverter, level + 1)
                << ", energyDetection = " << energyDetection
                << ", sensitivity = " << energyDetection
                << ", carrierFrequency = " << carrierFrequency
                << ", bandwidth = " << bandwidth
                << ", channelSpacing = " << channelSpacing
                << ", snirThreshold = " << snirThreshold
                << ", isCompliant = " << isCompliant;
     return stream;
 }

Member Data Documentation

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

protected

Hz inet::physicallayer::Ieee80211LayeredOFDMReceiver::bandwidth

protected

Hz inet::physicallayer::Ieee80211LayeredOFDMReceiver::carrierFrequency

protected

Hz inet::physicallayer::Ieee80211LayeredOFDMReceiver::channelSpacing

protected

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

protected

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

protected

W inet::physicallayer::Ieee80211LayeredOFDMReceiver::energyDetection

protected

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

protected

bool inet::physicallayer::Ieee80211LayeredOFDMReceiver::isCompliant

protected

LevelOfDetail inet::physicallayer::Ieee80211LayeredOFDMReceiver::levelOfDetail

protected

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

mutableprotected

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

protected

W inet::physicallayer::Ieee80211LayeredOFDMReceiver::sensitivity

protected

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

protected

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

protected

double inet::physicallayer::Ieee80211LayeredOFDMReceiver::snirThreshold

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