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::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
	ApskLayeredTransmitter ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) 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	getCenterFrequency () 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 communication range. More...
virtual m	getMaxInterferenceRange () const override
	Returns the maximum interference range. More...
virtual const ITransmission *	createTransmission (const IRadio *radio, const Packet *packet, const simtime_t startTime) const override
	Returns a transmission which describes the radio signal corresponding to the provided packet. 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
virtual const ITransmissionPacketModel *	createPacketModel (const Packet *packet) 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	centerFrequency

Member Enumeration Documentation

LevelOfDetail

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

ApskLayeredTransmitter()

inet::physicallayer::ApskLayeredTransmitter::ApskLayeredTransmitter

(

)

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

Member Function Documentation

createAnalogModel()

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

protectedvirtual

{
    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, centerFrequency, bandwidth, power);
    }
}

Referenced by createTransmission().

createBitModel()

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

protectedvirtual

{
    if (levelOfDetail >= BIT_DOMAIN)
        return encoder->encode(packetModel);
    else {
        auto packet = packetModel->getPacket();
        b netHeaderLength = packet->peekAtFront<ApskPhyHeader>()->getChunkLength();
        b netDataLength = packet->getTotalLength() - netHeaderLength;
        if (encoder) {
            const ApskEncoder *apskEncoder = check_and_cast<const ApskEncoder *>(encoder);
            const ConvolutionalCode *forwardErrorCorrection = apskEncoder->getCode()->getConvolutionalCode();
            if (forwardErrorCorrection == nullptr)
                return new TransmissionBitModel(netHeaderLength, bitrate, netDataLength, bitrate, nullptr, forwardErrorCorrection, nullptr, nullptr);
            else {
                b grossHeaderLength = b(forwardErrorCorrection->getEncodedLength(b(netHeaderLength).get()));
                b grossDataLength = b(forwardErrorCorrection->getEncodedLength(b(netDataLength).get()));
                bps grossBitrate = bitrate / forwardErrorCorrection->getCodeRate();
                return new TransmissionBitModel(grossHeaderLength, grossBitrate, grossDataLength, grossBitrate, nullptr, forwardErrorCorrection, nullptr, nullptr);
            }
        }
        else
            return new TransmissionBitModel(netHeaderLength, bitrate, netDataLength, bitrate, nullptr, nullptr, nullptr, nullptr);
    }
}

Referenced by createTransmission().

createPacketModel()

const ITransmissionPacketModel * inet::physicallayer::ApskLayeredTransmitter::createPacketModel ( const Packet *  packet ) const

protectedvirtual

{
    return new TransmissionPacketModel(check_and_cast<const Packet *>(packet), bitrate);
}

Referenced by createTransmission().

createSampleModel()

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

protectedvirtual

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

Referenced by createTransmission().

createSymbolModel()

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

protectedvirtual

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

Referenced by createTransmission().

createTransmission()

const ITransmission * inet::physicallayer::ApskLayeredTransmitter::createTransmission ( const IRadio *  transmitter, const Packet *  packet, const simtime_t  startTime  ) const

overridevirtual

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

This function never returns nullptr.

Implements inet::physicallayer::ITransmitter.

{
    const ITransmissionPacketModel *packetModel = createPacketModel(packet);
    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 Quaternion& startOrientation = mobility->getCurrentAngularPosition();
    const Quaternion& endOrientation = mobility->getCurrentAngularPosition();
    return new LayeredTransmission(packetModel, bitModel, symbolModel, sampleModel, analogModel, transmitter, packet, startTime, endTime, -1, -1, -1, startPosition, endPosition, startOrientation, endOrientation);
}

getBandwidth()

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

inlinevirtual

{ return bandwidth; }

getBitrate()

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

inlinevirtual

{ return bitrate; }

getCenterFrequency()

virtual const Hz inet::physicallayer::ApskLayeredTransmitter::getCenterFrequency ( ) const

inlinevirtual

{ return centerFrequency; }

getDigitalAnalogConverter()

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

inlinevirtual

{ return digitalAnalogConverter; }

getEncoder()

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

inlinevirtual

{ return encoder; }

getMaxCommunicationRange()

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

inlineoverridevirtual

Returns the maximum communication range.

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

Reimplemented from inet::physicallayer::TransmitterBase.

{ return m(NaN); }

getMaxInterferenceRange()

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

getMaxPower()

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

getModulator()

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

inlinevirtual

{ return modulator; }

getPower()

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

inlinevirtual

{ return power; }

getPulseShaper()

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

inlinevirtual

{ return pulseShaper; }

initialize()

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"));
        if (bitrate <= bps(0))
            throw cRuntimeError("Invalid birate: %s", bitrate.str().c_str());
        bandwidth = Hz(par("bandwidth"));
        centerFrequency = Hz(par("centerFrequency"));
        const char *levelOfDetailStr = par("levelOfDetail");
        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");
    }
}

printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

{
    stream << "ApskLayeredTransmitter";
    if (level <= PRINT_LEVEL_DETAIL)
        stream << EV_FIELD(levelOfDetail)
               << EV_FIELD(centerFrequency);
    if (level <= PRINT_LEVEL_TRACE)
        stream << EV_FIELD(encoder, printFieldToString(encoder, level + 1, evFlags))
               << EV_FIELD(modulator, printFieldToString(modulator, level + 1, evFlags))
               << EV_FIELD(pulseShaper, printFieldToString(pulseShaper, level + 1, evFlags))
               << EV_FIELD(digitalAnalogConverter, printFieldToString(digitalAnalogConverter, level + 1, evFlags))
               << EV_FIELD(power)
               << EV_FIELD(bitrate)
               << EV_FIELD(bandwidth);
    return stream;
}

Member Data Documentation

bandwidth

Hz inet::physicallayer::ApskLayeredTransmitter::bandwidth

protected

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

bitrate

bps inet::physicallayer::ApskLayeredTransmitter::bitrate

protected

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

centerFrequency

Hz inet::physicallayer::ApskLayeredTransmitter::centerFrequency

protected

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

digitalAnalogConverter

const IDigitalAnalogConverter* inet::physicallayer::ApskLayeredTransmitter::digitalAnalogConverter

protected

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

encoder

const IEncoder* inet::physicallayer::ApskLayeredTransmitter::encoder

protected

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

levelOfDetail

LevelOfDetail inet::physicallayer::ApskLayeredTransmitter::levelOfDetail

protected

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

modulator

const IModulator* inet::physicallayer::ApskLayeredTransmitter::modulator

protected

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

power

W inet::physicallayer::ApskLayeredTransmitter::power

protected

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

pulseShaper

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