O uso de ontologias, tradicionalmente vinculado às ciências cognitivas e à web semântica, vem ganhando espaço em contextos mais técnicos como a Internet das Coisas (IoT) e os Sistemas Embarcados. Neste artigo, exploramos como ontologias podem organizar o conhecimento de sensores, dispositivos e contextos de forma padronizada e interoperável, facilitando o desenvolvimento, a escalabilidade e a manutenção de sistemas inteligentes. Também apresentamos exemplos práticos de aplicação em C no ESP32.

O que é Ontologia em Computação?

Na ciência da computação, uma ontologia é uma representação estruturada de conhecimento de um domínio específico, composta por:

• Conceitos (classes) — como “Temperatura”, “Sensor”, “Dispositivo”
• Propriedades (atributos) — como “valor”, “unidade”, “timestamp”
• Relações — como “um Sensor mede uma Temperatura”
• Regras de inferência e restrições — como “um valor de temperatura em °C deve estar entre -40 e 125”.

Aplicações de Ontologia em IoT e Sistemas Embarcados

1. Interoperabilidade Semântica

Permite que sensores de diferentes fabricantes “falem a mesma língua” em gateways, hubs ou sistemas centralizados.

2. Autodescrição de Dispositivos

Usando ontologias, um sensor pode anunciar seu tipo, unidade de medida, intervalo de operação, e método de leitura, facilitando configuração automática.

3. Raciocínio Baseado em Regras

Um sistema pode inferir que “o ambiente está em risco de incêndio” se Temperatura > 60°C e Sensor de Fumaça = Ativado.

4. Diagnóstico e Autoconfiguração

Ontologias permitem definir causas e efeitos, como “se umidade estiver zero e temperatura estiver alta, o sensor pode estar desconectado”.

Estrutura Ontológica Simples para Sensores

Vamos criar uma mini ontologia em C para o ESP32, simulando algo como:

Sensor → Temperatura
        → Umidade

Sensor tem:
  - nome
  - unidade
  - valor
  - função de leitura

Exemplo em C para ESP32

Estrutura Base

typedef struct {
    char nome[20];
    char unidade[10];
    float valor;
    float (*lerValor)(void);  // ponteiro para função de leitura
} Sensor;

Funções de Leitura Simuladas

float lerTemperatura() {
    // Simula leitura de sensor
    return 25.0 + (rand() % 1000) / 100.0;
}

float lerUmidade() {
    return 40.0 + (rand() % 1000) / 100.0;
}

Criando os Sensores

Sensor sensorTemp = {
    .nome = "Temperatura",
    .unidade = "C",
    .lerValor = lerTemperatura
};

Sensor sensorUmi = {
    .nome = "Umidade",
    .unidade = "%",
    .lerValor = lerUmidade
};

Leitura em Loop

void loopSensores() {
    sensorTemp.valor = sensorTemp.lerValor();
    sensorUmi.valor = sensorUmi.lerValor();

    printf("Sensor: %s = %.2f %s\n", sensorTemp.nome, sensorTemp.valor, sensorTemp.unidade);
    printf("Sensor: %s = %.2f %s\n", sensorUmi.nome, sensorUmi.valor, sensorUmi.unidade);
}

Expandindo com Inferência Simples

Vamos fazer uma “regra ontológica” hardcoded:

void verificarCondicoes() {
    if (sensorTemp.valor > 60.0 && sensorUmi.valor < 10.0) {
        printf("⚠ Risco de superaquecimento e ar seco!\n");
    }
}

Benefícios Concretos

• Reuso de código com base em tipos semânticos
• Padronização do comportamento de sensores
• Capacidade de diagnóstico automatizado
• Facilidade para integração com sistemas semânticos (ex: OWL + MQTT + RDF)

Ontologia em Comunicação Semântica: Integrando ESP32 com MQTT

Além da modelagem local de sensores no firmware, as ontologias brilham quando utilizadas em sistemas distribuídos, permitindo que um sensor transmita dados já semânticos, ou seja, com significado explícito.

Vamos ver como isso funciona na prática, criando uma camada que transmite dados com metadados semânticos usando MQTT — um dos protocolos mais populares em IoT.

Estrutura da Mensagem Ontológica

Em vez de apenas transmitir 25.3, transmitimos algo como:

{
  "sensor": "Temperatura",
  "valor": 25.3,
  "unidade": "C",
  "contexto": "ambiente_interno",
  "tipo": "observação",
  "timestamp": 1711459200
}

Essa estrutura, ainda que JSON simples, representa uma mini-ontologia em ação.

Enviando via MQTT com ESP32 (usando PubSubClient)

Instalação das dependências (no PlatformIO ou Arduino IDE)

lib_deps =
  knolleary/PubSubClient
  bblanchon/ArduinoJson

Código para Envio com Ontologia JSON

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

WiFiClient espClient;
PubSubClient mqtt(espClient);

const char* ssid = "SuaRedeWiFi";
const char* password = "SenhaDaRede";
const char* mqttServer = "broker.hivemq.com";

void conectarWiFi() {
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
}

void conectarMQTT() {
  mqtt.setServer(mqttServer, 1883);
  while (!mqtt.connected()) {
    mqtt.connect("esp32_ontologia");
  }
}

Função para Enviar um Dado Semântico

void enviarDadoOntologico(Sensor sensor, const char* contexto) {
  StaticJsonDocument<256> doc;
  doc["sensor"] = sensor.nome;
  doc["valor"] = sensor.valor;
  doc["unidade"] = sensor.unidade;
  doc["contexto"] = contexto;
  doc["tipo"] = "observação";
  doc["timestamp"] = millis();  // em produção use RTC ou NTP

  char mensagem[256];
  serializeJson(doc, mensagem);
  mqtt.publish("iot/esp32/sensores", mensagem);
}

Uso no Loop

void loop() {
  if (!mqtt.connected()) conectarMQTT();
  mqtt.loop();

  sensorTemp.valor = sensorTemp.lerValor();
  sensorUmi.valor = sensorUmi.lerValor();

  enviarDadoOntologico(sensorTemp, "ambiente_interno");
  enviarDadoOntologico(sensorUmi, "ambiente_interno");

  delay(5000);
}

Compatibilidade com Ontologias OWL/RDF

Esses dados, ao serem coletados no broker, podem ser convertidos para RDF ou consultados com SPARQL, caso estejam armazenados em uma base semântica (como o Apache Jena).

Você pode criar um mapeamento semântico entre o JSON e uma ontologia OWL, como:

:Sensor rdf:type owl:Class .
:valor rdf:type owl:DatatypeProperty ; rdfs:domain :Sensor ; rdfs:range xsd:float .

Benefícios de Integrar Ontologia com MQTT

• Reuso e composição automática de dados
• Integração com Knowledge Graphs e inferência
• Consulta semântica unificada de dispositivos heterogêneos
• Facilidade de extensão: novos sensores, mesmos padrões

Conclusão

A introdução de ontologias no desenvolvimento de sistemas embarcados e IoT não é apenas uma questão teórica — é uma abordagem pragmática para lidar com complexidade, interoperabilidade e evolução dos sistemas. Mesmo em plataformas como o ESP32, com recursos limitados, é possível aplicar os princípios semânticos para criar sistemas mais inteligentes, autodescritivos e expansíveis.

The post Ontologias Aplicadas a Sistemas Embarcados e IoT first appeared on MCU & FPGA.