ChannelControl.h Source File¶

Simu5G: ChannelControl.h Source File
Simu5G
//
//                  Simu5G
//
// Copyright (C) 2006 Levente Meszaros, 2005 Andras Varga
// Copyright (C) 2019-2021 Giovanni Nardini, Giovanni Stea, Antonio Virdis et al. (University of Pisa)
// Copyright (C) 2022-2026 Giovanni Nardini, Giovanni Stea et al. (University of Pisa)
//
// This file is part of a software released under the license included in file
// "license.pdf". Please read LICENSE and README files before using it.
// The above files and the present reference are part of the software itself,
// and cannot be removed from it.
//
 
#ifndef CHANNELCONTROL_H
#define CHANNELCONTROL_H
 
#include <vector>
#include <list>
#include <set>
 
#include <inet/common/INETDefs.h>
#include <inet/common/geometry/common/Coord.h>
 
#include "simu5g/world/radio/IChannelControl.h"
 
namespace simu5g {
 
using namespace omnetpp;
 
// Forward declarations
class AirFrame;
 
#define TRANSMISSION_PURGE_INTERVAL    1.0
struct IChannelControl::RadioEntry {
    opp_component_ptr<cModule> radioModule;  // the module that registered this radio interface
    cGate *radioInGate = nullptr;  // gate on host module used to receive airframes
    int channel;
    inet::Coord pos; // cached radio position
 
    struct Compare {
        bool operator()(const RadioRef& lhs, const RadioRef& rhs) const {
            ASSERT(lhs != nullptr);
            ASSERT(rhs != nullptr);
            return lhs->radioModule->getId() < rhs->radioModule->getId();
        }
    };
    // we cache neighbors set in a std::vector, because std::set iteration is slow;
    // std::vector is created and updated on demand
    std::set<RadioRef, Compare> neighbors; // cached neighbor list
    std::vector<RadioRef> neighborList;
    bool isNeighborListValid;
    bool isActive;
};
class ChannelControl : public cSimpleModule, public IChannelControl
{
  protected:
    typedef std::list<RadioEntry> RadioList;
    typedef std::vector<RadioRef> RadioRefVector;
 
    RadioList radios;
    typedef std::vector<TransmissionList> ChannelTransmissionLists;
    ChannelTransmissionLists transmissions; // indexed by channel number (size=numChannels)
    simtime_t lastOngoingTransmissionsUpdate = 0;
 
    friend std::ostream& operator<<(std::ostream&, const RadioEntry&);
    friend std::ostream& operator<<(std::ostream&, const TransmissionList&);
    double maxInterferenceDistance;
    int numChannels;
 
  protected:
    virtual void updateConnections(RadioRef h);
    virtual double calcInterfDist();
    void initialize(int stage) override;
    int numInitStages() const override { return inet::NUM_INIT_STAGES; }
    virtual void purgeOngoingTransmissions();
    virtual void checkChannel(int channel);
    virtual const RadioRefVector& getNeighbors(RadioRef h);
    virtual void addOngoingTransmission(RadioRef h, AirFrame *frame);
    virtual RadioRef lookupRadio(cModule *radioModule);
 
  public:
    ~ChannelControl() override;
    RadioRef registerRadio(cModule *radioModule, cGate *radioInGate = nullptr) override;
    void unregisterRadio(RadioRef r) override;
    cModule *getRadioModule(RadioRef r) const override { return r->radioModule; }
    cGate *getRadioGate(RadioRef r) const override { return r->radioInGate; }
    int getRadioChannel(RadioRef r) const override { return r->channel; }
    void setRadioPosition(RadioRef r, const inet::Coord& pos) override;
    void setRadioChannel(RadioRef r, int channel) override;
    int getNumChannels() override { return numChannels; }
    const TransmissionList& getOngoingTransmissions(int channel) override;
    void sendToChannel(RadioRef srcRadio, AirFrame *airFrame) override;
    double getInterferenceRange(RadioRef r) override { return maxInterferenceDistance; }
    void disableReception(RadioRef r) override { r->isActive = false; };
    void enableReception(RadioRef r) override { r->isActive = true; };
    double getPropagationSpeed() override { return SPEED_OF_LIGHT; }
};
 
} //namespace
 
#endif
 