User Manual, Developers Guide and API Documentation

PhyUser.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 5, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef LTE_MACR_PHYUSER_HPP
#define LTE_MACR_PHYUSER_HPP

#include <LTE/macr/PhyCommand.hpp>
#include <LTE/helper/HasModeName.hpp>

#include <WNS/ldk/FunctionalUnit.hpp>
#include <WNS/ldk/Compound.hpp>
#include <WNS/ldk/CommandTypeSpecifier.hpp>
#include <WNS/ldk/HasReceptor.hpp>
#include <WNS/ldk/HasConnector.hpp>
#include <WNS/ldk/HasDeliverer.hpp>
#include <WNS/ldk/Receptor.hpp>
#include <WNS/ldk/Connector.hpp>
#include <WNS/probe/bus/json/probebus.hpp>

#include <WNS/service/phy/ofdma/Handler.hpp>
#include <WNS/service/phy/ofdma/Notification.hpp>
#include <WNS/service/phy/ofdma/DataTransmission.hpp>
#include <WNS/service/phy/power/PowerMeasurement.hpp>
#include <WNS/service/phy/phymode/PhyModeInterface.hpp>
#include <WNS/service/dll/Address.hpp>

#include <WNS/pyconfig/View.hpp>
#include <WNS/Positionable.hpp>
#include <WNS/Observer.hpp>

namespace dll {
    class ILayer2;
    namespace services {
        namespace management {
            class InterferenceCache;
        }
    }
}

namespace dll {
    class StationManager;
    namespace services { namespace control {
            class Association;
        }}}

namespace wns {
    namespace service { namespace phy { namespace phymode {
                class SNR2MIInterface;
            }}}
}
namespace lte{
    namespace macr {

        class IRxTxSettable
        {
        public:
            typedef enum { Invalid, Tx, Rx, BothRxTx } StateRxTx;

            virtual void
            setStateRxTx(StateRxTx _state) = 0;
        };

        class PhyUser :
                virtual public wns::ldk::FunctionalUnit,
                public wns::ldk::CommandTypeSpecifier< PhyCommand >,
                public wns::ldk::HasReceptor<>,
                public wns::ldk::HasConnector<>,
                public wns::ldk::HasDeliverer<>,
                public wns::Cloneable<PhyUser>,
                virtual public wns::service::phy::ofdma::Handler,
                public lte::helper::HasModeName,
                public IRxTxSettable
        {
            class StartTxEvent
            {
                wns::ldk::CompoundPtr compound;
                int subBand;
                PhyUser* phyUser;
            public:
                StartTxEvent(const wns::ldk::CompoundPtr& _compound,
                             PhyUser* _phyUser) :
                    compound(_compound),
                    phyUser(_phyUser)
                {};

                virtual ~StartTxEvent(){
                    compound = wns::ldk::CompoundPtr();
                }

                virtual void
                operator()()
                {
                    phyUser->startTransmission(compound);
                };
            };

            class StopTxEvent
            {
                wns::ldk::CompoundPtr compound;
                int subBand;
                PhyUser* phyUser;
            public:
                StopTxEvent(const wns::ldk::CompoundPtr& _compound,
                            int _subBand,
                            PhyUser* _phyUser) :
                    compound(_compound),
                    subBand(_subBand),
                    phyUser(_phyUser)
                {};

                virtual
                ~StopTxEvent(){
                    compound = wns::ldk::CompoundPtr();
                }

                virtual void
                operator()()
                {
                    phyUser->stopTransmission(compound, subBand);
                };
            };

        public:

            PhyUser(wns::ldk::fun::FUN* fun, const wns::pyconfig::View& pyConfigView);
            virtual ~PhyUser();


            virtual void
            onFUNCreated();

            virtual bool
            doIsAccepting(const wns::ldk::CompoundPtr& compound) const;
            virtual void
            doSendData(const wns::ldk::CompoundPtr& sdu);
            virtual void
            doOnData(const wns::ldk::CompoundPtr& compound);
            virtual void
            doWakeup();

            virtual void
            onData(wns::osi::PDUPtr pdu, wns::service::phy::power::PowerMeasurementPtr rxPowerMeasurement);

            void
            startTransmission(const wns::ldk::CompoundPtr& compound);
            void
            stopTransmission(wns::osi::PDUPtr pdu, int subBand);

            bool
            checkIdle();

            void
            setStateRxTx(StateRxTx _state);

            std::string
            getStateRxTx() const;

            virtual void
            rapTuning();

            virtual void
            utTuning();

            virtual void
            setNotificationService(wns::service::Service* phy);

            virtual wns::service::phy::ofdma::Notification*
            getNotificationService() const;

            virtual void
            setDataTransmissionService(wns::service::Service* phy);

            virtual wns::service::phy::ofdma::DataTransmission*
            getDataTransmissionService() const;

            virtual void
            setMACAddress(const wns::service::dll::UnicastAddress& address);

            void
            setMobility(wns::PositionableInterface* _mobility);

            bool
            isFddCapable() const;

            void
            setReceiveAntennaPattern(wns::node::Interface* destination, wns::service::phy::ofdma::PatternPtr pattern);

            void
            deleteReceiveAntennaPatterns();
        private:

#ifndef NDEBUG
            void
            traceIncoming(wns::ldk::CompoundPtr compound, wns::service::phy::power::PowerMeasurementPtr rxPowerMeasurement);

            wns::ldk::CommandReaderInterface* schedulerCommandReader_;
#endif 
            void
            measureInterference(PhyCommand*, wns::Power);            

            wns::pyconfig::View config_;

            dll::ILayer2* layer2;
            StateRxTx stateRxTx;
            wns::logger::Logger logger;

            std::list< std::pair<wns::osi::PDUPtr, int> > activeSubBands;

            bool fddCapable;

            simTimeType safetyFraction;

            wns::events::scheduler::Interface* es;

            wns::service::dll::UnicastAddress address;

            dll::services::management::InterferenceCache* iCache;

            wns::service::phy::ofdma::BFInterface* bfTransmission;

            wns::service::phy::ofdma::NonBFInterface* transmission;

            wns::service::phy::ofdma::Notification* notificationService;

            wns::PositionableInterface* mobility;

            dll::StationManager* stationManager;

            bool sendAllBroadcast;

            std::map<int, wns::Power> interf;

            wns::simulator::Time lastMeasureTime;

            wns::simulator::Time measurementDelay_;

            wns::probe::bus::ContextCollectorPtr jsonTracingCC_;

        };
    } }
#endif // NOT defined LTE_MACR_PHYUSER_HPP

---