5.3 PLANO DE TESTES
5.3.2 Análises de Resultados de Testes
Por fim pode-se efetuar uma análise por meio de cada um dos parâmetros
obtidos nos testes executados, em cada uma das redes.
Quanto a distribuição espacial dos dispositivos verifica-se que são similares,
pois são posições geradas por meio de sorteios aleatórios, não havendo diferenças
de tratamento entre os testes 09, 10, 11 e 12.
A Figura 13 - Throughput Downlink Teste 09, Figura 14 - Throughput Downlink
Teste 10, Figura 17 - Throughput Uplink Teste 09 e a Figura 18 - Throughput Uplink
Teste 10 indicam um throughput estável, distribuído ao longo do tempo por tipo de
dispositivo, apresentando uma distribuição regular temporal, ocupando a rede por
mais tempo, porém trafegando menos dados em cada acesso. Já a Figura 15 -
Throughput Downlink Teste 11 e a Figura 19 - Throughput Uplink Teste 11 indicam a
tentativa de acesso de todos os dispositivos da rede em um intervalo de 3 segundos,
em uma simulação no modo pré-definido avalanche, o que ocasiona uma aparente
perda de pacotes. Na Figura 16 - Throughput Downlink Teste 12 e na Figura 20 -
Throughput Uplink Teste 12 podem ser verificados acessos aleatórios à rede,
ocorrendo uma grande variação no tráfego do Downlink, e menor variação do uplink.
Com relação as taxas de erro, pode-se verificar por meio da Figura 21 - Análise
de Taxa de Erro Uplink Teste 09 e Figura 22 - Análise de Taxa de Erro Uplink Teste
10 que não ocorreram perdas de pacotes durante as simulações. Isto se deve ao fato
dos acessos terem sido distribuídos ao longo do tempo. Já na Figura 23 - Análise de
Taxa de Erro Uplink Teste 11 e na Figura 24 - Análise de Taxa de Erro Uplink Teste
12 podem ser verificados erros que ocorreram na tentativa de acesso a rede pelos
dispositivos. Isto se deve as tentativas de acessos praticamente simultâneas. Porém,
ainda assim, os erros ocorridos estão dentro do parâmetro de referência aceitável.
Dois parâmetros importantes que também são analisados neste software são
Delay e Jitter. Neste caso, a Figura 25 - Análise de Delay e Jitter Uplink Teste 09 e a
Figura 26 - Análise de Delay e Jitter Uplink Teste 10 indicam a regularidade das redes
dos testes 09 e 10, sendo o delay dos pacotes trafegados uma média de 16ms.
Verifica-se também nestes exemplos a não existência de dados relativos ao jitter, visto
que são pacotes únicos enviados de cada dispositivo. Na Figura 27 - Análise de Delay
e Jitter Uplink Teste 11 pode-se verificar por meio do histograma a pequena ocorrência
de delays próximos aos limites aceitáveis, e a não presença de jitter por se tratarem
de pacotes únicos. Já a Figura 28 - Análise de Delay e Jitter Uplink Teste 12 indica a
pequena ocorrência de delay e jitter acima dos limites aceitáveis, porém com suas
médias dentro dos limites.
Por fim, são analisados os mesmos parâmetros de Delay e Jitter verificando o
Downlink. A Figura 29 - Análise de Delay e Jitter Downlink Teste 09, a Figura 30 -
Análise de Delay e Jitter Downlink Teste 10 e a Figura 31 - Análise de Delay e Jitter
Downlink Teste 11 indicam a não ocorrência de valores acima dos limites aceitáveis
de delay, e também verifica-se a não ocorrência de jitter por se tratar do envio de
pacotes únicos. Já a Figura 32 - Análise de Delay e Jitter Downlink Teste 12 indica a
ocorrência de delay apenas abaixo dos limites aceitáveis, e jitter com pequena
frequência de ocorrência acima dos limites, porém com média dentro do esperado.
6 CONCLUSÃO
O problema de tráfego causado pela inserção de dados originados por redes e
dispositivos de IoT, é tratado de forma detalhada no presente documento. Este é um
problema intrínseco à evolução dos sistemas de controle e monitoramento.
Para atendimento desta demanda, a utilização da tecnologia LTE-NB ou
NB-IoT (Narrowband NB-IoT) se apresenta como possível solução viável para o tráfego destes
dados, possuindo vantagens em relação ao custo, por utilizar os hardwares presentes
atualmente em redes LTE.
Entendemos que o trabalho atingiu o seu objetivo visto que a sua proposição
era ser um software capaz de simular redes NB-IoT, tratar as informações e gerar
resultados.
Dentre os problemas encontrados no decorrer do desenvolvimento destacamos
a limitação do software NS-3 para realização de simulação com um número de
dispositivos maior do que 300. Isto se dá devido a característica construtiva do NS-3,
sendo necessárias alterações em seu código fonte, para permitir assim, a realização
de testes com número maior de nós. Entende-se que esta é uma melhoria possível de
ser realizada em um estudo mais aprofundado sobre a ferramenta desenvolvida.
Outro problema encontrado no decorrer do processo, e que consumiu muito
tempo de desenvolvimento foi a integração de arquivos de registro gerados pelo
NS-3 com o software de tratamento de dados Matlab. Esta dificuldade aconteceu devido
a incompatibilidade de formatos, e modos de registro do software. Esta questão foi
tratada dentro do software Matlab, permitindo assim a integração de todas as
informações, independente da forma de registro gerada pelo NS-3.
Verificou-se que um dos limitantes do trabalho foi o tempo necessário para
realização das simulações necessárias para validação das redes. Mesmo com um
curto tempo de simulação, o tempo necessário para concluir os testes superou
centenas de vezes, limitando assim a apresentação de mais resultados.
Para o futuro do desenvolvimento desta aplicação sugere-se que sejam
realizadas alterações no código de modo a criação de bibliotecas específicas para
cada uma das funcionalidades macro existentes, tais como: entrada de dados,
parâmetros de rede, configuração dos devices e aplicações.
Com o estudo e aprofundamento sobre redes NB-IoT, conclui-se que uma das
grandes vantagens da sua utilização é a capacidade que os dispositivos possuem de
realizar economia de energia, entrando em modo de espera, onde o consumo é
mínimo e preservando assim o tempo de vida útil da bateria. Pelo fato das baterias
serem ambientalmente agressivas, devido à grande dificuldade de reciclagem, o
prolongamento de sua vida útil acaba gerando um impacto positivo para a sociedade
como um todo, devido ao fato de minimizar a entrada de novas baterias no mercado,
com a adoção deste tipo de tecnologia.
Como um fator de incentivo a utilização da plataforma de testes de redes
NB-IoT, pode-se destacar o fato do software ter sido desenvolvido sobre uma plataforma
livre, eliminando assim quaisquer tipos de custo com aquisições para implementação
desta solução. Assim, espera-se que o projeto seja utilizado e continuado por todas
as partes interessadas.
REFERÊNCIAS BIBLIOGRÁFICAS
[1] PENNACCHIONI, Marco; et al. NB-IoT System Deployment for Smart Metering:
Evaluation of Coverage and Capacity Performances. IEEExplore.
[http://ieeexplore.ieee.org/abstract/document/8240561/]. Acesso em 05/04/2018.
[2] AL-SHAMMARI, Basim K. J. et al. IoT Traffic Management and Integration
in the QoS Supported Network. IEEExplore.
<https://ieeexplore.ieee.org/document/8226756/>. Acesso em 15/06/2018.
[3] BASTOS, Anderson et al. Base de conhecimento em teste de software. Rio de
Janeiro, Martins Fontes, 2007.
[4] GRAHAM, Dorothy et al. Foundations of Software Testing. 2. ed. Londres:
Cengage Learning, 2008.
[5] LUCIDCHART. Símbolos de diagramas de fluxo de dados. Disponível em
<https://www.lucidchart.com/pages/pt/simbolos-de-diagramas-de-fluxo-de-dados> .
Acesso em 17/06/2018.
ANEXO A – SIMULAÇÕES DE 01 A 08
ANEXO B – CÓDIGO NS-3
/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ /*
* Copyright (c) 2018 Pontifícia Universidade Católica do Paraná (PUC-PR) *
* This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
* Authors: Carlos Eduardo de Abreu Verchai <[email protected]> * Felipe de Bortoli <[email protected]>
*/ #include "ns3/core-module.h" #include "ns3/applications-module.h" #include "ns3/buildings-module.h" #include "ns3/config-store-module.h" #include "ns3/config-store.h" #include "ns3/epc-helper.h" #include "ns3/flow-monitor-module.h" #include "ns3/internet-module.h" #include "ns3/ipv4-global-routing-helper.h" #include "ns3/log.h" #include "ns3/lte-control-messages.h" #include "ns3/lte-helper.h" #include "ns3/lte-module.h" #include "ns3/mobility-module.h" #include "ns3/netanim-module.h" #include "ns3/network-module.h" #include "ns3/point-to-point-helper.h" #include <cstdlib> #include <fstream> #include <iostream> #include <ns3/internet-trace-helper.h> #include <ns3/log.h> #include <ns3/lte-enb-net-device.h> #include <ns3/lte-enb-rrc.h> #include <ns3/spectrum-module.h> #include <ns3/string.h> #include <sstream> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/timeb.h> #include <time.h> #include <unistd.h> #include <vector> #define PI 3.14159265359 using namespace ns3; using namespace std; NS_LOG_COMPONENT_DEFINE ("TestesIntegracao"); struct Sensor { int quantidade; int tamanho; int frequencia_acesso; }; struct Config_sim {
double tempo; //Tempo da simulação em segundos
};
int distance = 500.0; ///Módulo de distribuição dos dispositivos int module = 500; ///Módulo de distribuição dos dispositivos int degree = 360; //Angulo de distribuição dos dispositivos double startapp01 = 0.1; double startapp02 = 0.2; double startapp03 = 0.3; double startapp04 = 0.4; double startapp05 = 0.5; double startapp06 = 0.6;
int total_devs; //Número total de devices da rede double intervalo_pkt1 = 0.25; //Segundos double intervalo_pkt2 = 0.25; //Segundos double intervalo_pkt3 = 0.25; //Segundos double intervalo_pkt4 = 0.25; //Segundos double intervalo_pkt5 = 0.25; //Segundos double intervalo_pkt6 = 0.25; //Segundos char modo_de_teste;
int main (int argc, char *argv[]) {
//CRIA ARQUIVO PARA ARMAZENAMETO DAS POSIÇÕES DOS DEVICES FILE * fp = fopen ("Position.txt", "wt");
int result;
char tipo_ue[2], id_ue[4], posx_ue[8], posy_ue[8];
char string_write[100] = "Tipo \t Device \t Posição X \t Posição Y \n"; result = fputs(string_write, fp);
if(result == EOF) {
cout << "Erro de gravação" << endl; }
Sensor tipo01, tipo02, tipo03, tipo04, tipo05, tipo06; Config_sim config_nb_iot;
CommandLine cmd; cmd.Parse (argc, argv);
Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
//lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
lteHelper->SetEpcHelper (epcHelper); ConfigStore inputConfig;
inputConfig.ConfigureDefaults ();
//PERIODICIDADE DE MODELAMENTO DO CANAL
Config::SetDefault ("ns3::LteEnbRrc::SrsPeriodicity", UintegerValue (320)); cmd.Parse (argc, argv);
Ptr<Node> pgw = epcHelper->GetPgwNode (); //CRIAÇÃO DE HOST REMOTO
NodeContainer remoteHostContainer; remoteHostContainer.Create (1);
Ptr<Node> remoteHost = remoteHostContainer.Get (0); InternetStackHelper internet;
internet.Install (remoteHostContainer); //CRIANDO A INTERNET
PointToPointHelper p2ph;
p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("200kbps"))); NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost); Ipv4AddressHelper ipv4h;
ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices); Ipv4StaticRoutingHelper ipv4RoutingHelper;
Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ()); remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);
cout << "####################################################" << endl; cout << "SISTEMA DE TESTES DE REDES NB-IOT" << endl;
cout << "TRABALHO FINAL DE GUADUAÇÃO - ENGENHARIA ELÉTRICA" << endl; cout << "CARLOS EDUARDO DE ABREU VERCHAI E FELIPE DE BORTOLI" << endl; cout << "ORIENTADOR: VALTER KLEIN JUNIOR" << endl;
cout << "####################################################" << endl; cout << "\n";
srand(time(NULL)); ///////////////////////////////////////
//AQUISIÇÃO DAS INFORMAÇÕES DO USUÁRIO ///////////////////////////////////////
do {
cout << "1 - Modo de Testes: " << endl; cout << ("1.1 - Pré-definido [s/n]: "); cin >> modo_de_teste;
cout << "\n"; }
while (not((modo_de_teste != 's') ^ (modo_de_teste != 'n'))); NS_LOG_INFO ("---");
NS_LOG_INFO ("MODO DE TESTES PRÉ-DEFINIDO: " << modo_de_teste); NS_LOG_INFO ("---");
cout << "\n"; do
{
cout << "2 - Definição do Tempo de Simulação" << endl; cout << ("2.1 - Inserir o tempo de simulação em segundos: "); cin >> config_nb_iot.tempo;
cout << endl; }
while (not((config_nb_iot.tempo > 0) & (config_nb_iot.tempo < 7200))); cout << endl;
NS_LOG_INFO ("---");
NS_LOG_INFO ("TEMPO DE SIMULAÇÃO INFORMADO: " << config_nb_iot.tempo); NS_LOG_INFO ("---");
cout << endl; do
{
cout << "3 - Sensor do Tipo 01" << endl;
cout << ("3.1 - Inserir a quantidade de dispositivos: "); cin >> tipo01.quantidade;
}
while (not((tipo01.quantidade > 0) & (tipo01.quantidade < 300))); do
{
cout << ("3.2 - Inserir tamanho dos pacotes de dados [bytes]: "); cin >> tipo01.tamanho;
}
while (not((tipo01.tamanho > 20) & (tipo01.tamanho <= 512))); if (modo_de_teste == 'n')
{
do {
cout << ("3.3 - Inserir frequência de acesso dos dispositivos à rede: "); cin >> tipo01.frequencia_acesso;
}
while (not((tipo01.frequencia_acesso > 0) & (tipo01.frequencia_acesso <= 2*config_nb_iot.tempo))); }
cout << endl;
NS_LOG_INFO ("---");
NS_LOG_INFO ("SENSOR DO TIPO 01 - NÚMERO DE SENSORES INFORMADOS: " << tipo01.quantidade); NS_LOG_INFO ("SENSOR DO TIPO 01 - TAMANHO DOS PACOTES INFORMADOS: " << tipo01.tamanho);
NS_LOG_INFO ("SENSOR DO TIPO 01 - FREQUÊNCIA DE ACESSO À REDE INFORMADA: " << tipo01.frequencia_acesso); NS_LOG_INFO ("---");
cout << endl; do
{
cout << ("4.1 - Inserir a quantidade de dispositivos: "); cin >> tipo02.quantidade;
}
while (not((tipo02.quantidade > 0) & (tipo02.quantidade < 300))); do
{
cout << ("4.2 - Inserir tamanho dos pacotes de dados [bytes]: "); cin >> tipo02.tamanho;
}
while (not((tipo02.tamanho > 20) & (tipo02.tamanho <= 512))); if (modo_de_teste == 'n')
{
do {
cout << ("4.3 - Inserir frequência de acesso dos dispositivos à rede: "); cin >> tipo02.frequencia_acesso;
}
while (not((tipo02.frequencia_acesso > 0) & (tipo02.frequencia_acesso <= 2*config_nb_iot.tempo))); }
cout << endl;
NS_LOG_INFO ("---");
NS_LOG_INFO ("SENSOR DO TIPO 02 - NÚMERO DE SENSORES INFORMADOS: " << tipo02.quantidade); NS_LOG_INFO ("SENSOR DO TIPO 02 - TAMANHO DOS PACOTES INFORMADOS: " << tipo02.tamanho);
NS_LOG_INFO ("SENSOR DO TIPO 02 - FREQUÊNCIA DE ACESSO À REDE INFORMADA: " << tipo02.frequencia_acesso); NS_LOG_INFO ("---");
cout << endl; do
{
cout << "5 - Sensor do Tipo 03" << endl;
cout << ("5.1 - Inserir a quantidade de dispositivos: "); cin >> tipo03.quantidade;
}
while (not((tipo03.quantidade > 0) & (tipo03.quantidade < 300)));
do {
cout << ("5.2 - Inserir tamanho dos pacotes de dados [bytes]: "); cin >> tipo03.tamanho;
}
while (not((tipo03.tamanho > 20) & (tipo03.tamanho <= 512))); if (modo_de_teste == 'n')
{
do {
cout << ("5.3 - Inserir frequência de acesso dos dispositivos à rede: "); cin >> tipo03.frequencia_acesso;
}
while (not((tipo03.frequencia_acesso > 0) & (tipo03.frequencia_acesso <= 2*config_nb_iot.tempo))); }
cout << endl;
NS_LOG_INFO ("---");
NS_LOG_INFO ("SENSOR DO TIPO 03 - NÚMERO DE SENSORES INFORMADOS: " << tipo03.quantidade); NS_LOG_INFO ("SENSOR DO TIPO 03 - TAMANHO DOS PACOTES INFORMADOS: " << tipo03.tamanho);
NS_LOG_INFO ("SENSOR DO TIPO 03 - FREQUÊNCIA DE ACESSO À REDE INFORMADA: " << tipo03.frequencia_acesso); NS_LOG_INFO ("---");
cout << endl; do
{
cout << "6 - Sensor do Tipo 04" << endl;
cout << ("6.1 - Inserir a quantidade de dispositivos: "); cin >> tipo04.quantidade;
}
while (not((tipo04.quantidade > 0) & (tipo04.quantidade < 300))); do
{
cout << ("6.2 - Inserir tamanho dos pacotes de dados [bytes]: "); cin >> tipo04.tamanho;
}
if (modo_de_teste == 'n') {
do {
cout << ("6.3 - Inserir frequência de acesso dos dispositivos à rede: "); cin >> tipo04.frequencia_acesso;
}
while (not((tipo04.frequencia_acesso > 0) & (tipo04.frequencia_acesso <= 2*config_nb_iot.tempo))); }
cout << endl;
NS_LOG_INFO ("---");
NS_LOG_INFO ("SENSOR DO TIPO 04 - NÚMERO DE SENSORES INFORMADOS: " << tipo04.quantidade); NS_LOG_INFO ("SENSOR DO TIPO 04 - TAMANHO DOS PACOTES INFORMADOS: " << tipo04.tamanho);
NS_LOG_INFO ("SENSOR DO TIPO 04 - FREQUÊNCIA DE ACESSO À REDE INFORMADA: " << tipo04.frequencia_acesso); NS_LOG_INFO ("---");
cout << endl; do
{
cout << "7 - Sensor do Tipo 05" << endl;
cout << ("7.1 - Inserir a quantidade de dispositivos: "); cin >> tipo05.quantidade;
}
while (not((tipo05.quantidade > 0) & (tipo05.quantidade < 300))); do
{
cout << ("7.2 - Inserir tamanho dos pacotes de dados [bytes]: "); cin >> tipo05.tamanho;
}
while (not((tipo05.tamanho > 20) & (tipo05.tamanho <= 512))); if (modo_de_teste == 'n')
{
do {
cout << ("7.3 - Inserir frequência de acesso dos dispositivos à rede: "); cin >> tipo05.frequencia_acesso;
}
while (not((tipo05.frequencia_acesso > 0) & (tipo05.frequencia_acesso <= 2*config_nb_iot.tempo))); }
cout << endl;
NS_LOG_INFO ("---");
NS_LOG_INFO ("SENSOR DO TIPO 05 - NÚMERO DE SENSORES INFORMADOS: " << tipo05.quantidade); NS_LOG_INFO ("SENSOR DO TIPO 05 - TAMANHO DOS PACOTES INFORMADOS: " << tipo05.tamanho);
NS_LOG_INFO ("SENSOR DO TIPO 05 - FREQUÊNCIA DE ACESSO À REDE INFORMADA: " << tipo05.frequencia_acesso); NS_LOG_INFO ("---");
cout << endl; do
{
cout << "8 - Sensor do Tipo 06" << endl;
cout << ("8.1 - Inserir a quantidade de dispositivos: "); cin >> tipo06.quantidade;
}
while (not((tipo06.quantidade > 0) & (tipo06.quantidade < 300))); do
{
cout << ("8.2 - Inserir tamanho dos pacotes de dados [bytes]: "); cin >> tipo06.tamanho;
}
while (not((tipo06.tamanho > 20) & (tipo06.tamanho <= 512))); if (modo_de_teste == 'n')
{
do {
cout << ("8.3 - Inserir frequência de acesso dos dispositivos à rede: "); cin >> tipo06.frequencia_acesso;
}
while (not((tipo06.frequencia_acesso > 0) & (tipo06.frequencia_acesso <= 2*config_nb_iot.tempo))); }
cout << endl;
NS_LOG_INFO ("SENSOR DO TIPO 06 - NÚMERO DE SENSORES INFORMADOS: " << tipo06.quantidade); NS_LOG_INFO ("SENSOR DO TIPO 06 - TAMANHO DOS PACOTES INFORMADOS: " << tipo06.tamanho);
NS_LOG_INFO ("SENSOR DO TIPO 06 - FREQUÊNCIA DE ACESSO À REDE INFORMADA: " << tipo06.frequencia_acesso); NS_LOG_INFO ("---");
cout << endl;
if (modo_de_teste == 's') {
cout << "9 - Definição do Modo de Simulação" << endl; cout << ("9.1 - [1] Baixo ") << endl;
cout << ("9.2 - [2] Normal ") << endl; cout << ("9.3 - [3] Avalanche ") << endl; cin >> config_nb_iot.modo;
}
//CRIAÇÃO DE NÓS - ESTAÇÃO RÁDIO-BASE E DISPOSITIVOS MÓVEIS NodeContainer enbNodes;
NodeContainer Nodes_device01; //Sensor do Tipo 01 NodeContainer Nodes_device02; //Sensor do Tipo 02 NodeContainer Nodes_device03; //Sensor do Tipo 03 NodeContainer Nodes_device04; //Sensor do Tipo 04 NodeContainer Nodes_device05; //Sensor do Tipo 05 NodeContainer Nodes_device06; //Sensor do Tipo 06 enbNodes.Create (1); Nodes_device01.Create (tipo01.quantidade); Nodes_device02.Create (tipo02.quantidade); Nodes_device03.Create (tipo03.quantidade); Nodes_device04.Create (tipo04.quantidade); Nodes_device05.Create (tipo05.quantidade); Nodes_device06.Create (tipo06.quantidade);
//DEFINIÇÃO DO POSICIONAMENTO DOS DISPOSITIVOS
Ptr<ListPositionAllocator> positionAlloc1 = CreateObject<ListPositionAllocator> (); Ptr<ListPositionAllocator> positionAlloc2 = CreateObject<ListPositionAllocator> (); Ptr<ListPositionAllocator> positionAlloc3 = CreateObject<ListPositionAllocator> (); Ptr<ListPositionAllocator> positionAlloc4 = CreateObject<ListPositionAllocator> (); Ptr<ListPositionAllocator> positionAlloc5 = CreateObject<ListPositionAllocator> (); Ptr<ListPositionAllocator> positionAlloc6 = CreateObject<ListPositionAllocator> (); //MODELO DE MOBILIDADE - ESTÁTICO
MobilityHelper mobility; mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobility.Install (enbNodes); mobility.Install (Nodes_device01); mobility.Install (Nodes_device02); mobility.Install (Nodes_device03); mobility.Install (Nodes_device04); mobility.Install (Nodes_device05); mobility.Install (Nodes_device06);
//DEFINIÇÃO DE POSIÇÕES DOS DISPOSITIVOS //POSIÇÃO ENB (0,0,0)
Ptr<Node> enbNode = enbNodes.Get (0);
Ptr<MobilityModel> enbMob01 = enbNode->GetObject<MobilityModel> (); Vector pos = Vector(0, 0, 0);
enbMob01->SetPosition (pos); //POSIÇÃO UES
for (uint32_t u = 0; u < Nodes_device01.GetN (); ++u) {
if (u == 0) {
NS_LOG_INFO ("---");
NS_LOG_INFO ("DEFININDO POSIÇÕES DOS DISPOSITIVOS DO TIPO 01 CRIADOS"); }
//SORTEIO DE POSIÇÃO DE CADA UM DOS EQUIPAMENTOS, DENTRO DO RAIO DE ABRANGÊNCIA DA REDE int mpos,fpos;
mpos = (rand() % module + 50); fpos = (rand() % degree);
Ptr<Node> ueNode01 = Nodes_device01.Get (u);
Vector pos = Vector(((cos((fpos*PI/180))*mpos)), ((sin((fpos*PI/180))*mpos)), 0); ueMob01->SetPosition (pos);
//IMPRIME A POSIÇÃO DOS DISPOSITIVOS
//cout << "Posicao device 01 - (" << pos.x << ", " << pos.y << ")\n"; Vector get_pos1 = ueMob01->GetPosition ();
NS_LOG_INFO ("SENSOR DO TIPO 01 - SENSOR " << (u+1) << " - POSIÇÃO: (" << get_pos1.x << ", " << get_pos1.y << ")");
//GRAVA EM ARQUIVO POSIÇÃO DOS SENSORES strcpy (string_write, "");
strcpy (tipo_ue, "01"); sprintf(id_ue, "%d", (u+1)); sprintf(posx_ue, "%f", get_pos1.x); sprintf(posy_ue, "%f", get_pos1.y); strcat (string_write, tipo_ue); strcat (string_write, "\t"); strcat (string_write, id_ue); strcat (string_write, "\t"); strcat (string_write, posx_ue); strcat (string_write, "\t"); strcat (string_write, posy_ue); strcat (string_write, "\n"); result = fputs(string_write, fp); if(result == EOF)
{
cout << "Erro de gravação" << endl; }
}
for (uint32_t u = 0; u < Nodes_device02.GetN (); ++u) {
if (u == 0) {
NS_LOG_INFO ("---");
NS_LOG_INFO ("DEFININDO POSIÇÕES DOS DISPOSITIVOS DO TIPO 02 CRIADOS"); }
//SORTEIO DE POSIÇÃO DE CADA UM DOS EQUIPAMENTOS, DENTRO DO RAIO DE ABRANGÊNCIA DA REDE int mpos,fpos;
mpos = (rand() % module + 50); fpos = (rand() % degree);
Ptr<Node> ueNode02 = Nodes_device02.Get (u);
Ptr<MobilityModel> ueMob02 = ueNode02->GetObject<MobilityModel> (); Vector pos = Vector(((cos((fpos*PI/180))*mpos)), ((sin((fpos*PI/180))*mpos)), 0); ueMob02->SetPosition (pos);
//IMPRIME A POSIÇÃO DOS DISPOSITIVOS Vector get_pos2 = ueMob02->GetPosition ();
NS_LOG_INFO ("SENSOR DO TIPO 02 - SENSOR " << (u+1) << " - POSIÇÃO: (" << get_pos2.x << ", " << get_pos2.y << ")");
//GRAVA EM ARQUIVO POSIÇÃO DOS SENSORES strcpy (string_write, "");
strcpy (tipo_ue, "02"); sprintf(id_ue, "%d", (u+1)); sprintf(posx_ue, "%f", get_pos2.x); sprintf(posy_ue, "%f", get_pos2.y); strcat (string_write, tipo_ue); strcat (string_write, "\t"); strcat (string_write, id_ue); strcat (string_write, "\t"); strcat (string_write, posx_ue); strcat (string_write, "\t"); strcat (string_write, posy_ue); strcat (string_write, "\n"); result = fputs(string_write, fp); if(result == EOF)
{
} }
for (uint32_t u = 0; u < Nodes_device03.GetN (); ++u) {
if (u == 0) {
NS_LOG_INFO ("---");
NS_LOG_INFO ("DEFININDO POSIÇÕES DOS DISPOSITIVOS DO TIPO 03 CRIADOS"); }
//SORTEIO DE POSIÇÃO DE CADA UM DOS EQUIPAMENTOS, DENTRO DO RAIO DE ABRANGÊNCIA DA REDE int mpos,fpos;
mpos = (rand() % module + 50); fpos = (rand() % degree);
Ptr<Node> ueNode03 = Nodes_device03.Get (u);
Ptr<MobilityModel> ueMob03 = ueNode03->GetObject<MobilityModel> (); Vector pos = Vector(((cos((fpos*PI/180))*mpos)), ((sin((fpos*PI/180))*mpos)), 0); ueMob03->SetPosition (pos);
//IMPRIME A POSIÇÃO DOS DISPOSITIVOS Vector get_pos3 = ueMob03->GetPosition ();
NS_LOG_INFO ("SENSOR DO TIPO 03 - SENSOR " << (u+1) << " - POSIÇÃO: (" << get_pos3.x << ", " << get_pos3.y << ")");
//GRAVA EM ARQUIVO POSIÇÃO DOS SENSORES strcpy (string_write, "");
strcpy (tipo_ue, "03"); sprintf(id_ue, "%d", (u+1)); sprintf(posx_ue, "%f", get_pos3.x); sprintf(posy_ue, "%f", get_pos3.y); strcat (string_write, tipo_ue); strcat (string_write, "\t"); strcat (string_write, id_ue); strcat (string_write, "\t"); strcat (string_write, posx_ue); strcat (string_write, "\t"); strcat (string_write, posy_ue); strcat (string_write, "\n"); result = fputs(string_write, fp); if(result == EOF)
{
cout << "Erro de gravação" << endl; }
}
for (uint32_t u = 0; u < Nodes_device04.GetN (); ++u) {
if (u == 0) {
NS_LOG_INFO ("---");
NS_LOG_INFO ("DEFININDO POSIÇÕES DOS DISPOSITIVOS DO TIPO 04 CRIADOS"); }
//SORTEIO DE POSIÇÃO DE CADA UM DOS EQUIPAMENTOS, DENTRO DO RAIO DE ABRANGÊNCIA DA REDE int mpos,fpos;
mpos = (rand() % module + 50); fpos = (rand() % degree);
Ptr<Node> ueNode04 = Nodes_device04.Get (u);
Ptr<MobilityModel> ueMob04 = ueNode04->GetObject<MobilityModel> (); Vector pos = Vector(((cos((fpos*PI/180))*mpos)), ((sin((fpos*PI/180))*mpos)), 0); ueMob04->SetPosition (pos);
//IMPRIME A POSIÇÃO DOS DISPOSITIVOS Vector get_pos4 = ueMob04->GetPosition ();
NS_LOG_INFO ("SENSOR DO TIPO 04 - SENSOR " << (u+1) << " - POSIÇÃO: (" << get_pos4.x << ", " << get_pos4.y << ")");
//GRAVA EM ARQUIVO POSIÇÃO DOS SENSORES strcpy (string_write, "");
sprintf(id_ue, "%d", (u+1)); sprintf(posx_ue, "%f", get_pos4.x); sprintf(posy_ue, "%f", get_pos4.y); strcat (string_write, tipo_ue); strcat (string_write, "\t"); strcat (string_write, id_ue); strcat (string_write, "\t"); strcat (string_write, posx_ue); strcat (string_write, "\t"); strcat (string_write, posy_ue); strcat (string_write, "\n"); result = fputs(string_write, fp); if(result == EOF)
{
cout << "Erro de gravação" << endl; }
}
for (uint32_t u = 0; u < Nodes_device05.GetN (); ++u) {
if (u == 0) {
NS_LOG_INFO ("---");
NS_LOG_INFO ("DEFININDO POSIÇÕES DOS DISPOSITIVOS DO TIPO 05 CRIADOS"); }
//SORTEIO DE POSIÇÃO DE CADA UM DOS EQUIPAMENTOS, DENTRO DO RAIO DE ABRANGÊNCIA DA REDE int mpos,fpos;
mpos = (rand() % module + 50); fpos = (rand() % degree);
Ptr<Node> ueNode05 = Nodes_device05.Get (u);
Ptr<MobilityModel> ueMob05 = ueNode05->GetObject<MobilityModel> (); Vector pos = Vector(((cos((fpos*PI/180))*mpos)), ((sin((fpos*PI/180))*mpos)), 0); ueMob05->SetPosition (pos);
//IMPRIME A POSIÇÃO DOS DISPOSITIVOS Vector get_pos5 = ueMob05->GetPosition ();
NS_LOG_INFO ("SENSOR DO TIPO 05 - SENSOR " << (u+1) << " - POSIÇÃO: (" << get_pos5.x << ", " << get_pos5.y << ")");
//GRAVA EM ARQUIVO POSIÇÃO DOS SENSORES strcpy (string_write, "");
strcpy (tipo_ue, "05"); sprintf(id_ue, "%d", (u+1)); sprintf(posx_ue, "%f", get_pos5.x); sprintf(posy_ue, "%f", get_pos5.y); strcat (string_write, tipo_ue); strcat (string_write, "\t"); strcat (string_write, id_ue); strcat (string_write, "\t"); strcat (string_write, posx_ue); strcat (string_write, "\t"); strcat (string_write, posy_ue); strcat (string_write, "\n"); result = fputs(string_write, fp); if(result == EOF)
{
cout << "Erro de gravação" << endl; }
}
for (uint32_t u = 0; u < Nodes_device06.GetN (); ++u) {
if (u == 0) {
NS_LOG_INFO ("---");
NS_LOG_INFO ("DEFININDO POSIÇÕES DOS DISPOSITIVOS DO TIPO 06 CRIADOS"); }
//SORTEIO DE POSIÇÃO DE CADA UM DOS EQUIPAMENTOS, DENTRO DO RAIO DE ABRANGÊNCIA DA REDE int mpos,fpos;
mpos = (rand() % module + 50); fpos = (rand() % degree);
Ptr<Node> ueNode06 = Nodes_device06.Get (u);
Ptr<MobilityModel> ueMob06 = ueNode06->GetObject<MobilityModel> (); Vector pos = Vector(((cos((fpos*PI/180))*mpos)), ((sin((fpos*PI/180))*mpos)), 0); ueMob06->SetPosition (pos);
//IMPRIME A POSIÇÃO DOS DISPOSITIVOS