User Manual, Developers Guide and API Documentation

DRPScheduler.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_DRP_DRPSCHEDULER_H
#define WIMEMAC_DRP_DRPSCHEDULER_H

#include <WNS/ldk/fu/Plain.hpp>
#include <WNS/logger/Logger.hpp>
#include <WNS/service/dll/Address.hpp>
#include <WIMEMAC/helper/Queues.hpp>
#include <WNS/probe/bus/ContextCollector.hpp>

#include <WIMEMAC/helper/IDRPQueueInterface.hpp>
#include <WIMEMAC/drp/TempSendBuffer.hpp>

#include <WNS/events/CanTimeout.hpp>

#include <map>
#include <WNS/PowerRatio.hpp>

#include <WNS/probe/bus/utils.hpp>
#include <WNS/ldk/probe/Probe.hpp>
#include <WNS/probe/bus/ContextCollector.hpp>
#include <WIMEMAC/management/BeaconBuilder.hpp>
#include <WIMEMAC/management/BeaconCommand.hpp>
#include <WIMEMAC/lowerMAC/timing/DCF.hpp>
#include <WIMEMAC/lowerMAC/TXOP.hpp>
#include <WIMEMAC/drp/IDRPSchedulerServices.hpp>

#include <DLL/Layer2.hpp>
#include <WNS/ldk/CommandTypeSpecifier.hpp>
#include <WNS/ldk/Layer.hpp>
#include <WIMEMAC/TxType.hpp>
#include <WIMEMAC/lowerMAC/ITXOPWindow.hpp>

#include <WIMEMAC/management/PERInformationBase.hpp>
#include <boost/bind.hpp>
#include <WNS/events/scheduler/Callable.hpp>

//  //
namespace wimemac { namespace helper {
        class Queues;
}}
//  //
namespace wimemac { namespace drp {
         class TempSendBuffer;
}}
//  //
namespace wimemac { namespace management {
         class BeaconBuilder;
}}
//  //
namespace wimemac { namespace lowerMAC { namespace timing {
         class DCF;
}}}
//  //
namespace wimemac { namespace lowerMAC { 
         class TXOP;
}}

namespace wimemac { namespace drp {

    class DRPSchedulerCommand :
        public wimemac::IKnowsTxTypeCommand
    {
    public:
        struct { } local;

        struct {
            wimemac::TxType type;
            } peer;

        struct { } magic;

        DRPSchedulerCommand()
        {
            peer.type = DRP;
        }

        TxType getTxType()
        {
            return peer.type;
        }
    };


    typedef std::vector<wns::Power> PowerMap;
    typedef std::vector<bool> Vector;

    class DRPScheduler :

        public wns::ldk::fu::Plain<DRPScheduler, DRPSchedulerCommand>,
        public wimemac::helper::IDRPQueueInterface,
        public wns::events::CanTimeout,
        public wns::ldk::probe::Probe,
        public wimemac::lowerMAC::ITXOPWindow,
        public wimemac::drp::IDRPSchedulerServices

        {
        friend class TempSendBuffer;

        public:

            DRPScheduler(wns::ldk::fun::FUN* fun, const wns::pyconfig::View& config_ );
            ~DRPScheduler();
            void doOnData(const wns::ldk::CompoundPtr& );

            void doSendData(const wns::ldk::CompoundPtr& );
            bool doIsAccepting(const wns::ldk::CompoundPtr& compound) const;
            void doWakeup();
            void SendCompounds();
            void SendCompounds(wns::service::dll::UnicastAddress macaddress);
            void Acknowledgment(wns::service::dll::UnicastAddress tx);

            void
            TimeToTransmit(wns::service::dll::UnicastAddress macaddress, wns::simulator::Time duration);

            wimemac::convergence::PhyMode
            getPhyMode(wns::service::dll::UnicastAddress rx, int masNumber);

            wimemac::lowerMAC::Manager*
            getManager() {return friends.manager;}

            wimemac::management::BeaconBuilder*
            getBeaconBuilder() {return friends.bb;}

            double getDesiredPER() {return maxPER;}

            double getPatternPEROffset() {return patternPEROffset;}

            int getIsDroppingAfterRetr() {return isDroppingAfterRetr;}

            wns::service::dll::UnicastAddress
            getCurrentTransmissionTarget();

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

            void failedAck(wns::service::dll::UnicastAddress rx);

            bool adjustMCSdown(wns::service::dll::UnicastAddress rx);

            bool UpdateMapWithPeerAvailabilityMap(wns::service::dll::UnicastAddress rx , Vector& DRPMap);

            void RequestIE(wns::service::dll::UnicastAddress rx, wimemac::management::BeaconCommand::ProbeElementID elementID);

            wns::simulator::Time
            getNextTransmissionDuration();

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

            bool
            startPCAtransmission();
            void
            stopPCAtransmission();
            void
            txOPCloseIn(wns::simulator::Time duration);

            wns::simulator::Time
            getTimeUntilNextDRPReservation();

            void
            onBPStart(wns::simulator::Time BPduration);
            void
            RegisterDRPReservations(int thisMAS);

            void onDRPStart();
            void onDRPStop();

            int getNumOfRetransmissions(const wns::ldk::CompoundPtr& compound);

            void UpdateDRPMap(Vector DRPMap);

        protected:

            void onFUNCreated();

        private:

            wns::logger::Logger logger;
            helper::Queues* DRPQueues;
            wns::pyconfig::View config;
            typedef std::map<wns::service::dll::UnicastAddress, TempSendBuffer*> SendBufferContainer;

            int isDroppingAfterRetr;
            bool isPCAtransmissionActive;
            bool PCAcompoundsWereSent;
            wns::service::dll::UnicastAddress ActivePCArx;
            Vector currentDRPMap;
            Vector currentRegisterDRPMap;

            wns::simulator::Time nextDRPReservationTime;

            SendBufferContainer SendBuffer;
            SendBufferContainer PCABuffer;
            void onTimeout();
            bool AccessPermission;
            wns::service::dll::UnicastAddress AccessRx;

            double maxPER;
            double patternPEROffset;
            const std::string managerName;
            const std::string dcfName;
            const std::string txopName;
            const std::string beaconBuilderName;
            const std::string perMIBServiceName;

            wimemac::management::PERInformationBase* perMIB;
            wns::probe::bus::ContextCollectorPtr pcaPortionProbe;

            struct Friends
            {
                wimemac::management::BeaconBuilder* bb;
                wns::ldk::CommandReaderInterface* keyReader;
                wimemac::lowerMAC::Manager* manager;
                wimemac::lowerMAC::timing::DCF* dcf;
                wimemac::lowerMAC::TXOP* txop;
            } friends;

    };
}//drp
}//wimemac
#endif

---