User Manual, Developers Guide and API Documentation

Manager.hpp

Go to the documentation of this file.

/******************************************************************************
 * WiMeMac                                                                    *
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2011
 * 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 WIMEMAC_LOWERMAC_MANAGER_HPP
#define WIMEMAC_LOWERMAC_MANAGER_HPP

#include <WIMEMAC/convergence/PhyUser.hpp>
#include <WIMEMAC/convergence/PhyMode.hpp>
#include <WIMEMAC/FrameType.hpp>
#include <WIMEMAC/drp/DRPScheduler.hpp>
#include <WIMEMAC/convergence/ErrorModelling.hpp>
#include <WIMEMAC/management/ProtocolCalculator.hpp>
#include <WIMEMAC/lowerMAC/IManagerServices.hpp>

#include <WNS/logger/Logger.hpp>

#include <WNS/ldk/Command.hpp>
#include <WNS/ldk/fu/Plain.hpp>
#include <WNS/ldk/Processor.hpp>

#include <WNS/service/dll/Address.hpp>
#include <WNS/probe/bus/ContextCollector.hpp>

#include <DLL/Layer2.hpp>
#include <DLL/UpperConvergence.hpp>

#include <list>

namespace wimemac {
namespace lowerMAC {

    class IManagerServices;
}

namespace convergence {
    class PhyUser;
    class ErrorModelling;
}}

namespace wimemac { namespace drp {
    class DRPScheduler;
}}

namespace wimemac { namespace lowerMAC {

    typedef std::vector<bool> Vector;
  
    class ManagerCommand :
        public wimemac::IKnowsFrameTypeCommand
    {
    public:
        struct {
            wns::simulator::Time expirationTime;
        } local;

        struct {
            bool hasPayload;
            wimemac::CompoundType CompoundType;
            wimemac::convergence::PhyMode phyMode;

            wns::simulator::Time frameExchangeDuration;
            wns::simulator::Time psduDuration;

            bool requiresDirectReply;
        } peer;

        struct { } magic;

        ManagerCommand()
        {
            peer.CompoundType = DATA;
            peer.hasPayload = true;
            peer.frameExchangeDuration = 0;
            peer.psduDuration = 0;
            peer.requiresDirectReply = false;
        }

        CompoundType getCompoundType()
        {
            return peer.CompoundType;
        }

        std::string getPreambleMode()
        {
            return this->peer.phyMode.getPreambleMode();
        }

        bool isPreamble() const
        {
            return (peer.CompoundType == ACK_PREAMBLE || peer.CompoundType == BEACON_PREAMBLE || peer.CompoundType == DATA_PREAMBLE);
        }

        wimemac::convergence::PhyMode getPhyMode() const
        {
            return this->peer.phyMode;
        }
    };

    class Manager :
        public wns::ldk::fu::Plain<Manager, ManagerCommand>,
        public wns::ldk::Processor<Manager>,
        public wimemac::lowerMAC::IManagerServices


    {
    public:

        Manager(wns::ldk::fun::FUN* fun, const wns::pyconfig::View& config);

        virtual
        ~Manager();

        void processIncoming(const wns::ldk::CompoundPtr& compound);

        void processOutgoing(const wns::ldk::CompoundPtr& compound);

        bool doIsAccepting(const wns::ldk::CompoundPtr& compound) const;

        wimemac::convergence::PhyUser*
        getPhyUser();

        dll::Layer2::StationType
        getStationType() const;

        wns::service::dll::UnicastAddress
        getMACAddress() const;

        bool getRateAdaptation() {return useRateAdaptation;}
        int getReservationBlocks() {return reservationBlocks;}
        bool getRandomUse() {return useRandomPattern;}

        bool getDRPchannelAccess() {return useDRPchannelAccess;}
        bool getPCAchannelAccess() {return usePCAchannelAccess;}

        wns::ldk::CommandPool*
        createReply(const wns::ldk::CommandPool* original) const;

        wns::ldk::CommandPool*
        createReply(const wns::ldk::CommandPool* original, wimemac::CompoundType compoundType) const;

        wns::ldk::CompoundPtr
        createCompound(const wns::service::dll::UnicastAddress transmitterAddress,
                       const wns::service::dll::UnicastAddress receiverAddress,
                       const CompoundType compoundType,
                       const bool hasPayload,
                       const wns::simulator::Time frameExchangeDuration,
                       const bool requiresDirectReply = false);

        wns::service::dll::UnicastAddress
        getTransmitterAddress(const wns::ldk::CommandPool* commandPool) const;

        wns::service::dll::UnicastAddress
        getReceiverAddress(const wns::ldk::CommandPool* commandPool) const;

        bool
        isForMe(const wns::ldk::CommandPool* commandPool) const;

        bool
        hasPayload(const wns::ldk::CommandPool* commandPool) const;

        void
        setHasPayload(const wns::ldk::CommandPool* commandPool, bool setPayloadTo);

        wimemac::CompoundType
        getCompoundType(const wns::ldk::CommandPool* commandPool) const;

        std::string
        getPreambleMode(const wns::ldk::CommandPool* commandPool) const;

        void
        setCompoundType(const wns::ldk::CommandPool* commandPool, const CompoundType type);

        bool
        isPreamble(const wns::ldk::CommandPool* commandPool) const;

        bool
        isBeacon(const wns::ldk::CommandPool* commandPool) const;

        wns::simulator::Time
        getFrameExchangeDuration(const wns::ldk::CommandPool* commandPool) const;

        void
        setFrameExchangeDuration(const wns::ldk::CommandPool* commandPool, const wns::simulator::Time duration);

        wns::simulator::Time
        getpsduDuration(const wns::ldk::CommandPool* commandPool) const;

        void
        setpsduDuration(const wns::ldk::CommandPool* commandPool, const wns::simulator::Time duration);

        wimemac::convergence::PhyMode
        getPhyMode(const wns::ldk::CommandPool* commandPool) const;

        void
        setPhyMode(const wns::ldk::CommandPool* commandPool, const wimemac::convergence::PhyMode phyMode);

        wimemac::convergence::PhyMode
        getDefaultPhyMode() const;

        wns::Power
        getRxPower(const wns::ldk::CommandPool* commandPool);

        wns::Power
        getInterference(const wns::ldk::CommandPool* commandPool);

        wimemac::convergence::MCS getMaxPosMCS(wns::Ratio sinr_, Bit maxCompoundSize_, double per_);
        
        double getErrorRateForCommandFrames(wns::Ratio sinr_, Bit maxCompoundSize_);

        double getDesiredPER();

        double getPatternPEROffset();

        bool
        getRequiresDirectReply(const wns::ldk::CommandPool* commandPool) const;

        void
        setRequiresDirectReply(const wns::ldk::CommandPool* commandPool, bool requiresDirectReply);

        bool
        lifetimeExpired(const wns::ldk::CommandPool* commandPool) const;

        wns::simulator::Time
        getExpirationTime(const wns::ldk::CommandPool* commandPool) const;

        void
        setBPStartTime(wns::simulator::Time bpStartTime_) {BPStartTime = bpStartTime_;}

        wns::simulator::Time
        getBPStartTime() { return BPStartTime;}

        int
        getMASNumber(wns::simulator::Time time_);

        wimemac::management::ProtocolCalculator* getProtocolCalculator();

        // For BeaconBuilder Services
        void prepareDRPConnection(wns::service::dll::UnicastAddress rx, int CompoundspSF, int BitspSF, int MaxCompoundSize);

        void updateDRPConnection(wns::service::dll::UnicastAddress rx, int CompoundspSF, int BitspSF, int MaxCompoundSize);
        
        void BuildDTPmap();
        
        void SetBPDuration(wns::simulator::Time duration);
        
        // For DRPScheduler Services
        bool startPCAtransmission();
        void stopPCAtransmission();
        void txOPCloseIn(wns::simulator::Time duration);
        
        wns::service::dll::UnicastAddress getCurrentTransmissionTarget();
        
        int getNumOfRetransmissions(const wns::ldk::CompoundPtr& compound);
        
        bool UpdateMapWithPeerAvailabilityMap(wns::service::dll::UnicastAddress rx , Vector& DRPMap);
        
        bool adjustMCSdown(wns::service::dll::UnicastAddress rx);
        
        void UpdateDRPMap(Vector DRPMap);
        
        void onBPStart(wns::simulator::Time BPduration);
        
        void Acknowledgment(wns::service::dll::UnicastAddress tx);
        
        
    private:
        virtual void
        onFUNCreated();

        const wns::pyconfig::View config_;
        wns::logger::Logger logger_;
        const wns::simulator::Time expectedACKDuration;

        const wns::simulator::Time sifsDuration;

        const wns::service::dll::UnicastAddress myMACAddress_;

        const std::string ucName_;

        const wns::simulator::Time msduLifetimeLimit;

        int reservationBlocks;

        bool useRandomPattern;
        bool useRateAdaptation;

        bool useDRPchannelAccess;
        bool usePCAchannelAccess;

        wns::simulator::Time BPStartTime;
        const std::string protocolCalculatorName;
        wns::probe::bus::ContextCollectorPtr mcsProbe;

        wimemac::management::ProtocolCalculator* protocolCalculator;

        struct Friends
        {
            dll::UpperConvergence* upperConvergence;
            wimemac::convergence::PhyUser* phyUser;
            wimemac::drp::DRPScheduler* drpScheduler;
            wimemac::convergence::ErrorModelling* errorModelling;
        } friends;
    };
} // lowerMAC
} // wimemac

#endif // WIMEMAC_LOWERMAC_MANAGER_HPP

---