User Manual, Developers Guide and API Documentation

TimingScheduler.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_TIMING_TIMINGSCHEDULER_HPP
#define LTE_TIMING_TIMINGSCHEDULER_HPP

#include <LTE/helper/HasModeName.hpp>

#include <DLL/services/control/Association.hpp>

#include <WNS/ldk/ManagementServiceInterface.hpp>
#include <WNS/ldk/fun/FUN.hpp>
#include <WNS/pyconfig/View.hpp>
#include <WNS/pyconfig/Sequence.hpp>
#include <WNS/events/PeriodicTimeout.hpp>
#include <WNS/events/EventFactory.hpp>
#include <WNS/logger/Logger.hpp>
#include <WNS/Enum.hpp>
#include <WNS/container/Registry.hpp>

#include <WNS/service/dll/Address.hpp>

#include <vector>
#include <cstdlib>

namespace lte {
    namespace controlplane {
        class MapHandler;
        namespace associationHandler {
            class AssociationHandler;
        }
    }
    namespace timing {
        namespace events {
            class Base;
        }

        // e.g. lte::timing::StationTasks::RAP()
        ENUM_BEGIN(StationTasks);
        ENUM(RAP, 1);
        ENUM(UT, 2);
        ENUM(IDLE, 3);
        ENUM(INVALID, 4);
        ENUM_END();
        typedef int StationTask;

        ENUM_BEGIN(DuplexSchemes);
        ENUM(TDD, 1);
        ENUM(FDD, 2);
        ENUM_END();
        typedef int DuplexScheme;

        class FrameStartNotificationInterface
        {
        public:
            virtual
            ~FrameStartNotificationInterface(){}

            virtual void
            onFrameStart() = 0;
        };

        class SuperFrameStartNotificationInterface
        {
        public:
            virtual
            ~SuperFrameStartNotificationInterface(){}

            virtual void
            onSuperFrameStart() = 0;
        };

        class TimingScheduler :
                public wns::ldk::ManagementService,
                public wns::events::PeriodicTimeout,
                public lte::helper::HasModeName,
                public dll::services::control::AssociationObserver,
                public wns::Subject<FrameStartNotificationInterface>,
                public wns::Subject<SuperFrameStartNotificationInterface>
        {
            friend class controlplane::associationHandler::AssociationHandler;

        public:
            TimingScheduler(wns::ldk::ManagementServiceRegistry* msr,
                            wns::pyconfig::View _config);

            virtual
            ~TimingScheduler();

            virtual void periodically();

            bool isPeerListeningAt(const wns::service::dll::UnicastAddress& peerAddress, const int frameNr);

            bool canReceiveMapNow(const wns::service::dll::UnicastAddress& address);

            void onMSRCreated();

            void onWorldCreated();

            lte::timing::StationTask
            stationTaskAtOffset(const simTimeType offset) const;

            lte::timing::StationTask
            stationTaskAtFrame(int frameNr) const;

            void
            initStationTaskPhases();

            uint32_t
            phaseNumberAtOffset(const simTimeType offset) const;

            uint32_t
            phaseNumberAtFrame(int frameNr) const;

            virtual void onDisassociated(wns::service::dll::UnicastAddress userAdr,
                                         wns::service::dll::UnicastAddress dstAdr);

            virtual void onAssociated(wns::service::dll::UnicastAddress userAdr,
                                      wns::service::dll::UnicastAddress dstAdr);

            void
            superFrameTrigger();

            void
            frameTrigger();

        private:
            dll::ILayer2* layer2;
            wns::ldk::fun::FUN* fun;
            wns::pyconfig::View config;
            wns::logger::Logger logger;

            struct Friends {
                lte::controlplane::MapHandler* mapHandler;
            } friends;

            simTimeType superFrameLength;
            simTimeType superFrameStartTime;
            struct TimingEvent {
                simTimeType timeOffset;
                lte::timing::events::Base* event;
            };
            typedef std::vector<TimingEvent> EventContainer;
            struct StationTaskPhase {
                simTimeType startTime; // relative to superframe start
                simTimeType duration; // [s]
                StationTask task;
            };
            typedef std::vector<StationTaskPhase> StationTaskPhaseContainer;
            typedef wns::container::Registry<wns::service::dll::UnicastAddress, EventContainer> PeerTiming;
            typedef wns::container::Registry<wns::service::dll::UnicastAddress, TimingScheduler*> PeerTimingSchedulers;

            EventContainer eventContainer;
            StationTaskPhaseContainer stationTaskPhaseContainer;
            PeerTiming peerTiming;
            PeerTimingSchedulers peerTimingSchedulers;

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

            void readEvents(std::string viewName);
            void readStationTaskPhases(std::string viewName);

            void
            addPeerTimingScheduler(wns::service::dll::UnicastAddress peerAddress, TimingScheduler* _timingScheduler);
            void
            removePeerTimingScheduler(wns::service::dll::UnicastAddress peerAddress);

            simTimeType startOfFirstFrame;
            simTimeType frameLength;
            int schedulingOffset;
            int numberOfFramesToSchedule;
            int framesPerSuperFrame;
        public:
            simTimeType switchingPointOffset;
            lte::timing::DuplexScheme duplex;
            int getSchedulingOffset() const;
            int getNumberOfFramesToSchedule() const;
        }; // TimingScheduler
    } //timing
} // lte

#endif // NOT defined LTE_TIMING_TIMINGSCHEDULER_HPP

---