27 NS_LOG_COMPONENT_DEFINE(
"SatRandomAccess");
32 NS_OBJECT_ENSURE_REGISTERED(SatRandomAccess);
38 TypeId(
"ns3::SatRandomAccess").SetParent<Object>().AddConstructor<SatRandomAccess>();
43 : m_uniformRandomVariable(),
44 m_randomAccessModel(
SatEnums::RA_MODEL_OFF),
46 m_numOfAllocationChannels(),
51 NS_LOG_FUNCTION(
this);
53 NS_FATAL_ERROR(
"SatRandomAccess::SatRandomAccess - Constructor not in use");
58 : m_uniformRandomVariable(),
59 m_randomAccessModel(randomAccessModel),
60 m_randomAccessConf(randomAccessConf),
61 m_numOfAllocationChannels(randomAccessConf->GetNumOfAllocationChannelsConfigurations()),
66 NS_LOG_FUNCTION(
this);
72 NS_FATAL_ERROR(
"SatRandomAccess::SatRandomAccess - Configuration object is NULL");
80 NS_LOG_FUNCTION(
this);
99 NS_LOG_FUNCTION(
this);
130 NS_LOG_FUNCTION(
this << allocationChannel);
139 NS_LOG_FUNCTION(
this << allocationChannel);
142 ->GetSlottedAlohaAllowed();
148 NS_LOG_FUNCTION(
this << allocationChannel);
158 NS_LOG_FUNCTION(
this << allocationChannelId
168 NS_LOG_INFO(
"------------------------------------");
169 NS_LOG_INFO(
"------ Starting Random Access ------");
170 NS_LOG_INFO(
"------------------------------------");
177 NS_LOG_INFO(
"Only CRDSA enabled && CRDSA trigger, checking allocation channel");
181 NS_LOG_INFO(
"Valid CRDSA allocation channel, checking backoff status");
185 NS_LOG_INFO(
"CRDSA backoff period over, evaluating CRDSA");
186 txOpportunities =
DoCrdsa(allocationChannel);
190 NS_LOG_INFO(
"CRDSA backoff period in effect, aborting");
198 "SatRandomAccess::DoRandomAccess - Invalid allocation channel for CRDSA");
206 "SatRandomAccess::DoRandomAccess - Only ESSA enabled, checking allocation channel");
211 "SatRandomAccess::DoRandomAccess - Valid allocation channel, evaluating ESSA");
213 txOpportunities =
DoEssa(allocationChannel);
217 NS_FATAL_ERROR(
"SatRandomAccess::DoRandomAccess - Invalid allocation channel for ESSA");
224 NS_LOG_INFO(
"Only SA enabled, checking allocation channel");
228 NS_LOG_INFO(
"Valid allocation channel, evaluating Slotted ALOHA");
235 "SatRandomAccess::DoRandomAccess - Invalid allocation channel for Slotted ALOHA");
242 NS_LOG_INFO(
"RA based on RCS2 specification enabled");
245 ->GetCrdsaNumOfInstances() < 2)
251 NS_LOG_INFO(
"Valid Slotted ALOHA allocation channel, evaluating Slotted ALOHA");
256 NS_FATAL_ERROR(
"SatRandomAccess::DoRandomAccess - Invalid allocation channel "
257 "for Slotted ALOHA");
262 NS_LOG_INFO(
"Number of instances is < 2, only Slotted ALOHA is in use");
271 NS_LOG_INFO(
"Valid CRDSA allocation channel, checking backoff status");
275 NS_LOG_INFO(
"CRDSA backoff period over, evaluating CRDSA");
276 txOpportunities =
DoCrdsa(allocationChannel);
280 NS_LOG_INFO(
"CRDSA backoff period in effect, aborting");
288 "SatRandomAccess::DoRandomAccess - Invalid allocation channel for CRDSA");
293 NS_LOG_INFO(
"Number of instances is > 1, only CRDSA is in use");
300 NS_LOG_INFO(
"Slotted ALOHA is disabled");
306 NS_LOG_INFO(
"CRDSA is disabled");
314 std::map<uint32_t, std::set<uint32_t>>::iterator iter;
315 uint32_t uniquePacketId = 1;
321 std::set<uint32_t>::iterator iterSet;
322 for (iterSet = iter->second.begin(); iterSet != iter->second.end(); iterSet++)
324 NS_LOG_INFO(
"CRDSA transmission opportunity for unique packet: "
325 << uniquePacketId <<
" at slot: " << (*iterSet));
337 NS_LOG_INFO(
"SatRandomAccess::DoRandomAccess - ESSA minimum time to wait: "
342 NS_LOG_INFO(
"No Tx opportunity");
346 NS_FATAL_ERROR(
"SatRandomAccess::DoRandomAccess - Invalid result type");
349 NS_LOG_INFO(
"------------------------------------");
350 NS_LOG_INFO(
"------ Random Access FINISHED ------");
351 NS_LOG_INFO(
"------------------------------------");
353 return txOpportunities;
359 NS_LOG_FUNCTION(
this);
361 NS_LOG_INFO(
"Simulation time: " << Now().GetSeconds() <<
" seconds");
365 NS_LOG_INFO(
"---------------");
369 Ptr<SatRandomAccessAllocationChannel> allocationChannel =
371 NS_LOG_INFO(
"ALLOCATION CHANNEL: " << index);
372 NS_LOG_INFO(
"Backoff release at: "
373 << allocationChannel->GetCrdsaBackoffReleaseTime().GetSeconds() <<
" seconds");
374 NS_LOG_INFO(
"Backoff time: " << allocationChannel->GetCrdsaBackoffTimeInMilliSeconds()
376 NS_LOG_INFO(
"Backoff probability: " << allocationChannel->GetCrdsaBackoffProbability() * 100
378 NS_LOG_INFO(
"Slot randomization: "
379 << allocationChannel->GetCrdsaNumOfInstances() *
380 allocationChannel->GetCrdsaMaxUniquePayloadPerBlock()
381 <<
" Tx opportunities with range from "
382 << allocationChannel->GetCrdsaMinRandomizationValue() <<
" to "
383 << allocationChannel->GetCrdsaMaxRandomizationValue());
384 NS_LOG_INFO(
"Number of unique payloads per block: "
385 << allocationChannel->GetCrdsaMaxUniquePayloadPerBlock());
386 NS_LOG_INFO(
"Number of instances: " << allocationChannel->GetCrdsaNumOfInstances());
387 NS_LOG_INFO(
"Number of consecutive blocks accessed: "
388 << allocationChannel->GetCrdsaNumOfConsecutiveBlocksUsed() <<
"/"
389 << allocationChannel->GetCrdsaMaxConsecutiveBlocksAccessed());
390 NS_LOG_INFO(
"Number of idle blocks left: " << allocationChannel->GetCrdsaIdleBlocksLeft()
392 << allocationChannel->GetCrdsaMinIdleBlocks());
405 NS_LOG_FUNCTION(
this);
419 NS_FATAL_ERROR(
"SatRandomAccess::SetBackoffTime - Wrong random access model in use");
428 NS_LOG_FUNCTION(
this);
442 NS_FATAL_ERROR(
"SatRandomAccess::SetBackoffProbability - Wrong random access model in use");
460 uint32_t controlRandomizationIntervalInMilliSeconds)
462 NS_LOG_FUNCTION(
this << controlRandomizationIntervalInMilliSeconds);
468 controlRandomizationIntervalInMilliSeconds);
474 NS_FATAL_ERROR(
"SatRandomAccess::SetSlottedAlohaControlRandomizationIntervalInMilliSeconds "
475 "- Wrong random access model in use");
479 "New control randomization interval : " << controlRandomizationIntervalInMilliSeconds);
485 NS_LOG_FUNCTION(
this);
490 NS_LOG_INFO(
"---------------------------------------------");
491 NS_LOG_INFO(
"------ Running Slotted ALOHA algorithm ------");
492 NS_LOG_INFO(
"---------------------------------------------");
493 NS_LOG_INFO(
"Slotted ALOHA control randomization interval: "
496 NS_LOG_INFO(
"---------------------------------------------");
498 NS_LOG_INFO(
"Checking if we have DAMA allocations");
503 NS_LOG_INFO(
"No DAMA -> Running Slotted ALOHA");
510 NS_LOG_INFO(
"----------------------------------------------");
511 NS_LOG_INFO(
"------ Slotted ALOHA algorithm FINISHED ------");
512 NS_LOG_INFO(
"----------------------------------------------");
514 return txOpportunity;
520 NS_LOG_FUNCTION(
this);
522 NS_LOG_INFO(
"Randomizing the release time...");
528 NS_LOG_INFO(
"TX opportunity in the next slot after " << releaseTime <<
" milliseconds");
538 uint32_t backoffTimeInFrames)
543 NS_LOG_FUNCTION(
this);
548 ->SetFSimBackoffTimeInFrames(backoffTimeInFrames);
553 "SatRandomAccess::SetFSimBackoffTimeInFrames - Wrong random access model in use");
563 NS_LOG_FUNCTION(
this);
568 ->SetFSimBackoffProbability(backoffPersistence);
573 "SatRandomAccess::SetFSimBackoffProbability - Wrong random access model in use");
580 NS_LOG_FUNCTION(
this);
584 NS_LOG_INFO(
"------------------------------------");
585 NS_LOG_INFO(
"------ Running ESSA algorithm ------");
586 NS_LOG_INFO(
"------------------------------------");
595 uint32_t numberOfBackoff = 0;
598 ->GetFSimBackoffProbability())
604 numberOfBackoff *
m_randomAccessConf->GetAllocationChannelConfiguration(allocationChannel)
605 ->GetFSimBackoffTimeInMilliSeconds();
607 NS_LOG_INFO(
"-------------------------------------");
608 NS_LOG_INFO(
"------ ESSA algorithm FINISHED ------");
609 NS_LOG_INFO(
"-------------------------------------");
611 return txOpportunity;
620 uint32_t backoffTimeInMilliSeconds)
622 NS_LOG_FUNCTION(
this);
629 ->SetCrdsaBackoffTimeInMilliSeconds(backoffTimeInMilliSeconds);
632 ->DoCrdsaVariableSanityCheck();
636 NS_FATAL_ERROR(
"SatRandomAccess::SetCrdsaBackoffTimeInMilliSeconds - Wrong random access "
644 NS_LOG_FUNCTION(
this);
651 ->SetCrdsaBackoffProbability(backoffProbability);
654 ->DoCrdsaVariableSanityCheck();
659 "SatRandomAccess::SetCrdsaBackoffProbability - Wrong random access model in use");
665 uint32_t minRandomizationValue,
666 uint32_t maxRandomizationValue,
667 uint32_t numOfInstances)
669 NS_LOG_FUNCTION(
this);
676 ->SetCrdsaMinRandomizationValue(minRandomizationValue);
678 ->SetCrdsaMaxRandomizationValue(maxRandomizationValue);
680 ->SetCrdsaNumOfInstances(numOfInstances);
683 ->DoCrdsaVariableSanityCheck();
688 "SatRandomAccess::SetCrdsaRandomizationParameters - Wrong random access model in use");
694 uint32_t maxUniquePayloadPerBlock,
695 uint32_t maxConsecutiveBlocksAccessed,
696 uint32_t minIdleBlocks)
698 NS_LOG_FUNCTION(
this);
705 ->SetCrdsaMaxUniquePayloadPerBlock(maxUniquePayloadPerBlock);
707 ->SetCrdsaMaxConsecutiveBlocksAccessed(maxConsecutiveBlocksAccessed);
709 ->SetCrdsaMinIdleBlocks(minIdleBlocks);
712 ->DoCrdsaVariableSanityCheck();
716 NS_FATAL_ERROR(
"SatRandomAccess::SetCrdsaMaximumDataRateLimitationParameters - Wrong "
717 "random access model in use");
724 NS_LOG_FUNCTION(
this);
732 NS_LOG_FUNCTION(
this);
734 bool hasCrdsaBackoffTimePassed =
false;
736 if ((Now() >=
m_randomAccessConf->GetAllocationChannelConfiguration(allocationChannel)
737 ->GetCrdsaBackoffReleaseTime()))
739 hasCrdsaBackoffTimePassed =
true;
742 NS_LOG_INFO(
"For allocation channel " << allocationChannel <<
": "
743 << hasCrdsaBackoffTimePassed);
745 return hasCrdsaBackoffTimePassed;
751 NS_LOG_FUNCTION(
this);
753 uint32_t idleBlocksLeft =
755 ->GetCrdsaIdleBlocksLeft();
757 if (idleBlocksLeft > 0)
759 NS_LOG_INFO(
"Reducing allocation channel: " << allocationChannel <<
" idle blocks by one");
761 ->SetCrdsaIdleBlocksLeft(idleBlocksLeft - 1);
768 NS_LOG_FUNCTION(
this);
779 NS_LOG_FUNCTION(
this << allocationChannel);
782 ->SetCrdsaNumOfConsecutiveBlocksUsed(0);
788 NS_LOG_FUNCTION(
this);
799 NS_LOG_FUNCTION(
this);
802 ->GetCrdsaIdleBlocksLeft() > 0)
804 NS_LOG_INFO(
"Allocation channel: " << allocationChannel <<
" idle in effect");
807 NS_LOG_INFO(
"Allocation channel: " << allocationChannel <<
" free");
814 NS_LOG_FUNCTION(
this);
816 bool doCrdsaBackoff =
false;
820 ->GetCrdsaBackoffProbability())
822 doCrdsaBackoff =
true;
825 NS_LOG_INFO(
"For allocation channel " << allocationChannel <<
": " << doCrdsaBackoff);
827 return doCrdsaBackoff;
833 NS_LOG_FUNCTION(
this << allocationChannel);
835 uint32_t backoff =
m_randomAccessConf->GetAllocationChannelConfiguration(allocationChannel)
836 ->GetCrdsaBackoffTimeInMilliSeconds();
838 ->SetCrdsaBackoffReleaseTime(Now() + MilliSeconds(backoff));
844 NS_LOG_FUNCTION(
this);
849 uint32_t maxUniquePackets =
851 ->GetCrdsaMaxUniquePayloadPerBlock();
861 std::pair<std::set<uint32_t>, std::set<uint32_t>> slots;
863 for (uint32_t i = 0; i < maxUniquePackets; i++)
872 NS_LOG_INFO(
"New Tx candidate for allocation channel: " << allocationChannel);
877 "Preparing for transmission with allocation channel: " << allocationChannel);
884 std::make_pair(*slots.second.begin(), slots.second));
897 return txOpportunities;
903 NS_LOG_FUNCTION(
this << allocationChannel);
906 ->SetCrdsaNumOfConsecutiveBlocksUsed(
908 ->GetCrdsaNumOfConsecutiveBlocksUsed() +
912 ->GetCrdsaNumOfConsecutiveBlocksUsed() >=
914 ->GetCrdsaMaxConsecutiveBlocksAccessed())
916 NS_LOG_INFO(
"Maximum number of consecutive blocks reached, forcing idle blocks for "
917 "allocation channel: "
918 << allocationChannel);
921 ->SetCrdsaIdleBlocksLeft(
923 ->GetCrdsaMinIdleBlocks());
932 NS_LOG_FUNCTION(
this);
943 NS_LOG_FUNCTION(
this);
948 NS_LOG_INFO(
"-------------------------------------");
949 NS_LOG_INFO(
"------ Running CRDSA algorithm ------");
950 NS_LOG_INFO(
"-------------------------------------");
954 NS_LOG_INFO(
"-------------------------------------");
956 NS_LOG_INFO(
"Backoff period over, checking DAMA status...");
960 NS_LOG_INFO(
"No DAMA, checking buffer status...");
964 NS_LOG_INFO(
"Data in buffer, continuing CRDSA");
970 NS_LOG_INFO(
"Evaluating back off...");
974 NS_LOG_INFO(
"Initial new data backoff triggered");
989 NS_LOG_INFO(
"Tx opportunity, increasing consecutive blocks used");
996 "No Tx opportunity, reducing idle blocks & resetting consecutive blocks");
1004 NS_LOG_INFO(
"Empty buffer, reducing idle blocks & resetting consecutive blocks, "
1005 "aborting CRDSA...");
1013 NS_LOG_INFO(
"DAMA allocation found, aborting CRDSA...");
1019 NS_LOG_INFO(
"--------------------------------------");
1020 NS_LOG_INFO(
"------ CRDSA algorithm FINISHED ------");
1023 <<
" ---------------------");
1024 NS_LOG_INFO(
"--------------------------------------");
1026 return txOpportunities;
1029 std::pair<std::set<uint32_t>, std::set<uint32_t>>
1031 uint32_t allocationChannel,
1032 std::pair<std::set<uint32_t>, std::set<uint32_t>> slots)
1034 NS_LOG_FUNCTION(
this);
1036 std::pair<std::set<uint32_t>::iterator,
bool> resultAllSlotsInFrame;
1037 std::pair<std::set<uint32_t>::iterator,
bool> resultThisUniquePacket;
1039 std::set<uint32_t> emptySet;
1040 slots.second = emptySet;
1042 NS_LOG_INFO(
"Randomizing TX opportunities for allocation channel: " << allocationChannel);
1044 uint32_t successfulInserts = 0;
1045 uint32_t instances =
m_randomAccessConf->GetAllocationChannelConfiguration(allocationChannel)
1046 ->GetCrdsaNumOfInstances();
1047 while (successfulInserts < instances)
1051 ->GetCrdsaMinRandomizationValue(),
1053 ->GetCrdsaMaxRandomizationValue());
1055 resultAllSlotsInFrame = slots.first.insert(slot);
1057 if (resultAllSlotsInFrame.second)
1059 successfulInserts++;
1061 resultThisUniquePacket = slots.second.insert(slot);
1063 if (!resultAllSlotsInFrame.second)
1065 NS_FATAL_ERROR(
"SatRandomAccess::CrdsaRandomizeTxOpportunities - Slots out of "
1066 "sync, this should never happen");
1070 NS_LOG_INFO(
"Allocation channel: "
1071 << allocationChannel <<
" insert successful " << resultAllSlotsInFrame.second
1072 <<
" for TX opportunity slot: " << (*resultAllSlotsInFrame.first));
1075 NS_LOG_INFO(
"Randomizing done");
1083 NS_LOG_FUNCTION(
this << &callback);
1091 NS_LOG_FUNCTION(
this << &callback);
SatEnums class is for simplifying the use of enumerators in the satellite module.
static std::string GetRandomAccessModelName(RandomAccessModel_t model)
static std::string GetRandomAccessTriggerTypeName(RandomAccessTriggerType_t triggerType)
@ RA_TX_OPPORTUNITY_SLOTTED_ALOHA
@ RA_TX_OPPORTUNITY_CRDSA
@ RA_TX_OPPORTUNITY_DO_NOTHING
static std::string GetRandomAccessOpportunityTypeName(RandomAccessTxOpportunityType_t opportunityType)
RandomAccessModel_t
The defined random access models.
@ RA_MODEL_RCS2_SPECIFICATION
RandomAccessTriggerType_t
The defined random access trigger types.
@ RA_TRIGGER_TYPE_SLOTTED_ALOHA
SatEnums::RandomAccessModel_t m_randomAccessModel
The used random access model.
void CrdsaResetConsecutiveBlocksUsedForAllAllocationChannels()
Function for resetting the number of consecutive blocks to zero for all allocation channels.
bool IsEssaAllocationChannel(uint32_t allocationChannel)
Function for checking if the allocation channel is ESSA allocation channel.
void PrintVariables()
Function for printing out various module variables to console.
void SetCrdsaMaximumDataRateLimitationParameters(uint32_t allocationChannel, uint32_t maxUniquePayloadPerBlock, uint32_t maxConsecutiveBlocksAccessed, uint32_t minIdleBlocks)
Function for setting the maximum rate limitation parameters.
SatRandomAccess::RandomAccessTxOpportunities_s DoEssa(uint32_t allocationChannel)
Main function for ESSA.
void SetCrdsaBackoffTimeInMilliSeconds(uint32_t allocationChannel, uint32_t backoffTimeInMilliSeconds)
Function for setting the backoff time in milliseconds.
SatRandomAccess()
Constructor.
IsDamaAvailableCallback m_isDamaAvailableCb
Callback for known DAMA status.
std::pair< std::set< uint32_t >, std::set< uint32_t > > CrdsaRandomizeTxOpportunities(uint32_t allocationChannel, std::pair< std::set< uint32_t >, std::set< uint32_t >> slots)
Function for randomizing the CRDSA Tx opportunities (slots) for each unique packet.
bool IsSlottedAlohaAllocationChannel(uint32_t allocationChannel)
Function for checking if the allocation channel is Slotted ALOHA allocation channel.
SatRandomAccess::RandomAccessTxOpportunities_s DoRandomAccess(uint32_t allocationChannel, SatEnums::RandomAccessTriggerType_t triggerType)
Main function of this module.
uint32_t m_numOfAllocationChannels
Number of allocation channels available.
void CrdsaIncreaseConsecutiveBlocksUsed(uint32_t allocationChannel)
Function for increasing the allocation channel specific count of consecutive used blocks.
uint32_t GetConfigurationIdForAllocationChannel(uint32_t allocationChannelId)
Function to convert a carrier allocation channel ID into its allocation channel configuration ID.
void CrdsaResetConsecutiveBlocksUsed(uint32_t allocationChannel)
Function for resetting the number of consecutive blocks to zero for a specific allocation channel.
SatRandomAccess::RandomAccessTxOpportunities_s CrdsaPrepareToTransmit(uint32_t allocationChannel)
Function for evaluating backoff for each unique CRDSA packet and calling the randomization of Tx oppo...
bool CrdsaIsAllocationChannelFree(uint32_t allocationChannel)
Function for checking if the allocation channel is free.
void CrdsaIncreaseConsecutiveBlocksUsedForAllAllocationChannels()
Function for increasing the count of consecutive used blocks for all allocation channels.
void SetSlottedAlohaControlRandomizationIntervalInMilliSeconds(uint32_t controlRandomizationIntervalInMilliSeconds)
Function for setting the Slotted ALOHA control randomization interval.
AreBuffersEmptyCallback m_areBuffersEmptyCb
Callback for buffer status.
static TypeId GetTypeId(void)
NS-3 type id function.
Callback< bool > AreBuffersEmptyCallback
Typedef of callback for buffer status.
void CrdsaSetBackoffTimer(uint32_t allocationChannel)
Function for setting the allocation channel specific backoff timer.
void SetFSimBackoffTimeInFrames(uint32_t allocationChannel, uint32_t backoffTimeInFrames)
Function for setting the backoff time in frames.
SatRandomAccess::RandomAccessTxOpportunities_s DoCrdsa(uint32_t allocationChannel)
Main function for CRDSA algorithm.
void SetFSimBackoffProbability(uint32_t allocationChannel, uint16_t backoffPersistence)
Function for setting the backoff probability.
void SetCrdsaRandomizationParameters(uint32_t allocationChannel, uint32_t minRandomizationValue, uint32_t maxRandomizationValue, uint32_t numOfInstances)
Function for setting the parameters related to CRDSA randomization.
Ptr< SatRandomAccessConf > m_randomAccessConf
A pointer to random access configuration.
bool CrdsaHasBackoffTimePassed(uint32_t allocationChannel) const
Function for checking whether the backoff time has passed for this allocation channel.
Ptr< UniformRandomVariable > m_uniformRandomVariable
Uniform random variable object.
void SetAreBuffersEmptyCallback(SatRandomAccess::AreBuffersEmptyCallback callback)
Function for setting the AreBuffersEmpty callback.
void SetRandomAccessModel(SatEnums::RandomAccessModel_t randomAccessModel)
Function for setting the used random access model.
void SetIsDamaAvailableCallback(SatRandomAccess::IsDamaAvailableCallback callback)
Function for setting the IsDamaAvailable callback.
uint32_t GetSlottedAlohaSignalingOverheadInBytes()
Function for getting the Slotted ALOHA signaling overhead in bytes.
bool CrdsaDoBackoff(uint32_t allocationChannel)
Function for evaluating the backoff for this allocation channel.
SatRandomAccess::RandomAccessTxOpportunities_s DoSlottedAloha()
Main function for Slotted ALOHA.
uint32_t SlottedAlohaRandomizeReleaseTime()
Function for performing the Slotted ALOHA release time randomization, i.e., the time after which the ...
void CrdsaReduceIdleBlocksForAllAllocationChannels()
Function for reducing the idle blocks in effect for all allocation channels.
void SetBackoffTime(uint32_t allocationChannel, uint32_t backoffTime)
Function for setting the backoff time.
uint32_t GetCrdsaSignalingOverheadInBytes()
Function for getting the CRDSA signaling overhead in bytes.
bool m_crdsaNewData
A flag defining whether the buffers were emptied the last time RA was evaluated, i....
bool IsCrdsaAllocationChannel(uint32_t allocationChannel)
Function for checking if the allocation channel is CRDSA allocation channel.
void SetCrdsaBackoffProbability(uint32_t allocationChannel, uint16_t backoffProbability)
Function for setting the backoff probability.
void DoDispose()
Function for disposing the module and its variables.
void SetBackoffProbability(uint32_t allocationChannel, uint16_t backoffProbability)
Function for setting the backoff probability.
void CrdsaReduceIdleBlocks(uint32_t allocationChannel)
Function for reducing the allocation channel specific number of idle blocks in effect.
virtual ~SatRandomAccess()
Destructor.
Callback< bool > IsDamaAvailableCallback
Typedef of callback for known DAMA status.
SatArqSequenceNumber is handling the sequence numbers for the ARQ process.
Random access Tx opportunities.
uint32_t slottedAlohaTxOpportunity
SatEnums::RandomAccessTxOpportunityType_t txOpportunityType
uint32_t allocationChannel
std::map< uint32_t, std::set< uint32_t > > crdsaTxOpportunities