Running DCF and HCCA together

Asked by Rahamatullah on 2009-05-15

Dear all,
I have two systems in a overlapping scenario. Each system consists of an access point and some stations. Now, I want to run these two systems together, one with DCF channel access mechanism and another with HCCA channel access mechanism.

For doing this, I needed to activate and deactivate a group of FUs in the FUN during run time. For example, when the access point is configured as DCF, then certain FUs will be activated and when the access point is configred as HCCA, then certain other FUs will be activated.

What I did,
in the access point configuration, for one system I added (dcf = True) when that system will follow DCF
for another system I added (dcf = False) when that system will follow HCCA

In the FUN, I took this configured value from rate adaptation FU which resides above TXOP FU and then I added some statements like

if (config.ra.dcf == True):
useTXOP11e = False
else:
useTXOP11e = True

In the useTXOP11e contains several FUs which are necessary for HCCA, not for DCF

With these statements and configuration, after running 1.5000450s, I got an error, Invalid CommandTypeSpecifier instance with id 36 requested.

Now, my question is, is it possible to activate and deactivate a group of FUs in a FUN depending on certain condition given from the configuration during run time such as the specified above scenario? If not, what could be the solution for this type of scenario?

Thanks

Question information

Language:
English Edit question
Status:
Solved
For:
openWNS WiFiMAC Edit question
Assignee:
No assignee Edit question
Solved by:
Maciej Muehleisen
Solved:
2009-08-07
Last query:
2009-08-07
Last reply:
2009-08-05
Sebastian Max (smx-comnets) said : #1

Dear Rahmatullah,

Thank you very much for the interesting question.

First of all, I need more information to answer your question properly... From your text, I assume that you have already some kind of implementation of the HCCA in addition to the DCF which is provided by default. This implementation uses special FU(s) that you have written, and a special FUN consisting of existing and new FU(s).

I do not understand what this has to do with the rate adaptation FU that you mention?

But now let's come to your question. If (and only if) I have understood right what you are doing, then the answer is "Yes, it is certainly possible to have different nodes with different FUNs during runtime, as you would like to have".

The following is guessed, based on your description:

The error that you are running into ("Invalid CommandTypeSpecifier") has the following reason: Assume that node 1 has FUN A, node 2 has FUN B. FUN A differs from FUN B that it has (some) other FUs, which manipulate the frame in some way (a different multiplexing FU would suffice for example). If node 2 sends a compound, the command pool of the compound will not contain the command from the FU which is special for FUN B. Then, node 1 receives this compound and the special FU tries to access the special command from the command pool - which does not exist.

To circumvent this, you need to check in the (special) FU if the command is activated. If not, you need to take action (e.g. drop the compound, or simply forward it, or, or, or).

BR, Sebastian

Rahamatullah (rahbd052000) said : #2

Hello Sebastian,
Thank you very much for your answer. Still, I am stuck in running both DCF and HCCA together.

Actually, for getting the value to __init__.py (FUN) during runtime from the configuration, I tried to get the value (dcf=true, dcf=false) through the rate adaptation FU. I know that it was really meaningless to use the rate adaptation FU as a medium. But, now, I am trying to get the value through Layer2.py.

You are right telling that somehow a command is not activated during runtime. I checked it out. What I observed is that the command

Command ID: 35, Role name: TXOPDispatcherCommand

is not activated. So, what I did,

since the TXOPDispatcher FU is constructed from Dispatcher FU,

   TXOPDispatcher = openwns.Multiplexer.Dispatcher(commandName = 'TXOPDispatcherCommand',
                                                    functionalUnitName = 'TXOPDispatcher' + str(transceiverAddress),
                                                    opcodeSize = 0,
                                                    parentLogger = logger,
                                                    logName = 'TXOPDispatcher',
                                                    moduleName = 'WiFiMAC')

I activated the command using the following statements during both incoming and outgoing,

if ((getFUN()->getProxy()->commandIsActivated(compound->getCommandPool(), this)) != 1)
 {
 getFUN()->getProxy()->activateCommand(compound->getCommandPool(), this);
 MESSAGE_SINGLE(NORMAL, this->logger, "This command is activated");
 }

Still, I am getting the same error.

For making the question easier, I am explaining the problem of running HCCA HCCA together.
Running (HCCA HCCA)
__________________________

In __init__.py, there is a condition like this

if (config.dcf == True):
          useTXOP11e = False
    else:
          useTXOP11e = True

So, when I assign in Layer2.py

self.dcf = False

and configuring both access points as using HCCA meaning (dcf=false), it works fine

But, when I assign in Layer2.py

self.dcf = True, then it shows the following error,

Backtrace (most recent call last, stack size: 121):
 121) __gxx_personality_v0
 120) __libc_start_main
 119) __gxx_personality_v0
 118) wns::simulator::IApplication::run()
 117) wns::simulator::Main<wns::simulator::Application>::doRun()
 116) wns::simulator::IApplication::run()
 115) wns::simulator::Application::doRun()
 114) wns::events::scheduler::Interface::start()
 113) wns::events::scheduler::Map::doStart()
 112) wns::events::scheduler::Interface::processOneEvent()
 111) wns::events::scheduler::Map::doProcessOneEvent()
 110) wns::events::scheduler::Map::Event::operator()()
 109) boost::function0<void, std::allocator<void> >::operator()() const
 108) boost::detail::function::void_function_obj_invoker0<wifimac::convergence::StopTransmission, void>::invoke(boost::detail::function::function_buffer&)
 107) wifimac::convergence::StopTransmission::operator()()
 106) ofdmaphy::Station::stopTransmission(wns::SmartPtr<wns::osi::PDU>, int)
 105) rise::Transmitter::stopTransmitting(wns::SmartPtr<rise::TransmissionObject>)
 104) rise::medium::PhysicalResource::stopTransmission(wns::SmartPtr<rise::TransmissionObject>)
 103) rise::medium::PhysicalResource::notifyReceivers(wns::SmartPtr<rise::TransmissionObject> const&) const
 102) std::binder2nd<std::mem_fun1_t<void, rise::PhysicalResourceObserver, wns::SmartPtr<rise::TransmissionObject> > > std::for_each<__gnu_cxx::_Slist_iterator<rise::PhysicalResourceObserver*, rise::PhysicalResourceObserver* const&, rise::PhysicalResourceObserver* const*>, std::binder2nd<std::mem_fun1_t<void, rise::PhysicalResourceObserver, wns::SmartPtr<rise::TransmissionObject> > > >(__gnu_cxx::_Slist_iterator<rise::PhysicalResourceObserver*, rise::PhysicalResourceObserver* const&, rise::PhysicalResourceObserver* const*>, __gnu_cxx::_Slist_iterator<rise::PhysicalResourceObserver*, rise::PhysicalResourceObserver* const&, rise::PhysicalResourceObserver* const*>, std::binder2nd<std::mem_fun1_t<void, rise::PhysicalResourceObserver, wns::SmartPtr<rise::TransmissionObject> > >)
 101) std::binder2nd<std::mem_fun1_t<void, rise::PhysicalResourceObserver, wns::SmartPtr<rise::TransmissionObject> > >::operator()(rise::PhysicalResourceObserver* const&) const
 100) std::mem_fun1_t<void, rise::PhysicalResourceObserver, wns::SmartPtr<rise::TransmissionObject> >::operator()(rise::PhysicalResourceObserver*, wns::SmartPtr<rise::TransmissionObject>) const
  99) ofdmaphy::Receiver::notify(wns::SmartPtr<rise::TransmissionObject>)
  98) ofdmaphy::Station::receiveData(wns::SmartPtr<wns::osi::PDU>, wns::SmartPtr<wns::service::phy::power::PowerMeasurementInterface const>)
  97) wifimac::convergence::PhyUser::onData(wns::SmartPtr<wns::osi::PDU>, wns::SmartPtr<wns::service::phy::power::PowerMeasurementInterface const>)
  96) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  95) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  94) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  93) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  92) wifimac::convergence::PhyUser::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  91) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  90) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  89) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  88) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  87) wns::ldk::Processor<wifimac::convergence::ErrorModelling>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  86) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  85) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  84) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  83) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  82) wns::ldk::crc::CRC::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  81) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  80) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  79) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  78) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  77) wifimac::convergence::FrameSynchronization::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  76) wifimac::convergence::FrameSynchronization::processPSDU(wns::SmartPtr<wns::ldk::Compound> const&)
  75) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  74) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  73) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  72) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  71) wns::ldk::Processor<wifimac::convergence::ChannelState>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  70) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  69) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  68) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  67) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  66) wns::ldk::Processor<wifimac::convergence::TxDurationSetter>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  65) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  64) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  63) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  62) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  61) wns::ldk::Delayed<wifimac::convergence::PreambleGenerator>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  60) wifimac::convergence::PreambleGenerator::processIncoming(wns::SmartPtr<wns::ldk::Compound> const&)
  59) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  58) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  57) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  56) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  55) wns::ldk::Processor<wns::ldk::multiplexer::Dispatcher>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  54) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  53) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  52) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  51) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  50) wns::ldk::Processor<wns::ldk::multiplexer::OpcodeSetter>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  49) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  48) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  47) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  46) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  45) wns::ldk::FlowGate::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  44) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  43) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  42) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  41) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  40) wns::ldk::Processor<wns::ldk::multiplexer::Dispatcher>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  39) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  38) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  37) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  36) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  35) wns::ldk::Processor<wns::ldk::multiplexer::OpcodeSetter>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  34) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  33) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  32) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  31) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  30) wns::ldk::Delayed<wns::ldk::tools::ConstantDelay>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  29) wns::ldk::tools::ConstantDelay::processIncoming(wns::SmartPtr<wns::ldk::Compound> const&)
  28) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  27) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  26) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  25) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  24) wns::ldk::Processor<wns::ldk::multiplexer::Dispatcher>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  23) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  22) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  21) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  20) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  19) wns::ldk::Processor<wns::ldk::multiplexer::OpcodeSetter>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  18) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  17) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  16) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  15) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  14) dll::compoundSwitch::CompoundSwitch::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
  13) wns::ldk::CompoundHandlerInterface::onData(wns::SmartPtr<wns::ldk::Compound> const&)
  12) wns::ldk::FunctionalUnit::onDataForwarded(wns::SmartPtr<wns::ldk::Compound> const&)
  11) wns::ldk::SimpleLinkHandler::onDataForwarded(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
  10) wns::ldk::LinkHandlerInterface::doOnData(wns::ldk::FunctionalUnit*, wns::SmartPtr<wns::ldk::Compound> const&)
   9) wns::ldk::Processor<wns::ldk::multiplexer::Dispatcher>::doOnData(wns::SmartPtr<wns::ldk::Compound> const&)
   8) wns::ldk::multiplexer::Dispatcher::processIncoming(wns::SmartPtr<wns::ldk::Compound> const&)
   7) wns::ldk::CommandTypeSpecifier<wns::ldk::multiplexer::OpcodeCommand>::getCommand(wns::ldk::CommandPool const*) const
   6) wns::ldk::CommandProxy::getCommand(wns::ldk::CommandPool const*, wns::ldk::CommandTypeSpecifierInterface const*) const
   5) wns::ldk::CommandProxy::getCommand(wns::ldk::CommandPool const*, unsigned int) const
   4) void wns::Assure::expression<wns::Assure::Exception>(std::string const&, std::string const&, int, std::string const&, std::string const&)
   3) wns::Assure::Exception::Exception(std::string const&)
   2) wns::Exception::Exception(std::string const&)
   1) wns::Backtrace::snapshot()
openWNS: Caught wns::Assure::Exception:

In 'wns::ldk::Command* wns::ldk::CommandProxy::getCommand(const wns::ldk::CommandPool*, uint32_t) const' (framework/libwns--main--1.0/src/ldk/CommandProxy.cpp:200):
failed assertion (commandPool->knows(n)).
Reason: Command (Command ID: 35) not activated in CommandPool. Only activated Commands may be retrieved.
The following commands are in the CommandPool:
Command ID: 0, Type: NULL
Command ID: 1, Type: NULL
Command ID: 2, Type: NULL
Command ID: 3, Type: NULL
Command ID: 4, Type: NULL
Command ID: 5, Type: NULL
Command ID: 6, Type: NULL
Command ID: 7, Type: NULL
Command ID: 8, Type: NULL
Command ID: 9, Type: NULL
Command ID: 10, Type: NULL
Command ID: 11, Type: NULL
Command ID: 12, Type: NULL
Command ID: 13, Type: NULL
Command ID: 14, Type: NULL
Command ID: 15, Type: NULL
Command ID: 16, Type: NULL
Command ID: 17, Type: NULL
Command ID: 18, Type: NULL
Command ID: 19, Type: wns::ldk::probe::bus::WindowCommand
Command ID: 20, Type: wns::ldk::probe::bus::PacketCommand
Command ID: 21, Type: wifimac::pathselection::ForwardingCommand
Command ID: 22, Type: NULL
Command ID: 23, Type: dll::UpperCommand
Command ID: 24, Type: NULL
Command ID: 25, Type: NULL
Command ID: 26, Type: wifimac::lowerMAC::ManagerCommand
Command ID: 27, Type: wns::ldk::tools::OverheadCommand
Command ID: 28, Type: wns::ldk::probe::bus::WindowCommand
Command ID: 29, Type: NULL
Command ID: 30, Type: wifimac::lowerMAC::DuplicateFilterCommand
Command ID: 31, Type: NULL
Command ID: 32, Type: wns::ldk::arq::StopAndWaitCommand
Command ID: 33, Type: NULL
Command ID: 34, Type: NULL
Command ID: 35, Type: NULL
Command ID: 36, Type: NULL
Command ID: 37, Type: NULL
Command ID: 38, Type: NULL
Command ID: 39, Type: wns::ldk::multiplexer::OpcodeCommand
Command ID: 40, Type: NULL
Command ID: 41, Type: NULL
Command ID: 42, Type: wns::ldk::multiplexer::OpcodeCommand
Command ID: 43, Type: NULL
Command ID: 44, Type: NULL
Command ID: 45, Type: NULL
Command ID: 46, Type: NULL
Command ID: 47, Type: wns::ldk::multiplexer::OpcodeCommand
Command ID: 48, Type: NULL
Command ID: 49, Type: wifimac::convergence::TxDurationSetterCommand
Command ID: 50, Type: NULL
Command ID: 51, Type: NULL
Command ID: 52, Type: wns::ldk::crc::CRCCommand
Command ID: 53, Type: wifimac::convergence::ErrorModellingCommand
Command ID: 54, Type: wifimac::convergence::PhyUserCommand

The following commands are registered at the CommandProxy:
Command ID: 32, Role name: ARQCommand
Command ID: 24, Role name: BeaconCommand
Command ID: 25, Role name: BeaconLQMCommand
Command ID: 29, Role name: BufferCommand
Command ID: 36, Role name: CFPollCommand
Command ID: 52, Role name: CRCCommand
Command ID: 50, Role name: ChannelStateCommand
Command ID: 30, Role name: DuplicateFilterCommand
Command ID: 53, Role name: ErrorModellingCommand
Command ID: 21, Role name: ForwardingCommand
Command ID: 44, Role name: FrameSwitchCommand
Command ID: 51, Role name: FrameSynchronizationCommand
Command ID: 6, Role name: IP.forwarding
Command ID: 18, Role name: IP.lowerConvergence
Command ID: 10, Role name: IP.routing
Command ID: 1, Role name: IP.upperConvergence
Command ID: 26, Role name: ManagerCommand
Command ID: 27, Role name: OverheadCommand
Command ID: 40, Role name: PIFSDelayCommand
Command ID: 54, Role name: PhyUserCommand
Command ID: 48, Role name: PreambleCommand
Command ID: 41, Role name: QOSNULLDelayCommand
Command ID: 45, Role name: QoSNullCommand
Command ID: 37, Role name: RTSCTSCommand
Command ID: 43, Role name: RTSSwitchCommand
Command ID: 33, Role name: RateAdaptationCommand
Command ID: 46, Role name: RxFilterCommand
Command ID: 42, Role name: RxFilterDispatcherCommand
Command ID: 38, Role name: SIFSDelayCommand
Command ID: 39, Role name: SIFSDispatcherCommand
Command ID: 34, Role name: TXOP11eCommand
Command ID: 35, Role name: TXOPDispatcherCommand
Command ID: 49, Role name: TxDurationCommand
Command ID: 15, Role name: arpResolver
Command ID: 22, Role name: compoundSwitch
Command ID: 20, Role name: e2eDelayProbeCommand
Command ID: 19, Role name: e2eWindowProbeCommand
Command ID: 4, Role name: endToEndProbe
Command ID: 16, Role name: flowSeparatorPrototype
Command ID: 7, Role name: forwardChain
Command ID: 8, Role name: hopProbe
Command ID: 3, Role name: inputChain
Command ID: 0, Role name: ip.ipHeader
Command ID: 31, Role name: nextFrameGetterCommand
Command ID: 14, Role name: outputBuffer
Command ID: 17, Role name: outputBuffers
Command ID: 2, Role name: outputChain
Command ID: 47, Role name: planeDispatcherCommand
Command ID: 11, Role name: postroutingChain
Command ID: 12, Role name: preroutingChain
Command ID: 13, Role name: synchronizer
Command ID: 23, Role name: upperConvergence
Command ID: 28, Role name: wifimac.txUpperProbeCommand
Command ID: 5, Role name: windowedEndToEndProbe
Command ID: 9, Role name: windowedHopProbe

Learning point,

Both access points are configured as (dcf=false). so it runs HCCA HCCA together.
1. When, self.dcf=False is assigned in Layer2.py, it works fine.
2. When, self.dcf=True is assigned in Layer2.py, it doesnt work.

That means that, during runtime, it is possible to change the configuration but not the already assigned FUN. Am I right?

Thanks,
Rahamatullah

Sebastian Max (smx-comnets) said : #3

Dear Rahmatullah,

I can only guess from your description that you are trying to simulate nodes with different FUNs in one scenario, right? If yes, then you have to be very careful:

Let's say node 1 has not in its FUN the FU "TXOPDispatcher", but node 2 one has it. The node 1 sends a compound; because there is no FU TXOPDispatcher, the entry to the dispatcher will not be stored; hence, there is no command of this FU in the compound. Node 2 receives the compound; it is forwarded upwards in its FUN. When it reaches the TXOPDispatcher, the FU has to know the entry so that it can deliver the compound to the correct path - hence, it tries to access the command, which fails.

Could you please verify that this is the reason for you error? If yes, then you have to change the FUN of the node 1: In any case, any node in the simulation has to have a FUN that is _compatible_ to any other node's FUN. It does not have to be the same, but incoming compounds from other nodes must be processed correctly.

BR,
Sebastian

Hi,

I'm not sure if this fits your problem but please be sure you keep the
dispatcher (or if possible leave it out) in both configurations. You
cannot have one with and one without dispatcher so please change your if
clauses accordingly. It is not a problem to connect just one FU to the
dispatcher.

I'm not getting what you are trying to do: Do you want DCF and HCCA to
take turns in time / in the superframe? In this case you need some FU
above (most likely a CompoundFilter) that decides by the offset in super
frame which FU he passes the Compound to:

                                             |

--------------------------------------------------------------------------------
      | CompoundSwitch (FilterBySuperFrameOffset |<---------------
Friend: Somebody who knows the superframe (BeaconFU?)

--------------------------------------------------------------------------------
          | |
------------------ ------------------- -------------
| TXOP | | TXOP11e| |CFPoll|
------------------ ------------------ -------------
           | | |
           | ----------------------
           | | Dispatcher|
           | ----------------------
          ---------------------------- |
                                    | |
                                    | |
                            ----------------------
                            | Dispatcher|
                            ----------------------
                                       |

Greats,

Mac

Sebastian Max wrote:
> Question #71251 on openWNS WiFiMAC changed:
> https://answers.launchpad.net/openwns-wifimac/+question/71251
>
> Status: Open => Needs information
>
> Sebastian Max requested for more information:
> Dear Rahmatullah,
>
> I can only guess from your description that you are trying to simulate
> nodes with different FUNs in one scenario, right? If yes, then you have
> to be very careful:
>
> Let's say node 1 has not in its FUN the FU "TXOPDispatcher", but node 2
> one has it. The node 1 sends a compound; because there is no FU
> TXOPDispatcher, the entry to the dispatcher will not be stored; hence,
> there is no command of this FU in the compound. Node 2 receives the
> compound; it is forwarded upwards in its FUN. When it reaches the
> TXOPDispatcher, the FU has to know the entry so that it can deliver the
> compound to the correct path - hence, it tries to access the command,
> which fails.
>
> Could you please verify that this is the reason for you error? If yes,
> then you have to change the FUN of the node 1: In any case, any node in
> the simulation has to have a FUN that is _compatible_ to any other
> node's FUN. It does not have to be the same, but incoming compounds from
> other nodes must be processed correctly.
>
> BR,
> Sebastian
>
>

The ASCII drawing did not work to well. See the picture here:

www.comnets.rwth-aachen.de/~mue/TXOP11FUN.pdf

You might also need to put the NextFrame FU in each path below the CompoundSwitch

OK, now I understand what you try. You want to have legacy stations that do not understand CFPoll etc. the problem is the "Command". The CommandPool is the header of a packet (Compound). Each Command represents one or multiple entries in the Command. And there is a FUs on both sides who knows how to manipulate these entries.

Now the legacy stations transmit with a TXOP FU using an EmptyCommand (do not write header operation). The TXOP11e FU uses a TXOP11eCommand. But as I figured this command is empty so what needs to be done is just change the command to EmptyCommand as done in the normal TXOP FU and remove the TXOP11eCommand.

Things are harder with the CFPoll FU since this one has a non empty command. Legacy stations need to have a CFPoll FU but it should have a parameter "isLegacy" or something. If it is true onData should return ignoring the incoming CFPoll.

Summarized that means a legacy STA has TXOP instead of TXOP11e FU but also needs the dispatcher with the CFPoll FU. CFPoll FU is configured to ignore incoming data. It should also not try to find its TXOP11e Friend if isLegacy = True.

Rahamatullah (rahbd052000) said : #7

Thanks Maciej Muehleisen, that solved my question.