Welcome to LoRaWan_BME280_THP Discussions!

[dmoibm]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.
• but: please only in connection with the technologies in this project!

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[Alex19931993]

Hello I am using NS3 on ubento and after compiling this is the result, any one knows what does it mean and how to show gui in NS3

THIS IS THE CODE:
/*

• This script simulates a complex scenario with multiple gateways and end
• devices. The metric of interest for this script is the throughput of the
• network.
  */

#include "ns3/end-device-lora-phy.h"
#include "ns3/gateway-lora-phy.h"
#include "ns3/class-a-end-device-lorawan-mac.h"
#include "ns3/gateway-lorawan-mac.h"
#include "ns3/simulator.h"
#include "ns3/log.h"
#include "ns3/pointer.h"
#include "ns3/constant-position-mobility-model.h"
#include "ns3/lora-helper.h"
#include "ns3/node-container.h"
#include "ns3/mobility-helper.h"
#include "ns3/position-allocator.h"
#include "ns3/double.h"
#include "ns3/random-variable-stream.h"
#include "ns3/periodic-sender-helper.h"
#include "ns3/command-line.h"
#include "ns3/network-server-helper.h"
#include "ns3/correlated-shadowing-propagation-loss-model.h"
#include "ns3/building-penetration-loss.h"
#include "ns3/building-allocator.h"
#include "ns3/buildings-helper.h"
#include "ns3/forwarder-helper.h"
#include
#include

using namespace ns3;
using namespace lorawan;

NS_LOG_COMPONENT_DEFINE ("ComplexLorawanNetworkExample");

// Network settings
int nDevices = 200;
int nGateways = 1;
double radius = 6400; //Note that due to model updates, 7500 m is no longer the maximum distance
double simulationTime = 600;

// Channel model
bool realisticChannelModel = false;

int appPeriodSeconds = 600;

// Output control
bool print = true;

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

CommandLine cmd;
cmd.AddValue ("nDevices", "Number of end devices to include in the simulation", nDevices);
cmd.AddValue ("radius", "The radius of the area to simulate", radius);
cmd.AddValue ("simulationTime", "The time for which to simulate", simulationTime);
cmd.AddValue ("appPeriod",
"The period in seconds to be used by periodically transmitting applications",
appPeriodSeconds);
cmd.AddValue ("print", "Whether or not to print various informations", print);
cmd.Parse (argc, argv);

// Set up logging
LogComponentEnable ("ComplexLorawanNetworkExample", LOG_LEVEL_ALL);
// LogComponentEnable("LoraChannel", LOG_LEVEL_INFO);
// LogComponentEnable("LoraPhy", LOG_LEVEL_ALL);
// LogComponentEnable("EndDeviceLoraPhy", LOG_LEVEL_ALL);
// LogComponentEnable("GatewayLoraPhy", LOG_LEVEL_ALL);
// LogComponentEnable("LoraInterferenceHelper", LOG_LEVEL_ALL);
// LogComponentEnable("LorawanMac", LOG_LEVEL_ALL);
// LogComponentEnable("EndDeviceLorawanMac", LOG_LEVEL_ALL);
// LogComponentEnable("ClassAEndDeviceLorawanMac", LOG_LEVEL_ALL);
// LogComponentEnable("GatewayLorawanMac", LOG_LEVEL_ALL);
// LogComponentEnable("LogicalLoraChannelHelper", LOG_LEVEL_ALL);
// LogComponentEnable("LogicalLoraChannel", LOG_LEVEL_ALL);
// LogComponentEnable("LoraHelper", LOG_LEVEL_ALL);
// LogComponentEnable("LoraPhyHelper", LOG_LEVEL_ALL);
// LogComponentEnable("LorawanMacHelper", LOG_LEVEL_ALL);
// LogComponentEnable("PeriodicSenderHelper", LOG_LEVEL_ALL);
// LogComponentEnable("PeriodicSender", LOG_LEVEL_ALL);
// LogComponentEnable("LorawanMacHeader", LOG_LEVEL_ALL);
// LogComponentEnable("LoraFrameHeader", LOG_LEVEL_ALL);
// LogComponentEnable("NetworkScheduler", LOG_LEVEL_ALL);
// LogComponentEnable("NetworkServer", LOG_LEVEL_ALL);
// LogComponentEnable("NetworkStatus", LOG_LEVEL_ALL);
// LogComponentEnable("NetworkController", LOG_LEVEL_ALL);

/***********

• Setup *
  ***********/

// Create the time value from the period
Time appPeriod = Seconds (appPeriodSeconds);

// Mobility
MobilityHelper mobility;
mobility.SetPositionAllocator ("ns3::UniformDiscPositionAllocator", "rho", DoubleValue (radius),
"X", DoubleValue (0.0), "Y", DoubleValue (0.0));
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

/************************

• Create the channel *
  ************************/

// Create the lora channel object
Ptr loss = CreateObject ();
loss->SetPathLossExponent (3.76);
loss->SetReference (1, 7.7);

if (realisticChannelModel)
{
// Create the correlated shadowing component
Ptr shadowing =
CreateObject ();

  // Aggregate shadowing to the logdistance loss
  loss->SetNext (shadowing);

  // Add the effect to the channel propagation loss
  Ptr<BuildingPenetrationLoss> buildingLoss = CreateObject<BuildingPenetrationLoss> ();

  shadowing->SetNext (buildingLoss);
}

Ptr delay = CreateObject ();

Ptr channel = CreateObject (loss, delay);

/************************

• Create the helpers *
  ************************/

// Create the LoraPhyHelper
LoraPhyHelper phyHelper = LoraPhyHelper ();
phyHelper.SetChannel (channel);

// Create the LorawanMacHelper
LorawanMacHelper macHelper = LorawanMacHelper ();

// Create the LoraHelper
LoraHelper helper = LoraHelper ();
helper.EnablePacketTracking (); // Output filename
// helper.EnableSimulationTimePrinting ();

//Create the NetworkServerHelper
NetworkServerHelper nsHelper = NetworkServerHelper ();

//Create the ForwarderHelper
ForwarderHelper forHelper = ForwarderHelper ();

/************************

• Create End Devices *
  ************************/

// Create a set of nodes
NodeContainer endDevices;
endDevices.Create (nDevices);

// Assign a mobility model to each node
mobility.Install (endDevices);

// Make it so that nodes are at a certain height > 0
for (NodeContainer::Iterator j = endDevices.Begin (); j != endDevices.End (); ++j)
{
Ptr mobility = (*j)->GetObject ();
Vector position = mobility->GetPosition ();
position.z = 1.2;
mobility->SetPosition (position);
}

// Create the LoraNetDevices of the end devices
uint8_t nwkId = 54;
uint32_t nwkAddr = 1864;
Ptr addrGen =
CreateObject (nwkId, nwkAddr);

// Create the LoraNetDevices of the end devices
macHelper.SetAddressGenerator (addrGen);
phyHelper.SetDeviceType (LoraPhyHelper::ED);
macHelper.SetDeviceType (LorawanMacHelper::ED_A);
helper.Install (phyHelper, macHelper, endDevices);

// Now end devices are connected to the channel

// Connect trace sources
for (NodeContainer::Iterator j = endDevices.Begin (); j != endDevices.End (); ++j)
{
Ptr node = *j;
Ptr loraNetDevice = node->GetDevice (0)->GetObject ();
Ptr phy = loraNetDevice->GetPhy ();
}

/*********************

• Create Gateways *
  *********************/

// Create the gateway nodes (allocate them uniformely on the disc)
NodeContainer gateways;
gateways.Create (nGateways);

Ptr allocator = CreateObject ();
// Make it so that nodes are at a certain height > 0
allocator->Add (Vector (0.0, 0.0, 15.0));
mobility.SetPositionAllocator (allocator);
mobility.Install (gateways);

// Create a netdevice for each gateway
phyHelper.SetDeviceType (LoraPhyHelper::GW);
macHelper.SetDeviceType (LorawanMacHelper::GW);
helper.Install (phyHelper, macHelper, gateways);

/**********************

• Handle buildings *
  **********************/

double xLength = 130;
double deltaX = 32;
double yLength = 64;
double deltaY = 17;
int gridWidth = 2 * radius / (xLength + deltaX);
int gridHeight = 2 * radius / (yLength + deltaY);
if (realisticChannelModel == false)
{
gridWidth = 0;
gridHeight = 0;
}
Ptr gridBuildingAllocator;
gridBuildingAllocator = CreateObject ();
gridBuildingAllocator->SetAttribute ("GridWidth", UintegerValue (gridWidth));
gridBuildingAllocator->SetAttribute ("LengthX", DoubleValue (xLength));
gridBuildingAllocator->SetAttribute ("LengthY", DoubleValue (yLength));
gridBuildingAllocator->SetAttribute ("DeltaX", DoubleValue (deltaX));
gridBuildingAllocator->SetAttribute ("DeltaY", DoubleValue (deltaY));
gridBuildingAllocator->SetAttribute ("Height", DoubleValue (6));
gridBuildingAllocator->SetBuildingAttribute ("NRoomsX", UintegerValue (2));
gridBuildingAllocator->SetBuildingAttribute ("NRoomsY", UintegerValue (4));
gridBuildingAllocator->SetBuildingAttribute ("NFloors", UintegerValue (2));
gridBuildingAllocator->SetAttribute (
"MinX", DoubleValue (-gridWidth * (xLength + deltaX) / 2 + deltaX / 2));
gridBuildingAllocator->SetAttribute (
"MinY", DoubleValue (-gridHeight * (yLength + deltaY) / 2 + deltaY / 2));
BuildingContainer bContainer = gridBuildingAllocator->Create (gridWidth * gridHeight);

BuildingsHelper::Install (endDevices);
BuildingsHelper::Install (gateways);

// Print the buildings
if (print)
{
std::ofstream myfile;
myfile.open ("buildings.txt");
std::vector<Ptr>::const_iterator it;
int j = 1;
for (it = bContainer.Begin (); it != bContainer.End (); ++it, ++j)
{
Box boundaries = (*it)->GetBoundaries ();
myfile << "set object " << j << " rect from " << boundaries.xMin << "," << boundaries.yMin
<< " to " << boundaries.xMax << "," << boundaries.yMax << std::endl;
}
myfile.close ();
}

/**********************************************

• Set up the end device's spreading factor *
  **********************************************/

macHelper.SetSpreadingFactorsUp (endDevices, gateways, channel);

NS_LOG_DEBUG ("Completed configuration");

/*********************************************

• Install applications on the end devices *
  *********************************************/

Time appStopTime = Seconds (simulationTime);
PeriodicSenderHelper appHelper = PeriodicSenderHelper ();
appHelper.SetPeriod (Seconds (appPeriodSeconds));
appHelper.SetPacketSize (23);
Ptr rv = CreateObjectWithAttributes (
"Min", DoubleValue (0), "Max", DoubleValue (10));
ApplicationContainer appContainer = appHelper.Install (endDevices);

appContainer.Start (Seconds (0));
appContainer.Stop (appStopTime);

/**************************

• Create Network Server *
  ***************************/

// Create the NS node
NodeContainer networkServer;
networkServer.Create (1);

// Create a NS for the network
nsHelper.SetEndDevices (endDevices);
nsHelper.SetGateways (gateways);
nsHelper.Install (networkServer);

//Create a forwarder for each gateway
forHelper.Install (gateways);

////////////////
// Simulation //
////////////////

Simulator::Stop (appStopTime + Hours (1));

NS_LOG_INFO ("Running simulation...");
Simulator::Run ();

Simulator::Destroy ();

///////////////////////////
// Print results to file //
///////////////////////////
NS_LOG_INFO ("Computing performance metrics...");

LoraPacketTracker &tracker = helper.GetPacketTracker ();
std::cout << tracker.CountMacPacketsGlobally (Seconds (0), appStopTime + Hours (1)) << std::endl;

return 0;
}

[dmoibm]

I never worked with NS-3!

[4711engel]

Hallo, ich betreibe eine kleine Wetterstation im Helium Netz und würde gerne noch einen Anemometer an einem CubeCell einbinden, um auch Windgeschwindigkeit zu messen.
Dazu suche ich einen Sketch für den CubeCell und einen Decoder für Helium-Console und UBIDOTS.

Wer kann helfen? Ich bin kein Programmierer.
Vielen Dank

[mouaadh1010]

hello sir,
i have the same result
but i didn't anderstand the solution , if anyone can help