SISTEMA DE TESTES DE REDES NB-IOT E ANÁLISE DE...

PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ

ESCOLA POLITÉCNICA

CURSO DE ENGENHARIA ELÉTRICA

CARLOS EDUARDO DE ABREU VERCHAI

FELIPE DE BORTOLI

SISTEMA DE TESTES DE REDES NB-IOT

E ANÁLISE DE DESEMPENHO

RELATÓRIO TÉCNICO FINAL

Curitiba - Paraná

2018


E ANÁLISE DE DESEMPENHO

Relatório Técnico Final

Relatório técnico final apresentado a Disciplina de Trabalho Final de Graduação II do Curso de Graduação em Engenharia Elétrica – Ênfase em Telecomunicações da Pontifícia Universidade Católica do Paraná como forma parcial de avaliação referente a 2a Parcial.

Orientador: Prof. Valter Klein Junior

Curitiba, 21 de novembro de 2018

BANCA EXAMINADORA

________________________________________

Prof. Valter Klein Junior

Orientador

________________________________________

Prof. Luiz Augusto de Paula Lima Junior

Coordenador

LISTA DE ILUSTRAÇÕES

Figura 1 - Nível 0 do módulo de simulação da rede NB-IoT ........................................ 8

Figura 2 - Nível 1 do módulo de simulação da rede NB-IoT ........................................ 9

Figura 3 – Setup do modo testes do Sistema de Testes de Redes NB-IoT .............. 10

Figura 4 - Setup tempo de simulação do Sistema de Testes de Redes NB-IoT ....... 11

Figura 5 - Setup componentes da rede do Sistema de Testes de Redes NB-IoT ..... 12

Figura 6 - Setup modo de simulação do Sistema de Testes de Redes NB-IoT ........ 12

Figura 7 - Módulo de análise de desempenho .......................................................... 19

Figura 8 - QoS proposta pela 3GPP para LTE .......................................................... 20

Figura 9 - Distribuição Espacial Dispositivos Teste 09 .............................................. 38

Figura 10 - Distribuição Espacial Dispositivos Teste 10 ............................................ 39

Figura 11 - Distribuição Espacial Dispositivos Teste 11 ............................................ 39

Figura 12 - Throughput Downlink Teste 09 ............................................................... 40



Figura 15 - Throughput Uplink Teste 09 .................................................................... 42



Figura 18 - Análise de Taxa de Erro Uplink Teste 09 ................................................ 44



Figura 21 - Análise de Delay e Jitter Uplink Teste 09 ................................................ 46



Figura 24 - Análise de Delay e Jitter Downlink Teste 09 ........................................... 48



LISTA DE TABELAS

Tabela 1 - Tipos de sensores a serem implementados ............................................. 14

Tabela 2 – Testes de componentes .......................................................................... 28

Tabela 3 – Testes de integração ............................................................................... 29

Tabela 4 – Testes de Aceitação ................................................................................ 33

4

SUMÁRIO

1 RESUMO ................................................................................................................ 5

2 INTRODUÇÃO ........................................................................................................ 6

3 DETALHAMENTO DO PROJETO .......................................................................... 7

3.1 MÓDULO DE SIMULAÇÃO DA REDE NB-IOT .................................................. 7

3.1.1 Usuários .......................................................................................................... 9

3.1.2 Criação da rede NB-IoT ................................................................................ 13

3.1.3 Execução do simulador ................................................................................ 17

3.1.4 Resultados das simulações ......................................................................... 18

3.2 MÓDULO DE ANÁLISE DE DESEMPENHO DA REDE NB-IOT ...................... 18

3.2.1 Resultados das simulações ......................................................................... 19

3.2.2 Recomendações técnicas ............................................................................ 19

3.2.3 Matlab ............................................................................................................ 20

3.2.4 Resultados de viabilidade da rede .............................................................. 21

5 PROCEDIMENTO DE TESTES E VALIDAÇÃO DO PROJETO .......................... 23

5.1 TESTES CAIXA BRANCA ................................................................................ 24

5.1.1 Testes de Componente ................................................................................ 24

5.1.2 Testes de Integração .................................................................................... 25

5.2 TESTES CAIXA PRETA ................................................................................... 27

5.2.1 Testes de Aceitação ..................................................................................... 27

5.3 PLANO DE TESTES ......................................................................................... 28

5.3.1 Resultados de Testes ................................................................................... 38

5.3.2 Análises de Resultados de Testes .............................................................. 50

6 CONCLUSÃO ....................................................................................................... 52

REFERÊNCIAS BIBLIOGRÁFICAS ......................................................................... 54

ANEXO A – CÓDIGO NS-3 ...................................................................................... 79

ANEXO B – CÓDIGO MATLAB ............................................................................... 95

ANEXO C - MANUAL DE OPERAÇÃO .................................................................. 101

5

1 RESUMO

Com a necessidade de implementação de redes inteligentes e a gradativa

estruturação de cidades inteligentes, tem-se o aumento da demanda por informação.

Estas informações são basicamente oriundas de sistemas de monitoramento, e

consequentemente precisam estar acessíveis ininterruptamente por uma central de

gerenciamento. A avaliação da utilização do NB-IoT, uma tecnologia voltada para

dispositivos de IoT de baixa potência, largura de banda reduzida, e de baixa taxa de

transferência, para tráfego destes dados é a base de estudos do presente trabalho.

Esta avaliação se dará pela implementação de um simulador tendo como base o

Software NS-3 (Network Simulator), por meio da linguagem de programação C++.

6

2 INTRODUÇÃO

Com a maior conectividade de pessoas, equipamentos e sistemas, é percebido

aumento de maneira significativa nos últimos anos, com perspectiva de maior

escalada para os próximos, do número de acesso e uso da rede de dados para os

diversos fins. Com base nesta tendência, é necessário a existência de alternativas

para fluxo de dados ante as redes tradicionais de internet fixa e móvel.

Com a chegada dos dispositivos de IoT em diversos setores e, pensando na

maior necessidade dos recursos de conexão, a 3GPP (3rd Generation Partnership

Project) introduziu na Release 13 a Narrowband IoT como uma nova tecnologia de

acesso por rádio, dando suporte para largura de banda estreita para comunicações

de máquinas sobre a tecnologia LTE ([1] PENNACCHIONI et al., 2017). Porém, como

toda a nova tecnologia, existe a necessidade de avaliação de seu comportamento e

identificação dos pontos fortes e fracos, de acordo com a região geográfica em que

esta tecnologia será implementada, antes de adotá-la como solução ideal.

Sendo um dos possíveis clientes para este projeto, a Copel necessita identificar

quais as vantagens e limitações serão incorporadas às suas redes, seja para

planejamento, operação e manutenção, com a utilização desta tecnologia, visando a

substituição de redes legadas e utilizadas atualmente, tais como GPRS, GSM, 3G, ou

até mesmo redes cabeadas.

Desse modo, o projeto tem como foco realizar a implementação de diversos

cenários de rede por meio do NS-3, para estabelecimento do comportamento dos itens

a serem monitorados e controlados – tanto os já existentes e integrantes das redes

atuais como os novos devices - e posteriormente feita uma análise dos parâmetros de

rede obtidos nestas simulações por meio do software Matlab, de modo que seja

possível mensurar suas características técnicas.

É parte presentes deste documento o detalhamento do projeto, passando pelo

dimensionamento dos dispositivos utilizados para simulação da rede NB-IoT, e como

estas simulações são efetuadas, representadas por meio de diagrama de blocos.

Além disto, serão apresentadas as ferramentas desenvolvidas para possibilitar a

realização destes testes e avaliação do projeto. Também será possível identificar as

tecnologias empregadas para este desenvolvimento e as métricas de testes que serão

executados para validação das ferramentas.

7

3 DETALHAMENTO DO PROJETO

Com o intuito de avaliar o funcionamento de uma rede NB-IoT efetuando o

transporte dos dados de redes inteligentes e dos dispositivos de IoT, o trabalho a ser

desenvolvido é definido por um módulo de simulação de tráfego de dados, tendo como

base o software NS-3 (Network Simulator 3), e posterior tratamento e análise dos

dados obtidos por meio do software Matlab.

O software NS-3 possuí a característica de ser um software de código aberto,

licenciado sob os termos da GLP GNU. Esta característica permite que o código fonte

do NS-3 seja distribuído de maneira aberta, sem restrições de acesso. A característica

deste tipo de licenciamento exige que todas as customizações realizadas no código

fonte sejam tornadas públicas, sem qualquer tipo de restrição ao acesso do código

fonte.

O módulo de simulação tem o objetivo de dimensionar os dispositivos, efetuar

a criação da rede e todos os seus parâmetros de acordo com dados pré-existentes e

dados alimentados pelo usuário, bem como a execução efetiva de simulações de

acessos dos dispositivos à rede.

O módulo de análise de desempenho tem o objetivo de filtrar os dados obtidos

por meio das simulações, compará-los com dados pré-existentes de acordo com

critérios técnicos de qualidade, e efetuar a avaliação dos resultados obtidos, indicando

ao usuário a viabilidade técnica ou não de determinada rede.

Dessa forma, o presente projeto divide-se em dois módulos:

• Módulo de simulação da rede NB-IoT

• Módulo de análise de desempenho da rede NB-IoT

3.1 MÓDULO DE SIMULAÇÃO DA REDE NB-IOT

O módulo de simulação da rede NB-IoT é composto pelos processos

envolvendo a criação da rede, criação dos dispositivos que compõem a rede, bem

como as aplicações que estarão rodando em cada dispositivo, as quais serão

abordadas com mais detalhes posteriormente. Uma das funções do módulo é também

a criação e configuração do canal de comunicação, configuração dos dispositivos de

8

rede, e criação da topologia da rede. Por fim, após a obtenção de todos os parâmetros

necessários é executada a simulação de operação da rede.

Este processo pode ser visualizado por meio do diagrama de fluxo de dados de

nível 0, apresentado na Figura 1 - Nível 0 do módulo de simulação da rede NB-IoT:

CRIAÇÃO DA

REDE NB-IOTUSUÁRIOS

SIMULAÇÃO DA

REDE NB-IOT

Consulta Viabilidade de Rede

RESULTADOS

Figura 1 - Nível 0 do módulo de simulação da rede NB-IoT Fonte: Os autores

De maneira mais detalhada, aumentando o nível de representação do fluxo de

dados, na Figura 2 - Nível 1 do módulo de simulação da rede NB-IoT - é apresentado

o nível 1 do diagrama:

9

USUÁRIOS

Inserção de Dados dos Sensores de Corrente, temperatura, medidores de energia, indicadores de posição, dispositivos com entradas e saídas, e subestação móvel

Definição do Tempo Desejado de Simulação

Definição do Modo de Simulação

1CRIAÇÃO DA

REDE NB-IOT

1.1Criação da

eNodeB

1.2Criação dos

Sensores

1.3Criação Canal Comunicação

1.4Criação dos

Dispositivos de Rede

1.5Criação da

Topologia da Rede

Parâmetros dos

Dispositivos

Parâmetros da Simulação

1.6Criação das Aplicações

eNodeB

Sensores

Canal de Comunicação

Dispositivos de Rede

Topologia da Rede

Aplicações

2SIMULAÇÃO DA

REDE NB-IOT

Resultados da Simulação

RESULTADOS

Figura 2 - Nível 1 do módulo de simulação da rede NB-IoT Fonte: Os autores

Conforme apresentado, o módulo de simulação possui entidades externas,

fluxos, processos e repositórios, de acordo com as características do sistema ([5]

Lucidchart, 2018). Cada uma dessas partes integrantes do diagrama é apresentada a

seguir de maneira detalhada.

3.1.1 Usuários

Os usuários são definidos por uma entidade externa, a qual recebe ou envia

dados de modo a comunicar-se com o sistema presente no diagrama, sendo assim, é

uma fonte ou destino de informação dentro de um sistema ([5] Lucidchart, 2018).

10

No presente projeto, os usuários representam os responsáveis técnicos da

empresa COPEL, ou usuários independentes, os quais deverão ter conhecimento

técnico da rede a ter sua viabilidade técnica testada.

Assim como os usuários tem a função de inserção de dados, eles recebem os

dados produzidos pelo sistema. Dessa forma, a existência da entidade externa

usuários é fundamental para a interação com o sistema.

3.1.1.1 Entrada de dados

A entrada de dados em um sistema é parte fundamental do processo de

simulação de uma rede NB-IoT.

O primeiro setup à ser realizado no programa pelo usuário é a forma como os

testes podem ser realizados. Para a aplicação, será possível utilizar modos de testes

pré-definidos ou com as características estabelecidas pelo usuário, conforme sua

necessidade.

• Modo de testes pré-definidos [s/n]: Este parâmetro do sistema permite ao

usuário configurar um modo pré-definido de testes. Os demais parâmetros da

simulação serão apresentados ou não de acordo com a opção selecionada.

Esta sequência pode ser visualizada na Figura 3 – Setup do modo testes do

Sistema de Testes de Redes NB-IoT:

Figura 3 – Setup do modo testes do Sistema de Testes de Redes NB-IoT Fonte: Os autores

Os dados a serem inseridos são estabelecidos pela entidade usuário, de acordo

com os seguintes tipos:

11

• Quantidade de sensores: define efetivamente a quantidade de cada tipo de

sensor que terá acesso à rede;

• Tamanho do pacote de dados dos sensores: define, de acordo com o tipo do

sensor, o tamanho e quantidade de dados necessários para transmissão;

• Frequência de acesso dos sensores à rede: define, de acordo com a

necessidade de cada sensor, a frequência com a qual o sensor se conectará a

rede, e fará o envio de dados (este parâmetro somente estará disponível caso

o setup 1 – Modo de testes, estiver configurado com a opção “n”);

Estes parâmetros foram estabelecidos pelo grupo desenvolvedor do projeto

como sendo fatores fundamentais para simulação de uma rede com as características

propostas.

A coleta dos dados oriundos da entidade usuários se dará por meio do prompt

de comando, com interação entre máquina e usuário.

O primeiro parâmetro a ser coletado é o tempo desejado para execução da

simulação, conforme apresenta a Figura 4 - Setup tempo de simulação do Sistema de

Testes de Redes NB-IoT. Quanto maior o tempo de simulação, maior a possibilidade

de obtenção de resultados com maior confiabilidade, visto que há um maior número

de eventos a serem analisados.

Figura 4 - Setup tempo de simulação do Sistema de Testes de Redes NB-IoT Fonte: Os autores

Posteriormente, cada sensor terá seus dados coletados individualmente,

havendo uma sequência lógica entre cada coleta, e ordenamento por tipo de sensor.

Esta sequência pode ser visualizada na Figura 5 - Setup componentes da rede

do Sistema de Testes de Redes NB-IoT:

12

Figura 5 - Setup componentes da rede do Sistema de Testes de Redes NB-IoT Fonte: Os autores

O próximo parâmetro se refere ao modo de execução da simulação.

Considerando que, ao definirmos uma quantidade de sensores e a frequência de

acesso desses sensores à rede, temos que os acessos de sensores de mesmo tipo

podem ser praticamente simultâneos, ou divididos, de modo que cada sensor acesse

a rede com grandes diferenças de tempo.

Estes parâmetros poderão ser definidos pela entidade usuários, conforme

apresenta Figura 6 - Setup modo de simulação do Sistema de Testes de Redes NB-

IoT:

Figura 6 - Setup modo de simulação do Sistema de Testes de Redes NB-IoT Fonte: Os autores

13

Após esta coleta de dados, a entidade usuários finaliza os procedimentos

iniciais, requeridos para inicialização dos processos subsequentes. Desse modo,

partindo de uma entidade externa, por meio de fluxos de dados, o processo seguinte:

“Criação da Rede NB-IoT” é alimentado, conforme Figura 2 - Nível 1 do módulo de

simulação da rede NB-IoT.

3.1.2 Criação da rede NB-IoT

O primeiro processo que o diagrama da Figura 2 - Nível 1 do módulo de

simulação da rede NB-IoT - apresenta é o de “criação da rede NB-IoT”. Este processo

tem como objetivo a configuração de uma rede composta por uma eNobeB (estação

rádio base) e dispositivos conectados a ela, com quantidades e tipos definidos

previamente por meio da entidade usuários.

O processo de criação da rede NB-IoT é dividido em subprocessos,

responsáveis individualmente pela criação de cada elemento da rede. Estes

subprocessos executam funções específicas de criação, e configuração, além de

serem responsáveis pela criação de repositórios para armazenamento dos dados.

Os subprocessos são:

• Criação da eNobeB;

• Criação dos Sensores;

• Criação do Canal de Comunicação;

• Criação dos Dispositivos de Rede;

• Criação da Topologia de Rede;

• Criação das Aplicações.

3.1.2.1 Criação da eNodeB

O subprocesso de criação da eNodeB é responsável pela criação de um único

nó (node), o qual será implementada uma estação rádio base.

No software NS-3, a abstração nó (node) se refere a um dispositivo, podendo

ser entendido por um computador o qual serão adicionadas funcionalidades. Neste

14

caso, as aplicações instaladas neste nó serão responsáveis pela sua caracterização,

exercendo função de uma eNodeB.

Este subprocesso é chamado por meio de um comando presente no script a

ser executado no início do módulo de simulação, o qual realiza a criação do nó por

meio do código fonte do NS-3.

Após a criação do nó responsável pelo funcionamento da eNodeB, os dados

referentes a este nó são armazenados em um repositório, para posterior utilização da

simulação.

3.1.2.2 Criação dos sensores

O subprocesso de criação dos sensores é responsável pela criação de diversos

nós, os quais serão implementados os sensores.

Como o nó pode ser entendido por um computador o qual serão adicionadas

funcionalidades, as aplicações instaladas nos nós que representam os dispositivos

serão responsáveis pela caracterização destes, exercendo funções de coleta de

dados e envio para a rede.

Este subprocesso é chamado por meio de um comando presente no script em

a ser executado no início do módulo de simulação, o qual realiza a criação dos nós

por meio do código fonte do NS-3.

Após a criação dos nós responsáveis pelo funcionamento dos diversos tipos de

sensores, os dados referentes a estes nós são armazenados em um repositório, para

posterior utilização da simulação.

De acordo com critérios estabelecidos inicialmente pelos desenvolvedores do

presente projeto, juntamente com o professor orientador, foi determinado que a rede

deverá possuir seis tipos de sensores, podendo ser diferenciados pelos tamanhos de

seus pacotes de dados, e pela sua frequência de acesso a rede. Estes sensores são

diferenciados dentro da rede criada de acordo com sua identificação, conforme

descritos na tabela Tabela 1 - Tipos de sensores a serem implementados:

Tabela 1 - Tipos de sensores a serem implementados Tipos de Sensores

Id Descrição

15

1 Sensor do Tipo 01

2 Sensor do Tipo 02

3 Sensor do Tipo 03

4 Sensor do Tipo 04

5 Sensor do Tipo 05

6 Sensor do Tipo 06

Fonte: Os autores

Como as aplicações dos sensores do presente projeto são usualmente

medições estáticas, um dos parâmetros configurados nestes sensores foi a defini-los

com características semelhantes quanto à não possuírem mobilidade.

Outro parâmetro a ser considerado para implementação dos sensores é o

tamanho do pacote de dados enviado em cada acesso à rede. Estes parâmetros são

definidos pelas aplicações instaladas nos sensores, as quais são abordadas a seguir.

3.1.2.3 Criação do canal de comunicação

O subprocesso de criação do canal de comunicação é responsável pela criação

do meio físico o qual é responsável pela ligação dos sensores e da eNodeB.

Cada nó criado por meio do NS-3 deve ser conectado a algum meio físico.

Dessa forma, inicialmente são consultados os dados de todos os nós da rede

(sensores e eNodeB), para criação do canal e estabelecimento de comunicação entre

cada sensor com a eNodeB. Esta configuração é efetuada de modo que, cada sensor

possuirá comunicação direta e independente com a eNodeB, apresentando uma

topologia do tipo estrela.


ser executado no início do módulo de simulação, o qual realiza a criação dos canais


Após a criação dos canais de comunicação dos sensores e eNodeB, os dados

referentes a estes canais são armazenados em um repositório específico para


3.1.2.4 Criação dos dispositivos de rede

16

O subprocesso de criação dos dispositivos de rede é responsável pela criação

dos hardwares de rede e drivers dos sensores e da eNodeB.

Um dispositivo de rede é instalado em um nó para permitir a comunicação entre

este nó e demais nós presentes na rede. Ou seja, um dispositivo de rede pode ser

entendido como uma placa de rede e o seu driver.

Cada nó criado deve possuir um dispositivo de rede. Desta forma, inicialmente

são consultados os dados de todos os nós da rede (sensores e eNodeB), e

posteriormente atualizados os repositórios de sensores e eNodeB.


ser executado no início do módulo de simulação, o qual realiza a criação dos canais





3.1.2.5 Criação da topologia da rede

O subprocesso de criação da topologia da rede é responsável pela conclusão

dos processos de criação da rede, efetivando a relação entre sensores e eNodeB.

Todo dispositivo de rede deve ser configurado de modo a ter condições de

comunicação entre seus pares. Estas configurações vão desde a definição de um

endereço MAC a um endereço IP, parâmetros necessários para a configuração de

dispositivos em uma rede.

Como a configuração manual de diversos dispositivos é inviável, do ponto de

vista da realização de testes em massa, o software NS-3 disponibiliza um assistente

de topologia. Dessa forma, este subprocesso é chamado por meio de um comando

presente no script a ser executado no início do módulo de simulação, o qual realiza a

configuração e criação da topologia por meio do código fonte do NS-3.




17

3.1.2.6 Criação das aplicações

O subprocesso de criação das aplicações é responsável pela criação das

aplicações a serem implementadas nos sensores e na eNodeB.

As funcionalidades de cada nó podem ser definidas pelas aplicações que neles

estão instaladas. Desse modo, para caracterização dos sensores de diversos tipos,

bem como da eNodeB, serão instaladas aplicações responsáveis pelo envio de dados

no caso dos sensores, e de gerenciamento e recepção no caso da eNodeB.

Estas aplicações podem ser entendidas como softwares exercendo função de

emulação dentro de um nó, e serão configuradas por meio da linguagem de

programação C++.

Após a criação das aplicações responsáveis pela caracterização dos sensores

e eNodeB, os dados referentes a estas aplicações são armazenados em um

repositório específico para posterior utilização da simulação, e também atualizam o

repositório de dados de sensores, salvando neste, suas novas características.

3.1.3 Execução do simulador

O segundo processo do diagrama da Figura 2 - Nível 1 do módulo de simulação

da rede NB-IoT - apresenta é o de execução do simulador. Este processo tem como

objetivo a execução dos eventos discretos de acesso dos sensores à rede NB-IoT.

Previamente a execução dos eventos de simulação, este processo é

alimentado pelo repositório de parâmetros de simulação, e por todos os demais

repositórios: eNodeB, Sensores, Canal de Comunicação, Dispositivos de Rede,

Topologia de Rede e Aplicações.

Este processo é chamado por meio de um comando presente no script a ser

executado no início do módulo de simulação, o qual realiza a execução dos eventos

de simulação por meio do código fonte do NS-3.

Após a execução das simulações, os resultados referentes a estes eventos são

armazenados em um repositório específico para visualização do usuário, e também

salvos em um arquivo representado por uma entidade externa, para posterior

tratamento e análise.

18

3.1.4 Resultados das simulações

O resultado do processo de execução do simulador, efetuado pelo software NS-

3 é parte fundamental do presente projeto. Os dados obtidos após o término da

simulação são armazenados em arquivos, contendo parâmetros de características e

desempenho da rede, como:

• Posições dos Dispositivos;

• Delay;

• Perda de pacotes;

Apesar da relevância dos dados obtidos, como estes são armazenados em

repositórios, e possuem grande quantidade de informações, a simples apresentação

dos dados ao usuário não apresenta praticidade. Porém, apesar disso, caso seja

necessária uma análise técnica, esta opção de acesso aos dados também estará

disponível.

Uma segunda forma para análise de desempenho da rede, se dá por meio do

tratamento desses dados, obtendo valores relevantes quanto às métricas de

desempenho da rede NB-IoT simulada.

Considerando a segunda opção, optou-se pela utilização do software MATLAB

para importação dos arquivos de simulações, e processamento dos dados de modo a

obtenção de resultados práticos e relevantes.

3.2 MÓDULO DE ANÁLISE DE DESEMPENHO DA REDE NB-IOT

Para análise efetiva de uma rede NB-IoT, e dos dados obtidos por meio das

simulações, considerou-se a implementação de um módulo paralelo, para tratamento

e análise desses dados.

Com o auxílio do software MATLAB, será efetuada a importação dos arquivos

de dados gerados nas simulações. Esses dados serão tratados, de modo a obter

informações relevantes a respeito da viabilidade rede proposta.

19

Os processos e entidades envolvendo o módulo de análise de desempenho

são apresentados na Figura 7 - Módulo de análise de desempenho:

MATLAB

RESULTADOS

DAS SIMULAÇÕES

RECOMENDAÇÕES

TÉCNICAS

RESULTADOS DE

VIABILIDADE DA

REDE

Filtragem e Tratamento

de Dados

Análises Estatísticas

Dados de Qualidade da Rede

Dados de Recomendações

técnicas

Figura 7 - Módulo de análise de desempenho Fonte: Os autores

Conforme apresentado, o módulo de análise de desempenho possui entidades

externas, fluxos, processos e repositórios, de acordo com as características do

sistema ([5] Lucidchart, 2018). Cada uma destas partes integrantes do diagrama é

apresentada a seguir de maneira detalhada.

3.2.1 Resultados das simulações

A entidade externa “resultados das simulações” é especificamente a entidade

a qual os dados de resultados de simulações foram salvos. Desse modo, conforme

informado anteriormente, esta entidade é responsável pela alimentação das

informações no MATLAB.

De posse desses arquivos, o software MATLAB realizará o tratamento desses

dados, filtrando e realizando operações de modo a obter resultados objetivos, com

base em métricas estatísticas.

3.2.2 Recomendações técnicas

A 3GPP, a partir do Release 13, indica alguns valores médios esperados para

o comportamento de uma rede NB-IoT.

Devido a característica de economia de energia adotada pelos dispositivos, é

possível que o delay para envio de dados por parte do dispositivo seja de até 10

20

segundos. Já para o jitter, a recomendação da ITU-R é de que este valor seja inferior

a 25 ms ([2] Al-Shammari, 2018).

Pelo fato do NB-IoT operar em banda de frequência licenciada, é possível que

o core da rede opere com a técnica de Qualidade de Serviço (QoS).

Pensado no QoS, a 3GPP propõem as configurações apresentadas na Figura

8 - QoS proposta pela 3GPP para LTE

Figura 8 - QoS proposta pela 3GPP para LTE Fonte: IEEE Internet Of Things Journal [2]

PDB msec – Atraso em milissegundos

PLR – Taxa de perdas de pacotes

Assim, para mensurar a qualidade dos resultados obtidos durante o processo

de simulação, estes parâmetros de referências serão utilizados.

3.2.3 Matlab

O software MATLAB receberá os dados originados pelas entidades externas

“resultados das simulações” e “recomendações técnicas”, e efetuará o tratamento

dessas informações.

Inicialmente, serão filtrados os dados relevantes dos “resultados das

simulações”, e efetuadas operações de modo a obter valores totais de perda de

21

pacotes, jitter, delay e colisões, e posteriormente esses dados serão comparados com

dados técnicos, de modo a estabelecer um critério de viabilidade de uma rede.

3.2.3.1 Filtragem e tratamento de dados

Os resultados das simulações são arquivos extensos, com informações sobre

cada dispositivo, e cada evento ocorrido nesse dispositivo.

O processo de filtragem e tratamento de dados tem como objetivo a separação

entre informação e redundância presente nos arquivos de registro. As informações

devem ser tratadas, de modo a gerar resultados pertinentes aos usuários do sistema.

3.2.3.2 Análises estatísticas

Posterior ao tratamento dos dados originados da simulação da rede, eles estão

disponíveis em um repositório de dados específico.

Nesse ponto, o processo de “análises estatísticas” efetua a comparação,

recebendo informações de ambos os repositórios: “Dados de qualidade da rede” e

dados de “recomendações técnicas”.

A comparação entre estes dados deve ser efetuada de maneira a obter um

resultado positivo ou negativo quanto a viabilidade da rede proposta. Em ambos os

casos os resultados são exportados para uma entidade externa, de modo a serem

utilizados posteriormente por quem possa interessar.

3.2.4 Resultados de viabilidade da rede

Conforme apresentado na Figura 7 - Módulo de análise de desempenho – os

resultados das análises serão armazenados em uma entidade externa.

Nesta entidade, as seguintes informações serão apresentadas:

• Valores de referência;

• Valores das simulações;

• Histograma das simulações.

22

Assim, para o usuário final, este report conterá as informações do desempenho

da rede de forma compilada, facilitando o processo de compreensão e tomada de

decisão sobre a implementação ou não da rede NB-IoT simulada.

23

5 PROCEDIMENTO DE TESTES E VALIDAÇÃO DO PROJETO

É fato que todos nós, seres humanos, cometemos erros em nossas atividades

diárias, independente da área o nicho no qual estamos inseridos. Por isso, testes de

softwares são necessários, pois, alguns desses erros não são importantes, mas outros

são caros ou perigosos ([4] Graham et al., 2008).

Para validação do módulo desenvolvido a ser integrado no software NS-3, faz

parte do cronograma do projeto a realização de baterias de testes a fim de comprovar

a eficácia deste sistema desenvolvido.

A metodologia de testes escolhido para realização de validação do módulo a

ser implementado, será baseado nos procedimentos definidos pela International

Software Testing Qualifications Board (ISTQB).

A ISTQB é uma organização que não possuí fins lucrativos, voltada para

definição de metodologias de testes de software e capacitação de profissionais

responsáveis por estas atividades ([4] Graham et al., 2008).

Como proposta, a ISTQB sugere que as execuções dos testes sejam divididas

em 4 principais áreas, sendo elas:

1. Teste de componentes;

2. Teste de integração;

3. Teste de sistema;

4. Teste de aceite;

Neste projeto, por sua característica, optou-se pela utilização de apenas 3

destes testes sugeridos, sendo o teste de sistema excluído deste processo de

validação. O detalhamento sobre as atividades que devem fazer parte de cada um

dos itens listados anteriormente, será abordado de maneira separada na sequência

deste documento.

Outro conceito que será utilizado no programa de testes do sistema são os

testes caixa branca e testes caixa preta.

Testes de caixa branca garantem que a implementação de uma funcionalidade

será testada em sua totalidade ([3] Bastos, 2007). Neste tipo de teste, o avaliador

possui acesso ao código fonte e tem como objetivo analisar a estrutura do código

elaborado bem como executar esta função, acompanhando assim as entradas e

24

saídas. Com isso, garante-se que ao menos uma vez, todas as funções do código

foram executadas e estão funcionando em conformidade.

Testes de caixa preta garantem que os requisitos especificados foram

devidamente cumpridos pelo sistema ([3] Bastos, 2007). Para este formato de testes,

o avaliador não possuí acesso ao código tão pouco conhece a estrutura do programa.

Seu objetivo é testar o comportamento do software, identificando se as saídas geradas

são coerentes com os resultados esperados. É conhecido também como teste

funcional, já que esta validação é normalmente feita pelo cliente.

Deste modo, o sistema de testes será formado pela união destes dois conceitos

de validação de sistemas.

5.1 TESTES CAIXA BRANCA

Os testes de caixa branca, para o projeto em questão, serão executados no

início do processo de testes, pois, erros com grau de impacto alto podem ser

descobertos mais cedo deste modo.

Serão utilizados como base os seguintes testes propostos pela ISTQB:

1. Teste de componente;

2. Teste de integração;

5.1.1 Testes de Componente

Os testes de componentes serão os primeiros a serem executados no código

desenvolvido.

Nesta etapa, são validadas as partes mais elementares que compõem o

software, de forma a garantir suas funcionalidades isoladamente. Serão validadas

funções, objetos, classe e outros itens que compõem a base do módulo.

Os objetivos da etapa de testes de componentes são:

• Identificação de defeitos básicos da codificação do módulo;

• Identificação de falhas na abordagem;

• Validação das funções propostas;

25

• Identificação dos recursos necessários para execução em runtime do

módulo, tais como consumo de memória RAM, consumo de

processamento, etc.

• Realização de levantamento dos tempos de respostas do módulo para

as funções desenvolvidas.

Os seguintes módulos serão testados nesta etapa:

• Criação da rede NB-IoT;

• Simulação da rede NB-IoT;

• Módulo de aplicações;

• Parametrização dos módulos existentes.

Em termos cronológicos, esta etapa dos testes ocorrerá de maneira paralela a

elaboração de código fonte. Devido a esta característica, não são necessários

registros formais sobre os problemas encontrados, sendo recomendado somente o

armazenamento dos dados extraídos do software nesta etapa.

5.1.1.1 Resultados esperados

Para estes testes, os resultados esperados são:

• Compilação dos códigos;

• Processamento lógico da função;

• Saídas coerentes com os valores de entradas.

5.1.2 Testes de Integração

Após a realização dos testes de componentes, serão realizados os testes de

integração do módulo desenvolvido.

Serão avaliados e validados pelos programadores a integração do módulo com

o software NS-3, a fim de garantir a compatibilidade entre estes dois entes.

As atividades que compõem esta etapa do módulo de testes são:

26

• Garantir que a integração entre estes dois sistemas ocorra de modo que

todas as funcionalidades do software NS-3 necessárias no módulo

estejam disponíveis e em correto funcionamento;

• Características de desempenho do NS-3, as quais não deverão ser

alteradas após a introdução do novo módulo.

Os seguintes módulos serão testados nesta etapa:

• Criação da rede NB-IoT;

• Simulação da rede NB-IoT;

• Módulo de Aplicações.

Deverá ser mantido registro histórico dos problemas encontrados durante esta

etapa e as soluções aplicadas para a correção do problema.



• Módulo de criação da rede:

o Entrada de dados dos usuários alimente o processo;

o Geração da saída com parâmetros dos dispositivos;

o Geração de saída com parâmetros de simulação;

o Criação de eNodeB;

o Geração de saída para alimentar simulação da rede.

• Criação das aplicações:

o Entrada de dados oriunda da eNodeB;

o Troca de dados com sensores;

o Criação do canal de comunicação;

27

o Geração de saída com os parâmetros da aplicação.

• Simulação da rede NB-IoT:

o Entrada de dados oriunda da criação da rede;

o Entradas de dados oriunda da eNodeB;

o Entradas de dados oriundas dos parâmetros de simulação;

o Entradas de dados dos componentes da rede;

o Geração de saída com os resultados da simulação;

o Geração da saída com os parâmetros da qualidade da rede.

5.2 TESTES CAIXA PRETA

Os testes de caixa preta serão executados após a finalização dos testes de

caixa branca.

Serão utilizados como base os seguintes testes propostos pela ISTQB:

1. Teste de aceite;

5.2.1 Testes de Aceitação

Os testes de aceitação serão a última etapa entre o desenvolvimento do código

e a disponibilização deste módulo para uso do cliente final.

Desta forma, a realização desta etapa deverá ser efetuada em conjunto, entre

todas as partes interessadas no projeto, sendo elas:

• Desenvolvedores;

• Orientador.

É desejável que se tenha como foco desta etapa de validação que todas as

funcionalidades desenvolvidas no módulo devem estar respondendo de maneira

satisfatória aos parâmetros de entrada repassados ao software, conforme validação

realizada nos testes de caixa branca.

28

Como o módulo proposto irá realizar simulação do tráfego na rede NB-IoT com

diversos parâmetros de entrada e condições variadas de funcionamento, as saídas

resultantes do processamento deste módulo serão também variadas.



• Confirmação de aceite dos valores inseridos;

• Apresentação do cenário proposto;

• Apresentação dos resultados da simulação em tela;

• Geração de arquivo contendo dados de todos os eventos simulados.

5.3 PLANO DE TESTES

O plano de testes completo, contendo todos os passos necessários para a

validação das condições estabelecidas, é apresentado na sequência.

Para facilitar a sequência dos testes, este estão divididos em 3 etapas, sendo

elas:

• Testes de componentes;

• Testes de integração;

• Testes de Aceitação;

A Tabela 2 – Testes de componentes, apresentada a seguir, deve ser utilizada

e preenchida com o resultado os testes de compontentes.

Tabela 2 – Testes de componentes

TESTES DE COMPONENTES

Id Teste Procedimento Resultados

Esperado Verificado

1 Compilação do software 1 – Abri o terminal do ubuntu

2 – Efetuar o comando de

compilação ./waf

Compilação do código

sem a presença de erros

Ok

29

3 – Verificar o retorno do comando

no terminal.

2 Verificação de consumo

de memória

1 – Iniciar a aplicação

2 – Inserir ao menos 1 dispositivo de

cada tipo.

3 – Informar tempo de simulação de,

ao menos, 10 segundos

4 – Verificar consumo de memória do

NS-3, utilizando o terminal do Ubuntu

Consumo de memória

ram inferior a 1 GB

Ok. Utilizado 100MB

de memória.

Obs.: Utilizado 95%

do processamento.

Fonte: Os autores

A Tabela 3 – Testes de integração, apresentada a seguir, deve ser utilizada e

preenchida com o resultado os testes de integração.

Tabela 3 – Testes de integração

TESTES DE INTEGRAÇÃO

MÓDULO DE CRIAÇÃO DA REDE


Esperado Verificado

1 Validação entrada de

dados – Modo de

simulação

1 – Executar o simulador com a

seguinte sintaxe: NS_LOG =

“TestesIntegracao” ./waf --run

scratch/NB_IoT

2 – Informar modo de simulação

como pré-definido

3 – Verificar o retorno do LOG.

Informação de LOG

contendo a seguinte

mensagem: “MODO DE

TESTES PRÉ-

DEFINIDO: S”

Ok


dados – Sensor do Tipo

01




scratch/NB_IoT


como não pré-definido


Informação de LOG

devem conter as

seguintes mensagens:

1 - “SENSOR DO TIPO

01 - NÚMERO DE

SENSORES

INFORMADOS = X”


01 - TAMANHO DOS

PACOTES

INFORMADOS = Y”


01 - FREQUÊNCIA DE

ACESSO A REDE

INFORMADA = Z”

Obs. – x, y e z são os valores

informados pelo usuário

Ok



02




scratch/NB_IoT

Informação de LOG

devem conter as


Ok

30





02 - NÚMERO DE

SENSORES

INFORMADOS = X”


02 - TAMANHO DOS

PACOTES

INFORMADOS = Y”


02 - FREQUÊNCIA DE

ACESSO A REDE

INFORMADA = Z”





03




scratch/NB_IoT




Informação de LOG

devem conter as



03 - NÚMERO DE

SENSORES

INFORMADOS = X”


03 - TAMANHO DOS

PACOTES

INFORMADOS = Y”


03 - FREQUÊNCIA DE

ACESSO A REDE

INFORMADA = Z”



Ok



04




scratch/NB_IoT




Informação de LOG

devem conter as



04 - NÚMERO DE

SENSORES

INFORMADOS = X”


04 - TAMANHO DOS

PACOTES

INFORMADOS = Y”


04 - FREQUÊNCIA DE

ACESSO A REDE

INFORMADA = Z”



Ok



05




scratch/NB_IoT

Informação de LOG

devem conter as


Ok

31





05 - NÚMERO DE

SENSORES

INFORMADOS = X”


05 - TAMANHO DOS

PACOTES

INFORMADOS = Y”


05 - FREQUÊNCIA DE

ACESSO A REDE

INFORMADA = Z”





06




scratch/NB_IoT




Informação de LOG

devem conter as



06 - NÚMERO DE

SENSORES

INFORMADOS = X”


06 - TAMANHO DOS

PACOTES

INFORMADOS = Y”


06 - FREQUÊNCIA DE

ACESSO A REDE

INFORMADA = Z”



Ok

8 Validação do número de

dispositivos criados –

ENodeB




scratch/NB_IoT

2 – Inserir informação sobre a

topologia de rede


Informação de LOG

devem conter as


1 - “ENODE-B – TOTAL

CRIADOS = X”

Obs. – x é o valor efetivamente

criado pelo NS-3

Ok

9 Validação do número de

dispositivos criados –

Total de sensores




scratch/NB_IoT


topologia de rede


Informação de LOG

devem conter as


1 - “DEVICES– TOTAL

CRIADOS = X”

Obs. – x é o valor efetivamente

criado pelo NS-3

Ok

10 Validação da posição –

Sensores de corrente




scratch/NB_IoT

Informação de LOG

devem conter as



01 W – POSIÇÃO = X,Y”

Ok

32


topologia de rede


Obs. – x,y é a coordenada onde

o NS-3 criou o device

Obs. – W é o número do

dispositivo. Varia de acordo com

o número de sensores criados

pelo usuário


Sensores de

temperatura de

transformadores




scratch/NB_IoT


topologia de rede


Informação de LOG

devem conter as









pelo usuário

Ok


Medidor de energia




scratch/NB_IoT


topologia de rede


Informação de LOG

devem conter as









pelo usuário

Ok


Sensor de indicação de

posição




scratch/NB_IoT


topologia de rede


Informação de LOG

devem conter as









pelo usuário

Ok


Dispositivo de IOs




scratch/NB_IoT


topologia de rede


Informação de LOG

devem conter as



05 W – POSIÇÃO =

X,Y”






pelo usuário

Ok


Subestação Móvel



Informação de LOG

devem conter as


Ok

33


scratch/NB_IoT


topologia de rede









pelo usuário

16 Validação dos arquivos

de LOG




scratch/NB_IoT


topologia de rede. Deverão ser

inseridos ao menos 1 elemento de

cada tipo na rede

3 – Verificar os arquivos de LOG na

pasta “/repos/ns-3-allinone/ns-3-dev”

Na pasta indicada

deverão existir os

seguintes arquivos:

• DLPdcStatus.txt

• ULPdcStatus.txt

• DlRlcStats.txt

• UlRlcStats.txt

• UlRxPhyStats.txt

• Position.txt

Estes arquivos devem

possuir a data de

atualização compatível

com o horário da

simulação realizada

Ok

Fonte: Os autores

A Tabela 4 – Testes de Aceitação, apresentada a seguir, deve ser utilizada e

preenchida com o resultado os testes de aceitação.

Tabela 4 – Testes de Aceitação

TESTES DE ACEITAÇÃO


Esperado Verificado

1 Cenário 1 – Modo Pré-

Definido como Baixo -

Validação de

funcionamento


seguinte sintaxe: ./waf --run

scratch/NB_IoT


como pré-definido

3 – Informar somente 1 elemento de

cada tipo

4 – Definir o modo de simulação

como baixo

5 – Informar o tempo de simulação

em 10 segundos

6 – Executar a aplicação do Matlab

para análise dos resultados

7 – Avaliar os resultados gerados

pelo Matlab

Os seguintes resultados

são esperados:

1 – Geração dos

resultados pelo NS-3 de

acordo com a rede

proposta;

2 – Geração de gráficos

comparativos,

apresentando os

parâmetros verificados

pelo NS-3 e os

parâmetros de

referência. Também é

esperado a

apresentação de

resultados estatísticos

das variáveis analisadas

Ok

Obs.: Resultados em

anexo

34


Definido como Normal -

Validação de

funcionamento



scratch/NB_IoT


como pré-definido


cada tipo


como normal


em 10 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok

Obs.: Resultados em

anexo


Definido como

Avalanche - Validação

de funcionamento



scratch/NB_IoT


como pré-definido


cada tipo


como avalanche


em 10 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok

Obs.: Resultados em

anexo

4 Cenário 1 – Modo Não -

Validação de

funcionamento



scratch/NB_IoT




cada tipo


em 10 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de

Ok

Obs.: Resultados em

anexo

35





Validação de

funcionamento



scratch/NB_IoT


como pré-definido

3 – Informar 10 elementos de cada

tipo


como baixo


em 10 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok

Obs.: Resultados em

anexo



Validação de

funcionamento



scratch/NB_IoT


como pré-definido


tipo


como normal


em 10 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok

Obs.: Resultados em

anexo


Definido como


de funcionamento



scratch/NB_IoT


como pré-definido


tipo


como avalanche


em 10 segundos – Executar a

aplicação do Matlab para análise dos

resultados


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

Ok

36


pelo Matlab

apresentação de

Okresultados estatísticos


Obs.: Resultados em

anexo


Validação de

funcionamento



scratch/NB_IoT




tipo


em 10 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok

Obs.: Resultados em

anexo



Validação de

funcionamento



scratch/NB_IoT


como pré-definido


tipo


como baixo


em 1200 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok



Validação de

funcionamento



scratch/NB_IoT


como pré-definido


tipo


como normal


em 1200 segundos




são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


Ok

37


pelo Matlab

esperado a

apresentação de




Definido como


de funcionamento



scratch/NB_IoT


como pré-definido


tipo


como avalanche


em 60 segundos – Executar a

aplicação do Matlab para análise dos

resultados


pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok


Validação de

funcionamento



scratch/NB_IoT




tipo


em 1200 segundos




pelo Matlab


são esperados:

1 – Geração dos


acordo com a rede

proposta;


comparativos,

apresentando os


pelo NS-3 e os

parâmetros de


esperado a

apresentação de



Ok

Fonte: Os autores

Os cenários de testes propostos foram estabelecidos com base em pesquisas

e levantamento realizados em conjunto pelos acadêmicos e orientador do projeto.

38

5.3.1 Resultados de Testes

Conforme plano de testes proposto na Tabela 4 – Testes de Aceitação, foram

efetuadas as simulações com o intuito de validação e análise das redes criadas. Na

sequência são apresentados os testes de 09 a 12, se tratando de redes mais

relevantes por possuírem maior quantidade de dispositivos. Já os testes de 01 a 08

estão presentes em anexo a este documento, por serem redes menores.

5.3.1.1 Distribuição Espacial dos Dispositivos

Figura 9 - Distribuição Espacial Dispositivos Teste 09

39



40


5.3.1.2 Throughput – Downlink

Figura 13 - Throughput Downlink Teste 09

41



42


5.3.1.3 Throughput – Uplink

Figura 17 - Throughput Uplink Teste 09

43



44


5.3.1.4 Análise de Taxa de Erro – Uplink

Figura 21 - Análise de Taxa de Erro Uplink Teste 09

45



46


5.3.1.5 Análise Delay e Jitter – Uplink

Figura 25 - Análise de Delay e Jitter Uplink Teste 09

47



48


5.3.1.6 Análise Delay e Jitter – Downlink

Figura 29 - Análise de Delay e Jitter Downlink Teste 09

49



50


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.

51

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.

52

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 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

53

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.

54

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.

https://www.lucidchart.com/pages/pt/simbolos-de-diagramas-de-fluxo-de-dados

55

ANEXO A – SIMULAÇÕES DE 01 A 08

Simulação 01

58

Simulação 02

61

Simulação 03

64

Simulação 04

67

Simulação 05

70

Simulação 06

73

Simulação 07

76

Simulação 08

79

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 modo; //Modo de Simulação: 1 - Baixo | 2 - Normal | 3 - Avalanche

80

}; 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);

81

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 - Sensor do Tipo 02" << endl;

82

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; } while (not((tipo04.tamanho > 20) & (tipo04.tamanho <= 512)));

83

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 ("----------------------------------------------------");

84

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); Ptr<MobilityModel> ueMob01 = ueNode01->GetObject<MobilityModel> ();

85

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) { cout << "Erro de gravação" << endl;

86

} } 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, ""); strcpy (tipo_ue, "04");

87

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"); }

88

//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 Vector get_pos6 = ueMob06->GetPosition (); NS_LOG_INFO ("SENSOR DO TIPO 06 - SENSOR " << (u+1) << " - POSIÇÃO: (" << get_pos6.x << ", " << get_pos6.y << ")"); //GRAVA EM ARQUIVO POSIÇÃO DOS SENSORES strcpy (string_write, ""); strcpy (tipo_ue, "06"); sprintf(id_ue, "%d", (u+1)); sprintf(posx_ue, "%f", get_pos6.x); sprintf(posy_ue, "%f", get_pos6.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; } } //INSTALAÇÃO DE DISPOSITIVOS NB-IOT NOS NÓS NetDeviceContainer enbDevs = lteHelper->InstallEnbDevice (enbNodes); NetDeviceContainer ueDevs01 = lteHelper->InstallUeDevice (Nodes_device01); NetDeviceContainer ueDevs02 = lteHelper->InstallUeDevice (Nodes_device02); NetDeviceContainer ueDevs03 = lteHelper->InstallUeDevice (Nodes_device03); NetDeviceContainer ueDevs04 = lteHelper->InstallUeDevice (Nodes_device04); NetDeviceContainer ueDevs05 = lteHelper->InstallUeDevice (Nodes_device05); NetDeviceContainer ueDevs06 = lteHelper->InstallUeDevice (Nodes_device06); total_devs = ueDevs01.GetN() + ueDevs02.GetN() + ueDevs03.GetN() + ueDevs04.GetN() + ueDevs05.GetN() + ueDevs06.GetN(); NS_LOG_INFO ("----------------------------------------------------"); NS_LOG_INFO ("ENODEB - TOTAL CRIAD0S: " << enbDevs.GetN ()); NS_LOG_INFO ("DEVICES - TOTAL CRIADOS: " << total_devs); //INSTALAÇÃO DE PACOTES IPV4 NOS DISPOSITIVOS internet.Install (Nodes_device01); internet.Install (Nodes_device02); internet.Install (Nodes_device03); internet.Install (Nodes_device04); internet.Install (Nodes_device05); internet.Install (Nodes_device06); Ipv4InterfaceContainer ueIpIface01; Ipv4InterfaceContainer ueIpIface02; Ipv4InterfaceContainer ueIpIface03; Ipv4InterfaceContainer ueIpIface04; Ipv4InterfaceContainer ueIpIface05; Ipv4InterfaceContainer ueIpIface06; ueIpIface01 = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs01)); ueIpIface02 = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs02)); ueIpIface03 = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs03)); ueIpIface04 = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs04)); ueIpIface05 = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs05)); ueIpIface06 = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs06)); Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress (1); //ATRIBUIÇÃO DE IP AOS DISPOSITIVOS

89

for (uint32_t u = 0; u < Nodes_device01.GetN (); ++u) { Ptr<Node> ueNode1 = Nodes_device01.Get (u); //GATEWAY DEFAULT Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode1->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } for (uint32_t u = 0; u < Nodes_device02.GetN (); ++u) { Ptr<Node> ueNode2 = Nodes_device02.Get (u); //GATEWAY DEFAULT Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode2->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } for (uint32_t u = 0; u < Nodes_device03.GetN (); ++u) { Ptr<Node> ueNode3 = Nodes_device03.Get (u); //GATEWAY DEFAULT Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode3->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } for (uint32_t u = 0; u < Nodes_device04.GetN (); ++u) { Ptr<Node> ueNode4 = Nodes_device04.Get (u); //GATEWAY DEFAULT Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode4->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } for (uint32_t u = 0; u < Nodes_device05.GetN (); ++u) { Ptr<Node> ueNode5 = Nodes_device05.Get (u); //GATEWAY DEFAULT Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode5->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } for (uint32_t u = 0; u < Nodes_device06.GetN (); ++u) { Ptr<Node> ueNode6 = Nodes_device06.Get (u); //GATEWAY DEFAULT Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode6->GetObject<Ipv4> ()); ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); } //ATTACH for (uint16_t i = 0; i < Nodes_device01.GetN (); i++) { lteHelper->Attach (ueDevs01.Get(i), enbDevs.Get(0)); //BEARER PADRÃO ATIVADO PARA CADA DISPOSITIVO } for (uint16_t i = 0; i < Nodes_device02.GetN (); i++) { lteHelper->Attach (ueDevs02.Get(i), enbDevs.Get(0)); //BEARER PADRÃO ATIVADO PARA CADA DISPOSITIVO } for (uint16_t i = 0; i < Nodes_device03.GetN (); i++) { lteHelper->Attach (ueDevs03.Get(i), enbDevs.Get(0)); //BEARER PADRÃO ATIVADO PARA CADA DISPOSITIVO } for (uint16_t i = 0; i < Nodes_device04.GetN (); i++) { lteHelper->Attach (ueDevs04.Get(i), enbDevs.Get(0)); //BEARER PADRÃO ATIVADO PARA CADA DISPOSITIVO } for (uint16_t i = 0; i < Nodes_device05.GetN (); i++) {

90

lteHelper->Attach (ueDevs05.Get(i), enbDevs.Get(0)); //BEARER PADRÃO ATIVADO PARA CADA DISPOSITIVO } for (uint16_t i = 0; i < Nodes_device06.GetN (); i++) { lteHelper->Attach (ueDevs06.Get(i), enbDevs.Get(0)); //BEARER PADRÃO ATIVADO PARA CADA DISPOSITIVO } if (modo_de_teste == 's') { if (config_nb_iot.modo == 1) { tipo01.frequencia_acesso = 1; tipo02.frequencia_acesso = 1; tipo03.frequencia_acesso = 1; tipo04.frequencia_acesso = 1; tipo05.frequencia_acesso = 1; tipo06.frequencia_acesso = 1; startapp01 = (config_nb_iot.tempo)/6; startapp02 = (config_nb_iot.tempo)/3; startapp03 = (config_nb_iot.tempo)/2; startapp04 = (config_nb_iot.tempo)/1.5; startapp05 = (config_nb_iot.tempo)/1.2; startapp06 = (config_nb_iot.tempo); //TEMPO MÍNIMO DE SIMULAÇÃO config_nb_iot.tempo = config_nb_iot.tempo + intervalo_pkt1; } if (config_nb_iot.modo == 2) { tipo01.frequencia_acesso = 1; tipo02.frequencia_acesso = 1; tipo03.frequencia_acesso = 1; tipo04.frequencia_acesso = 1; tipo05.frequencia_acesso = 1; tipo06.frequencia_acesso = 1; startapp01 = (config_nb_iot.tempo)/3; startapp02 = ((config_nb_iot.tempo)/3)+0.25; startapp03 = (config_nb_iot.tempo)/1.5; startapp04 = ((config_nb_iot.tempo)/1.5)+0.25; startapp05 = (config_nb_iot.tempo); startapp06 = (config_nb_iot.tempo)+0.25; //TEMPO MÍNIMO DE SIMULAÇÃO config_nb_iot.tempo = config_nb_iot.tempo + intervalo_pkt1; } if (config_nb_iot.modo == 3) { tipo01.frequencia_acesso = 1; tipo02.frequencia_acesso = 1; tipo03.frequencia_acesso = 1; tipo04.frequencia_acesso = 1; tipo05.frequencia_acesso = 1; tipo06.frequencia_acesso = 1; startapp01 = (0.5); startapp02 = (1.0); startapp03 = (1.5); startapp04 = (2.0); startapp05 = (2.5); startapp06 = (3.0); //TEMPO MÍNIMO DE SIMULAÇÃO config_nb_iot.tempo = config_nb_iot.tempo + 3; } } else { intervalo_pkt1 = (config_nb_iot.tempo)/(tipo01.frequencia_acesso); intervalo_pkt2 = (config_nb_iot.tempo)/(tipo02.frequencia_acesso);

91

intervalo_pkt3 = (config_nb_iot.tempo)/(tipo03.frequencia_acesso); intervalo_pkt4 = (config_nb_iot.tempo)/(tipo04.frequencia_acesso); intervalo_pkt5 = (config_nb_iot.tempo)/(tipo05.frequencia_acesso); intervalo_pkt6 = (config_nb_iot.tempo)/(tipo06.frequencia_acesso); //TEMPO MÍNIMO DE SIMULAÇÃO config_nb_iot.tempo = 1.1*config_nb_iot.tempo; } // INSTALAÇÃO E START DE APLICAÇÕES NOS DISPOSITIVOS uint16_t dlPort = 1234; uint16_t ulPort = 2000; uint16_t otherPort = 3000; ApplicationContainer serverApps; ApplicationContainer clientApps1; for (uint32_t u = 0; u < Nodes_device01.GetN (); ++u) { ++ulPort; ++otherPort; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), otherPort)); serverApps.Add (dlPacketSinkHelper.Install (Nodes_device01.Get(u))); serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); serverApps.Add (packetSinkHelper.Install (Nodes_device01.Get(u))); UdpClientHelper dlClient (ueIpIface01.GetAddress (u), dlPort); dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt1))); dlClient.SetAttribute ("MaxPackets", UintegerValue(tipo01.frequencia_acesso)); dlClient.SetAttribute ("PacketSize", UintegerValue(tipo01.tamanho)); UdpClientHelper ulClient (remoteHostAddr, ulPort); ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt1))); ulClient.SetAttribute ("MaxPackets", UintegerValue(tipo01.frequencia_acesso)); ulClient.SetAttribute ("PacketSize", UintegerValue(tipo01.tamanho)); UdpClientHelper client (ueIpIface01.GetAddress (u), otherPort); client.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt1))); client.SetAttribute ("MaxPackets", UintegerValue(tipo01.frequencia_acesso)); client.SetAttribute ("PacketSize", UintegerValue(tipo01.tamanho)); clientApps1.Add (dlClient.Install (remoteHost)); clientApps1.Add (ulClient.Install (Nodes_device01.Get(u))); if (u+1 < Nodes_device01.GetN ()) { clientApps1.Add (client.Install (Nodes_device01.Get(u+1))); } else { clientApps1.Add (client.Install (Nodes_device01.Get(0))); } } ApplicationContainer clientApps2; for (uint32_t u = 0; u < Nodes_device02.GetN (); ++u) { ++ulPort; ++otherPort; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), otherPort)); serverApps.Add (dlPacketSinkHelper.Install (Nodes_device02.Get(u))); serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); serverApps.Add (packetSinkHelper.Install (Nodes_device02.Get(u))); UdpClientHelper dlClient (ueIpIface02.GetAddress (u), dlPort); dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt2))); dlClient.SetAttribute ("MaxPackets", UintegerValue(tipo02.frequencia_acesso)); dlClient.SetAttribute ("PacketSize", UintegerValue(tipo02.tamanho)); UdpClientHelper ulClient (remoteHostAddr, ulPort); ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt2))); ulClient.SetAttribute ("MaxPackets", UintegerValue(tipo02.frequencia_acesso));

92

ulClient.SetAttribute ("PacketSize", UintegerValue(tipo02.tamanho)); UdpClientHelper client (ueIpIface02.GetAddress (u), otherPort); client.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt2))); client.SetAttribute ("MaxPackets", UintegerValue(tipo02.frequencia_acesso)); client.SetAttribute ("PacketSize", UintegerValue(tipo02.tamanho)); clientApps2.Add (dlClient.Install (remoteHost)); clientApps2.Add (ulClient.Install (Nodes_device02.Get(u))); if (u+1 < Nodes_device02.GetN ()) { clientApps2.Add (client.Install (Nodes_device02.Get(u+1))); } else { clientApps2.Add (client.Install (Nodes_device02.Get(0))); } } ApplicationContainer clientApps3; for (uint32_t u = 0; u < Nodes_device03.GetN (); ++u) { ++ulPort; ++otherPort; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), otherPort)); serverApps.Add (dlPacketSinkHelper.Install (Nodes_device03.Get(u))); serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); serverApps.Add (packetSinkHelper.Install (Nodes_device03.Get(u))); UdpClientHelper dlClient (ueIpIface03.GetAddress (u), dlPort); dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt3))); dlClient.SetAttribute ("MaxPackets", UintegerValue(tipo03.frequencia_acesso)); dlClient.SetAttribute ("PacketSize", UintegerValue(tipo03.tamanho)); UdpClientHelper ulClient (remoteHostAddr, ulPort); ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt3))); ulClient.SetAttribute ("MaxPackets", UintegerValue(tipo03.frequencia_acesso)); ulClient.SetAttribute ("PacketSize", UintegerValue(tipo03.tamanho)); UdpClientHelper client (ueIpIface03.GetAddress (u), otherPort); client.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt3))); client.SetAttribute ("MaxPackets", UintegerValue(tipo03.frequencia_acesso)); client.SetAttribute ("PacketSize", UintegerValue(tipo03.tamanho)); clientApps3.Add (dlClient.Install (remoteHost)); clientApps3.Add (ulClient.Install (Nodes_device03.Get(u))); if (u+1 < Nodes_device03.GetN ()) { clientApps3.Add (client.Install (Nodes_device03.Get(u+1))); } else { clientApps3.Add (client.Install (Nodes_device03.Get(0))); } } ApplicationContainer clientApps4; for (uint32_t u = 0; u < Nodes_device04.GetN (); ++u) { ++ulPort; ++otherPort; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), otherPort)); serverApps.Add (dlPacketSinkHelper.Install (Nodes_device04.Get(u))); serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); serverApps.Add (packetSinkHelper.Install (Nodes_device04.Get(u))); UdpClientHelper dlClient (ueIpIface04.GetAddress (u), dlPort); dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt4))); dlClient.SetAttribute ("MaxPackets", UintegerValue(tipo04.frequencia_acesso)); dlClient.SetAttribute ("PacketSize", UintegerValue(tipo04.tamanho)); UdpClientHelper ulClient (remoteHostAddr, ulPort);

93

ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt4))); ulClient.SetAttribute ("MaxPackets", UintegerValue(tipo04.frequencia_acesso)); ulClient.SetAttribute ("PacketSize", UintegerValue(tipo04.tamanho)); UdpClientHelper client (ueIpIface04.GetAddress (u), otherPort); client.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt4))); client.SetAttribute ("MaxPackets", UintegerValue(tipo04.frequencia_acesso)); client.SetAttribute ("PacketSize", UintegerValue(tipo04.tamanho)); clientApps4.Add (dlClient.Install (remoteHost)); clientApps4.Add (ulClient.Install (Nodes_device04.Get(u))); if (u+1 < Nodes_device04.GetN ()) { clientApps4.Add (client.Install (Nodes_device04.Get(u+1))); } else { clientApps4.Add (client.Install (Nodes_device04.Get(0))); } } ApplicationContainer clientApps5; for (uint32_t u = 0; u < Nodes_device05.GetN (); ++u) { ++ulPort; ++otherPort; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), otherPort)); serverApps.Add (dlPacketSinkHelper.Install (Nodes_device05.Get(u))); serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); serverApps.Add (packetSinkHelper.Install (Nodes_device05.Get(u))); UdpClientHelper dlClient (ueIpIface05.GetAddress (u), dlPort); dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt5))); dlClient.SetAttribute ("MaxPackets", UintegerValue(tipo05.frequencia_acesso)); dlClient.SetAttribute ("PacketSize", UintegerValue(tipo05.tamanho)); UdpClientHelper ulClient (remoteHostAddr, ulPort); ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt5))); ulClient.SetAttribute ("MaxPackets", UintegerValue(tipo05.frequencia_acesso)); ulClient.SetAttribute ("PacketSize", UintegerValue(tipo05.tamanho)); UdpClientHelper client (ueIpIface05.GetAddress (u), otherPort); client.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt5))); client.SetAttribute ("MaxPackets", UintegerValue(tipo05.frequencia_acesso)); client.SetAttribute ("PacketSize", UintegerValue(tipo05.tamanho)); clientApps5.Add (dlClient.Install (remoteHost)); clientApps5.Add (ulClient.Install (Nodes_device05.Get(u))); if (u+1 < Nodes_device05.GetN ()) { clientApps5.Add (client.Install (Nodes_device05.Get(u+1))); } else { clientApps5.Add (client.Install (Nodes_device05.Get(0))); } } ApplicationContainer clientApps6; for (uint32_t u = 0; u < Nodes_device06.GetN (); ++u) { ++ulPort; ++otherPort; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); PacketSinkHelper ulPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), ulPort)); PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), otherPort)); serverApps.Add (dlPacketSinkHelper.Install (Nodes_device06.Get(u))); serverApps.Add (ulPacketSinkHelper.Install (remoteHost)); serverApps.Add (packetSinkHelper.Install (Nodes_device06.Get(u))); UdpClientHelper dlClient (ueIpIface06.GetAddress (u), dlPort); dlClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt6))); dlClient.SetAttribute ("MaxPackets", UintegerValue(tipo06.frequencia_acesso)); dlClient.SetAttribute ("PacketSize", UintegerValue(tipo06.tamanho));

94

UdpClientHelper ulClient (remoteHostAddr, ulPort); ulClient.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt6))); ulClient.SetAttribute ("MaxPackets", UintegerValue(tipo06.frequencia_acesso)); ulClient.SetAttribute ("PacketSize", UintegerValue(tipo06.tamanho)); UdpClientHelper client (ueIpIface06.GetAddress (u), otherPort); client.SetAttribute ("Interval", TimeValue (MilliSeconds(1000*intervalo_pkt6))); client.SetAttribute ("MaxPackets", UintegerValue(tipo06.frequencia_acesso)); client.SetAttribute ("PacketSize", UintegerValue(tipo06.tamanho)); clientApps6.Add (dlClient.Install (remoteHost)); clientApps6.Add (ulClient.Install (Nodes_device06.Get(u))); if (u+1 < Nodes_device06.GetN ()) { clientApps6.Add (client.Install (Nodes_device06.Get(u+1))); } else { clientApps6.Add (client.Install (Nodes_device06.Get(0))); } } cout << "----------------------------------------------------" << endl; cout << "INICIANDO AS APLICAÇÕES" << endl; cout << "EXECUTANDO AS SIMULAÇÕES" << endl; cout << "ENODEB - TOTAL CRIAD0S: " << enbDevs.GetN () << endl; cout << "DEVICES - TOTAL CRIADOS: " << total_devs << endl; cout << "TEMPO DE SIMULAÇÃO: " << config_nb_iot.tempo << " s" << endl; serverApps.Start (Seconds (0.1)); clientApps1.Start (Seconds (startapp01)); clientApps2.Start (Seconds (startapp02)); clientApps3.Start (Seconds (startapp03)); clientApps4.Start (Seconds (startapp04)); clientApps5.Start (Seconds (startapp05)); clientApps6.Start (Seconds (startapp06)); //FECHA O ARQUIVO DE POSIÇÃO fclose (fp); Simulator::Stop (Seconds (config_nb_iot.tempo)); lteHelper->EnableUlRxPhyTraces (); lteHelper->EnableMacTraces (); lteHelper->EnablePdcpTraces (); lteHelper->EnableRlcTraces (); Simulator::Run (); Simulator::Destroy (); return 0; }

95

ANEXO C – CÓDIGO MATLAB

%%TRABALHO FINAL DE GRADUAÇÃO %%CURSO DE ENGENHARIA ELÉTRICA %%GRADUANDOS: CARLOS EDUARDO DE ABREU VERCHAI E FELIPE DE BORTOLI %%ORIENTADOR: VALTER KLEIN JUNIOR %%NOVEMBRO DE 2018 %%CÓDIGO PARA TRATAMENTO DE INFORMAÇÕES RECEBIDAS DO NS-3 APÓS A SIMULAÇÃO DE ARQUITETURA DE REDE %%CONFIGURAÇÃO DO MATLAB clc; clear; close all; format long; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%ANALISE DE COMPORTAMENTO DO DOWNLOAD %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%IMPORTA OS ARQUIVOS %%CARREGA ARQUIVO DE SAÍDA GERADO PELO NS-3 filename = 'C:\PastaComp\DlPdcpStats.txt'; data = load (filename); %%CARREGA ARQUIVO COM OS PARÂMETROS DE REFERÊNCIA filename = 'C:\PastaComp\RefParametersDl.txt'; param = load (filename,'-ascii'); %%TRATA OS VALORES RECEBIDOS DO ARQUIVO %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%DELAY %%%%%%%%%%%%%%%%%%%%%%%%%%% %%APRESENTA O VALOR DO DELAY vector_delay(:,1) = data(:,4); vector_delay(:,2) = data(:,11); vector_delay(:,3) = data(:,13); vector_delay(:,4) = data(:,14); %%TOPOLOGIA GERAL delay_topology_mean = mean(vector_delay(:,2)); delay_topology_std = std(vector_delay(:,2)); delay_topology_var = var(vector_delay(:,2)); %VALORES MÁXIMO E MÍNIMOS delay_topology_mean_min = min(vector_delay(:,3)); delay_topology_mean_max = max(vector_delay(:,3)); %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%JITTER %%%%%%%%%%%%%%%%%%%%%%%%%%% %%APRESENTA O VALOR DO DELAY vector_jitter(:,1) = data(:,4); vector_jitter(:,2) = data(:,11); %%DESLOCA O VETOR DE DELAY PARA CALCULO DO JITTER (JITTER(N) = DELAY(N) - DELAY(N-1)) vector_jitter_cp = vector_jitter; vector_jitter_cp = sortrows(vector_jitter_cp,1); %%TRATAMENTO PARA CÁLCULO DO JITTER vector_jitter_cp_deloc(:,1) = [vector_jitter_cp(:,1); 0]; vector_jitter_cp_deloc(:,2) = [0; vector_jitter_cp(:,1)]; vector_jitter_calc(:,1) = [vector_jitter_cp(:,2); 0]; vector_jitter_calc(:,2) = [0; vector_jitter_cp(:,2)]; vector_jitter_calc(:,3) = abs(vector_jitter_calc(:,1) - vector_jitter_calc(:,2)); vector_jitter_cp_deloc(:,3) = vector_jitter_cp_deloc(:,1) - vector_jitter_cp_deloc(:,2); vec_pos_jitter_dl = find(vector_jitter_cp_deloc(:,3) ~= 0); vector_jitter_calc(vec_pos_jitter_dl,:)=[]; jitter_topology_mean = mean(vector_jitter_calc(:,3));

96

jitter_topology_std = std(vector_jitter_calc(:,3)); jitter_topology_var = var(vector_jitter_calc(:,3)); jitter_topology_mean_min = min(vector_jitter_calc(:,3)); jitter_topology_mean_max = max(vector_jitter_calc(:,3)); %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%PLOT DAS INFORMAÇOES %%%%%%%%%%%%%%%%%%%%%%%%%%% %%DELAY vector_ref_delay = [param(1,2) param(1,3)]; fig1 = figure(1); fig1.MenuBar = 'none'; fig1.ToolBar = 'none'; fig1.OuterPosition = [60 60 1200 700]; fig1.Name = 'Downlink - Delay e Jitter Análise'; subplot(2,2,1); pd = bar(([vector_ref_delay delay_topology_mean_min delay_topology_mean delay_topology_mean_max])*1000,'r'); set(gca, 'xticklabel',{'ParamMin', 'ParamMax', 'SimMin', 'SimMed', 'SimMax'}); axis([0 6 0 1100*max([vector_ref_delay delay_topology_mean_min delay_topology_mean delay_topology_mean_max])]); title('Delay Análise'); ylabel('Milisegundos'); %%PLOT DA CURVA CARACTERÍSTICA DO DELAY subplot(2,2,2); %plot([1:length(vector_delay(:,2))], (vector_delay(:,2).*1000),'r'); hist((vector_delay(:,2).*1000), (ceil(1000*(max(vector_delay(:,2))))-floor(1000*min(vector_delay(:,2))))); title('Histograma Delay'); ylabel('Eventos'); xlabel('Delay (ms)'); axis([floor(min(vector_delay(:,2).*1000)) ceil(max(vector_delay(:,2).*1000)) 0 1.1*max(hist((vector_delay(:,2).*1000), (ceil(1000*(max(vector_delay(:,2))))-floor(1000*min(vector_delay(:,2))))))]); %%JITTER vector_ref_jitter = param(1,1); subplot(2,2,3); pd = bar(([vector_ref_jitter jitter_topology_mean_min jitter_topology_mean jitter_topology_mean_max]).*1000,'B'); set(gca, 'xticklabel',{'ParamMed', 'SimMin', 'SimMed', 'SimMax'}); axis([0 5 0 1100*max([vector_ref_jitter jitter_topology_mean_min jitter_topology_mean jitter_topology_mean_max])]); title('Jitter Análise'); ylabel('Milisegundos'); %%PLOT DA CURVA CARACTERÍSTICA DO JITTER subplot(2,2,4); hist((vector_jitter_calc(:,3).*1000), (ceil(1000*(max(vector_jitter_calc(:,3))))-floor(1000*min(vector_jitter_calc(:,3))))); title('Histograma Jitter'); ylabel('Eventos'); xlabel('Jitter (ms)'); if (max(vector_jitter_calc(:,3)> 0)) axis([floor(min(vector_jitter_calc(:,3).*1000)) ceil(max(vector_jitter_calc(:,3).*1000)) 0 1.1*max(hist((vector_jitter_calc(:,3).*1000), (ceil(1000*(max(vector_jitter_calc(:,3))))-floor(1000*min(vector_jitter_calc(:,3))))))]); end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%ANALISE DE COMPORTAMENTO DO UPLOAD %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%Zera as variáveis clear; %%%IMPORTA OS ARQUIVOS %%CARREGA ARQUIVO DE SAÍDA GERADO PELO NS-3 filename = 'C:\PastaComp\UlPdcpStats.txt'; data = load (filename); filename = 'C:\PastaComp\UlRxPhyStats.txt'; data_error = load (filename); %%CARREGA ARQUIVO COM OS PARÂMETROS DE REFERÊNCIA filename = 'C:\PastaComp\RefParametersUl.txt'; param = load (filename,'-ascii');

97

%%TRATA OS VALORES RECEBIDOS DO ARQUIVO %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%DELAY %%%%%%%%%%%%%%%%%%%%%%%%%%% %%APRESENTA O VALOR DO DELAY vector_delay(:,1) = data(:,4); vector_delay(:,2) = data(:,11); vector_delay(:,3) = data(:,13); vector_delay(:,4) = data(:,14); %%APRESENTA O VALOR DE ERROS vector_erro(:,1) = data_error(:,3); vector_erro(:,2) = data_error(:,10); %%TOPOLOGIA GERAL delay_topology_mean = mean(vector_delay(:,2)); delay_topology_std = std(vector_delay(:,2)); delay_topology_var = var(vector_delay(:,2)); error_topology_perc = (1-(sum(vector_erro(:,2)))/length(vector_erro(:,2))); %VALORES MÁXIMO E MÍNIMOS delay_topology_mean_min = min(vector_delay(:,3)); delay_topology_mean_max = max(vector_delay(:,3)); %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%JITTER %%%%%%%%%%%%%%%%%%%%%%%%%%% vector_jitter = []; vector_jitter_cp= []; vector_jitter_cp_deloc = []; vector_jitter_calc = []; %%APRESENTA O VALOR DO DELAY vector_jitter(:,1) = data(:,4); vector_jitter(:,2) = data(:,11); %%DESLOCA O VETOR DE DELAY PARA CALCULO DO JITTER (JITTER(N) = DELAY(N) - DELAY(N-1)) vector_jitter_cp = vector_jitter; vector_jitter_cp = sortrows(vector_jitter_cp,1); %%TRATAMENTO PARA CÁLCULO DO JITTER vector_jitter_cp_deloc(:,1) = [vector_jitter_cp(:,1); 0]; vector_jitter_cp_deloc(:,2) = [0; vector_jitter_cp(:,1)]; vector_jitter_calc(:,1) = [vector_jitter_cp(:,2); 0]; vector_jitter_calc(:,2) = [0; vector_jitter_cp(:,2)]; vector_jitter_calc(:,3) = abs(vector_jitter_calc(:,1) - vector_jitter_calc(:,2)); vector_jitter_cp_deloc(:,3) = vector_jitter_cp_deloc(:,1) - vector_jitter_cp_deloc(:,2); vec_pos_jitter_ul = find(vector_jitter_cp_deloc(:,3) ~= 0); vector_jitter_calc(vec_pos_jitter_ul,:)=[]; jitter_topology_mean = mean(vector_jitter_calc(:,3)); jitter_topology_std = std(vector_jitter_calc(:,3)); jitter_topology_var = var(vector_jitter_calc(:,3)); jitter_topology_mean_min = min(vector_jitter_calc(:,3)); jitter_topology_mean_max = max(vector_jitter_calc(:,3)); %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%PLOT DAS INFORMAÇOES %%%%%%%%%%%%%%%%%%%%%%%%%%% %%DELAY vector_ref_delay = [param(1,2) param(1,3)]; fig2 = figure(2); fig2.MenuBar = 'none'; fig2.ToolBar = 'none'; fig2.OuterPosition = [60 60 1200 700]; fig2.Name = 'Uplink - Delay e Jitter Análise'; subplot(2,2,1); pd = bar(([vector_ref_delay delay_topology_mean_min delay_topology_mean delay_topology_mean_max])*1000,'r');

98

set(gca, 'xticklabel',{'ParamMin', 'ParamMax', 'SimMin', 'SimMed', 'SimMax'}); axis([0 6 0 1100*max([vector_ref_delay delay_topology_mean_min delay_topology_mean delay_topology_mean_max])]); title('Delay Análise'); ylabel('Milisegundos'); %%PLOT DA CURVA CARACTERÍSTICA DO DELAY subplot(2,2,2); %plot([1:length(vector_delay(:,2))], (vector_delay(:,2).*1000),'r'); hist((vector_delay(:,2).*1000), (ceil(1000*(max(vector_delay(:,2))))-floor(1000*min(vector_delay(:,2))))); title('Histograma Delay'); ylabel('Eventos'); xlabel('Delay (ms)'); axis([floor(min(vector_delay(:,2).*1000)) ceil(max(vector_delay(:,2).*1000)) 0 1.1*max(hist((vector_delay(:,2).*1000), (ceil(1000*(max(vector_delay(:,2))))-floor(1000*min(vector_delay(:,2))))))]); %%JITTER vector_ref_jitter = param(1,1); subplot(2,2,3); pd = bar(([vector_ref_jitter jitter_topology_mean_min jitter_topology_mean jitter_topology_mean_max]).*1000,'B'); set(gca, 'xticklabel',{'ParamMed', 'SimMin', 'SimMed', 'SimMax'}); axis([0 5 0 1100*max([vector_ref_jitter jitter_topology_mean_min jitter_topology_mean jitter_topology_mean_max])]); title('Jitter Análise'); ylabel('Milisegundos'); %%PLOT DA CURVA CARACTERÍSTICA DO JITTER subplot(2,2,4); hist((vector_jitter_calc(:,3).*1000), (ceil(1000*(max(vector_jitter_calc(:,3))))-floor(1000*min(vector_jitter_calc(:,3))))); title('Histograma Jitter'); ylabel('Eventos'); xlabel('Jitter (ms)'); if (max(vector_jitter_calc(:,3)> 0)) axis([floor(min(vector_jitter_calc(:,3).*1000)) ceil(max(vector_jitter_calc(:,3).*1000)) 0 1.1*max(hist((vector_jitter_calc(:,3).*1000), (ceil(1000*(max(vector_jitter_calc(:,3))))-floor(1000*min(vector_jitter_calc(:,3))))))]); end %%TAXA DE ERRO vector_ref_error = [param(1,4)]; fig3 = figure(3); fig3.MenuBar = 'none'; fig3.ToolBar = 'none'; fig3.OuterPosition = [60 60 1200 700]; fig3.Name = 'Uplink - Análise de Taxa de Erro'; vet = 100*[vector_ref_error error_topology_perc]; pd = bar((100*[vector_ref_error error_topology_perc]),'k'); text(1:length(vet),vet,num2str(vet'),'vert','bottom','horiz','center'); set(gca, 'xticklabel',{'Parâmetro de Referência', 'Erros ocorridos durante a Simulação'}) axis([0 3 0 110*max([vector_ref_error(1,1) error_topology_perc(1,1)])]); title('Análise Taxa de Erro') ylabel('% erros') %%%THROUGHPUT %%%IMPORTA OS ARQUIVOS %%CARREGA ARQUIVO DE SAÍDA GERADO PELO NS-3 %%%%%%%%%%%%%% %%UPLINK %%%%%%%%%%%%%% filename = 'C:\PastaComp\UlRlcStats.txt'; data_ul = load (filename); %%AGRUPAMENTO DO TRÁFEGO POR SLOT DE TEMPO DA SIMULAÇÃO data_ul_deslocado(:,1) = [data_ul(:,2); 0]; data_ul_deslocado(:,2) = [0; data_ul(:,2)]; data_ul_deslocado(:,3) = data_ul_deslocado(:,1) - data_ul_deslocado(:,2); vec_pos_ul = find(data_ul_deslocado(:,3) ~= 0); vec_throughput_ul = []; %%MONTAGEM DE VETOR CONTENDO O PONTOS DE TEMPO E TRÁFEGO for (i=1:length(vec_pos_ul)-1) vec_throughput_ul(1,i) = data_ul_deslocado(vec_pos_ul(i,1),1); vec_aux = data_ul(vec_pos_ul(i,1):(vec_pos_ul(i+1,1))-1,10); vec_throughput_ul(2,i) = sum(vec_aux); end

99

%%PLOTA GRÁFICO DE THROUGHPUT DO UPLINK vec_throughput_ul(2,:) = vec_throughput_ul(2,:).*8./1000; fig4 = figure(4); fig4.MenuBar = 'none'; fig4.ToolBar = 'none'; fig4.OuterPosition = [60 60 1200 700]; fig4.Name = 'Throughput - eNodeB - Uplink'; plot(vec_throughput_ul(1,:), vec_throughput_ul(2,:), '-*') axis([0 1.1*max(vec_throughput_ul(1,:)) 0 1.1*max(vec_throughput_ul(2,:))]) title('Throughput - eNodeB - Uplink') ylabel('Tráfego [KB]') xlabel('Tempo [s]') title('Throughput - eNodeB - Uplink') %%%%%%%%%%%%%% %%DOWNLINK %%%%%%%%%%%%%% filename = 'C:\PastaComp\DlRlcStats.txt'; data_dl = load (filename); %%AGRUPAMENTO DO TRÁFEGO POR SLOT DE TEMPO DA SIMULAÇÃO data_dl_deslocado(:,1) = [data_dl(:,2); 0]; data_dl_deslocado(:,2) = [0; data_dl(:,2)]; data_dl_deslocado(:,3) = data_dl_deslocado(:,1) - data_dl_deslocado(:,2); vec_pos_dl = find(data_dl_deslocado(:,3) ~= 0); vec_throughput_dl = []; %%MONTAGEM DE VETOR CONTENDO O PONTOS DE TEMPO E TRÁFEGO for (i=1:length(vec_pos_dl)-1) vec_throughput_dl(1,i) = data_dl_deslocado(vec_pos_dl(i,1),1); vec_aux = data_dl(vec_pos_dl(i,1):(vec_pos_dl(i+1,1))-1,10); vec_throughput_dl(2,i) = sum(vec_aux); end %%PLOTA GRÁFICO DE THROUGHPUT DO DOWNLINK vec_throughput_dl(2,:) = vec_throughput_dl(2,:).*8./1000; fig5 = figure(5); fig5.MenuBar = 'none'; fig5.ToolBar = 'none'; fig5.OuterPosition = [60 60 1200 700]; fig5.Name = 'Throughput - eNodeB - Downlink'; plot(vec_throughput_dl(1,:), vec_throughput_dl(2,:), '-*') axis([0 1.1*max(vec_throughput_dl(1,:)) 0 1.1*max(vec_throughput_dl(2,:))]) title('Throughput - eNodeB - Downlink') ylabel('Tráfego [KB]') xlabel('Tempo [s]') title('Throughput - eNodeB - Downlink') %%%POSIÇÕES %%%IMPORTA OS ARQUIVOS %%CARREGA ARQUIVO DE POSIÇÕES GERADO PELO NS-3 filename = 'C:\PastaComp\Position.txt'; arq = importdata(filename, '\t', 1); %%TRATA OS VALORES RECEBIDOS DO ARQUIVO [cord_pol(:,1), cord_pol(:,2)] = cart2pol(arq.data(:,3), arq.data(:,4)); cord_pol = cord_pol'; cord_pol(3,:) = arq.data(:,1); %%CALCULA AS POSIÇÃO POSIÇÕES, COMO MÓDULO E ÂNGULO E MÓDULO, PARA O SENSOR DE TIPO 01 posmin = min(find(cord_pol(3,:) == 1)); posmax = max(find(cord_pol(3,:) == 1)); cord_pol1 = cord_pol(1:2,posmin:posmax); %%CALCULA AS POSIÇÃO POSIÇÕES, COMO MÓDULO E ÂNGULO E MÓDULO, PARA O SENSOR DE TIPO 02 posmin = min(find(cord_pol(3,:) == 2)); posmax = max(find(cord_pol(3,:) == 2)); cord_pol2 = cord_pol(1:2,posmin:posmax); %%CALCULA AS POSIÇÃO POSIÇÕES, COMO MÓDULO E ÂNGULO E MÓDULO, PARA O SENSOR DE TIPO 03 posmin = min(find(cord_pol(3,:) == 3)); posmax = max(find(cord_pol(3,:) == 3)); cord_pol3 = cord_pol(1:2,posmin:posmax); %%CALCULA AS POSIÇÃO POSIÇÕES, COMO MÓDULO E ÂNGULO E MÓDULO, PARA O SENSOR DE TIPO 04 posmin = min(find(cord_pol(3,:) == 4)); posmax = max(find(cord_pol(3,:) == 4)); cord_pol4 = cord_pol(1:2,posmin:posmax);

100

%%CALCULA AS POSIÇÃO POSIÇÕES, COMO MÓDULO E ÂNGULO E MÓDULO, PARA O SENSOR DE TIPO 05 posmin = min(find(cord_pol(3,:) == 5)); posmax = max(find(cord_pol(3,:) == 5)); cord_pol5 = cord_pol(1:2,posmin:posmax); %%CALCULA AS POSIÇÃO POSIÇÕES, COMO MÓDULO E ÂNGULO E MÓDULO, PARA O SENSOR DE TIPO 06 posmin = min(find(cord_pol(3,:) == 6)); posmax = max(find(cord_pol(3,:) == 6)); cord_pol6 = cord_pol(1:2,posmin:posmax); %%PLOTAGEM DA ÁREA DE COBERTURA DA ENODEB fig6 = figure(6); fig6.MenuBar = 'none'; fig6.ToolBar = 'none'; fig6.OuterPosition = [60 60 1200 700]; fig6.Name = 'Distribuição dos Dispositivos'; polarplot(0, 0, 'r square') ax = gca; rng('default'); ax.ThetaTick = 0:45:360; ax.ThetaZeroLocation = 'right'; ax.ThetaDir = 'counterclockwise'; ax.ThetaTickLabels = {'E','NE','N','NW', 'W','SW','S','SE'}; ax.RTickLabel = []; rlim([0 600]); thetalim([0 360]); hold on; polarplot(cord_pol1(1,:), cord_pol1(2,:), 'b o'); polarplot(cord_pol2(1,:), cord_pol2(2,:), 'g o'); polarplot(cord_pol3(1,:), cord_pol3(2,:), 'k o'); polarplot(cord_pol4(1,:), cord_pol4(2,:), 'm o'); polarplot(cord_pol5(1,:), cord_pol5(2,:), 'y o'); polarplot(cord_pol6(1,:), cord_pol6(2,:), 'c o'); legend('eNodeB','Sensor Tipo 01','Sensor Tipo 02','Sensor Tipo 03','Sensor Tipo 04','Sensor Tipo 05','Sensor Tipo 06');

101

ANEXO D - MANUAL DE OPERAÇÃO

PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ

ESCOLA POLITÉCNICA

CURSO DE ENGENHARIA ELÉTRICA

CARLOS EDUARDO DE ABREU VERCHAI

FELIPE DE BORTOLI


MANUAL DE OPERAÇÃO

Curitiba - Paraná

2018

LISTA DE ILUSTRAÇÕES

Figura 1 - Local de armazenamento do arquivo .......................................................... 9

Figura 2 - Tela inicial da aplicação ............................................................................ 10

Figura 3 - Configuração sem modo pré-definido ....................................................... 11

Figura 4 - Configuração com modo pré-definido ....................................................... 13

Figura 5 - Arquivos alocados na pasta PastaComp .................................................. 15

Figura 6 - Código do Matlab para análise ................................................................. 16

Figura 7 - Distribuição dos devices ........................................................................... 16

Figura 8 - Gráfico de Throughput para Downlink ...................................................... 17

Figura 9 - Gráfico de Throughput para Uplink ........................................................... 17

Figura 10 - Gráfico de taxa de erros.......................................................................... 18

Figura 11 - Gráficos de desempenho de uplink ......................................................... 18

Figura 12 - Gráficos de desempenho de downlink .................................................... 19

Figura 13 - Código NS-3 editado no Notepad++ ....................................................... 20

Figura 13 - Código matlab.m editado software Matlab .............................................. 21

LISTA DE TABELAS

Tabela 1 - Lista de softwares ...................................................................................... 5

3

SUMÁRIO

1 INTRODUÇÃO ........................................................................................................ 4

2 CARACTERÍSTICAS E VERSÕES DE HARDWARE ............................................ 5

3 DOWNLOAD E INSTALAÇÃO DO SOFTWARE ................................................... 6

3.1 DOWNLOAD NS-3 .............................................................................................. 6

4 COMPILAÇÃO DO ARQUIVO E SIMULAÇÃO ...................................................... 9

4.1 COMPILAÇÃO .................................................................................................... 9

4.2 SIMULAÇÃO ..................................................................................................... 10

5 ANÁLISE DE DESEMPENHO .............................................................................. 15

5.1 ANÁLISE ........................................................................................................... 16

6 CÓDIGOS ............................................................................................................. 20

6.1 NB-IOT.CC........................................................................................................ 20

6.2 MATLAB.M........................................................................................................ 21

7 REFERÊNCIAS .................................................................................................... 22

4

1 INTRODUÇÃO

Este documento foi elaborado para detalhar a forma de utilização da aplicação

desenvolvida para testes de redes NB-IoT, utilizando como base da aplicação o

software NS-3.

É objetivo deste documento apresentar, passo a passo, o processo de

instalação, compilação e realização de testes, de modo que qualquer usuário consiga

utilizar a aplicação desenvolvida para efetuar testes, conforme a sua necessidade.

Pelo fato da aplicação ser open source, baseada nos termos GNU GLP, o

código fonte da aplicação é aberto e pode ser utilizado por qualquer pessoa. Assim

sendo, serão abortados aspectos genéricos sobre o código, para permitir adequações,

caso necessário.

5

2 CARACTERÍSTICAS E VERSÕES DE HARDWARE

Para permitir aos usuários reproduzirem os mesmos cenários de testes

adotados durante o desenvolvimento, a seguir são listados os softwares utilizados,

bem com as versões em que as aplicações foram validadas.

SOFTWARES UTILIZADOS

Software Versão Url

Ubuntu 16.04.4 LTS https://www.ubuntu.com/download/des

ktop

NS-3 3.13 https://www.nsnam.org/

Matlab 9.0.0.341360 (R2016a) https://www.mathworks.com/products/

matlab.html

Windows Win7 Professional (SP1) https://www.microsoft.com/pt-

br/software-download/

Virtual

Box

Versão 5.1.28 r117968

(Qt5.6.2)

https://www.virtualbox.org/

Tabela 1 - Lista de softwares

Com a apresentação destas informações, é possível que os usuários busquem

as ferramentas necessárias para compreender e reproduzir os demais itens neste

documento.

6

3 DOWNLOAD E INSTALAÇÃO DO SOFTWARE

A execução do software NS-3 necessita ser realizada em uma máquina que

utilize sistema operacional Linux. Como apresentado anteriormente, o sistema

utilizado para estes testes foi o Ubuntu. Este sistema operacional foi utilizado de modo

virtualizado, visto a praticidade deste processo.

Para realizar a virtualização deste sistema operacional, utilizou-se o VirtualBox,

da Oracle.

Consideraremos, a partir de agora, que o usuário possuí a máquina virtual

Ubuntu em operação, ou seja, com todo o processo de virtualização finalizado. Este

passo a passo não será abordado neste documento pelo fato de não ser foco e por

existirem outros tutoriais destinados a este fim.

3.1 DOWNLOAD NS-3

Na sequência deste documento, são apresentados todos os comandos

necessários para realização de instalação, tanto do NS-3 quanto dos softwares

utilitários.

Abaixo são apresentados todos os pacotes que são recomendados para

instalação. Eles não formam o núcleo do NS-3, mas são importantes ferramentas que

podem auxiliar os desenvolvedores.

C++ e Python:

>sudo apt-get install gcc g++ python python-dev

Mercurial:

>sudo apt-get install mercurial

Árvore de desenvolvedores ns-3:

>sudo apt-get install bzr

Debugging:

>sudo apt-get install gdb valgrind

7

Modelos de erro para WiFi:

>sudo apt-get install gsl-bin libgsl0-dev libgsl0ldbl

Analisador léxico e parser:

>sudo apt-get install flex bison libfl-dev

Traces pcap:

>sudo apt-get install tcpdump

Database para estatística:

>sudo apt-get install sqlite sqlite3 libsqlite3-dev

Xml:

>sudo apt-get install libxml2 libxml2-dev

GTK:

>sudo apt-get install libgtk2.0-0 libgtk2.0-dev

Máquinas virtuais:

>sudo apt-get install vtun lxc

Utilitários:

>sudo apt-get install uncrustify

Documentação:

>sudo apt-get install doxygen graphviz imagemagick texlive texlive-extra-utils

texlive-latex-extra python-sphinx dia

Visualizador:

>sudo apt-get install python-pygraphviz python-kiwi python-pygoocanvas

libgoocanvas-dev

Openflow:

>sudo apt-get install libboost-signals-dev libboost-filesystem-dev

8

Emulador:

>sudo apt-get install openmpi*

A realização do download do núcleo do NS-3 é apresentada a seguir, onde,

através dos comandos, o NS-3 será instalado na máquina virtualizada, rodando o SO

Ubuntu.

>cd; mkdir repos; cd repos

>hg clone http://code.nsnam.org/ns-3-allinone

>./download.py -n ns-3-dev

>ls -la

Para complicação das aplicações geradas utilizando o NS-3, é necessário

baixar compilador para estas funções. A seguir, os comandos necessários para este

fim são apresentados.

>cd ns-3-allinone

>./build.py –enable-examples –enable-tests

>cd ns-3-dev; ls -la

9

4 COMPILAÇÃO DO ARQUIVO E SIMULAÇÃO NO NS-3

A aplicação de “Testes de Redes NB-IoT” foi codificada em linguagem de

programação C++ e o arquivo foi nomeado como “NB-IoT.cc”.

Este arquivo deve estar localizado na pasta “/home/tcc01/repos/ns-3-

allinone/ns-3-dev/TCC”. Inicialmente esta pasta não existia, e foi criado pelos

desenvolvedores para armazenar o arquivo de configuração do software.

Figura 1 - Local de armazenamento do arquivo

4.1 COMPILAÇÃO

Na primeira vez em que a simulação for executada, ou sempre que houver uma

alteração do código fonte, será necessário realizar a compilação do arquivo.

O processo de compilação é realizado em 2 passos, apresentados a seguir;

1. Copiar arquivo para o local de destino

Comando: cp TCC/NB_IoT.cc Scratch/NB_IoT.cc

10

2. Compila o arquivo

Comando: ./waf

Após a realização destes comandos, sem a geração de erros, a aplicação está

apta para rodar.

4.2 SIMULAÇÃO

A simulação somente poderá ser realizada após o arquivo ter sido compilado

(vide item 4.1).

Para executar a aplicação desenvolvida, o seguinte comando é necessário.

1. Executa a aplicação

Comando: ./waf --run scratch/NB-IoT

A partir da execução desta linha de comando a aplicação será iniciada e a

seguinte tela será apresentada:

Figura 2 - Tela inicial da aplicação

Modo de testes pré-definidos [s/n]: Este parâmetro do sistema permite ao

usuário configurar um modo pré-definido de testes. Os demais parâmetros da

simulação serão apresentados ou não de acordo com a opção selecionada.

11

Caso seja selecionada a opções “s” para este parâmetro, no grupo de

parâmetros 9, será solicitado o modo da simulação pré-definida.

Os dados a serem inseridos são estabelecidos pela entidade usuário, de acordo

com os seguintes tipos:

Quantidade de sensores: define efetivamente a quantidade de cada tipo de

sensor que terá acesso à rede;

Tamanho do pacote de dados dos sensores: define, de acordo com o tipo do

sensor, o tamanho e quantidade de dados necessários para transmissão;

Frequência de acesso dos sensores à rede: define, de acordo com a

necessidade de cada sensor, a frequência com a qual o sensor se conectará a

rede, e fará o envio de dados (este parâmetro somente estará disponível caso

o setup 1 – Modo de testes, estiver configurado com a opção “n”);

A Figura 3 apresenta os parâmetros disponíveis quando selecionado o modo

não pré-definido.

Figura 3 - Configuração sem modo pré-definido

12

Definição do modo de Simulação: Este parâmetro permite ao usuário

determinar qual dos 3 modos pré-definidos será utilizado.

o Baixo – Distribui o acesso em slots de tempo para cada um dos 6 tipos

de sensores existentes. Envia 1 pacote dentro do período de simulação

para cada sensor. Ex: 1200 segundos de simulação, distribui o acesso

a rede a cada 200 segundos. Assim, no tempo de 200 segundos, o tipo

1 de sensores enviará seus pacotes, no tempo 400 segundos, o tipo 2

enviará seus pacotes e assim sucessivamente.

o Normal – Distribui o acesso em slots de tempo de modo a agrupar os

sensores de 2 em 2 tipos de sensores existentes. Envia 1 pacote por

sensor dentro do período de simulação. Ex: 1200 segundos de

simulação, distribui o acesso a rede a cada 400 segundos. Assim, no

tempo de 400 segundos, o tipo 1 e tipo 2 de sensores enviarão seus

pacotes, no tempo 800 segundos, o tipo 3 e tipo 4 enviarão seus pacotes

e assim sucessivamente.

o Avalanche – Distribui o acesso em um único slot de tempo de modo a

agrupar todos os tipos de sensores existentes. Envia 1 pacote por

sensor dentro do período de simulação. Ex: 1200 segundos de

simulação, todos os dispositivos enviarão seus pacotes no startup da

aplicação, ou seja, no segundo 0. O tempo restante de simulação não

será utilizado como slot para envio de informação.

13

Figura 4 - Configuração com modo pré-definido

Os setups do sistema de Testes de Redes NB-IoT poderão ser inseridos

respeitando os seguintes limites:

1. Modo de pré-definido

a. Opção 1: “s” – Sim

b. Opção 2: “n” – Não

2. Tempo de Simulação

a. Mínimo: 1 segundos

b. Máximo: 7199 segundos

3. Quantidade de devices

a. Mínimo: 1 segundos

b. Máximo: 299 segundos

4. Tamanho do payload

14

a. Mínimo: 21 Bytes

b. Máximo: 512 Bytes

5. Frequência de acesso

a. Mínimo: 1

b. Máximo: 2*Tempo de Simulação

6. Modo de Simulação

a. Opção 1: 1 – Baixa

b. Opção 2: 2 –Normal

c. Opção 3: 3 – Avalanche

Os arquivos gerados durante o processo de simulação são:

1. Position.txt

2. UlMacStat.txt

3. DlMacStat.txt

4. UlRxPhyStat.txt

5. DlRxPhyStat.txt

6. UlTxPhyStat.txt

7. DlTxPhyStat.txt

8. UlPdcpStat.txt

9. DlPdcpStat.txt

10. UlRlcStat.txt

11. DlRlcStat.txt

Estes arquivos estão localizados no caminho “/home/tcc01/repos/ns-3-

allinone/ns-3-dev”.

15

5 ANÁLISE DE DESEMPENHO

Para a análise de desempenho da rede, o software Matlab é utilizado.

Diferentemente do NS-3, ele foi executado sobre o sistema operacional Windows 7.

A análise é efetuada com base nos seguintes arquivos gerados pelo NS-3.

1. Position.txt

2. UlRxPhyStat.txt

3. UlPdcpStat.txt

4. DlPdcpStat.txt

5. UlRlcStat.txt

6. DlRlcStat.txt

Os usuários deverão, assim que o processo de simulação for finalizado, copiar

estes arquivos listados para a seguinte pasta: “C:/PastaComp”. Caso esta pasta não

exista em seu sistema operacional, ela deverá ser criada.

Além dos arquivos listados acima, é necessário estar presente na pasta dois

arquivos que contém os parâmetros de referência para serem plotados a fins de

comparação. Estes arquivos são listados abaixo:

1. RefParametersUl.txt

2. RefParametersDl.txt

Figura 5 - Arquivos alocados na pasta PastaComp

16

5.1 ANÁLISE

Para que os resultados possam ser compilados e apresentados de forma mais

amigável, o arquivo “Matlab.m” deve ser aberto e executados pelo usuário.

Figura 6 - Código do Matlab para análise

Os resultados gerados em cada uma das simulações são apresentados e

detalhados na sequência.

Figura 7 - Distribuição dos devices

Apresenta a distribuição dos devices na área de cobertura da eNodeB.

17

Figura 8 - Gráfico de Throughput para Downlink

Gráfico para análise do tráfego de downlink na eNodeB.

Figura 9 - Gráfico de Throughput para Uplink

Gráfico para análise do tráfego de uplink na eNodeB.

18

Figura 10 - Gráfico de taxa de erros

Gráfico para taxa de erros existente na simulação.

Figura 11 - Gráficos de desempenho de uplink

Gráfico para análise de comportamento de jitter e delay no Uplink.

19

Figura 12 - Gráficos de desempenho de downlink

Gráfico para análise de comportamento de jitter e delay no Downlink.

20

6 CÓDIGOS

Os códigos dos aplicativos do Matlab e do NS-3, bem como os demais arquivos

necessários, estão localizados no seguinte link:

https://drive.google.com/drive/folders/1GbQ8tsOqeqLXg5yDgHRN9rRUWJToNbq-

?usp=sharing

6.1 NB-IOT.CC

Este arquivo deve ser utilizado para rodar o NS-3, conforme relatado no item 4.

Ele foi desenvolvido utilizando linguagem de programação C++. Deste modo, pode-se

editá-lo em qualquer software de edição de texto, sem a necessidade de compilação

em uma IDE especifica.

Figura 13 - Código NS-3 editado no Notepad++

Para alterações no código, recomenda-se fortemente o conhecimento na

linguagem C++ e sobre os conceitos de estrutura do NS-3.

https://drive.google.com/drive/folders/1GbQ8tsOqeqLXg5yDgHRN9rRUWJToNbq-?usp=sharing

https://drive.google.com/drive/folders/1GbQ8tsOqeqLXg5yDgHRN9rRUWJToNbq-?usp=sharing

21

6.2 MATLAB.M

Este arquivo deve ser utilizado para rodar o sistema de análise de desempenho

no Matlab. conforme relatado no item 5. Ele foi desenvolvido utilizando linguagem de

programação M-código, padrão do software, porém, além da edição do Matlab, o

arquivo pode ser manipulado em qualquer software de edição de texto.

Figura 14 - Código matlab.m editado software Matlab

Para alterações no código, recomenda-se fortemente o conhecimento na

linguagem utilizada pelo Matlab bem como o formato dos arquivos gerados pelo NS-

3.

22

7 REFERÊNCIAS

[1] MATLAB, Suporte. <https://www.mathworks.com/help/matlab/>. Acesso em 16/11/2018. [2] NS-3, NS-3 Documentation.<https://www.nsnam.org/doxygen/>. Acesso em 16/11/2018.

SISTEMA DE TESTES DE REDES NB-IOT E ANÁLISE DE...

Documents

Transcript of SISTEMA DE TESTES DE REDES NB-IOT E ANÁLISE DE...