#include <Ieee802154UwbIrReceiver.h>

Inheritance diagram for inet::physicallayer::Ieee802154UwbIrReceiver:

Public Member Functions
	Ieee802154UwbIrReceiver ()

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

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

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 std::vector< bool > *	decode (const IReception reception, const std::vector< const IReception > interferingReceptions, const INoise backgroundNoise) const

virtual std::pair< double, double >	integrateWindow (simtime_t_cref pNow, simtime_t_cref burst, const IReception reception, const std::vector< const IReception > interferingReceptions, const INoise backgroundNoise) 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
Ieee802154UwbIrMode	cfg

Additional Inherited Members
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) }

Constructor & Destructor Documentation

◆ Ieee802154UwbIrReceiver()

inet::physicallayer::Ieee802154UwbIrReceiver::Ieee802154UwbIrReceiver ( )

                                                  :
     ReceiverBase()
 {
 }

Member Function Documentation

◆ computeIsReceptionAttempted()

bool inet::physicallayer::Ieee802154UwbIrReceiver::computeIsReceptionAttempted	(	const IListening *	listening,
		const IReception *	reception,
		IRadioSignal::SignalPart	part,
		const IInterference *	interference
	)		const

overridevirtual

Returns whether the reception of the provided part is actually attempted or ignored by the receiver.

For example, it might check that the radio is not already receiving another signal.

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.

 {
     return true;
 }

◆ computeIsReceptionSuccessful()

bool inet::physicallayer::Ieee802154UwbIrReceiver::computeIsReceptionSuccessful	(	const IListening *	listening,
		const IReception *	reception,
		IRadioSignal::SignalPart	part,
		const IInterference *	interference,
		const ISnir *	snir
	)		const

overridevirtual

Returns whether the reception of the provided part is actually successful or failed by the receiver.

For example, it might compute the error rate and draw a random number to make the decision.

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

Implements inet::physicallayer::IReceiver.

 {
     std::vector<bool> *bits = decode(reception, interference->getInterferingReceptions(), interference->getBackgroundNoise());
     int bitLength = bits->size() - 48 - 8;
     bool isReceptionSuccessful = true;
     for (int i = 0; i < bitLength; i++) {
         bool bitValue = bits->at(i);
         EV_INFO << "Received bit at " << i << " is " << (int)bitValue << endl;
     }
     // KLUDGE check fake CRC
     for (int i = 0; i < 8; i++) {
         for (int j = 0; j + i < bitLength; j += 8)
             bits->at(bitLength + i) = bits->at(bitLength + i) ^ bits->at(j + i);
         isReceptionSuccessful &= !bits->at(bitLength + i);
     }
     delete bits;
     return isReceptionSuccessful;
 }

Referenced by computeReceptionDecision().

◆ computeListeningDecision()

const IListeningDecision * inet::physicallayer::Ieee802154UwbIrReceiver::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.

 {
     return new ListeningDecision(listening, true);
 }

◆ computeReceptionDecision()

const IReceptionDecision * inet::physicallayer::Ieee802154UwbIrReceiver::computeReceptionDecision	(	const IListening *	listening,
		const IReception *	reception,
		IRadioSignal::SignalPart	part,
		const IInterference *	interference,
		const ISnir *	snir
	)		const

overridevirtual

Returns the reception decision for the transmission part that specifies whether the reception is possible, attempted, and successful.

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.

 {
     bool isReceptionSuccessful = computeIsReceptionSuccessful(listening, reception, part, interference, snir);
     return new ReceptionDecision(reception, part, true, true, isReceptionSuccessful);
 }

◆ createListening()

const IListening * inet::physicallayer::Ieee802154UwbIrReceiver::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.

 {
     return new BandListening(radio, startTime, endTime, startPosition, endPosition, cfg.centerFrequency, cfg.bandwidth);
 }

◆ decode()

std::vector< bool > * inet::physicallayer::Ieee802154UwbIrReceiver::decode	(	const IReception *	reception,
		const std::vector< const IReception * > *	interferingReceptions,
		const INoise *	backgroundNoise
	)		const

protectedvirtual

 {
     simtime_t now, offset;
     simtime_t aSymbol, shift, burst;
     // times are absolute
     offset = reception->getStartTime() + cfg.preambleLength;
     shift = cfg.shift_duration;
     aSymbol = cfg.data_symbol_duration;
     burst = cfg.burst_duration;
     now = offset + cfg.pulse_duration / 2;
     std::pair<double, double> energyZero, energyOne;
     // Loop to decode each bit value
     int symbol;
     double packetSNIR = 0;
     std::vector<bool> *bits = new std::vector<bool>();
     simtime_t duration = reception->getEndTime() - reception->getStartTime();
     for (symbol = 0; cfg.preambleLength + symbol * aSymbol < duration; symbol++) {
         // sample in window zero
         now = now + cfg.getHoppingPos(symbol) * cfg.burst_duration;
         energyZero = integrateWindow(now, burst, reception, interferingReceptions, backgroundNoise);
         // sample in window one
         now = now + shift;
         energyOne = integrateWindow(now, burst, reception, interferingReceptions, backgroundNoise);
         int decodedBit;
         if (energyZero.second > energyOne.second) {
             decodedBit = 0;
             packetSNIR = packetSNIR + energyZero.first;
         }
         else {
             decodedBit = 1;
             packetSNIR = packetSNIR + energyOne.first;
         }
         bits->push_back(decodedBit);
         now = offset + (symbol + 1) * aSymbol + cfg.pulse_duration / 2;
     }
     // TODO review this whole SNR computation, seems to be wrong (from MiXiM)
     packetSNIR = packetSNIR / (symbol + 1);
     // TODO double snirLastPacket = 10 * log10(packetSNIR);  // convert to dB
     // TODO return SNIR?
     return bits;
 }

Referenced by computeIsReceptionSuccessful().

◆ initialize()

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         cfg = Ieee802154UwbIrMode::cfg_mandatory_16M;
     }
 }

◆ integrateWindow()

std::pair< double, double > inet::physicallayer::Ieee802154UwbIrReceiver::integrateWindow	(	simtime_t_cref	pNow,
		simtime_t_cref	burst,
		const IReception *	reception,
		const std::vector< const IReception * > *	interferingReceptions,
		const INoise *	backgroundNoise
	)		const

protectedvirtual

 {
     std::pair<double, double> energy = std::make_pair(0.0, 0.0); // first: stores SNIR, second: stores total captured window energy
     simtime_t windowEnd = pNow + burst;
     const double peakPulsePower = 1.3E-3; // 1.3E-3 W peak power of pulse to reach  0dBm during burst; // peak instantaneous power of the transmitted pulse (A=0.6V) : 7E-3 W. But peak limit is 0 dBm
     // Triangular baseband pulses
     // we sample at each pulse peak
     // get the interpolated values of amplitude for each interferer
     // and add these to the peak with a random phase
     // we sample one point per pulse
     // caller has already set our time reference ("now") at the peak of the pulse
     for (simtime_t now = pNow; now < windowEnd; now += cfg.pulse_duration) {
         double signalValue = 0; // electric field from tracked signal [V/m²]
         double resPower = 0; // electric field at antenna = combination of all arriving electric fields [V/m²]
         double vEfield = 0; // voltage at antenna caused by electric field Efield [V]
         double vmeasured = 0; // voltage measured by energy-detector [V], including thermal noise
         double vmeasured_square = 0; // to the square [V²]
         double snir = 0; // burst SNIR estimate
         double vThermalNoise = 0; // thermal noise realization
         // consider signal power
         const DimensionalReception *dimensionalSignalReception = check_and_cast<const DimensionalReception *>(reception);
         const Ptr<const IFunction<WpHz, Domain<simsec, Hz>>>& signalPower = dimensionalSignalReception->getPower();
         Interval<simsec, Hz> interval(Point<simsec, Hz>(simsec(now), Hz(3.1)), Point<simsec, Hz>(simsec(now), Hz(10.6)), 0b10, 0b10, 0b10);
         double measure = signalPower->getMean(interval).get() * peakPulsePower; // TODO de-normalize (peakPulsePower should be in AirFrame or in Signal, to be set at run-time)
         signalValue = measure * 0.5; // we capture half of the maximum possible pulse energy to account for self  interference
         resPower = resPower + signalValue;
         // consider all interferers at this point in time
         for (const auto& interferingReception : *interferingReceptions) {
             const DimensionalReception *dimensionalInterferingReception = check_and_cast<const DimensionalReception *>(interferingReception);
             const Ptr<const IFunction<WpHz, Domain<simsec, Hz>>>& interferingPower = dimensionalInterferingReception->getPower();
             double measure = interferingPower->getMean(interval).get() * peakPulsePower; // TODO de-normalize (peakPulsePower should be in AirFrame or in Signal, to be set at run-time)
             // measure = measure * uniform(0, +1); // random point of Efield at sampling (due to pulse waveform and self interference)
             // take a random point within pulse envelope for interferer
             resPower = resPower + measure * uniform(-1, +1);
         }
 //         double attenuatedPower = resPower / 10; // 10 dB = 6 dB implementation loss + 5 dB noise factor
         vEfield = sqrt(50 * resPower); // P=V²/R
         // add thermal noise realization
         const DimensionalNoise *dimensionalBackgroundNoise = check_and_cast<const DimensionalNoise *>(backgroundNoise);
         vThermalNoise = dimensionalBackgroundNoise->getPower()->getMean(interval).get();
         vmeasured = vEfield + vThermalNoise;
         vmeasured_square = pow(vmeasured, 2);
         // signal + interference + noise
         energy.second = energy.second + vmeasured_square; // collect this contribution
         // Now evaluates signal to noise ratio
         // signal converted to antenna voltage squared
         // TODO review this SNIR computation
         snir = signalValue / 2.0217E-12;
         energy.first = energy.first + snir;
  
     } // consider next point in time
     return energy;
 }

Referenced by decode().

◆ printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

 {
     return stream << "Ieee802154UwbIrReceiver";
 }

Member Data Documentation

◆ cfg

Ieee802154UwbIrMode inet::physicallayer::Ieee802154UwbIrReceiver::cfg

protected

Referenced by createListening(), decode(), initialize(), and integrateWindow().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ Ieee802154UwbIrReceiver()

Member Function Documentation

◆ computeIsReceptionAttempted()

◆ computeIsReceptionSuccessful()

◆ computeListeningDecision()

◆ computeReceptionDecision()

◆ createListening()

◆ decode()

◆ initialize()

◆ integrateWindow()

◆ printToStream()

Member Data Documentation

◆ cfg