Ieee80211: relax receiver center frequency matching to band containment for HT40 subchannels

- NarrowbandReceiverBase: check signal band containment in listening band instead of exact center frequency match
- ScalarReceiverAnalogModel / DimensionalReceiverAnalogModel: accept signals whose band is contained in listening band
- ScalarMediumAnalogModel: treat receptions contained in listening band as full interference
- Ieee80211LayeredOfdmReceiver / ApskLayeredReceiver: update reception possibility to use band containment
- omnetpp.ini: add sameTransmissionStartTimeCheck = "ignore" in channelwidths example
- Tests: add unit test Ieee80211Ht40SubchannelReception_1

Author: mgonzalezlopezudc

examples/wireless/channelwidths/omnetpp.ini

@@ -11,6 +11,7 @@ sim-time-limit = 2s
 # Radio medium parameters
 **.radioMedium.backgroundNoise.power = -110dBm
 **.radioMedium.analogModel.ignorePartialInterference = true
+**.radioMedium.sameTransmissionStartTimeCheck = "ignore"
 
 # Wi-Fi physical parameters
 **.wlan[*].opMode = "n(mixed-2.4Ghz)"

src/inet/physicallayer/wireless/apsk/bitlevel/ApskLayeredReceiver.cc

@@ -197,7 +197,11 @@ bool ApskLayeredReceiver::computeIsReceptionPossible(const IListening *listening
     const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
     // TODO scalar
     const ScalarReceptionAnalogModel *analogModel = check_and_cast<const ScalarReceptionAnalogModel *>(reception->getAnalogModel());
-    if (bandListening->getCenterFrequency() != analogModel->getCenterFrequency() || bandListening->getBandwidth() != analogModel->getBandwidth()) {
+    auto listeningMin = bandListening->getCenterFrequency() - bandListening->getBandwidth() / 2;
+    auto listeningMax = bandListening->getCenterFrequency() + bandListening->getBandwidth() / 2;
+    auto receptionMin = analogModel->getCenterFrequency() - analogModel->getBandwidth() / 2;
+    auto receptionMax = analogModel->getCenterFrequency() + analogModel->getBandwidth() / 2;
+    if (receptionMin < listeningMin || receptionMax > listeningMax) {
         EV_DEBUG << "Computing reception possible: listening and reception bands are different -> reception is impossible" << endl;
         return false;
     }

src/inet/physicallayer/wireless/common/analogmodel/dimensional/DimensionalReceiverAnalogModel.cc

@@ -48,7 +48,11 @@ bool DimensionalReceiverAnalogModel::computeIsReceptionPossible(const IListening
 
     const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
     const DimensionalReceptionAnalogModel *analogModel = check_and_cast<const DimensionalReceptionAnalogModel *>(reception->getAnalogModel());
-    if (bandListening->getCenterFrequency() != analogModel->getCenterFrequency() || bandListening->getBandwidth() < analogModel->getBandwidth()) {
+    auto listeningMin = bandListening->getCenterFrequency() - bandListening->getBandwidth() / 2;
+    auto listeningMax = bandListening->getCenterFrequency() + bandListening->getBandwidth() / 2;
+    auto receptionMin = analogModel->getCenterFrequency() - analogModel->getBandwidth() / 2;
+    auto receptionMax = analogModel->getCenterFrequency() + analogModel->getBandwidth() / 2;
+    if (receptionMin < listeningMin || receptionMax > listeningMax) {
         EV_DEBUG << "Computing whether reception is possible: listening and reception bands are different -> reception is impossible" << endl;
         return false;
     }

src/inet/physicallayer/wireless/common/analogmodel/scalar/ScalarMediumAnalogModel.cc

@@ -123,20 +123,26 @@ const INoise *ScalarMediumAnalogModel::computeNoise(const IListening *listening,
     std::map<simtime_t, W> powerChanges;
     powerChanges[math::getLowerBound<simtime_t>()] = W(0);
     powerChanges[math::getUpperBound<simtime_t>()] = W(0);
+    auto listeningMin = commonCenterFrequency - commonBandwidth / 2;
+    auto listeningMax = commonCenterFrequency + commonBandwidth / 2;
     const std::vector<const IReception *> *interferingReceptions = interference->getInterferingReceptions();
     for (auto reception : *interferingReceptions) {
         auto signalAnalogModel = reception->getAnalogModel();
         auto receptionAnalogModel = check_and_cast<const ScalarReceptionAnalogModel *>(signalAnalogModel);
         Hz signalCenterFrequency = receptionAnalogModel->getCenterFrequency();
         Hz signalBandwidth = receptionAnalogModel->getBandwidth();
-        if (commonCenterFrequency == signalCenterFrequency && commonBandwidth >= signalBandwidth)
+        auto signalMin = signalCenterFrequency - signalBandwidth / 2;
+        auto signalMax = signalCenterFrequency + signalBandwidth / 2;
+        if (signalMin >= listeningMin && signalMax <= listeningMax)
             addReception(reception, noiseStartTime, noiseEndTime, powerChanges);
         else if (!ignorePartialInterference && areOverlappingBands(commonCenterFrequency, commonBandwidth, signalCenterFrequency, signalBandwidth))
             throw cRuntimeError("Partially interfering signals are not supported by ScalarMediumAnalogModel, enable ignorePartialInterference to avoid this error!");
     }
     const ScalarNoise *scalarBackgroundNoise = dynamic_cast<const ScalarNoise *>(interference->getBackgroundNoise());
     if (scalarBackgroundNoise) {
-        if (commonCenterFrequency == scalarBackgroundNoise->getCenterFrequency() && commonBandwidth >= scalarBackgroundNoise->getBandwidth())
+        auto bgMin = scalarBackgroundNoise->getCenterFrequency() - scalarBackgroundNoise->getBandwidth() / 2;
+        auto bgMax = scalarBackgroundNoise->getCenterFrequency() + scalarBackgroundNoise->getBandwidth() / 2;
+        if (bgMin >= listeningMin && bgMax <= listeningMax)
             addNoise(scalarBackgroundNoise, noiseStartTime, noiseEndTime, powerChanges);
         else if (!ignorePartialInterference && areOverlappingBands(commonCenterFrequency, commonBandwidth, scalarBackgroundNoise->getCenterFrequency(), scalarBackgroundNoise->getBandwidth()))
             throw cRuntimeError("Partially interfering background noise is not supported by ScalarMediumAnalogModel, enable ignorePartialInterference to avoid this error!");

src/inet/physicallayer/wireless/common/analogmodel/scalar/ScalarReceiverAnalogModel.cc

@@ -46,7 +46,11 @@ bool ScalarReceiverAnalogModel::computeIsReceptionPossible(const IListening *lis
 
     const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
     const ScalarReceptionAnalogModel *analogModel = check_and_cast<const ScalarReceptionAnalogModel *>(reception->getAnalogModel());
-    if (bandListening->getCenterFrequency() != analogModel->getCenterFrequency() || bandListening->getBandwidth() < analogModel->getBandwidth()) {
+    auto listeningMin = bandListening->getCenterFrequency() - bandListening->getBandwidth() / 2;
+    auto listeningMax = bandListening->getCenterFrequency() + bandListening->getBandwidth() / 2;
+    auto receptionMin = analogModel->getCenterFrequency() - analogModel->getBandwidth() / 2;
+    auto receptionMax = analogModel->getCenterFrequency() + analogModel->getBandwidth() / 2;
+    if (receptionMin < listeningMin || receptionMax > listeningMax) {
         EV_DEBUG << "Computing whether reception is possible: listening and reception bands are different -> reception is impossible" << endl;
         return false;
     }

src/inet/physicallayer/wireless/common/base/packetlevel/NarrowbandReceiverBase.cc

@@ -55,15 +55,29 @@ bool NarrowbandReceiverBase::computeIsReceptionPossible(const IListening *listen
 {
     // TODO check if modulation matches?
     auto narrowbandTransmission = check_and_cast<const INarrowbandSignalAnalogModel *>(transmission->getAnalogModel());
-    return centerFrequency == narrowbandTransmission->getCenterFrequency() && bandwidth >= narrowbandTransmission->getBandwidth();
+    Hz listeningCenter = centerFrequency;
+    Hz listeningBandwidth = bandwidth;
+    if (auto bandListening = dynamic_cast<const BandListening *>(listening)) {
+        listeningCenter = bandListening->getCenterFrequency();
+        listeningBandwidth = bandListening->getBandwidth();
+    }
+    auto listeningMin = listeningCenter - listeningBandwidth / 2;
+    auto listeningMax = listeningCenter + listeningBandwidth / 2;
+    auto transmissionMin = narrowbandTransmission->getCenterFrequency() - narrowbandTransmission->getBandwidth() / 2;
+    auto transmissionMax = narrowbandTransmission->getCenterFrequency() + narrowbandTransmission->getBandwidth() / 2;
+    return transmissionMin >= listeningMin && transmissionMax <= listeningMax;
 }
 
 // TODO this is not purely functional, see interface comment
 bool NarrowbandReceiverBase::computeIsReceptionPossible(const IListening *listening, const IReception *reception, IRadioSignal::SignalPart part) const
 {
     const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
     auto narrowbandReception = check_and_cast<const INarrowbandSignalAnalogModel *>(reception->getAnalogModel());
-    if (bandListening->getCenterFrequency() != narrowbandReception->getCenterFrequency() || bandListening->getBandwidth() < narrowbandReception->getBandwidth()) {
+    auto listeningMin = bandListening->getCenterFrequency() - bandListening->getBandwidth() / 2;
+    auto listeningMax = bandListening->getCenterFrequency() + bandListening->getBandwidth() / 2;
+    auto receptionMin = narrowbandReception->getCenterFrequency() - narrowbandReception->getBandwidth() / 2;
+    auto receptionMax = narrowbandReception->getCenterFrequency() + narrowbandReception->getBandwidth() / 2;
+    if (receptionMin < listeningMin || receptionMax > listeningMax) {
         EV_DEBUG << "Computing whether reception is possible: listening and reception bands are different -> reception is impossible" << endl;
         return false;
     }

src/inet/physicallayer/wireless/ieee80211/bitlevel/Ieee80211LayeredOfdmReceiver.cc

@@ -466,7 +466,11 @@ bool Ieee80211LayeredOfdmReceiver::computeIsReceptionPossible(const IListening *
     else {
         const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
         const DimensionalReceptionAnalogModel *analogModel = check_and_cast<const DimensionalReceptionAnalogModel *>(reception->getAnalogModel());
-        if (bandListening->getCenterFrequency() != analogModel->getCenterFrequency() || bandListening->getBandwidth() != analogModel->getBandwidth()) {
+        auto listeningMin = bandListening->getCenterFrequency() - bandListening->getBandwidth() / 2;
+        auto listeningMax = bandListening->getCenterFrequency() + bandListening->getBandwidth() / 2;
+        auto receptionMin = analogModel->getCenterFrequency() - analogModel->getBandwidth() / 2;
+        auto receptionMax = analogModel->getCenterFrequency() + analogModel->getBandwidth() / 2;
+        if (receptionMin < listeningMin || receptionMax > listeningMax) {
             EV_DEBUG << "Computing reception possible: listening and reception bands are different -> reception is impossible" << endl;
             return false;
         }

tests/unit/Ieee80211Ht40SubchannelReception_1.test

@@ -0,0 +1,74 @@
+%description:
+Validate that HT40 listening on the bonded 40 MHz channel accepts 20 MHz transmissions on either primary or secondary subchannel as well as 40 MHz bonded transmissions, and rejects out-of-band transmissions.
+
+%includes:
+#include "inet/common/Units.h"
+#include "inet/physicallayer/wireless/common/radio/packetlevel/BandListening.h"
+#include "inet/physicallayer/wireless/common/analogmodel/scalar/ScalarReceptionAnalogModel.h"
+#include "inet/physicallayer/wireless/common/analogmodel/scalar/ScalarReceiverAnalogModel.h"
+#include "inet/physicallayer/wireless/common/analogmodel/scalar/ScalarTransmissionAnalogModel.h"
+#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211Band.h"
+#include "inet/physicallayer/wireless/ieee80211/mode/Ieee80211Channel.h"
+
+%global:
+using namespace inet;
+using namespace inet::physicallayer;
+using namespace inet::units::values;
+
+%activity:
+{
+    const IIeee80211Band *band24 = Ieee80211CompliantBands::getBand("2.4 GHz");
+    ASSERT(band24 != nullptr);
+
+    // Channel 0 (2412 MHz) HT40+ (secondary above, bonded = 2422 MHz, span = [2402, 2442] MHz)
+    Ieee80211Channel ch0Above(band24, 0, IEEE80211_SECONDARY_CHANNEL_ABOVE);
+    Hz bondedCenter = ch0Above.getBondedCenterFrequency();
+    Hz bondedBw = MHz(40);
+
+    BandListening listening40(nullptr, 0, 1, Coord::ZERO, Coord::ZERO, bondedCenter, bondedBw);
+
+    // Primary 20 MHz signal (center 2412 MHz, span = [2402, 2422] MHz)
+    ScalarTransmissionAnalogModel primaryTxModel(0, 0, 1, ch0Above.getCenterFrequency(), MHz(20), mW(20));
+    // Secondary 20 MHz signal (center 2432 MHz, span = [2422, 2442] MHz)
+    ScalarTransmissionAnalogModel secondaryTxModel(0, 0, 1, ch0Above.getSecondaryCenterFrequency(), MHz(20), mW(20));
+    // Bonded 40 MHz signal (center 2422 MHz, span = [2402, 2442] MHz)
+    ScalarTransmissionAnalogModel bondedTxModel(0, 0, 1, bondedCenter, MHz(40), mW(20));
+    // Out-of-band 20 MHz signal on Channel 8 (center 2452 MHz, span = [2442, 2462] MHz)
+    ScalarTransmissionAnalogModel outOfBandTxModel(0, 0, 1, Hz(2452000000.0), MHz(20), mW(20));
+
+    auto isContained = [](const BandListening& l, const INarrowbandSignalAnalogModel& s) {
+        auto lMin = l.getCenterFrequency() - l.getBandwidth() / 2;
+        auto lMax = l.getCenterFrequency() + l.getBandwidth() / 2;
+        auto sMin = s.getCenterFrequency() - s.getBandwidth() / 2;
+        auto sMax = s.getCenterFrequency() + s.getBandwidth() / 2;
+        return sMin >= lMin && sMax <= lMax;
+    };
+
+    ASSERT(isContained(listening40, primaryTxModel));
+    ASSERT(isContained(listening40, secondaryTxModel));
+    ASSERT(isContained(listening40, bondedTxModel));
+    ASSERT(!isContained(listening40, outOfBandTxModel));
+
+    // Channel 4 (2432 MHz) HT40- (secondary below, bonded = 2422 MHz, span = [2402, 2442] MHz)
+    Ieee80211Channel ch4Below(band24, 4, IEEE80211_SECONDARY_CHANNEL_BELOW);
+    BandListening listening40Below(nullptr, 0, 1, Coord::ZERO, Coord::ZERO, ch4Below.getBondedCenterFrequency(), bondedBw);
+    ScalarTransmissionAnalogModel primaryTxModel4(0, 0, 1, ch4Below.getCenterFrequency(), MHz(20), mW(20));
+    ScalarTransmissionAnalogModel secondaryTxModel4(0, 0, 1, ch4Below.getSecondaryCenterFrequency(), MHz(20), mW(20));
+
+    ASSERT(isContained(listening40Below, primaryTxModel4));
+    ASSERT(isContained(listening40Below, secondaryTxModel4));
+
+    // 20 MHz listening on Channel 0 should reject 40 MHz bonded signal
+    BandListening listening20(nullptr, 0, 1, Coord::ZERO, Coord::ZERO, ch0Above.getCenterFrequency(), MHz(20));
+    ASSERT(isContained(listening20, primaryTxModel));
+    ASSERT(!isContained(listening20, bondedTxModel));
+    ASSERT(!isContained(listening20, secondaryTxModel));
+
+    EV << "HT40 subchannel containment tests PASSED.\n";
+}
+
+EV << ".\n";
+
+%contains: stdout
+HT40 subchannel containment tests PASSED.
+.