Simulando aplicações simples com TinyOS e Cooja

Ultimamente, os sistemas distribuídos usando redes de sensores sem fio (RSSF), estão sendo bastante estudados. Apesar de poucas pessoas conhecerem o trabalho, que é desenvolvido com esse tipo de rede, existem várias aplicações que fazem seu uso – aplicações de sensoreamento em geral (exército, medicina, escritórios, plantações).

Venho, portanto, por meio deste tutorial, mostrar como simular algo no TinyOS, uma espécie de sistema operacional voltado para o desenvolvimento de aplicações de RSSF, juntamente com o software Cooja, que simula um ambiente de rede, permitindo analisar tudo o que acontece durante a execução da aplicação.

A linguagem de programação utilizada no desenvolvimento é bem parecida com a linguagem C, ela se chama nesC (network embedded systems C).

De uma maneira geral, um programa em nesC é composto por dois arquivos, são eles o componente de configuração e o componente de implementação:

1. O primeiro é voltado para definir e criar uma interface para componentes reais, que vão prover as funcionalidades que estamos interessados.
2. O segundo, visa implementar os eventos das interfaces do módulo, que contém as interfaces que serão usadas na aplicação.

Obs.: a compreensão do código fica por conta do aprendiz. Eu utilizo o livro “TinyOS Programming eBook”.

Esta é a máquina virtual, já configurada com os softwares que serão utilizados (a senha é user):

• http://cia2.inf.ufg.br/ftp/images/Contiki_TinyOS.ova

1. Simulando a app Blink:

Inicialmente, irei demonstrar como simular uma simples aplicação exemplo do TinyOS, chamada Blink.

Em resumo, este exemplo tem como finalidade, apenas ligar e desligar os LEDs dos sensores. Para acessar as aplicações disponíveis, acesse o diretório “home/tinyos/apps”. Nesta pasta você terá acesso a alguns apps exemplos do TinyOS.

2. Entre na pasta Blink e verifique os arquivos “BlinkAppC.nc” e “BlinkC.nc”, o Makefile e o README.

2.1 Você poderá abrir os arquivos e ver os códigos.

3. Temos que compilar a aplicação, e para isso, abra o terminal e vá até ao diretório em que o respectivo exemplo se encontra. Digite o seguinte comando:

$ make telosb

Obs.: telosb é um tipo de sensor, executando o comando make telosb, você estará compilando a aplicação para o sensor telosb, o mais usado geralmente.

Caso o make for executado sem erros, você visualizará este mesmo log de compilação.

4. Você irá perceber que na pasta em que se encontra os arquivos “.nc”, foi criado uma pasta com o nome build, que contém a pasta telosb. Dentro dessa pasta, estão os arquivos resultantes da compilação.

5. Vá ao Desktop e abra o simulador Cooja (ele será pré-carregado pelo terminal, abrindo logo em seguida.)

5.1. File → New Simulation (Ctrl+n).

5.2. Dê um nome a sua simulação e clique em: Create.

5.3. Você verá que o ambiente de simulação será carregado.

6. Agora, temos que carregar o código compilado da aplicação para os sensores em nossa rede. Para isso, precisamos criar os sensores.

6.1. Motes → Add Motes → Create new mote type → Sky mote.

6.2. A seguinte janela irá aparecer, pedindo a descrição do sensor (nome e o firmware). O nome pode ser qualquer.

Já o firmware será o arquivo “main.exe”, que se encontra no diretório “…/build/telosb” do app Blink.

Clique em Browse e navegue até selecionar o arquivo “main.exe”. Clique em Open e em seguida, em Create.

6.3. Escolha a quantidade de sensores que você quer ter na sua simulação (para esta, basta um sensor) e clique em: Add motes.

6.4. Você verá que o nó foi criado na aba Network do simulador. Para ativar atributos desse sensor, clique no menu View e escolha o desejado. Como nossa aplicação irá trabalhar com os LEDs do sensor, queremos então, ativar os LEDs.

6.5. Antes de colocar a simulação para rodar, vá até a aba Simulation control e defina a velocidade para 100%, simulando numa métrica real de tempo.

6.6. Clique em Start.

A simulação irá iniciar, começando a piscar os LEDs após 4~6 segundos de simulação (este é o tempo que, supostamente, demora para carregar o código no sensor). Para parar a simulação, clique em Stop.

6.7. Você poderá ver o resultado no próprio nó e também na aba Timeline, na parte inferior do simulador Cooja.

1. Simulando comunicação “cliente-servidor” com apps PppRouter e MyEcho:

Para trabalharmos com essa simulação, precisaremos de dois APPs, que também vêm junto com o TinyOS.

O funcionamento da aplicação é simples:

Definimos um nó como servidor, que recebe uma requisição de um nó na ponta da rede. Ocorre a troca de mensagens com estes dois nós por intermédio de outros nós “secundários” na rede e, o nó principal, que funcionará como servidor, irá responder ao comando recebido com uma mensagem de eco, retornando o que ele receber – se eu enviar a mensagem “TESTE ECO”, o servidor retornará “TESTE ECO”.

2. Entre na pasta do pppRouter (/home/tinyos/apps) e compile o APP com o seguinte comando:

$ make telosb blip

3. Entre na pasta do MyEcho (/home/tinyos/apps) e compile o APP com o mesmo comando anterior.

Compilamos os dois APPs necessários. Agora, vamos integrá-los na simulação no Cooja.

4. Abra o Cooja para configurar a simulação.

4.1. Crie uma nova simulação, com o nome que quiser.

4.2. Crie o primeiro Sky mote com o código do pppRouter (tem que ser o mote 1). Navegue até a pasta “build/telosb” dentro da pasta do APP pppRouter e selecione o main.exe:

* Importante: adicione apenas um nó com esta configuração.

4.3. Agora, você pode criar quantos Sky motes você quiser com o código do APP MyEcho (em média de 3 a 5 nós).

5. O tutorial em relação à primeira simulação difere-se neste ponto. Aqui, iremos fazer o uso de dois scripts simples que irão nos ajudar a configurar nossa interface de comunicação na rede simulada, criando uma conexão via socket.

5.1. Clique com o botão direito sobre o nó sensor 1 e procure a opção:

→ Mote tools for Sky 1 → Serial socket (SERVER)

5.1.1. Uma janela irá abrir indicando que a porta 60001 está escutando.

Neste momento, usaremos os dois scripts mencionados. Eles serão usados, basicamente, para criar uma interface chamada ppp0 de comunicação na rede.

5.2. Crie um documento em branco e salve-o com o nome socket.sh, contendo o seguinte conteúdo:

5.3. Crie um segundo arquivo com o nome de interface.sh com o seguinte conteúdo:

5.4. Crie um terceiro arquivo com o nome de pppd.sh contendo:

5.5. Abra um terminal para executar cada comando, deixando-os pré-escritos, ao ponto de se apertar Enter.

5.5.1. Deixe uma aba no terminal do socket.sh com o comando ifconfig, para que você possa verificar se a interface ppp0 foi realmente criada.

5.6. Volte ao Cooja, coloque a velocidade em 100% e inicie a simulação.

5.7. Ative o comando socket.sh.

5.8. Em seguida, rode o arquivo interface.sh, configurando assim, o endereço IPv6.

Se tudo der certo, irá criar uma interface de rede ppp0 – vide via comando ifconfig em uma aba do terminal.

Abri dois terminais, configurei o Cooja, e deixei o socket.sh no primeiro terminal, e o interface.sh no segundo. Ao iniciar a simulação, executei os comandos nos terminais.

Interface ppp0 criada.

6.Tudo deve estar funcionando.

6.1. Use o nc6 para iniciar uma comunicação com os sensores:

$ nc6 -u fec0::2 8989

6.2. Tudo que digitar depois será enviado até o sensores, que responderá com a mesma String.

Chegamos ao final deste tutorial, galera.

Espero que ele não esteja ficado muito confuso, mas também espero que tenha alcançado o objetivo de trazer um pouco sobre o funcionamento das aplicações em RSSF.

O TinyOS nos oferece um suporte junto com o IPv6, onde podemos criar aplicações poderosas e que sejam de grande utilidade no campo tecnológico. A partir destes simples tutorial fica livre o interesse da comunidade em aprofundar mais nesse ramo de Rede de Computadores.

Não pare por esses exemplos, procure compreender bem o funcionamento deles e sigam em frente com os estudos.

Muito obrigado.