inet::physicallayer::APSKLayeredTransmitter Class Reference

#include <APSKLayeredTransmitter.h>

Inheritance diagram for inet::physicallayer::APSKLayeredTransmitter:

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
	APSKLayeredTransmitter ()
virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...
virtual const IEncoder *	getEncoder () const
virtual const IModulator *	getModulator () const
virtual const IPulseShaper *	getPulseShaper () const
virtual const IDigitalAnalogConverter *	getDigitalAnalogConverter () const
virtual W	getPower () const
virtual bps	getBitrate () const
virtual const Hz	getBandwidth () const
virtual const Hz	getCarrierFrequency () 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...
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...
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
virtual int	computePaddingLength (BitVector *bits) const
virtual const APSKPhyFrame *	createPhyFrame (const cPacket *macFrame) const
virtual const ITransmissionPacketModel *	createPacketModel (const APSKPhyFrame *phyFrame) const
virtual const ITransmissionBitModel *	createBitModel (const ITransmissionPacketModel *packetModel) const
virtual const ITransmissionSymbolModel *	createSymbolModel (const ITransmissionBitModel *bitModel) const
virtual const ITransmissionSampleModel *	createSampleModel (const ITransmissionSymbolModel *symbolModel) const
virtual const ITransmissionAnalogModel *	createAnalogModel (const ITransmissionPacketModel *packetModel, const ITransmissionBitModel *bitModel, const ITransmissionSampleModel *sampleModel) const
Protected Member Functions inherited from inet::physicallayer::TransmitterBase
virtual int	numInitStages () const override

Protected Attributes
LevelOfDetail	levelOfDetail
const IEncoder *	encoder
const IModulator *	modulator
const IPulseShaper *	pulseShaper
const IDigitalAnalogConverter *	digitalAnalogConverter
W	power
bps	bitrate
Hz	bandwidth
Hz	carrierFrequency

Member Enumeration Documentation

enum inet::physicallayer::APSKLayeredTransmitter::LevelOfDetail

Enumerator
PACKET_DOMAIN
BIT_DOMAIN
SYMBOL_DOMAIN
SAMPLE_DOMAIN

                       {
        PACKET_DOMAIN,
        BIT_DOMAIN,
        SYMBOL_DOMAIN,
        SAMPLE_DOMAIN,
    };

Constructor & Destructor Documentation

inet::physicallayer::APSKLayeredTransmitter::APSKLayeredTransmitter

(

)

                                               :
    levelOfDetail((LevelOfDetail) - 1),
    encoder(nullptr),
    modulator(nullptr),
    pulseShaper(nullptr),
    digitalAnalogConverter(nullptr),
    power(W(NaN)),
    bitrate(bps(NaN)),
    bandwidth(Hz(NaN)),
    carrierFrequency(Hz(NaN))
{
}

Member Function Documentation

int inet::physicallayer::APSKLayeredTransmitter::computePaddingLength ( BitVector *  bits ) const

protectedvirtual

Referenced by createPacketModel().

{
    const ConvolutionalCode *forwardErrorCorrection = nullptr;
    if (encoder) {
        const APSKEncoder *apskEncoder = check_and_cast<const APSKEncoder *>(encoder);
        forwardErrorCorrection = apskEncoder->getCode()->getConvolutionalCode();
    }
    int modulationCodeWordSize = check_and_cast<const APSKModulationBase *>(modulator->getModulation())->getCodeWordSize();
    int encodedCodeWordSize = forwardErrorCorrection == nullptr ? modulationCodeWordSize : modulationCodeWordSize *forwardErrorCorrection->getCodeRatePuncturingK();
    return (encodedCodeWordSize - bits->getSize() % encodedCodeWordSize) % encodedCodeWordSize;
}

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

protectedvirtual

Referenced by createTransmission().

{
    if (digitalAnalogConverter) {
        if (sampleModel == nullptr)
            throw cRuntimeError("Digital analog converter needs sample domain representation");
        else
            return digitalAnalogConverter->convertDigitalToAnalog(sampleModel);
    }
    else {
        simtime_t duration = packetModel->getPacket()->getBitLength() / bitrate.get();
        return new ScalarTransmissionSignalAnalogModel(duration, carrierFrequency, bandwidth, power);
    }
}

const ITransmissionBitModel * inet::physicallayer::APSKLayeredTransmitter::createBitModel ( const ITransmissionPacketModel *  packetModel ) const

protectedvirtual

Referenced by createTransmission().

{
    if (levelOfDetail >= BIT_DOMAIN)
        return encoder->encode(packetModel);
    else {
        int netHeaderBitLength = APSK_PHY_FRAME_HEADER_BYTE_LENGTH * 8;
        int netPayloadBitLength = packetModel->getSerializedPacket()->getSize() - netHeaderBitLength;
        if (encoder) {
            const APSKEncoder *apskEncoder = check_and_cast<const APSKEncoder *>(encoder);
            const ConvolutionalCode *forwardErrorCorrection = apskEncoder->getCode()->getConvolutionalCode();
            if (forwardErrorCorrection == nullptr)
                return new TransmissionBitModel(netHeaderBitLength, bitrate, netPayloadBitLength, bitrate, nullptr, forwardErrorCorrection, nullptr, nullptr);
            else {
                int grossHeaderBitLength = forwardErrorCorrection->getEncodedLength(netHeaderBitLength);
                int grossPayloadBitLength = forwardErrorCorrection->getEncodedLength(netPayloadBitLength);
                bps grossBitrate = bitrate / forwardErrorCorrection->getCodeRate();
                return new TransmissionBitModel(grossHeaderBitLength, grossBitrate, grossPayloadBitLength, grossBitrate, nullptr, forwardErrorCorrection, nullptr, nullptr);
            }
        }
        else
            return new TransmissionBitModel(netHeaderBitLength, bitrate, netPayloadBitLength, bitrate, nullptr, nullptr, nullptr, nullptr);
    }
}

const ITransmissionPacketModel * inet::physicallayer::APSKLayeredTransmitter::createPacketModel ( const APSKPhyFrame *  phyFrame ) const

protectedvirtual

Referenced by createTransmission().

{
    if (levelOfDetail >= PACKET_DOMAIN) {
        BitVector *bits = APSKPhyFrameSerializer().serialize(phyFrame);
        bits->appendBit(0, computePaddingLength(bits));
        return new TransmissionPacketModel(phyFrame, bits, bitrate);
    }
    else
        return new TransmissionPacketModel(phyFrame, nullptr, bitrate);
}

const APSKPhyFrame * inet::physicallayer::APSKLayeredTransmitter::createPhyFrame ( const cPacket *  macFrame ) const

protectedvirtual

Referenced by createTransmission().

{
    APSKPhyFrame *phyFrame = new APSKPhyFrame();
    phyFrame->setByteLength(APSK_PHY_FRAME_HEADER_BYTE_LENGTH);
    phyFrame->encapsulate(const_cast<cPacket *>(macFrame));
    return phyFrame;
}

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

protectedvirtual

Referenced by createTransmission().

{
    if (levelOfDetail >= SAMPLE_DOMAIN)
        return pulseShaper->shape(symbolModel);
    else
        return nullptr;
}

const ITransmissionSymbolModel * inet::physicallayer::APSKLayeredTransmitter::createSymbolModel ( const ITransmissionBitModel *  bitModel ) const

protectedvirtual

Referenced by createTransmission().

{
    if (levelOfDetail >= SYMBOL_DOMAIN)
        return modulator->modulate(bitModel);
    else
        return new TransmissionSymbolModel(-1, NaN, -1, NaN, nullptr, modulator->getModulation(), modulator->getModulation());
}

const ITransmission * inet::physicallayer::APSKLayeredTransmitter::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.

{
    const APSKPhyFrame *phyFrame = createPhyFrame(macFrame);
    const ITransmissionPacketModel *packetModel = createPacketModel(phyFrame);
    const ITransmissionBitModel *bitModel = createBitModel(packetModel);
    const ITransmissionSymbolModel *symbolModel = createSymbolModel(bitModel);
    const ITransmissionSampleModel *sampleModel = createSampleModel(symbolModel);
    const ITransmissionAnalogModel *analogModel = createAnalogModel(packetModel, bitModel, sampleModel);
    // assuming movement and rotation during transmission is negligible
    IMobility *mobility = transmitter->getAntenna()->getMobility();
    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);
}

virtual const Hz inet::physicallayer::APSKLayeredTransmitter::getBandwidth ( ) const

inlinevirtual

{ return bandwidth; }

virtual bps inet::physicallayer::APSKLayeredTransmitter::getBitrate ( ) const

inlinevirtual

{ return bitrate; }

virtual const Hz inet::physicallayer::APSKLayeredTransmitter::getCarrierFrequency ( ) const

inlinevirtual

{ return carrierFrequency; }

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

inlinevirtual

{ return digitalAnalogConverter; }

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

inlinevirtual

{ return encoder; }

virtual m inet::physicallayer::APSKLayeredTransmitter::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.

{ return m(NaN); }

virtual m inet::physicallayer::APSKLayeredTransmitter::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.

{ return m(NaN); }

virtual W inet::physicallayer::APSKLayeredTransmitter::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.

{ return power; }

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

inlinevirtual

{ return modulator; }

virtual W inet::physicallayer::APSKLayeredTransmitter::getPower ( ) const

inlinevirtual

{ return power; }

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

inlinevirtual

{ return pulseShaper; }

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        encoder = dynamic_cast<const IEncoder *>(getSubmodule("encoder"));
        modulator = dynamic_cast<const IModulator *>(getSubmodule("modulator"));
        pulseShaper = dynamic_cast<const IPulseShaper *>(getSubmodule("pulseShaper"));
        digitalAnalogConverter = dynamic_cast<const IDigitalAnalogConverter *>(getSubmodule("digitalAnalogConverter"));
        power = W(par("power"));
        bitrate = bps(par("bitrate"));
        bandwidth = Hz(par("bandwidth"));
        carrierFrequency = Hz(par("carrierFrequency"));
        const char *levelOfDetailStr = par("levelOfDetail").stringValue();
        if (strcmp("packet", levelOfDetailStr) == 0)
            levelOfDetail = PACKET_DOMAIN;
        else 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
            throw cRuntimeError("Unknown level of detail='%s'", levelOfDetailStr);
        if (levelOfDetail >= BIT_DOMAIN && !encoder)
            throw cRuntimeError("Encoder not configured");
        if (levelOfDetail >= SYMBOL_DOMAIN && !modulator)
            throw cRuntimeError("Modulator not configured");
        if (levelOfDetail >= SAMPLE_DOMAIN && !pulseShaper)
            throw cRuntimeError("Pulse shaper not configured");
    }
}

std::ostream & inet::physicallayer::APSKLayeredTransmitter::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 << "APSKLayeredTransmitter";
    if (level <= PRINT_LEVEL_DETAIL)
        stream << ", levelOfDetail = " << levelOfDetail
               << ", carrierFrequency = " << carrierFrequency;
    if (level <= PRINT_LEVEL_TRACE)
        stream << ", encoder = " << printObjectToString(encoder, level + 1) 
               << ", modulator = " << printObjectToString(modulator, level + 1) 
               << ", pulseShaper = " << printObjectToString(pulseShaper, level + 1) 
               << ", digitalAnalogConverter = " << printObjectToString(digitalAnalogConverter, level + 1) 
               << ", power = " << power
               << ", bitrate = " << bitrate
               << ", bandwidth = " << bandwidth;
    return stream;
}

Member Data Documentation

Hz inet::physicallayer::APSKLayeredTransmitter::bandwidth

protected

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

bps inet::physicallayer::APSKLayeredTransmitter::bitrate

protected

Referenced by createAnalogModel(), createBitModel(), createPacketModel(), initialize(), and printToStream().

Hz inet::physicallayer::APSKLayeredTransmitter::carrierFrequency

protected

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

const IDigitalAnalogConverter* inet::physicallayer::APSKLayeredTransmitter::digitalAnalogConverter

protected

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

const IEncoder* inet::physicallayer::APSKLayeredTransmitter::encoder

protected

Referenced by computePaddingLength(), createBitModel(), initialize(), and printToStream().

LevelOfDetail inet::physicallayer::APSKLayeredTransmitter::levelOfDetail

protected

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

const IModulator* inet::physicallayer::APSKLayeredTransmitter::modulator

protected

Referenced by computePaddingLength(), createSymbolModel(), initialize(), and printToStream().

W inet::physicallayer::APSKLayeredTransmitter::power

protected

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

const IPulseShaper* inet::physicallayer::APSKLayeredTransmitter::pulseShaper

protected

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

---

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

• APSKLayeredTransmitter.h
• APSKLayeredTransmitter.cc