Adaptons le scénario pour une simulation sur ns-3, un simulateur de réseau

largement utilisé dans la recherche en réseau. Pour utiliser ns-3, vous devrez
écrire des scripts en C++ ou Python, en fonction de vos préférences. Voici une
version simplifiée en C++ :

```cpp
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/applications-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/wifi-module.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("WifiOffloadSimulator");

const int NUM_USERS = 50;

const double PRB_CAPACITY = 1000.0; // Total number of available PRBs
const double PRB_USAGE_RATE = 0.02; // Rate at which PRBs are used per user (adjust
based on your scenario)
const double SIMULATION_TIME = 10.0; // in seconds

struct User {
double dataDemand; // User's data demand in PRBs
Ptr<Node> node; // User's node in ns-3
};

double usedPRBs = 0.0;

void SimulateUserActivity(std::vector<User>& users) {

for (size_t i = 0; i < users.size(); ++i) {
// Simulate user data demand
users[i].dataDemand = (rand() % 10) + 1; // Example: random data demand
between 1 and 10 PRBs

// Check if there are enough available PRBs

if (usedPRBs + users[i].dataDemand <= PRB_CAPACITY) {
// Allocate PRBs to the user
usedPRBs += users[i].dataDemand;
} else {
// Handle congestion or queuing mechanisms
NS_LOG_INFO("Congestion: User " << i << " cannot get required PRBs.");
}
}
}

void ReleaseUnusedPRBs(std::vector<User>& users) {

// Simulate release of PRBs for users who have finished using resources
for (size_t i = 0; i < users.size(); ++i) {
if (usedPRBs >= users[i].dataDemand) {
usedPRBs -= users[i].dataDemand;
} else {
// Handle potential error or queuing mechanisms
NS_LOG_INFO("Error: User " << i << " trying to release more PRBs than
allocated.");
}
}
}

int main(int argc, char* argv[]) {

LogComponentEnable("WifiOffloadSimulator", LOG_LEVEL_INFO);

// Seed for random number generation

srand(time(0));

// Create nodes
NodeContainer enbNode;
enbNode.Create(1);

NodeContainer userNodes;
userNodes.Create(NUM_USERS);

// Mobility model for users (random walk)

MobilityHelper mobility;
mobility.SetMobilityModel("ns3::RandomWalk2dMobilityModel",
"Bounds", RectangleValue(Rectangle(-500, 500, -500,
500)));
mobility.Install(userNodes);

// Install Wi-Fi
WifiHelper wifi;
wifi.SetStandard(WIFI_PHY_STANDARD_80211n_5GHZ);

YansWifiChannelHelper channel;
channel.SetPropagationDelay("ns3::ConstantSpeedPropagationDelayModel");
channel.AddPropagationLoss("ns3::LogDistancePropagationLossModel");

YansWifiPhyHelper phy = YansWifiPhyHelper::Default();

phy.SetChannel(channel.Create());

WifiMacHelper mac;
Ssid ssid = Ssid("ns-3-ssid");
mac.SetType("ns3::StaWifiMac", "Ssid", SsidValue(ssid), "ActiveProbing",
BooleanValue(false));
NetDeviceContainer staDevices = wifi.Install(phy, mac, userNodes);

mac.SetType("ns3::ApWifiMac", "Ssid", SsidValue(ssid));

NetDeviceContainer apDevice = wifi.Install(phy, mac, enbNode);

// Internet stack
InternetStackHelper stack;
stack.Install(enbNode);
stack.Install(userNodes);

// Assign IP addresses
Ipv4AddressHelper address;
address.SetBase("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer apInterfaces = address.Assign(apDevice);
Ipv4InterfaceContainer staInterfaces = address.Assign(staDevices);

// Set up routing
Ipv4GlobalRoutingHelper::PopulateRoutingTables();

// Simulation loop
std::vector<User> users(NUM_USERS);
for (size_t i = 0; i < NUM_USERS; ++i) {
 users[i].node = userNodes.Get(i);
}

for (double currentTime = 0.0; currentTime < SIMULATION_TIME; currentTime +=

1.0) {
SimulateUserActivity(users);
ReleaseUnusedPRBs(users);

Simulator::Stop(Seconds(currentTime + 1.0));
Simulator::Run();
Simulator::Destroy();
}

return 0;
}

Assurez-vous d'installer ns-3 correctement et d'inclure les modules nécessaires en

fonction des fonctionnalités que vous souhaitez utiliser dans votre simulation. Ce
script utilise un modèle de mobilité de marche aléatoire 2D pour les utilisateurs
et des canaux WiFi avec des équipements stationnaires et d'accès. Vous devrez peut-
être ajuster certains paramètres en fonction de vos besoins spécifiques.