EMECA - Sistemas Distribuídos

📖 Descrição Geral

Este projeto demonstra a implementação de um sistema de comunicação de sensores baseado em Contiki OS v3.x, com foco em processamento modular, comunicação via UDP (Unicast/Multicast) e adaptação a múltiplas plataformas de hardware (Motes Z1 e SKY).

A arquitetura separa claramente as responsabilidades: sensores modulares independentes recolhem dados, um cliente UDP os recolhe e envia, e um servidor UDP os recebe e apresenta no terminal. Cada componente pode ser compilado para diferentes plataformas com ajustes automáticos via pré-processador.

Contiki OS v3.x C Embedded Systems WSN

🎯 Objetivos de Aprendizagem

Compreender a arquitetura modular de processos em Contiki OS
Implementar leitura de sensores periféricos com eventos
Estruturar comunicação de rede (UDP) em sistemas embebidos
Adaptar código para múltiplas plataformas (Z1, SKY)
Monitorizar consumo de energia (Energest)
Usar configuração centralizada para modificar comportamento

🏛️ Arquitetura do Sistema

┌─────────────────────────────────────────────────────────┐
│                 CLIENTE (Mote)                          │
├─────────────────────────────────────────────────────────┤
│                 UDP Client Process                      │
│  ┌──────────────────────────────────────────────────┐   │
│  │ Recolhe eventos dos sensores modulares           │   │
│  │ Envia pacotes UDP para Servidor                  │   │
│  │ Monitora consumo energético                      │   │
│  └──────────────────────────────────────────────────┘   │
│            ↓              ↓              ↓               │
│  ┌─────────────┐ ┌──────────────┐ ┌─────────────┐      │
│  │Temp Process │ │Button Process│ │   Energest  │      │
│  │ (Periódico) │ │ (Evento)     │ │   (Leitura) │      │
│  └─────────────┘ └──────────────┘ └─────────────┘      │
│         ↓              ↓                                 │
│  ┌─────────────────────────────────────┐               │
│  │      Hardware Sensors (Z1/SKY)      │               │
│  │ tmp102/sht11 (Temp) | Button        │               │
│  └─────────────────────────────────────┘               │
└─────────────────────────────────────────────────────────┘
               UDP (Unicast/Multicast)
               Port 1234
                    ↓
┌─────────────────────────────────────────────────────────┐
│                 SERVIDOR (Mote)                         │
├─────────────────────────────────────────────────────────┤
│                 UDP Server Process                      │
│  ┌──────────────────────────────────────────────────┐   │
│  │ Recebe pacotes UDP                               │   │
│  │ Formata dados por tipo de sensor                 │   │
│  │ Imprime no terminal                              │   │
│  └──────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘

📁 Estrutura de Ficheiros

1️⃣ Configuração e Build

Makefile — Configuração de compilação

Define projetos (udp-server, udp-client)
Inclui ficheiros de sensores modulares (sensor-temp.c, sensor-button.c)
Ativa project-conf.h via CFLAGS

Ver Makefile

project-conf.h — Configuração centralizada do projeto

UNICAST — Define modo Unicast (1) ou Multicast (0)
UIP_CONF_IPV6_RPL — Desativa RPL para comunicação 1-salto
NETSTACK_CONF_RDC — Define camada RDC (Radio Duty Cycling)
NETSTACK_CONF_MAC — Define camada MAC (CSMA)
ENERGEST_CONF_ON — Ativa monitorização de energia

Ver project-conf.h

clean.sh — Script de limpeza

Remove binários compilados para diferentes plataformas
Remove diretórios de objectos intermediários
Garante ambiente limpo para recompilação

Ver clean.sh

2️⃣ Módulos de Sensores

sensor-common.h — Definições partilhadas

IDs de sensores (ID_Z1_TEMP, ID_SKY_TEMP, ID_Z1_BUTTON, ID_SKY_BUTTON)
Estrutura pacote_sensor_t com atributo packed (compatibilidade entre arquiteturas)
Declaração de eventos globais (event_temp_reading, event_button_pressed)
Porta UDP (UDP_PORT = 1234)

Ver sensor-common.h

sensor-temp.h / sensor-temp.c — Processo de leitura de temperatura

Periodicidade: READING_TIME = 10 segundos
Detecção de Plataforma:
- Z1: Usa tmp102 (sensor integrado)
- SKY: Usa sht11_sensor (sensor de humidade com temp)
Funções: temp_start(), temp_stop(), temp_get()
Processo: sensor_temp_process (evento PROCESS_BROADCAST)
Saída: Estrutura pacote_sensor_t com timestamp, seq, id, value

Ver sensor-temp.h Ver sensor-temp.c

sensor-button.h / sensor-button.c — Processo de detecção de botão

Detecção de Plataforma:
- Z1: Suportado via button_sensor
- SKY: Pode ser adaptado se tiver botão
Funções: button_start(), button_stop()
Processo: sensor_button_process (evento ao detetar pressão)
Ativação: Manual (iniciado por udp-client)
Saída: Estrutura pacote_sensor_t com contagem de pressões

Ver sensor-button.h Ver sensor-button.c

3️⃣ Comunicação UDP

udp-client.h / udp-client.c — Cliente UDP (Emissor)

Descrição: Recolhe eventos de sensores e os envia via UDP
Inicialização: Aguarda 30 segundos para estabilização da rede
Modo Unicast: Envia para IP/MAC específico do servidor (configurado por plataforma)
Modo Multicast: Envia para todos os nós (ff02::1)
Sensores Ativados:
- SKY: Apenas temperatura
- Z1: Temperatura + botão
Energest: Imprime CPU, LPM, Listen, Transmit em cada envio

Ver udp-client.h Ver udp-client.c

udp-server.h / udp-server.c — Servidor UDP (Recetor)

Descrição: Recebe e interpreta pacotes UDP de sensores
Callback: udp_rx_callback() processa cada pacote recebido
Formatação de Saída:
- Temperatura: "Temp: XX.X C" (com decimais)
- Botão: "Button State: X" (valor discreto)
Validação: Verifica tamanho do pacote antes de processar
Impressão: Endereço IP do cliente, seq, tipo, valor, timestamp

Ver udp-server.h Ver udp-server.c

🔄 Fluxo de Execução

Passo	Processo	Ação	Tempo
1	udp-client	Inicia e regista ligação UDP	0s
2	udp-client	Aguarda 30s para estabilização de rede	0-30s
3	udp-client	Ativa sensor de temperatura (periodic: 10s)	30s
4	udp-client	Ativa sensor de botão (Z1 apenas)	30s
5	sensor-temp	Lê temperatura e envia evento	30s, 40s, 50s...
6	sensor-button	Aguarda pressão e envia evento (à pressão)	Evento
7	udp-client	Recebe evento e envia via UDP	Reativo
8	udp-server	Recebe e imprime pacote	Reativo
9	udp-client	Imprime métricas de energia (Energest)	A cada envio

💡 Conceitos-Chave de Contiki OS

Conceito	Uso no Projeto	Ficheiro
Processos	PROCESS, PROCESS_THREAD, AUTOSTART_PROCESSES	sensor-.c, udp-.c
Eventos	process_alloc_event(), process_post(), PROCESS_WAIT_EVENT_UNTIL	sensor-*.c, udp-client.c
Timers	etimer_set(), etimer_expired(), etimer_reset()	sensor-temp.c
Sensores	SENSORS_ACTIVATE, sensor.value()	sensor-temp.c, sensor-button.c
Network Stack	simple_udp_register(), simple_udp_sendto()	udp-client.c, udp-server.c
IPv6	uip_ip6addr(), uip_ds6_nbr_add(), PROCESS_BROADCAST	udp-client.c
Energia	energest_type_time(), energest_flush()	udp-client.c, project-conf.h
Compilação Condicional	#if CONTIKI_TARGET_Z1, #if UNICAST, etc.	Todos os ficheiros

🛠️ Compilação e Execução

Compilar para diferentes plataformas:

# Cliente UDP para Z1
$ make TARGET=z1 udp-client

# Cliente UDP para SKY
$ make TARGET=sky udp-client

# Servidor UDP para Z1
$ make TARGET=z1 udp-server

# Limpeza de build
$ bash clean.sh

Modificar modo de comunicação:

Editar project-conf.h:

#define UNICAST 1  // Unicast (para servidor específico)
#define UNICAST 0  // Multicast (broadcast para todos)

📊 Estrutura de Dados

Pacote de Sensor (pacote_sensor_t):

typedef struct {
  uint16_t seq;        // Número de sequência
  uint8_t id;          // Identificador do sensor (ID_Z1_TEMP, etc)
  uint32_t timestamp;  // Segundos desde boot
  int16_t value;       // Valor do sensor (temperatura em 1/10 ºC, botão em pulsos)
} __attribute__((packed)) pacote_sensor_t;

// Tamanho: 8 bytes (alinhado para compatibilidade entre arquiteturas)

Identificadores de Sensores:

ID_Z1_TEMP    = 1   // Temperatura (Z1, sensor tmp102)
ID_SKY_TEMP   = 2   // Temperatura (SKY, sensor sht11)
ID_Z1_BUTTON  = 3   // Botão (Z1)
ID_SKY_BUTTON = 4   // Botão (SKY, se disponível)

📚 Aplicações e Extensões Possíveis

Adicionar mais sensores: Humidade, luminosidade, movimento (criar novos ficheiros modulares)
Implementar armazenamento: Guardar dados em EEPROM ou SD card
Roteamento avançado: Implementar protocolo RPL para redes multi-salto
Compressão de dados: Reduzir tamanho de pacotes para economizar energia
Interface web: Dashboard para visualizar dados em tempo real
Machine Learning: Análise de padrões de sensores no servidor
Alertas: Notificações quando valores excedem limiares