Mudanças entre as edições de "ADS29009-2019-2"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
 
(53 revisões intermediárias por 2 usuários não estão sendo mostradas)
Linha 232: Linha 232:
  
 
==Módulo de Processamento Autônomo==
 
==Módulo de Processamento Autônomo==
 +
 +
<code>
 +
 +
#include <stdio.h>
 +
#include <sys/time.h>
 +
 +
//classe baseada no geekforgeeks
 +
 +
class t_duracao {
 +
    public:
 +
        void iniciar_medicao() {
 +
            gettimeofday(&start, NULL);
 +
        }
 +
        void finalizar_medicao(){
 +
            gettimeofday(&end, NULL);
 +
            time_taken = (end.tv_sec - start.tv_sec) * 1e6;
 +
            time_taken = (time_taken + (end.tv_usec -
 +
                                        start.tv_usec)) * 1e-6;
 +
        }
 +
        void mostrar_tempo(){
 +
            printf("valor de tempo = %lf", time_taken);
 +
 +
        }
 +
        float retornar_tempo(){
 +
            return time_taken;
 +
        }
 +
 +
    private:
 +
        double time_taken;
 +
        struct timeval start, end;
 +
} tempo_estimado;
 +
 +
 +
float computar_desloc_x()
 +
{
 +
  float d;
 +
 
 +
  d = 10+20*uniforme(); // uniforme retorna entre 0 e 1 - no minimo andará 10cm e no máximo 30 cm
 +
  return d;
 +
}
 +
 +
float computar_lateral(float meu_y, float meu_desloc)
 +
{
 +
  float lat;
 +
 +
  lat = seno (0.042*meu_desloc) * 50; /* amplitude máxima 50 cm
 +
  return lat-meu_y;
 +
}
 +
 +
main()
 +
{
 +
  receive(max_x,max_y);
 +
  tempo_estimado.iniciar_medicao();
 +
  x=0; //valor absoluto do movimento na direção x
 +
  desloc_x=0;
 +
  y=0; //valor absoluto do movimento na direção y
 +
  desloc_y=0;
 +
  while (x<max_x) {
 +
    //computar movimento para frente
 +
    desloc_x=computar_desloc_x();
 +
    x = desloc_x + x;
 +
    //andar para frente
 +
    movimento_avante(desloc);
 +
    //computar movimento lateral
 +
    desloc_y=computar_lateral(y, x);
 +
    y=y+desloc_y;
 +
    movimento_lateral(desloc_y);
 +
    rotacionar_frente();
 +
  }
 +
  finaliza_movimento();
 +
  tempo_estimado.finalizar_medicao();
 +
  send_annswer(tempo_estimado.retornar_tempo());
 +
}
 +
</syntaxhighlight>
 +
 +
<>
 +
uniforme()*10+10;
 +
<>
  
 
==Referências==
 
==Referências==
Linha 263: Linha 341:
  
 
https://www.dropbox.com/s/jycdd2dzqqsxb5g/FilaMM1_CapacidadeLimitada.pdf?dl=0
 
https://www.dropbox.com/s/jycdd2dzqqsxb5g/FilaMM1_CapacidadeLimitada.pdf?dl=0
 +
 +
=AULA 16 - Dia 08/10/2019=
 +
 +
==Objetivos==
 +
 +
*Aula antecipada para tratar o experimento do rob
 +
*Geração de Números Randômicos na Simulação
 +
 +
==Material de Referência==
 +
 +
*[https://www.dropbox.com/s/c221v4hlfdrpc1n/GeracaoNumerosRandomicosSimulacao.pdf?dl=0]
 +
 +
=AULA 17 - Dia 11/10/2019=
 +
 +
==Objetivos==
 +
 +
*finalização da classe de geração randômica de números;
 +
*construção do módulo autônomo do robô usando geração randômica.
 +
 +
==Links interessantes==
 +
 +
*[https://www.geeksforgeeks.org/measure-execution-time-with-high-precision-in-c-c/ Medição de Tempo no C]
 +
 +
 +
=AULA 18 - Dia 18/10/2019=
 +
 +
 +
==Objetivos==
 +
 +
*PARTE 1
 +
**Introdução a Simulação a Eventos Discretos
 +
**Exemplo de simulação e estatística de uma fila MM1
 +
 +
*PARTE 2
 +
**Preparação do robô para Feira de Ciências e Tecnologia
 +
 +
==Material de referência==
 +
 +
*[https://www.dropbox.com/s/amamol54anyxndj/SimulacaoAEventosDiscretos.pdf?dl=0 Slides de Introdução a Simulação a Eventos Discretos]
 +
 +
=AULA 19 - Dia 22/10/2019=
 +
 +
PALESTRA - IOT - IPTV
 +
 +
=AULA 20 - Dia 25/10/2019=
 +
 +
==Objetivos==
 +
 +
*Estudo de uma Implementação de um Simulador a Eventos Discretos;
 +
 +
==Material de Referência==
 +
 +
*Ver [http://stdcxx.apache.org/doc/stdlibug/11-3.html Projeto Apache]
 +
*Proposição de Exercício: simulação de uma rede de filas;
 +
 +
 +
#Adaptar o código de tratamento de uma fila MM1 simples, conforme colocado no slide para um formato de um simulador de eventos discretos com filas. Use o código abaixo como apoio.
 +
 +
<syntaxhighlight lang=c>
 +
//Basead em http://stdcxx.apache.org/doc/stdlibug/2-2.html#225
 +
 +
#include <queue>
 +
#include <iostream>
 +
#include <cstdlib>
 +
 +
//==================================================================
 +
// classes evento e simulação - base para o desenvolvimento da simulação
 +
//==================================================================
 +
 +
class event {
 +
public:
 +
  // Construct sets time of event.
 +
  event (double t) : time (t)
 +
    { }
 +
 +
  // Execute event by invoking this method.
 +
  virtual void processEvent () = 0;
 +
 +
  const double time;
 +
};
 +
 +
 +
class simulation {
 +
public:
 +
  simulation () : simtime (0), eventQueue ()
 +
    {}
 +
  void run ();
 +
  void  scheduleEvent (event * newEvent) {
 +
    eventQueue.push (newEvent);
 +
  }
 +
  double simtime;
 +
protected:
 +
  class eventComparator {
 +
    public:
 +
    bool operator() (const event * left, const event * right) const {
 +
      return left->time > right->time;
 +
    }
 +
  };
 +
  std::priority_queue<event*,
 +
                      std::vector<event *, std::allocator<event*> >,
 +
                      eventComparator> eventQueue;  //fila de eventos
 +
};
 +
 +
void simulation::run () {
 +
 +
  while (! eventQueue.empty ()) { //enquanto exisitr eventos na fila de eventos
 +
 +
    event * nextEvent = eventQueue.top (); //captura evento no topo da fila
 +
    eventQueue.pop ();  //retira evento da fila
 +
    simtime = nextEvent->time;  //ajusta tempo de simulação
 +
    nextEvent->processEvent ();  //processa evento
 +
    delete nextEvent;  //remove evento
 +
  }
 +
}
 +
 +
//===================================================================
 +
//Customização dos eventos e do simulador
 +
//===================================================================
 +
 +
class standardArrival : public event {
 +
public:
 +
  standardArrival (double t)
 +
    : event (t)
 +
    { }
 +
  virtual void processEvent ();
 +
};
 +
 +
void standardArrival::processEvent () {
 +
  std::cout << "processando evento no tempo " << time  << '\n';
 +
}
 +
 +
class simuladorFilas : public simulation {
 +
public:
 +
  simuladorFilas ()
 +
    { }
 +
 +
} oSimulador;
 +
 +
// from https://stackoverflow.com/questions/2704521/generate-random-double-numbers-in-c
 +
 +
double fRand(double fMin, double fMax)
 +
{
 +
    double f = (double)rand() / RAND_MAX;
 +
    return fMin + f * (fMax - fMin);
 +
}
 +
 +
int main () {
 +
 +
  // Inicializar aqui a fila de eventos
 +
  double t;
 +
 +
  oSimulador.scheduleEvent (new standardArrival (t=fRand(1.0,10.0)));
 +
  oSimulador.scheduleEvent (new standardArrival (t=t+fRand(1.0,10.0)));
 +
  oSimulador.scheduleEvent (new standardArrival (t=t+fRand(1.0,10.0)));
 +
 +
  // Executar simulador
 +
  oSimulador.run ();
 +
 +
 +
  return 0;
 +
}
 +
 +
</syntaxhighlight>
 +
 +
==Modelo de Simulação a ser implementado - Atividade A2.1==
 +
 +
A fila de MM1 a ser implementada segue o modelo abaixo. A geração de tráfego é Poisson e o serviço segue distribuição exponencial. 50% do tráfego gerado por queue0 é reconduzido para queue1 e 30% para queue2 e 20 % saem do sistema. Computar o tempo médio no sistema das requisições em cada ramo da rede (queue1 e queue2).
 +
 +
[[Arquivo:FilaMM1-ADS29009.png]]
 +
 +
=AULA 21 - Dia 29/10/2019=
 +
 +
==Objetivos==
 +
 +
*Estudo de uma Implementação de um Simulador a Eventos Discretos;
 +
*Uso de um SImulador a Eventos Discretos para Redes: Omnet
 +
**Tutorial Tic-Toc
 +
**conceito de gates e de vetor de gates;
 +
***envio de mensagens e de cópias de mensagens;
 +
**Modelagem de Delays
 +
**Uso de funções de geração de números randômicos
 +
**Modelagem de retransmisssão: timeouts e cancelamento de timeout;
 +
 +
==Considerações sobre a simulação com o omnet==
 +
 +
No  [https://omnetpp.org/doc/omnetpp/manual/index.html#sec:simple-modules:discrete-event-simulation manual de simulação do Omnet] pode-se observar que:
 +
 +
===Eventos e Ordem de Execução===
 +
 +
*mensagens são representadas por eventos (class cMessage) e subclasses;
 +
*o tempo de ocorrência de um evento é o momento da chegada da mensagem (arrival time) no módulo de destino;
 +
*timeouts serão implementados por um módulo emissor como mensagens para eles mesmos (self-messages);
 +
*eventos são processados de acordo com o tempo de chegada (mensagens com tempo mais antigos primeiro) de forma a manter a relação de causalidade;
 +
*Caso duas mensagens tenham o mesmo tempo de chegada tem-se que:
 +
**a mensagem com maior prioridade atribuída pelo usuário é executada primeiro ( higher scheduling priority);
 +
**caso tenham a mesma prioridade, será executada a que estiver primeiro na fila (escalonada pelo scheduler).
 +
 +
==Referência==
 +
 +
*[https://docs.omnetpp.org/tutorials/tictoc/ Tutorial Omnet]
 +
 +
==Acesso omnetpp na Cloud IFSC==
 +
 +
*Contribuição de  Gabriel de Souza/CTIC.
 +
 +
Fazer:
 +
 +
 +
ssh SEU_USUARIO_LDAP@nuvem.sj.ifsc.edu.br -p 2223 -XC
 +
 +
$ omnetpp
 +
 +
==Roteiro para Conceitos Básicos==
 +
 +
USando o manual rever:
 +
 +
*2.1 Conceitos de Modelagem
 +
**Hierarquia de Módulos;
 +
**Tipo Módulo;
 +
**Links, Portos e Mensagens
 +
 +
*2.4.Depuração do Código
 +
*2.5.Visualização da Troca de Mensagens após a Simulação (Sequence Chart)
 +
 +
=AULA 22 - Dia 1/11/2019=
 +
 +
==Objetivos==
 +
 +
*Continuação exemplo tic-toc
 +
*Fila MM1 no omnet
 +
 +
==Arquivo mm1.ned==
 +
 +
*Baseado em [http://www.telematica.polito.it/sites/default/files/public/courses/computer-network-design/labs.pdf Paolo Giaccone]
 +
 +
Criar mm1.ned:
 +
 +
<syntaxhighlight lang=c>
 +
// *** mm1.ned ***
 +
simple Generator {
 +
parameters:
 +
volatile double interArrivalTime; // sec
 +
@display("i=block/source");
 +
gates:
 +
output out;
 +
}
 +
 +
simple Queue {
 +
parameters:
 +
volatile double serviceTime; // sec
 +
@display("i=block/queue");
 +
gates:
 +
input in;
 +
output out;
 +
}
 +
 +
simple Sink {[General]
 +
parameters:
 +
@display("i=block/sink");
 +
gates:
 +
input in;
 +
}
 +
 +
network MM1 {
 +
submodules:
 +
gen: Generator{
 +
@display("p=273,101");
 +
        }
 +
queue: Queue{
 +
                @display("p=165,79");
 +
        }
 +
sink: Sink{
 +
                @display("p=50,79");
 +
        }
 +
connections:
 +
gen.out --> queue.in;
 +
queue.out --> sink.in;
 +
}
 +
</syntaxhighlight>
 +
 +
==Arquivo generator.cc==
 +
 +
*Baseado em [http://www.telematica.polito.it/sites/default/files/public/courses/computer-network-design/labs.pdf Paolo Giaccone]
 +
 +
Criar generator.cc:
 +
 +
<syntaxhighlight lang=c>
 +
/*** generator.cc ***/
 +
#include <string.h>
 +
#include <omnetpp.h>
 +
 +
using namespace omnetpp;
 +
 +
class Generator: public cSimpleModule {
 +
private:
 +
cMessage *sendMsgEvent;
 +
public:
 +
Generator(); // constructor
 +
virtual ~Generator(); // destructor
 +
protected:
 +
virtual void initialize();
 +
virtual void finish();
 +
virtual void handleMessage(cMessage *msg);
 +
};
 +
 +
Define_Module(Generator);
 +
 +
Generator::Generator() {
 +
sendMsgEvent=NULL;
 +
}
 +
 +
Generator::~Generator() {
 +
cancelAndDelete(sendMsgEvent);
 +
}
 +
 +
void Generator::initialize() {
 +
// create the "send" packet
 +
sendMsgEvent=new cMessage("sendEvent");
 +
// schedule the first event at random time
 +
scheduleAt(par("interArrivalTime"), sendMsgEvent);
 +
}
 +
 +
void Generator::finish() {
 +
}
 +
 +
void Generator::handleMessage(cMessage *msg) {
 +
cMessage *pkt;
 +
simtime_t departure_time;
 +
// create new packet
 +
pkt = new cMessage("packet");
 +
// sent to the output
 +
send(pkt,"out");
 +
// compute the new departure time
 +
departure_time=simTime()+par("interArrivalTime");
 +
// schedule the new packet generation
 +
scheduleAt(departure_time, sendMsgEvent);
 +
}
 +
</syntaxhighlight>
 +
 +
==Arquivo queue.cc==
 +
 +
*Baseado em [http://www.telematica.polito.it/sites/default/files/public/courses/computer-network-design/labs.pdf Paolo Giaccone]
 +
*NOTE que nesta implementação a requisição servida fica no topo da fila.
 +
 +
<syntaxhighlight lang=c>
 +
/*** queue.cc ***/
 +
#include <string.h>
 +
#include <omnetpp.h>
 +
 +
using namespace omnetpp;
 +
 +
class Queue : public cSimpleModule {
 +
private:
 +
// local variable
 +
cQueue buffer;
 +
cMessage *endServiceEvent;
 +
simtime_t service_time;
 +
public:
 +
// constructor
 +
Queue(); // constructor
 +
virtual ~Queue(); // destructor
 +
protected:
 +
virtual void initialize();
 +
virtual void finish();
 +
virtual void handleMessage(cMessage *msg);
 +
};
 +
 +
Define_Module(Queue);
 +
Queue::Queue() {
 +
endServiceEvent=NULL;
 +
}
 +
 +
Queue::~Queue() {
 +
cancelAndDelete(endServiceEvent);
 +
}
 +
 +
void Queue::initialize() {
 +
endServiceEvent=new cMessage("endService");
 +
}
 +
 +
void Queue::finish() {}
 +
 +
void Queue::handleMessage(cMessage *msg) {
 +
cMessage *pkt;
 +
// if msg is endServiceEvent, then
 +
//dequeue and send the pkt to the output
 +
//if another pkt is available in the buffer, then
 +
//start a new service
 +
// if msg is a packet, then
 +
//enqueue the pkt
 +
//if server idling, then
 +
//start a new service
 +
if (msg==endServiceEvent) {
 +
// dequeue
 +
pkt=(cMessage*)buffer.pop();
 +
// send
 +
send(pkt,"out");
 +
if (!buffer.isEmpty()) { // if another pkt is available
 +
// start the service
 +
service_time=par("serviceTime");
 +
scheduleAt(simTime()+service_time,endServiceEvent);
 +
}
 +
} else { // msg is a packet
 +
// enqueue
 +
buffer.insert(msg);
 +
// if the server is idling
 +
if (!endServiceEvent->isScheduled()) {
 +
// start the service
 +
service_time=par("serviceTime");
 +
scheduleAt(simTime()+service_time,endServiceEvent);
 +
}
 +
}
 +
}
 +
</syntaxhighlight>
 +
 +
==Arquivo sink.cc==
 +
 +
 +
 +
<syntaxhighlight lang=c>
 +
/*** sink.cc ***/
 +
#include <string.h>
 +
#include <omnetpp.h>
 +
 +
using namespace omnetpp;
 +
 +
class Sink : public cSimpleModule {
 +
private:
 +
// online stats
 +
cStdDev delayStats;
 +
cOutVector delayVector;
 +
public:
 +
Sink(); // constructor
 +
virtual ~Sink(); // destructor
 +
protected:
 +
virtual void initialize();
 +
virtual void finish();
 +
virtual void handleMessage(cMessage *msg);
 +
};
 +
 +
Define_Module(Sink);
 +
Sink::Sink() {}
 +
 +
Sink::~Sink() {}
 +
 +
void Sink::initialize() {
 +
delayStats.setName("TotalDelay");
 +
delayVector.setName("Delay");
 +
}
 +
 +
void Sink::finish() {
 +
recordScalar("Ave delay",delayStats.getMean());
 +
recordScalar("Number of packets",delayStats.getCount());
 +
}
 +
 +
void Sink::handleMessage(cMessage *msg) {
 +
// compute queueing delay
 +
simtime_t delay=simTime() - msg->getCreationTime();
 +
// update stats
 +
delayStats.collect(delay);
 +
delayVector.record(delay);
 +
// delete msg
 +
delete(msg);
 +
}
 +
</syntaxhighlight>
 +
 +
==Arquivo omnet.ini==
 +
 +
<syntaxhighlight lang=c>
 +
# omnetpp.ini
 +
[General]
 +
network = MM1
 +
sim-time-limit = 100s
 +
**.interArrivalTime=exponential(2)
 +
**.serviceTime=exponential(0.8)
 +
</syntaxhighlight>
 +
 +
=AULA 23 - Dia 5/11/2019=
 +
 +
==Objetivos==
 +
 +
*Exemplo de Rede de Filas no Omnet
 +
*ExperimentoxMediçãoXRepetição;
 +
*Análise de resultados da simulação usando o Omnet
 +
 +
<syntaxhighlight lang=c>
 +
// *** mm1.ned ***
 +
simple Generator
 +
{
 +
    parameters:
 +
        volatile double interArrivalTime; // sec
 +
        @display("i=block/source");
 +
    gates:
 +
        output out;
 +
}
 +
 +
simple Queue
 +
{
 +
    parameters:
 +
        volatile double serviceTime; // sec
 +
        @display("i=block/queue");
 +
    gates:
 +
        input in;
 +
        output out;
 +
}
 +
 +
simple Sink
 +
{
 +
    parameters:
 +
        @display("i=block/sink");
 +
    gates:
 +
        input in;
 +
}
 +
 +
simple Splitter
 +
{
 +
    parameters:
 +
        volatile double prob_out0; // sec
 +
        volatile double prob_out1; // sec       
 +
        @display("i=block/sink");
 +
    gates:
 +
        input in;
 +
        output out[2];
 +
}
 +
 +
network MM1Rede1
 +
{
 +
    submodules:
 +
        gen: Generator {
 +
            @display("p=265,212");
 +
        }
 +
        queue0: Queue {
 +
            @display("p=265,118");
 +
        }
 +
        queue1: Queue {
 +
            @display("p=110,58");
 +
        }
 +
        queue2: Queue {
 +
            @display("p=110,173");
 +
        }
 +
        splitter: Splitter {
 +
            @display("p=193,118");
 +
        }
 +
        sink1: Sink {
 +
            @display("p=49,58");
 +
        }
 +
        sink2: Sink {
 +
            @display("p=49,173");
 +
        }
 +
    connections:
 +
        gen.out --> queue0.in;
 +
        queue0.out --> splitter.in;
 +
        splitter.out[0] --> queue1.in;
 +
        splitter.out[1] --> queue2.in;
 +
        queue1.out --> sink1.in;
 +
        queue2.out --> sink2.in;
 +
 +
}
 +
 +
network MM1Rede2
 +
{
 +
    submodules:
 +
        gen: Generator {
 +
            @display("p=265,212");
 +
        }
 +
        queue0: Queue {
 +
            @display("p=265,118");
 +
        }
 +
        queue1: Queue {
 +
            @display("p=110,58");
 +
        }
 +
        queue2: Queue {
 +
            @display("p=110,173");
 +
        }
 +
        queue3: Queue {
 +
            @display("p=102,243");
 +
        }
 +
        splitter: Splitter {
 +
            @display("p=193,118");
 +
        }
 +
        sink1: Sink {
 +
            @display("p=49,58");
 +
        }
 +
        sink2: Sink {
 +
            @display("p=38,243");
 +
        }
 +
    connections:
 +
        gen.out --> queue0.in;
 +
        queue0.out --> splitter.in;
 +
        splitter.out[0] --> queue1.in;
 +
        splitter.out[1] --> queue2.in;
 +
        queue1.out --> sink1.in;
 +
        queue2.out --> queue3.in;
 +
        queue3.out --> sink2.in;
 +
 +
}
 +
 +
</syntaxhighlight>
 +
 +
<syntaxhighlight lang=c>
 +
# omnetpp.ini
 +
[General]
 +
 +
sim-time-limit = 100s
 +
 +
*.gen.interArrivalTime=exponential(1)
 +
**.queue0.serviceTime=exponential(0.2)
 +
**.queue1.serviceTime=exponential(0.2)
 +
**.queue2.serviceTime=exponential(0.8)
 +
 +
**.splitter.prob_out0 = 0.5
 +
**.splitter.prob_out1 = 0.3
 +
 +
repeat=3
 +
 +
[Config Experimento1]
 +
network = MM1Rede1
 +
 +
[Config Experimento2]
 +
network = MM1Rede2
 +
 +
*.gen.interArrivalTime=exponential(${1,2})
 +
**.queue3.serviceTime=exponential(0.8)
 +
</syntaxhighlight>
 +
 +
splitter.cc
 +
<syntaxhighlight lang=c>
 +
/*
 +
* splitter.cc
 +
*
 +
*  Created on: Nov 5, 2019
 +
*      Author: eraldo
 +
*/
 +
 +
/*** queue.cc ***/
 +
#include <string.h>
 +
#include <omnetpp.h>
 +
 +
using namespace omnetpp;
 +
 +
class Splitter : public cSimpleModule {
 +
private:
 +
    // local variable
 +
    cQueue buffer;
 +
    cMessage *endServiceEvent;
 +
    simtime_t service_time;
 +
public:
 +
    // constructor
 +
    Splitter(); // constructor
 +
    virtual ~Splitter(); // destructor
 +
protected:
 +
    virtual void initialize();
 +
    virtual void finish();
 +
    virtual void handleMessage(cMessage *msg);
 +
};
 +
 +
 +
Define_Module(Splitter);
 +
 +
Splitter::Splitter() {
 +
}
 +
 +
Splitter::~Splitter() {
 +
}
 +
 +
void Splitter::initialize() {
 +
    endServiceEvent=new cMessage("endService");
 +
}
 +
 +
void Splitter::finish() {}
 +
 +
void Splitter::handleMessage(cMessage *msg) {
 +
    double unif_rand = uniform(0, 1);
 +
    if ( unif_rand < par("prob_out0").doubleValue()) {
 +
            send(msg,"out",0);
 +
            EV << "Encaminhando queue1\n";
 +
    } else  if ( unif_rand > par("prob_out0").doubleValue() && unif_rand <  (par("prob_out0").doubleValue()+par("prob_out0").doubleValue())) {
 +
        send(msg,"out",1);
 +
        EV << "Encaminhando queue2\n";
 +
    } else
 +
        delete msg;
 +
}
 +
</syntaxhighlight>
 +
 +
=AULA 24 - Dia 8/11/2019=
 +
 +
==Objetivos==
 +
 +
*Ainda Exemplo de Rede de Filas no Omnet
 +
*Análise de resultados da simulação usando o Omnet
 +
*Intervalo de Confiança no Omnet
 +
*Instalação do inet
 +
*Início do Tutorial Wireless
 +
 +
 +
==Manuais Omnet==
 +
 +
*[https://doc.omnetpp.org/omnetpp/UserGuide.pdf Manual do IDE];
 +
*[https://doc.omnetpp.org/omnetpp/manual/#sec:ned-lang:gates Manual do Simulador ];
 +
*[https://inet.omnetpp.org/docs/tutorials/wireless/doc/index.html Tutorial Wireless]
 +
 +
=AULA 25 - Dia 19/11/2019=
 +
 +
*Curso Hitachi
 +
 +
=AULA 26 - Dia 22/11/2019=
 +
 +
==Objetivos==
 +
 +
*Ainda INET: Tutorial Wireless
 +
 +
==Material de Referência==
 +
 +
*[https://inet.omnetpp.org/assets/pdf/OMNET-2015-31-Slides.pdf Slides Resumo Tutorial no Site Omnet]
 +
 +
==Exercício 1==
 +
 +
*Modificar o Step 10 (Config Wireless10A no omnetpp.ini) para variar potência de transmissão para 0.6, 0.9 e 1.2mW
 +
*Verificar se existe impacto no EndToEndDelay
 +
 +
==Exercício 2==
 +
 +
*Modificar o Step 10 (Config Wireless10A no omnetpp.ini) um modelo  BonnMotionMobility que permita que os hosts A e B siga trajetórias prédefinidas (por exemplo, ruas de uma cidade). Mantenha os roteadores parados.
 +
 +
=AULA 27 - Dia 26/11/2019=
 +
 +
*Confiança Estatística:
 +
**Explorando os ShowCases no Omnet
 +
 +
=AULA 28 - Dia 29/11/2019=
 +
 +
 +
*Medição Ativa e Passiva em Redes
 +
 +
==Medição Ativa e Passiva em Redes==
 +
 +
*Referência:
 +
[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.227.9625&rep=rep1&type=pdf Survey Sobre Medição em Redes]
 +
 +
*Slides: Medição Ativa - Iperf
 +
https://www.dropbox.com/s/38qy76phjob7a3o/Medi__oEmRedes.pdf?dl=0
 +
 +
 +
==ATIVIDADE EM SALA - Questionário Medição Ativa x Passiva em Redes==
 +
 +
1.Explique a diferença entre medição ativa e passiva em redes.
 +
 +
2.Liste os benefícios advindos da a aquisição de dados/avaliação de desempenho derivado da medição ativa ou passiva.
 +
 +
3.Descreva como o SNMP e RMON podem ser usados no contexto de medição em redes.
 +
 +
4.Apresente brevemente as sete métricas de desempenho IP proposta pela IETF (IP Performance Metrics - IPPM)
 +
 +
5.Em medição passiva existem problemas associados ao sigilo de dados. Discuta que problemas são estes e como podem ser contornados.
 +
 +
6.Em medição ativa normalmente se usa o conceito de "probes". Explique o que é e discuta características desejáveis de uma pacote probe. Discuta também o conceito de intrusão neste contexto.
 +
 +
7.Explique como é formado o tempo de retardo (delay) fim-a-fim na comunicação de dados.
 +
 +
8.Explique como é computada a capacidade de um caminho (fim-a-fim) de comunicação.
 +
 +
9.Qual conceito de banda disponível ("Available bandwidth"). Discuta o conceito a luz do que é apresentado em [https://www.caida.org/publications/papers/2003/bwestmetrics/bwestmetrics.pdf]
 +
 +
10.Proponha um esboço de "Projeto de ADS" usando medição ATIVA usando o software  iperf para avaliar o comportamento de um Access Point Comercial ([http://static.tp-link.com/resources/document/TL-WDR4300_V1_User_Guide_19100.pdf Manual do TP-Link WDR4300]. O objetivo do experimento é avaliar a vazão no sistema comparando quando (i) um PC wireless está ligado diretamente a um AP que está ligado diretamente a uma rede cabeada e (2) um PC está ligado a um AP que está conectado em configuração WDS a outro AP em rede cabeada (https://www.tp-link.com/br/support/faq/227/).
 +
 +
==Outras Referências==
 +
 +
*[https://www.slac.stanford.edu/xorg/nmtf/nmtf-tools.html Network Monitoring Tool]
 +
 +
https://www.caida.org/publications/papers/2003/bwestmetrics/
 +
 +
=AULA 29 - Dia 3/12/2019=
 +
 +
==Objetivos==
 +
 +
*Confiança Estatística nos Resultados dos Experimetos;
 +
*Comparação de Sistemas baseado no Intervalo de Confiança;
 +
 +
==Material de Referência==
 +
 +
*[https://www.dropbox.com/s/4cfpzfbtwzt1td0/ConfiancaEstatistica.pdf?dl=0 Slides da Aula]
 +
 +
==Atividade==
 +
 +
*Computar o intervalo de confiança para um nível de 95% na estatística do problema de rede de filas. Usar 30 repetições.
 +
 +
=AULA 30 - Dia 6/12/2019=
 +
 +
*Medição Ativa e Passiva em Redes
 +
*Projeto de Experimento de Medição em Redes Sem Fio
 +
*Finalização do Projeto de Medição do Robô
 +
 +
=AULA 31 - Dia 13/12/2019=
 +
 +
*Apresentação do Projeto de Simuladores Discretos
 +
*Sobre Projetos Fatoriais
 +
*Finalização do Projeto de Medição do Robô
 +
 +
==Material de Referência==
 +
 +
*[https://homepages.dcc.ufmg.br/~jussara/metq/aula5-v2-2014-2.pdf Slides Profa. Jussara Almeida]
 +
 +
=AULA 33 - Dia 17/12/2019=
 +
 +
*Finalização do Projeto de Medição do Robô
  
 
=Livros sobre ADS=
 
=Livros sobre ADS=

Edição atual tal como às 06h39min de 26 de julho de 2021

AULA 1 - Dia 30/07/2019

Objetivos

  • Apresentação da Disciplina (SIGA A)
  • Plano de Ensino (SIGA A)
  • Avaliação (SIGA A)

Introdução a ADS

  • Que projeto estou fazendo? Como procedo para fazer uma ADS?

Tarefa A1.1

  • Pesquisar um artigo sobre ADS em uma área de seu interesse. Analisar um arquivo a luz das etapas e conceitos discutidos nesta semana.

Fazer slides que devem ser postados na data anterior da apresentação. O slide deve apresentar:

  • Objetivo da ADS no artigo
  • Métricas
  • Parâmetros
  • Fatores
  • Workload
  • Técnicas usadas
  • Resumo de como são apresentados os dados
  • Conclusão Pessoal

APRESENTAÇÃO: Dia 9/8/2019

Material de Referência

AULA 2 - Dia 2/08/2019

Objetivos

  • Continuação conceitos de ADS

Material de Referência

AULA 3 - Dia 9/08/2019

Objetivos

  • Finalização Introdução ADS
  • Apresentação dos Trabalhos

AULA 4 - Dia 13/08/2019

Objetivos

  • Introdução a DTMC

Materialde Referência

https://www.dropbox.com/s/oz2dlua2kmc1w2m/CadeiasDeMarkovDiscretas_Parte1.pdf?dl=0

AULA 5 - Dia 16/08/2019

Objetivos

  • Continuação DTMC

Material de Referência

https://www.dropbox.com/s/oz2dlua2kmc1w2m/CadeiasDeMarkovDiscretas_Parte1.pdf?dl=0

Links Interessantes

AULA 6 - Dia 23/08/2019

Objetivos

  • Continuação DTMC
  • Simulação DTMC

Itens a constar da atividade de simulação

  • código fonte matlab
  • minirelatório com:
    • comparação dos resultados das probabilidades em regime estacionário conforme slide;
    • resposta as questões do slide
    • Uma pdf das transições de primeira passagem para os estados colocados no slide.

Material de Referência

  P = [ 
          0.2    0    0.8    0    0    0    0    0    0    0;
          0    0.2    0.3  0.3  0.2  0    0    0    0    0;
          0    0    0.1    0    0    0.9  0    0    0    0;
          0    0    0    0    0    0    1.0  0    0    0;
          0    0    0    0    0    0.3  0.7  0    0    0;
          0    0    0    0    0    0    0    0.2  0    0.8;
          0    0    0    0    0    0    0    0    0.8  0.2;
          1.0  0    0    0    0    0    0    0    0    0;
          0    1.0  0    0    0    0    0    0    0    0;
          0.2 0.6  0    0    0    0    0    0    0    0.2;
         ];

AULA 7 - Dia 27/08/2019

  • Simulação da DTMC (conclusão)

AULA 8 - Dia 30/08/2019

Objetivos

  • Aplicações de DTMC: Aloha Puro
  • Discussão de Projeto usando os Mindstorms

Slides desta Aula

Aula 9 - Dia 06/09/2019

  • Introdução a CTMC
  • Projeto de Desempenho sobre o Robô

Material de Referência

Links sobre o EV3


Aula 10 - Dia 10/09/2019

  • Instalação de tools C++ no ev3

Usar máquina virtual com Ubuntu 18.04

Fazer conforme

  • Toolchain

O make e o gcc devem estar instalados.

https://c4ev3.github.io/ (Lembrar que são ferramentas 32 bits) 

sudo apt-get install lib32ncurses5 lib32z1
sudo apt-get install libudev-dev pkg-config
wget -c http://www.codesourcery.com/sgpp/lite/arm/portal/package4571/public/arm-none-linux-gnueabi/arm-2009q1-203-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
mkdir CodeSourcery
tar -jxvf ~/arm-2009q1-203-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 -C ~/CodeSourcery/
echo export PATH=~/CodeSourcery/arm-2009q1/bin/:$PATH >> ~/.bashrc && . ~/.bashrc
  • Uploader (não usei diretamente pois fiz scp para robot@IP_ROBO (password "maker".
git clone --recursive https://github.com/c4ev3/ev3duder

Entrar e compilar usando o make Entrar em EV3-API/API e compilar. EU tive que editar o Makefile para remover a referência ao Windows

  • Compilar
arm-none-linux-gnueabi-gcc -I../EV3-API/API  -L../EV3-API/API/ alo.c -lev3api

Aula 11 - Dia 13/09/2019

Objetivos

  • CTMC - Aplicações: modelagelam da alocação de GTS no IEEE802.15.4

Problema (simplificação do GTS no IEEE 802.15.4

O padrão de rede sem fio IEEE802.15.4 prevê a comunicação sem BEACON (CSMA-CA) e com BEACON, onde parte do frame possui até 7 canais que podem ser alocados sob demanda por um coordenaodor (supor topologia em estrela com coordenador no centro). A alocação é realizada em canal de controle a parte. Construir uma cadeia de Markov em Tempo Contínuo de forma:

(i) a computar a probabilidade de bloqueio. Supor N nodos com número médio de requisições

(ii) como poderia ser computada a vazão esperada do sistema?

(iii) como poderíamos estimar a vazão na parte CSMA-CA (supor comportamento como Slotted Aloha)

(iv) na parte GTS, como poderíamos considerar dois grupos de nodos onde o primeiro grupo pode ocupar os 7 slots e o segundo grupo, com taxa diferente poderia ocupar até dois slots?

Aula 12 - Dia 20/09/2019

  • Introdução a Teoria de Filas
  • Filas MM1 com buffer ilimitado

Material de Referência

Aula 13 - Dia 24/09/2019

Objteivos

  • Desenvolvimento de Projeto de ADS

Visão geral do Software no Mindstorm

ADSProjetoMindstorm.png

Especificação dos Recursos Rest

Especificação das mensagens no socket

O "programa sob teste" se conecta no servidor Flask através de um socket. O programa se comporta como um servidor que recebe comandos atraváes de uma string de tamanho fixo (15 caracteres). A todo comando ele envia uma resposta também de 15 caracteres.

No momento que recebe um comando o programa deve ler o tempo do sistema e ao enviar uma resposta ele deverá ler novamente o tempo e enviá-lo na string de resposta;

Formato da string (ideal seria usar padrão: XML,JSON?). Vantagem de usar XML seria usar uma biblioteca padrão.

Comando;P:par1;P:par2;...;TE:...tempo;TS:tempo

Pontos a verificar:

  • o tamanho da string deveria ser aumentada ou flexibilizado?


Especificação do Gerador de Cargas/Monitor

  • O gerador de carga deverá ler uma especificação de um arquivo e gerar a carga. Prever identificação do Experimento e da Repetição.
  • O monitor deverá ler as respostas e armazená-las devidamente em arquivo.
  • Um analisador/visalizador de dados deverá permitir sumarizar dados, gerar intervalo de confiança e mostrar os resultados

Módulo de Processamento Autônomo

  1. include <stdio.h>
  2. include <sys/time.h>

//classe baseada no geekforgeeks

class t_duracao { 

   public:
       void iniciar_medicao() {
           gettimeofday(&start, NULL);
       }
       void finalizar_medicao(){
           gettimeofday(&end, NULL);
           time_taken = (end.tv_sec - start.tv_sec) * 1e6;
           time_taken = (time_taken + (end.tv_usec -
                                       start.tv_usec)) * 1e-6;
       }
       void mostrar_tempo(){
           printf("valor de tempo = %lf", time_taken);

       }
       float retornar_tempo(){
           return time_taken;
       }

   private:
       double time_taken;
       struct timeval start, end;

} tempo_estimado;


float computar_desloc_x() { 

 float d;
 
 d = 10+20*uniforme(); // uniforme retorna entre 0 e 1 - no minimo andará 10cm e no máximo 30 cm
 return d;

}

float computar_lateral(float meu_y, float meu_desloc) { 

 float lat;

 lat = seno (0.042*meu_desloc) * 50; /* amplitude máxima 50 cm
 return lat-meu_y;

}

main() { 

 receive(max_x,max_y);
 tempo_estimado.iniciar_medicao();
 x=0; //valor absoluto do movimento na direção x
 desloc_x=0;
 y=0; //valor absoluto do movimento na direção y
 desloc_y=0;
 while (x<max_x) {
    //computar movimento para frente
    desloc_x=computar_desloc_x();
    x = desloc_x + x;
    //andar para frente
    movimento_avante(desloc);
    //computar movimento lateral
    desloc_y=computar_lateral(y, x);
    y=y+desloc_y;
    movimento_lateral(desloc_y);
    rotacionar_frente();
 }
 finaliza_movimento();
 tempo_estimado.finalizar_medicao();
 send_annswer(tempo_estimado.retornar_tempo());

} </syntaxhighlight>

<> uniforme()*10+10; <>

Referências

Aula 14 - Dia 27/09/2019

Objetivos

  • Revisão Fila M/M/1
  • Fila M/M/1/c (c servidores)

Material de Referência para esta aula


Aula 15 - Dia 04/10/2019

Objetivos

  • Revisão Fila M/M/n
  • Fila M/M/1/K

Material de Referência para esta aula

https://www.dropbox.com/s/jycdd2dzqqsxb5g/FilaMM1_CapacidadeLimitada.pdf?dl=0

AULA 16 - Dia 08/10/2019

Objetivos

  • Aula antecipada para tratar o experimento do rob
  • Geração de Números Randômicos na Simulação

Material de Referência

AULA 17 - Dia 11/10/2019

Objetivos

  • finalização da classe de geração randômica de números;
  • construção do módulo autônomo do robô usando geração randômica.

Links interessantes


AULA 18 - Dia 18/10/2019

Objetivos

  • PARTE 1
    • Introdução a Simulação a Eventos Discretos
    • Exemplo de simulação e estatística de uma fila MM1
  • PARTE 2
    • Preparação do robô para Feira de Ciências e Tecnologia

Material de referência

AULA 19 - Dia 22/10/2019

PALESTRA - IOT - IPTV

AULA 20 - Dia 25/10/2019

Objetivos

  • Estudo de uma Implementação de um Simulador a Eventos Discretos;

Material de Referência

  • Ver Projeto Apache
  • Proposição de Exercício: simulação de uma rede de filas;


  1. Adaptar o código de tratamento de uma fila MM1 simples, conforme colocado no slide para um formato de um simulador de eventos discretos com filas. Use o código abaixo como apoio.
//Basead em http://stdcxx.apache.org/doc/stdlibug/2-2.html#225

#include <queue>
#include <iostream>
#include <cstdlib>

//==================================================================
// classes evento e simulação - base para o desenvolvimento da simulação
//==================================================================

class event {
public:
  // Construct sets time of event.
  event (double t) : time (t)
    { }

  // Execute event by invoking this method.
  virtual void processEvent () = 0;

  const double time;
};


class simulation {
public:
  simulation () : simtime (0), eventQueue () 
    {}
  void run ();
  void  scheduleEvent (event * newEvent) {
    eventQueue.push (newEvent);
  }
  double simtime;
protected:
  class eventComparator {
    public:
    bool operator() (const event * left, const event * right) const {
      return left->time > right->time;
    }
  };
  std::priority_queue<event*,
                      std::vector<event *, std::allocator<event*> >,
                      eventComparator> eventQueue;  //fila de eventos 
};

void simulation::run () {

  while (! eventQueue.empty ()) { //enquanto exisitr eventos na fila de eventos

    event * nextEvent = eventQueue.top (); //captura evento no topo da fila
    eventQueue.pop ();  //retira evento da fila
    simtime = nextEvent->time;  //ajusta tempo de simulação
    nextEvent->processEvent ();  //processa evento
    delete nextEvent;  //remove evento
  }
}

//===================================================================
//Customização dos eventos e do simulador
//===================================================================

class standardArrival : public event {
public:
  standardArrival (double t)
    : event (t)
    { }
  virtual void processEvent ();
};

void standardArrival::processEvent () {
  std::cout << "processando evento no tempo " << time  << '\n';
}

class simuladorFilas : public simulation {
public:
  simuladorFilas ()
    { }
 
} oSimulador;

// from https://stackoverflow.com/questions/2704521/generate-random-double-numbers-in-c

double fRand(double fMin, double fMax)
{
    double f = (double)rand() / RAND_MAX;
    return fMin + f * (fMax - fMin);
}

int main () {

  // Inicializar aqui a fila de eventos
  double t;

  oSimulador.scheduleEvent (new standardArrival (t=fRand(1.0,10.0)));
  oSimulador.scheduleEvent (new standardArrival (t=t+fRand(1.0,10.0)));
  oSimulador.scheduleEvent (new standardArrival (t=t+fRand(1.0,10.0)));

  // Executar simulador
  oSimulador.run ();


  return 0;
}

Modelo de Simulação a ser implementado - Atividade A2.1

A fila de MM1 a ser implementada segue o modelo abaixo. A geração de tráfego é Poisson e o serviço segue distribuição exponencial. 50% do tráfego gerado por queue0 é reconduzido para queue1 e 30% para queue2 e 20 % saem do sistema. Computar o tempo médio no sistema das requisições em cada ramo da rede (queue1 e queue2).

FilaMM1-ADS29009.png

AULA 21 - Dia 29/10/2019

Objetivos

  • Estudo de uma Implementação de um Simulador a Eventos Discretos;
  • Uso de um SImulador a Eventos Discretos para Redes: Omnet
    • Tutorial Tic-Toc
    • conceito de gates e de vetor de gates;
      • envio de mensagens e de cópias de mensagens;
    • Modelagem de Delays
    • Uso de funções de geração de números randômicos
    • Modelagem de retransmisssão: timeouts e cancelamento de timeout;

Considerações sobre a simulação com o omnet

No manual de simulação do Omnet pode-se observar que:

Eventos e Ordem de Execução

  • mensagens são representadas por eventos (class cMessage) e subclasses;
  • o tempo de ocorrência de um evento é o momento da chegada da mensagem (arrival time) no módulo de destino;
  • timeouts serão implementados por um módulo emissor como mensagens para eles mesmos (self-messages);
  • eventos são processados de acordo com o tempo de chegada (mensagens com tempo mais antigos primeiro) de forma a manter a relação de causalidade;
  • Caso duas mensagens tenham o mesmo tempo de chegada tem-se que:
    • a mensagem com maior prioridade atribuída pelo usuário é executada primeiro ( higher scheduling priority);
    • caso tenham a mesma prioridade, será executada a que estiver primeiro na fila (escalonada pelo scheduler).

Referência

Acesso omnetpp na Cloud IFSC

  • Contribuição de Gabriel de Souza/CTIC.

Fazer: 


ssh SEU_USUARIO_LDAP@nuvem.sj.ifsc.edu.br -p 2223 -XC

$ omnetpp

Roteiro para Conceitos Básicos

USando o manual rever:

  • 2.1 Conceitos de Modelagem
    • Hierarquia de Módulos;
    • Tipo Módulo;
    • Links, Portos e Mensagens
  • 2.4.Depuração do Código
  • 2.5.Visualização da Troca de Mensagens após a Simulação (Sequence Chart)

AULA 22 - Dia 1/11/2019

Objetivos

  • Continuação exemplo tic-toc
  • Fila MM1 no omnet

Arquivo mm1.ned

Criar mm1.ned: 

// *** mm1.ned ***
simple Generator {
parameters:
	volatile double interArrivalTime; // sec
	@display("i=block/source");
gates:
	output out;
}

simple Queue {
parameters:
	volatile double serviceTime; // sec
	@display("i=block/queue");
gates:
	input in;
	output out;
}

simple Sink {[General]
parameters:
	@display("i=block/sink");
gates:
	input in;
}

network MM1 {
submodules:
	gen: Generator{
		@display("p=273,101");
        }
	queue: Queue{
                @display("p=165,79");
        }
	sink: Sink{
                @display("p=50,79");
        }
connections:
	gen.out --> queue.in;
	queue.out --> sink.in;
}

Arquivo generator.cc

Criar generator.cc: 

/*** generator.cc ***/
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Generator: public cSimpleModule {
private:
	cMessage *sendMsgEvent;
public:
	Generator(); // constructor
	virtual ~Generator(); // destructor
protected:
	virtual void initialize();
	virtual void finish();
	virtual void handleMessage(cMessage *msg);
};

Define_Module(Generator);

Generator::Generator() {
	sendMsgEvent=NULL;
}

Generator::~Generator() {
	cancelAndDelete(sendMsgEvent);
}

void Generator::initialize() {
	// create the "send" packet
	sendMsgEvent=new cMessage("sendEvent");
	// schedule the first event at random time
	scheduleAt(par("interArrivalTime"), sendMsgEvent);
}

void Generator::finish() {
}

void Generator::handleMessage(cMessage *msg) {
	cMessage *pkt;
	simtime_t departure_time;
	// create new packet
	pkt = new cMessage("packet");
	// sent to the output
	send(pkt,"out");
	// compute the new departure time
	departure_time=simTime()+par("interArrivalTime");
	// schedule the new packet generation
	scheduleAt(departure_time, sendMsgEvent);
}

Arquivo queue.cc

  • Baseado em Paolo Giaccone
  • NOTE que nesta implementação a requisição servida fica no topo da fila.
/*** queue.cc ***/
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Queue : public cSimpleModule {
private:
	// local variable
	cQueue buffer;
	cMessage *endServiceEvent;
	simtime_t service_time;
public:
	// constructor
	Queue(); // constructor
	virtual ~Queue(); // destructor
protected:
	virtual void initialize();
	virtual void finish();
	virtual void handleMessage(cMessage *msg);
};

Define_Module(Queue);
	Queue::Queue() {
	endServiceEvent=NULL;
}

Queue::~Queue() {
	cancelAndDelete(endServiceEvent);
}

void Queue::initialize() {
	endServiceEvent=new cMessage("endService");
}

void Queue::finish() {}

void Queue::handleMessage(cMessage *msg) {
	cMessage *pkt;
	// if msg is endServiceEvent, then
	//dequeue and send the pkt to the output
	//if another pkt is available in the buffer, then
	//start a new service
	// if msg is a packet, then
	//enqueue the pkt
	//if server idling, then
	//start a new service
	if (msg==endServiceEvent) {
		// dequeue
		pkt=(cMessage*)buffer.pop();
		// send
		send(pkt,"out");
		if (!buffer.isEmpty()) { // if another pkt is available
			// start the service
			service_time=par("serviceTime");
			scheduleAt(simTime()+service_time,endServiceEvent);
		}
	} else { // msg is a packet
		// enqueue
		buffer.insert(msg);
		// if the server is idling
		if (!endServiceEvent->isScheduled()) {
			// start the service
			service_time=par("serviceTime");
			scheduleAt(simTime()+service_time,endServiceEvent);
		}
	}
}

Arquivo sink.cc

/*** sink.cc ***/
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Sink : public cSimpleModule {
private:
	// online stats
	cStdDev delayStats;
	cOutVector delayVector;
public:
	Sink(); // constructor
	virtual ~Sink(); // destructor
protected:
	virtual void initialize();
	virtual void finish();
	virtual void handleMessage(cMessage *msg);
};

Define_Module(Sink);
Sink::Sink() {}

Sink::~Sink() {}

void Sink::initialize() {
	delayStats.setName("TotalDelay");
	delayVector.setName("Delay");
}

void Sink::finish() {
	recordScalar("Ave delay",delayStats.getMean());
	recordScalar("Number of packets",delayStats.getCount());
}

void Sink::handleMessage(cMessage *msg) {
	// compute queueing delay
	simtime_t delay=simTime() - msg->getCreationTime();
	// update stats
	delayStats.collect(delay);
	delayVector.record(delay);
	// delete msg
	delete(msg);
}

Arquivo omnet.ini

# omnetpp.ini
[General]
network = MM1
sim-time-limit = 100s
**.interArrivalTime=exponential(2)
**.serviceTime=exponential(0.8)

AULA 23 - Dia 5/11/2019

Objetivos

  • Exemplo de Rede de Filas no Omnet
  • ExperimentoxMediçãoXRepetição;
  • Análise de resultados da simulação usando o Omnet
// *** mm1.ned ***
simple Generator
{
    parameters:
        volatile double interArrivalTime; // sec
        @display("i=block/source");
    gates:
        output out;
}

simple Queue
{
    parameters:
        volatile double serviceTime; // sec
        @display("i=block/queue");
    gates:
        input in;
        output out;
}

simple Sink
{
    parameters:
        @display("i=block/sink");
    gates:
        input in;
}

simple Splitter
{
    parameters:
        volatile double prob_out0; // sec
        volatile double prob_out1; // sec        
        @display("i=block/sink");
    gates:
        input in;
        output out[2];
}

network MM1Rede1
{
    submodules:
        gen: Generator {
            @display("p=265,212");
        }
        queue0: Queue {
            @display("p=265,118");
        }
        queue1: Queue {
            @display("p=110,58");
        }
        queue2: Queue {
            @display("p=110,173");
        }
        splitter: Splitter {
            @display("p=193,118");
        }
        sink1: Sink {
            @display("p=49,58");
        }
        sink2: Sink {
            @display("p=49,173");
        }
    connections:
        gen.out --> queue0.in;
        queue0.out --> splitter.in;
        splitter.out[0] --> queue1.in;
        splitter.out[1] --> queue2.in;
        queue1.out --> sink1.in;
        queue2.out --> sink2.in;

}

network MM1Rede2
{
    submodules:
        gen: Generator {
            @display("p=265,212");
        }
        queue0: Queue {
            @display("p=265,118");
        }
        queue1: Queue {
            @display("p=110,58");
        }
        queue2: Queue {
            @display("p=110,173");
        }
        queue3: Queue {
            @display("p=102,243");
        }
        splitter: Splitter {
            @display("p=193,118");
        }
        sink1: Sink {
            @display("p=49,58");
        }
        sink2: Sink {
            @display("p=38,243");
        }
    connections:
        gen.out --> queue0.in;
        queue0.out --> splitter.in;
        splitter.out[0] --> queue1.in;
        splitter.out[1] --> queue2.in;
        queue1.out --> sink1.in;
        queue2.out --> queue3.in;
        queue3.out --> sink2.in;

}

# omnetpp.ini
[General]

sim-time-limit = 100s

*.gen.interArrivalTime=exponential(1)
**.queue0.serviceTime=exponential(0.2)
**.queue1.serviceTime=exponential(0.2)
**.queue2.serviceTime=exponential(0.8)

**.splitter.prob_out0 = 0.5
**.splitter.prob_out1 = 0.3

repeat=3

[Config Experimento1] 
network = MM1Rede1

[Config Experimento2]
network = MM1Rede2

*.gen.interArrivalTime=exponential(${1,2})
**.queue3.serviceTime=exponential(0.8)

splitter.cc 

/*
 * splitter.cc
 *
 *  Created on: Nov 5, 2019
 *      Author: eraldo
 */

/*** queue.cc ***/
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Splitter : public cSimpleModule {
private:
    // local variable
    cQueue buffer;
    cMessage *endServiceEvent;
    simtime_t service_time;
public:
    // constructor
    Splitter(); // constructor
    virtual ~Splitter(); // destructor
protected:
    virtual void initialize();
    virtual void finish();
    virtual void handleMessage(cMessage *msg);
};


Define_Module(Splitter);

Splitter::Splitter() {
}

Splitter::~Splitter() {
}

void Splitter::initialize() {
    endServiceEvent=new cMessage("endService");
}

void Splitter::finish() {}

void Splitter::handleMessage(cMessage *msg) {
    double unif_rand = uniform(0, 1);
    if ( unif_rand < par("prob_out0").doubleValue()) {
            send(msg,"out",0);
            EV << "Encaminhando queue1\n";
    } else  if ( unif_rand > par("prob_out0").doubleValue() && unif_rand <  (par("prob_out0").doubleValue()+par("prob_out0").doubleValue())) {
        send(msg,"out",1);
        EV << "Encaminhando queue2\n";
    } else
        delete msg;
}

AULA 24 - Dia 8/11/2019

Objetivos

  • Ainda Exemplo de Rede de Filas no Omnet
  • Análise de resultados da simulação usando o Omnet
  • Intervalo de Confiança no Omnet
  • Instalação do inet
  • Início do Tutorial Wireless


Manuais Omnet

AULA 25 - Dia 19/11/2019

  • Curso Hitachi

AULA 26 - Dia 22/11/2019

Objetivos

  • Ainda INET: Tutorial Wireless

Material de Referência

Exercício 1

  • Modificar o Step 10 (Config Wireless10A no omnetpp.ini) para variar potência de transmissão para 0.6, 0.9 e 1.2mW
  • Verificar se existe impacto no EndToEndDelay

Exercício 2

  • Modificar o Step 10 (Config Wireless10A no omnetpp.ini) um modelo BonnMotionMobility que permita que os hosts A e B siga trajetórias prédefinidas (por exemplo, ruas de uma cidade). Mantenha os roteadores parados.

AULA 27 - Dia 26/11/2019

  • Confiança Estatística:
    • Explorando os ShowCases no Omnet

AULA 28 - Dia 29/11/2019

  • Medição Ativa e Passiva em Redes

Medição Ativa e Passiva em Redes

  • Referência:

Survey Sobre Medição em Redes

  • Slides: Medição Ativa - Iperf

https://www.dropbox.com/s/38qy76phjob7a3o/Medi__oEmRedes.pdf?dl=0


ATIVIDADE EM SALA - Questionário Medição Ativa x Passiva em Redes

1.Explique a diferença entre medição ativa e passiva em redes.

2.Liste os benefícios advindos da a aquisição de dados/avaliação de desempenho derivado da medição ativa ou passiva.

3.Descreva como o SNMP e RMON podem ser usados no contexto de medição em redes.

4.Apresente brevemente as sete métricas de desempenho IP proposta pela IETF (IP Performance Metrics - IPPM)

5.Em medição passiva existem problemas associados ao sigilo de dados. Discuta que problemas são estes e como podem ser contornados.

6.Em medição ativa normalmente se usa o conceito de "probes". Explique o que é e discuta características desejáveis de uma pacote probe. Discuta também o conceito de intrusão neste contexto.

7.Explique como é formado o tempo de retardo (delay) fim-a-fim na comunicação de dados.

8.Explique como é computada a capacidade de um caminho (fim-a-fim) de comunicação.

9.Qual conceito de banda disponível ("Available bandwidth"). Discuta o conceito a luz do que é apresentado em [3]

10.Proponha um esboço de "Projeto de ADS" usando medição ATIVA usando o software iperf para avaliar o comportamento de um Access Point Comercial (Manual do TP-Link WDR4300. O objetivo do experimento é avaliar a vazão no sistema comparando quando (i) um PC wireless está ligado diretamente a um AP que está ligado diretamente a uma rede cabeada e (2) um PC está ligado a um AP que está conectado em configuração WDS a outro AP em rede cabeada (https://www.tp-link.com/br/support/faq/227/).

Outras Referências

https://www.caida.org/publications/papers/2003/bwestmetrics/

AULA 29 - Dia 3/12/2019

Objetivos

  • Confiança Estatística nos Resultados dos Experimetos;
  • Comparação de Sistemas baseado no Intervalo de Confiança;

Material de Referência

Atividade

  • Computar o intervalo de confiança para um nível de 95% na estatística do problema de rede de filas. Usar 30 repetições.

AULA 30 - Dia 6/12/2019

  • Medição Ativa e Passiva em Redes
  • Projeto de Experimento de Medição em Redes Sem Fio
  • Finalização do Projeto de Medição do Robô

AULA 31 - Dia 13/12/2019

  • Apresentação do Projeto de Simuladores Discretos
  • Sobre Projetos Fatoriais
  • Finalização do Projeto de Medição do Robô

Material de Referência

AULA 33 - Dia 17/12/2019

  • Finalização do Projeto de Medição do Robô

Livros sobre ADS

Links Interessantes
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=ADS29009-2019-2&oldid=177896”