ADS29009-2019-2

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

• Slides de Introdução a ADS

AULA 2 - Dia 2/08/2019

Objetivos

• Continuação conceitos de ADS

Material de Referência

• Slides de Introdução a ADS

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

• [1]

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

• DTMC parte2

• https://www.dropbox.com/s/hvgk42nhhcsyjlt/SimMarkovAlunos.m

  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

• Slides Aloha Puro

Aula 9 - Dia 06/09/2019

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

Material de Referência

• Slides CTMC - parte1

Links sobre o EV3

• Site Ev3 - Opções de Programação
• Biblioteca C++ from Germany

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

(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

• Introdução a Teoria de Filas
• Filas MM1

Aula 13 - Dia 24/09/2019

Objteivos

• Desenvolvimento de Projeto de ADS

Visão geral do Software no Mindstorm

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

• Guia Ev3
• PID explained
• Autonomous Navigation Robot
• Using tacho motors Using Tacho Motors

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

• Filas M/M/1/c

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

• [2]

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

• Medição de Tempo no C

AULA 18 - Dia 11/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

• Slides de Introdução a Simulação a Eventos Discretos

AULA 19 - Dia 11/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).

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

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

Exercício após step 2

1. Ler no manual sobre cPacket
2. Modificar o tictoc1 para usar cPacket, configurando o tamanho do pacote para 10bits
3. Ler no manual sobre Channel e como setar datarate
4. Configurar o channel para datarate de 2bps e delay de 1bps
5. Executar a simulação para algumas trocas de mensagens.
6. Examinar o arquivo de elog e examinar os resultados. Como aparece o delay? O atraso de transmissão está coerente?

Livros sobre ADS

• [3]
• [4]
• [5]
• [6]
• [7]
• [8]
• [9]

Links Interessantes

• [10]