Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/devices/wifi/wifi-phy-state-helper.cc
changeset 5189 8fcdf87a790a
parent 3905 99c9346b5d71
child 5819 514ec98954ab
equal deleted inserted replaced
5188:799fdd8fc54a 5189:8fcdf87a790a 
    52 WifiPhyStateHelper::WifiPhyStateHelper ()
 
    52 WifiPhyStateHelper::WifiPhyStateHelper ()
 
    53   : m_syncing (false),
 
    53   : m_syncing (false),
 
    54     m_endTx (Seconds (0)),
 
    54     m_endTx (Seconds (0)),
 
    55     m_endSync (Seconds (0)),
 
    55     m_endSync (Seconds (0)),
 
    56     m_endCcaBusy (Seconds (0)),
 
    56     m_endCcaBusy (Seconds (0)),
 
       
    57     m_endSwitching (Seconds (0)), 
    57     m_startTx (Seconds (0)),
 
    58     m_startTx (Seconds (0)),
 
    58     m_startSync (Seconds (0)),
 
    59     m_startSync (Seconds (0)),
 
    59     m_startCcaBusy (Seconds (0)),
 
    60     m_startCcaBusy (Seconds (0)),
 
       
    61     m_startSwitching (Seconds (0)), 
    60     m_previousStateChangeTime (Seconds (0))
 
    62     m_previousStateChangeTime (Seconds (0))
 
    61 {
 
    63 {
 
    62   NS_LOG_FUNCTION (this);
 
    64   NS_LOG_FUNCTION (this);
 
    63 }
 
    65 }
 
    64 
    66 
   101 }
 
   103 }
 
   102 bool 
   104 bool 
   103 WifiPhyStateHelper::IsStateTx (void)
 
   105 WifiPhyStateHelper::IsStateTx (void)
 
   104 {
 
   106 {
 
   105   return (GetState () == WifiPhy::TX)?true:false;
 
   107   return (GetState () == WifiPhy::TX)?true:false;
 
       
   108 }
 
       
   109 bool 
       
   110 WifiPhyStateHelper::IsStateSwitching (void)
 
       
   111 {
 
       
   112   return (GetState () == WifiPhy::SWITCHING)?true:false;
 
   106 }
 
   113 }
 
   107 
   114 
   108 
   115 
   109 
   116 
   110 Time
 
   117 Time
 
   125   case WifiPhy::TX:
 
   132   case WifiPhy::TX:
 
   126     retval = m_endTx - Simulator::Now ();
 
   133     retval = m_endTx - Simulator::Now ();
 
   127     break;
 
   134     break;
 
   128   case WifiPhy::CCA_BUSY:
 
   135   case WifiPhy::CCA_BUSY:
 
   129     retval = m_endCcaBusy - Simulator::Now ();
 
   136     retval = m_endCcaBusy - Simulator::Now ();
 
       
   137     break;
 
       
   138   case WifiPhy::SWITCHING: 
       
   139     retval = m_endSwitching - Simulator::Now (); 
   130     break;
 
   140     break;
 
   131   case WifiPhy::IDLE:
 
   141   case WifiPhy::IDLE:
 
   132     retval = Seconds (0);
 
   142     retval = Seconds (0);
 
   133     break;
 
   143     break;
 
   134   default:
 
   144   default:
 
   161     return "IDLE";
 
   171     return "IDLE";
 
   162     break;
 
   172     break;
 
   163   case WifiPhy::SYNC:
 
   173   case WifiPhy::SYNC:
 
   164     return "SYNC";
 
   174     return "SYNC";
 
   165     break;
 
   175     break;
 
       
   176   case WifiPhy::SWITCHING: 
       
   177     return "SWITCHING";
 
       
   178     break;
 
   166   default:
 
   179   default:
 
   167     NS_ASSERT (false);
 
   180     NS_ASSERT (false);
 
   168     // quiet compiler
 
   181     // quiet compiler
 
   169     return "INVALID";
 
   182     return "INVALID";
 
   170     break;
 
   183     break;
 
   180     } 
   193     } 
   181   else if (m_syncing) 
   194   else if (m_syncing) 
   182     {
 
   195     {
 
   183       return WifiPhy::SYNC;
 
   196       return WifiPhy::SYNC;
 
   184     } 
   197     } 
       
   198   else if (m_endSwitching > Simulator::Now ())  
       
   199     { 
       
   200       return WifiPhy::SWITCHING;
 
       
   201     }
 
   185   else if (m_endCcaBusy > Simulator::Now ()) 
   202   else if (m_endCcaBusy > Simulator::Now ()) 
   186     {
 
   203     {
 
   187       return WifiPhy::CCA_BUSY;
 
   204       return WifiPhy::CCA_BUSY;
 
   188     } 
   205     } 
   189   else 
   206   else 
   226 {
 
   243 {
 
   227   for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) {
 
   244   for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) {
 
   228     (*i)->NotifyMaybeCcaBusyStart (duration);
 
   245     (*i)->NotifyMaybeCcaBusyStart (duration);
 
   229   }
 
   246   }
 
   230 }
 
   247 }
 
       
   248 void 
       
   249 WifiPhyStateHelper::NotifySwitchingStart (Time duration)
 
       
   250 {
 
       
   251   for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) {
 
       
   252     (*i)->NotifySwitchingStart (duration);
 
       
   253   }
 
       
   254 }
 
   231 
   255 
   232 void
 
   256 void
 
   233 WifiPhyStateHelper::LogPreviousIdleAndCcaBusyStates (void)
 
   257 WifiPhyStateHelper::LogPreviousIdleAndCcaBusyStates (void)
 
   234 {
 
   258 {
 
   235   Time now = Simulator::Now ();
 
   259   Time now = Simulator::Now ();
 
   236   Time idleStart = Max (m_endCcaBusy, m_endSync);
 
   260   Time idleStart = Max (m_endCcaBusy, m_endSync);
 
   237   idleStart = Max (idleStart, m_endTx);
 
   261   idleStart = Max (idleStart, m_endTx);
 
       
   262   idleStart = Max (idleStart, m_endSwitching); 
   238   NS_ASSERT (idleStart <= now);
 
   263   NS_ASSERT (idleStart <= now);
 
   239   if (m_endCcaBusy > m_endSync && 
   264   if (m_endCcaBusy > m_endSync && 
       
   265       m_endCcaBusy > m_endSwitching &&  
   240       m_endCcaBusy > m_endTx) {
 
   266       m_endCcaBusy > m_endTx) {
 
   241     Time ccaBusyStart = Max (m_endTx, m_endSync);
 
   267     Time ccaBusyStart = Max (m_endTx, m_endSync);
 
   242     ccaBusyStart = Max (ccaBusyStart, m_startCcaBusy);
 
   268     ccaBusyStart = Max (ccaBusyStart, m_startCcaBusy);
 
       
   269     ccaBusyStart = Max (ccaBusyStart, m_endSwitching); 
   243     m_stateLogger (ccaBusyStart, idleStart - ccaBusyStart, WifiPhy::CCA_BUSY);
 
   270     m_stateLogger (ccaBusyStart, idleStart - ccaBusyStart, WifiPhy::CCA_BUSY);
 
   244   }
 
   271   }
 
   245   m_stateLogger (idleStart, now - idleStart, WifiPhy::IDLE);
 
   272   m_stateLogger (idleStart, now - idleStart, WifiPhy::IDLE);
 
   246 }
 
   273 }
 
   247 
   274 
   262     m_endSync = now;
 
   289     m_endSync = now;
 
   263     break;
 
   290     break;
 
   264   case WifiPhy::CCA_BUSY: {
 
   291   case WifiPhy::CCA_BUSY: {
 
   265     Time ccaStart = Max (m_endSync, m_endTx);
 
   292     Time ccaStart = Max (m_endSync, m_endTx);
 
   266     ccaStart = Max (ccaStart, m_startCcaBusy);
 
   293     ccaStart = Max (ccaStart, m_startCcaBusy);
 
       
   294     ccaStart = Max (ccaStart, m_endSwitching); 
   267     m_stateLogger (ccaStart, now - ccaStart, WifiPhy::CCA_BUSY);
 
   295     m_stateLogger (ccaStart, now - ccaStart, WifiPhy::CCA_BUSY);
 
   268   } break;
 
   296   } break;
 
   269   case WifiPhy::IDLE:
 
   297   case WifiPhy::IDLE:
 
   270     LogPreviousIdleAndCcaBusyStates ();
 
   298     LogPreviousIdleAndCcaBusyStates ();
 
   271     break;
 
   299     break;
 
       
   300   case WifiPhy::SWITCHING: 
   272   default:
 
   301   default:
 
   273     NS_ASSERT (false);
 
   302     NS_ASSERT (false);
 
   274     break;
 
   303     break;
 
   275   }
 
   304   }
 
   276   m_stateLogger (now, txDuration, WifiPhy::TX);
 
   305   m_stateLogger (now, txDuration, WifiPhy::TX);
 
   290     LogPreviousIdleAndCcaBusyStates ();
 
   319     LogPreviousIdleAndCcaBusyStates ();
 
   291     break;
 
   320     break;
 
   292   case WifiPhy::CCA_BUSY: {
 
   321   case WifiPhy::CCA_BUSY: {
 
   293     Time ccaStart = Max (m_endSync, m_endTx);
 
   322     Time ccaStart = Max (m_endSync, m_endTx);
 
   294     ccaStart = Max (ccaStart, m_startCcaBusy);
 
   323     ccaStart = Max (ccaStart, m_startCcaBusy);
 
       
   324     ccaStart = Max (ccaStart, m_endSwitching); 
   295     m_stateLogger (ccaStart, now - ccaStart, WifiPhy::CCA_BUSY);
 
   325     m_stateLogger (ccaStart, now - ccaStart, WifiPhy::CCA_BUSY);
 
   296   } break;
 
   326   } break;
 
       
   327   case WifiPhy::SWITCHING: 
   297   case WifiPhy::SYNC:
 
   328   case WifiPhy::SYNC:
 
   298   case WifiPhy::TX:
 
   329   case WifiPhy::TX:
 
   299     NS_ASSERT (false);
 
   330     NS_ASSERT (false);
 
   300     break;
 
   331     break;
 
   301   }
 
   332   }
 
   303   m_syncing = true;
 
   334   m_syncing = true;
 
   304   m_startSync = now;
 
   335   m_startSync = now;
 
   305   m_endSync = now + rxDuration;
 
   336   m_endSync = now + rxDuration;
 
   306   NS_ASSERT (IsStateSync ());
 
   337   NS_ASSERT (IsStateSync ());
 
   307 }
 
   338 }
 
       
   339 
       
   340 void 
       
   341 WifiPhyStateHelper::SwitchToChannelSwitching (Time switchingDuration)
 
       
   342 { 
       
   343   NotifySwitchingStart (switchingDuration); 
       
   344   Time now = Simulator::Now ();
 
       
   345   switch (GetState ()) {
 
       
   346   case WifiPhy::SYNC:
 
       
   347     /* The packet which is being received as well
 
       
   348      * as its endSync event are cancelled by the caller.
 
       
   349      */
 
       
   350     m_syncing = false;
 
       
   351     m_stateLogger (m_startSync, now - m_startSync, WifiPhy::SYNC);
 
       
   352     m_endSync = now;
 
       
   353     break;
 
       
   354   case WifiPhy::CCA_BUSY: {
 
       
   355     Time ccaStart = Max (m_endSync, m_endTx);
 
       
   356     ccaStart = Max (ccaStart, m_startCcaBusy);
 
       
   357     ccaStart = Max (ccaStart, m_endSwitching);  
       
   358     m_stateLogger (ccaStart, now - ccaStart, WifiPhy::CCA_BUSY);
 
       
   359   } break;
 
       
   360   case WifiPhy::IDLE:
 
       
   361     LogPreviousIdleAndCcaBusyStates (); 
       
   362     break;
 
       
   363   case WifiPhy::TX:
 
       
   364   case WifiPhy::SWITCHING:
 
       
   365   default:
 
       
   366     NS_ASSERT (false);
 
       
   367     break;
 
       
   368   }
 
       
   369   
       
   370   if (now < m_endCcaBusy)
 
       
   371     {
 
       
   372       m_endCcaBusy = now; 
       
   373     }
 
       
   374 
       
   375   m_stateLogger (now, switchingDuration, WifiPhy::SWITCHING);
 
       
   376   m_previousStateChangeTime = now;
 
       
   377   m_startSwitching = now;
 
       
   378   m_endSwitching = now + switchingDuration;
 
       
   379   NS_ASSERT (IsStateSwitching ());
 
       
   380 }
 
       
   381 
   308 void 
   382 void 
   309 WifiPhyStateHelper::SwitchFromSyncEndOk (Ptr<Packet> packet, double snr, WifiMode mode, enum WifiPreamble preamble)
 
   383 WifiPhyStateHelper::SwitchFromSyncEndOk (Ptr<Packet> packet, double snr, WifiMode mode, enum WifiPreamble preamble)
 
   310 {
 
   384 {
 
   311   m_rxOkTrace (packet, snr, mode, preamble);
 
   385   m_rxOkTrace (packet, snr, mode, preamble);
 
   312   NotifySyncEndOk ();
 
   386   NotifySyncEndOk ();
 
   346 WifiPhyStateHelper::SwitchMaybeToCcaBusy (Time duration)
 
   420 WifiPhyStateHelper::SwitchMaybeToCcaBusy (Time duration)
 
   347 {
 
   421 {
 
   348   NotifyMaybeCcaBusyStart (duration);
 
   422   NotifyMaybeCcaBusyStart (duration);
 
   349   Time now = Simulator::Now ();
 
   423   Time now = Simulator::Now ();
 
   350   switch (GetState ()) {
 
   424   switch (GetState ()) {
 
       
   425   case WifiPhy::SWITCHING: 
       
   426     break;
 
   351   case WifiPhy::IDLE:
 
   427   case WifiPhy::IDLE:
 
   352     LogPreviousIdleAndCcaBusyStates ();
 
   428     LogPreviousIdleAndCcaBusyStates ();
 
   353   break;
 
   429   break;
 
   354   case WifiPhy::CCA_BUSY:
 
   430   case WifiPhy::CCA_BUSY:
 
   355     break;
 
   431     break;
ns-3.24