Contiki

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar

Contiki

O que é o Contiki

Contiki é um sistema operacional de código aberto que conecta micro controladores de baixa potência à Internet. Contiki apoia plenamente o padrão IPv6 e IPv4 e os últimos padrões wireless de baixo consumo: 6LoWPAN , RPL, COAP. Contiki é executado em uma grande quantidade de dispositivos sem fio de baixa potência (Contiki et al. 2013). O Contiki introduziu a comunicação IP em redes de sensores de baixa potência (CONTIKI, 2012), este é desenvolvido por um grupo de desenvolvedores liderados por Adam Dunkels e contém duas pilhas de comunicação: uIP e Rime.

O kernel é orientado a eventos, mas o sistema suporta dar preferência à programação multi-threading que pode ser aplicado em uma base por processo. De preferência multi-threading é implementado como uma biblioteca que está ligada apenas com programas que exigem explicitamente multi-threading (DUNKELS et al, 2004). Este sistema operacional oferece suporte à comunicação IP, neste trabalho utilizamos uma pilha de comunicação μIP a qual também é suportada pelo sistema operacional, tanto nas versões quatro (IPv4) como na versão seis (IPv6). μiP e Contiki são utilizadas em centenas de empresas em sistemas de navios cargueiros, satélites e equipamentos de perfuração de petróleo, e são altamente reconhecidos pela popular ferramenta de escaneamento de redes nmap (CONTIKI 2.6, 2012)

Download Contiki e VMWare Player

Para instalar o Contiki acesse:

Foi escolhido o software VMWare Player pra simular a maquina virtual do Contiki. O VMWare pode ser baixado em:

Instalação

Baixe o Contiki

> git clone https://github.com/contiki-os/contiki


Teclado de Inglês para Português: > sudo dpkg-reconfigure keyboard-configuration

Estrutura genérica da aplicação Contiki

PROCESS(process_name, "The string representation of the process name"); 
AUTOSTART_PROCESSES(&process_name); 

PROCESS_THREAD(process_name, process_event_t, process_data_t){
 PROCESS_BEGIN();
 /*Execução do código*/
 PROCESS_END();
}

Erros previstos

Tópico reservado para anotar soluções de problemas previstos no uso do mote MicaZ no Cooja.

Cooja não compila arquivos para mote MicaZ

Esse é um erro que já é deparado em interações iniciais com o Cooja. Qualquer que seja o arquivo .c compilado pro MicaZ, dá o seguinte erro: 

 
In file included from ../../cpu/avr/dev/flash.c:4:0:
/usr/lib/avr/include/avr/boot.h:112:16: error: attempt to use poisoned "SPMCR"
 #elif defined (SPMCR)

Este é um bug do avr-gcc e é bem reportado. Então foi fácil consertar. Você precisa corrigir /usr/lib/avr/include/avr/boot.h da seguinte forma: 

#if defined (SPMCSR)
#  define __SPM_REG SPMCSR
#else
 #if defined (SPMCR)
  #  define __SPM_REG SPMCR
#else
  #  error AVR processor does not provide bootloader support!
 #endif
#endif

Com isso, os erros de compilação passam a não aparecer mais.

Módulo MicaZ não recebe informação

Esse problema é caracterizado usando o módulo MicaZ no Cooja. Usando exemplos simples como "examples/rime/example-abc.c", os motes transmitiam as mensagens porém o outro lado não recebia e vice-versa (printf da função receive não aparecia no output do Cooja).

A solução foi trocar os protocolos no arquivo "platform/micaz/contiki-conf.h", deixando assim: 

#define NETSTACK_CONF_NETWORK sicslowpan_driver
#define NETSTACK_CONF_MAC     csma_driver
//#define NETSTACK_CONF_MAC     nullmac_driver
#define NETSTACK_CONF_RDC     nullrdc_driver
//#define NETSTACK_CONF_RDC     sicslowmac_driver
#define NETSTACK_CONF_FRAMER  framer_802154

Criando um makefile

Para cada código .c que for criado, é necessária a criar o arquivo que contém as instruções para as ferramentas de compilação da tarefa, o conhecido makefile. O arquivo makefile deve estar no mesmo diretório do código criado para a aplicação Contiki. A seguir, alguns passos de como criar o seu makefile: Em breve...

Iniciando a implementação

Process

Como visto anteriormente, o process é um método essencial para o funcionamento da aplicação. Nesta seção, iremos estar explicando melhor cada método da biblioteca process.h e como são implementados no Contiki.

Uma process_thread contém o código do processo. Nela há uma protothread que é invocada pelo escalonador de processos. A protothread é uma maneira de estruturar o código de modo que permita que o sistema execute outras atividades enquanto o código está aguardando que algum determinado evento aconteça.

Vamos agora para os métodos:

  • PROCESS() -> Criador do processo.
  • AUTOSTART_PROCESS() -> Inicia o processo automaticamente passado o seu nome por referência.
  • PROCESS_BEGIN() -> Define o inicio de um processo.
  • PROCESS_END() -> Define o fim de um processo.
  • PROCESS_WAIT_EVENT() -> bloqueia o processo atualmente em execução até que o processo receba um evento.
  • PROCESS_WAIT_EVENT_UNTIL() -> Necessita ser passada uma condição que deve ser verdadeira para chamar o processo.
  • PROCESS_EXITHANDLER(handler) -> Especifica uma ação quando há uma saída do processo.

Timers

A utilização dos timers nos permitirá acionar eventos em um determinado momento, acelerando a transição de um estado para outro e automatizar um determinado processo ou tarefa.

No Contiki existem 4 tipos de timers:

  • Simple timer: A aplicação deve conferir manualmente se o timer expirou. #include "sys/timer.h".
  • Callback timer: Quanto o timer expira o callback chama uma determinada função. #include "sys/ctimer.h".
  • Timer Event: O mesmo que acima, mas em vez de chamar uma função, quando o timer expira posta um evento sinalizando sua expiração. #include "sys/etimer.h".
  • Real time timer: O módulo em tempo real lida com o agendamento e execução de tempo real tarefas. #include "sys/rtimer.h"

Clock Timer

A biblioteca clock é a interface entre o Contiki e a funcionalidade clock da plataforma especificada.

  • CLOCK_SECOND - A biblioteca clock define esse macro para converter segundos na resolução de instante da plataforma.

Interface de sistema de arquivo do Contiki

A interface do sistema de arquivos Contiki (CFS) define uma API abstrata para ler diretórios e ler e gravar arquivos. A seguir alguns principais métodos e atributos da biblioteca.

  • cfs_open (const char *name, int flags) - Abre um arquivo.
  • cfs_close (int fd) - Fecha um arquivo.
  • cfs_read (int fd, void *buf, unsigned int len) - Lê o dado de um arquivo aberto.
  • cfs_write (int fd, const void *buf, unsigned int len) - Escreve dado em um arquivo aberto.
  • cfs_seek (int fd, cfs_offset_t offset, int whence) - Procura uma posição especifica em um arquivo aberto.
  • cfs_remove (const char *name) - Remove um arquivo.
  • CFS_READ - Atributo que especifica ao cfs_open() que o arquivo aberto é para leitura.
  • CFS_WRITE - Atributo que especifica ao cfs_open() que o arquivo aberto é para escrita.

Packet buffer

Um packet buffer é uma estrutura que é usada para criar pacotes de saída ou para armazenar um pacote de entrada. Um packet buffer também é usado para realizar operações em um pacote e só é possível armazenar um pacote por vez.

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Contiki&oldid=150604”