Desenvolva aplicativos de IoT escaláveis usando o MQTT

O protocolo MQTT é um protocolo de rede padrão leve e flexível, sendo perfeito para desenvolvedores de IoT. Pode ser usado para passar mensagens entre dispositivos de clientes, como sensores de IoT, e brokers MQTT, que são um servidor que recebe e encaminha as mensagens a outros dispositivos de clientes. Leia meu artigo anterior para saber por que o MQTT é um dos melhores protocolos de rede para casos de uso de IoT.

Neste artigo, examinaremos casos de uso do MQTT no mundo real em dispositivos de borda de IoT, como o Raspberry Pi. Apenas com um pouco de código, mostrarei como capturar dados de sensores de IoT (sensores DHT11 ou DHT22) conectados ao Raspberry Pi e a usar um broker MQTT para processar, armazenar e encaminhar os dados a outros dispositivos na rede. Existem muitos casos de uso para esses sensores ambientais inteligentes. Você poderia, por exemplo, colocar esse Pi com seus sensores em uma estufa e deixá-lo controlar as unidades de climatização e irrigação para manter as plantas em um ambiente ideal.

Configurando um Raspberry Pi

O Raspberry Pi é um computador muito eficiente em um minúsculo pacote. A opção mais barata, o Raspberry Pi Zero, é capaz de executar uma distribuição Linux com todos os recursos e gerar uma exibição em alta definição. Tem o tamanho de duas moedas (de 25 centavos de dólar) e custa US$ 5. Por US$ 10, o Raspberry Pi Zero W vem com WiFi e Bluetooth integrados.

Caso este seja seu primeiro Raspberry Pi, a maneira mais fácil (porém mais cara) de configurá-lo é comprar um kit para desktop por cerca de US$ 100. Ele vem com tudo o que é necessário para um computador, exceto o monitor. O kit geralmente inclui um cartão MicroSD pré-carregado com Linux para Raspberry Pi. Caso não adquira um kit, é possível comprar um cartão MicroSD de 16 GB por US$ 10 online, um leitor de cartão MicroSD e usar o Raspberry Pi Imager para carregar um sistema operacional no cartão MicroSD usando seu laptop.

Instalando um sistema operacional em cartões MicroSD

As duas opções populares são Raspberry Pi OS e o Ubuntu Linux. Ambos são distribuições do Linux com base em Debian. A maioria dos kits para iniciantes tem a pré-instalação do Raspberry Pi OS nos cartões MicroSD (é chamada de NOOBS).

Para desenvolvedores que desejam apenas usar o dispositivo como servidor ou dispositivo de IoT, o Ubuntu Linux é uma opção melhor. Ele possui as bibliotecas e pacotes de software mais recentes. Pode ser muito mais eficiente sem o Windows para desktop, o navegador da web, Java, jogos e ferramentas de aprendizado.

É possível baixar imagens do Ubuntu Server para Raspberry Pi na web e carregar em um cartão MicroSD. No entanto, talvez seja mais fácil simplesmente usar o Raspberry Pi Imager, selecionar o Ubuntu Server 20.04 TLS no menu e gravá-lo em um cartão MicroSD vazio.

Depois que o cartão MicroSD estiver preparado, siga estas instruções para inserir o nome da rede WiFi e a senha. Desse modo, o dispositivo Raspberry Pi se conecta à rede assim que é inicializado.

Basicamente, basta inserir o cartão MicroSD no Raspberry Pi, conectar o cabo USB e esperar ele ficar online. É possível encontrar o IP do dispositivo raspberrypi no seu roteador WiFi e efetuar SSH nele usando qualquer computador na sua rede.

O nome de usuário e a senha iniciais são ubuntu / ubuntu. Não é necessário conectar um monitor ou teclado. E assim é feita uma configuração completamente headless!

Instalando o Node.js no seu Pi

Há várias bibliotecas MQTT para Linux no Raspberry Pi. Recomendo o uso do Node.js por vários motivos.

  • Em primeiro lugar, o Node.js fornece um ecossistema de ferramentas e bibliotecas que funcionam com casos de uso de IoT. É muito fácil instalar software no Node.js. Com o NPM, é possível instalar módulos para MQTT, suporte a sensor e novos tempos de execução com uma linha de comandos.
  • Em segundo lugar, para a maioria dos desenvolvedores, é fácil entender JavaScript. Trata-se de uma boa linguagem para escrever aplicativos de IoT.
  • Em terceiro lugar, o Node.js é um tempo de execução de alto desempenho. Embora os aplicativos Node.js sejam escritos em JavaScript, muitas tarefas computacionalmente pesadas ou intensivas em E/S são executadas, na verdade, por binários nativos por meio do tempo de execução.

Para instalar o Node.js no Ubuntu 20.04 ou no Raspberry Pi OS, efetue SSH no dispositivo e execute o comando a seguir no terminal de SSH.

$ curl -sL https://deb.nodesource.com/setup_10.x | sudo bash - $ sudo apt install nodejs

Para verificar se a instalação foi feita corretamente, execute os dois comandos a seguir: $ node -v e $ npm -v. Agora, node e npm estão disponíveis.

Aqui, é possível usar npm para instalar módulos adicionais para comunicação MQTT e acessórios de IoT.

Usando o MQTT para assinar uma fila de mensagens

Para instalar a biblioteca MQTT no Node.js, execute o comando a seguir em um console SSH conectado ao seu Raspberry Pi.

$ npm install mqtt --save

Agora, é possível escrever um aplicativo JavaScript simples para enviar mensagens à IBM Internet of Things Platform. Para saber como configurar um broker MQTT (IBM Internet of Things Platform) e as credenciais de acesso dele, leia meu artigo anterior.

const connectOptions = {
    port: 8883,
    host: za6xa7.messaging.internetofthings.ibmcloud.com,
    rejectUnauthorized: false,
    protocol: 'mqtts',
    username: a-za6xa7-lxmzussonj,
    password: auth-token-here,
    clientId: "a:za6xa7:test1",
    ca: "messaging.pem"
};

var mqtt = require('mqtt');
var client  = mqtt.connect(connectOptions);

client.subscribe("iot-2/type/test/id/4321/evt/status/fmt/+");

client.on('connect', function () {
  client.publish('iot-2/type/test/id/4321/evt/status/fmt/json', '{\"mesg\" : \"hello IBM\"}');
});

client.on('message', function (topic, message) {
  // message is Buffer
  console.log(message.toString());
});

Esse aplicativo JavaScript abre uma conexão MQTT segura com a IBM Internet of Things Platform e assina uma fila de mensagens. Ele envia uma mensagem de status quando está conectado e imprime todas as mensagens recebidas. O exemplo mostra que é possível capturar dados de sensores de IoT conectados ao Raspberry Pi, estruturar os dados em JSON e enviar a mensagem JSON a um broker MQTT para ser processada, armazenada ou encaminhada a outros dispositivos na rede.

Lendo e enviando dados com PINs GPIO no Pi

Quando acessórios de IoT, como sensores, luzes de LED e motores, são anexados ao Raspberry Pi, geralmente se comunicam com o dispositivo Pi por meio de PINs GPIO. No software, é possível ler a tensão em cada PIN e também definir a tensão em cada PIN. Isso permite que o software se comunique com o hardware externo conectado a esses PINs.

O pacote GPIO no Node.js permite que seu aplicativo leia e defina o status do PIN usando JavaScript simples. Para instalá-lo, use o comando npm a seguir.

$ npm install gpio

O comando a seguir define o PIN 4 como alta tensão. Se o PIN estiver conectado a uma luz de LED, a luz acenderá.

var gpio = require("gpio");

var gpio4 = gpio.export(4, {
   direction: gpio.DIRECTION.OUT,
   interval: 200 // Must wait this amount of ms between set() actions
});

gpio4.set(); // Set to high voltage; Turn on the light
// ...  do something else ...
gpio4.set(0); // Set of low voltage; Turn off the light.

O comando a seguir lê a tensão do PIN 4.

var gpio = require("gpio");
var gpio4 = gpio.export(4, {
   direction: gpio.DIRECTION.IN
});

gpio4.on("change", function(val) {
   // value will report either 1 or 0 (number) when the value changes
   console.log(val)
});

Com os módulos MQTT e GPIO, é possível usar uma IBM Internet of Things Platform para receber e armazenar dados de sensores remotos, bem como enviar comandos a eles.

Lendo e enviando dados de sensor do Pi para o broker MQTT

Existem muitos sensores de IoT que funcionam com o Raspberry Pi. Os sensores geralmente se comunicam com o dispositivo Raspberry Pi por meio de PINs GPIO na placa.

Vamos usar os sensores de temperatura e umidade DHT11 e DHT22 como exemplos. Esses sensores ambientais são úteis em vários aplicativos do mundo real. Um deles poderia ser colocado no quintal, por exemplo, do lado de fora da casa com condicionamento de ar. Ele será capaz de mensurar a temperatura e a umidade externas, computando o índice térmico no Raspberry Pi. É possível consultar as leituras no dispositivo móvel antes de sair de casa. Outro exemplo é colocar os sensores ambientais conectados do Raspberry Pi no interior de uma estufa. O dispositivo Raspberry Pi poderia controlar as unidades de climatização e irrigação na estufa por WiFi ou outros dispositivos conectados aos PINs GPIO de modo a manter as plantas no ambiente ideal.

O DHT11 e o DHT22 são sensores muito pequenos. Cada um tem quatro PINs para conectar ao Raspberry Pi. Dois dos PINs são para energia, um é para dados e um PIN não é conectado ou usado. Confira a Etapa 1 do tutorial “Introdução ao desenvolvimento de soluções para IoT” e aprenda a configurar os sensores de hardware e conectá-los ao dispositivo Pi. Observe a resistência necessária para regular a corrente elétrica fornecida ao sensor.

O Raspberry Pi envia um pulso de alta tensão através do PIN de dados para informar ao sensor que está pronto para ler os dados de temperatura e umidade. O sensor responde por 40 pulsos de 0s (baixa tensão) e 1s (alta tensão), o que codifica os valores de temperatura e umidade. Embora seja possível escrever um programa para ler os pulsos diretamente nos PINs GPIO e decodificar as leituras do sensor, existe uma maneira mais fácil.

O pacote NPM node-dht-sensor fornece uma API simples para ler dados desses sensores.

$ npm install node-dht-sensor

O código JavaScript abaixo lê os dados de temperatura e umidade de um sensor DHT11 com o PIN DATA conectado ao GPIO 4 do Raspberry Pi.

var sensor = require("node-dht-sensor");

sensor.read(11, 4, function(err, temperature, humidity) {
  if (!err) {
    console.log(`temp: ${temperature}°C, humidity: ${humidity}%`);
  }
});

Depois de ler os valores de temperatura e umidade, é possível enviá-los a um broker MQTT, como a IBM Internet of Things Platform, para que outros dispositivos e serviços conectados ao broker possam ver essas leituras e responder a elas. Por exemplo, um serviço de envio de mensagens conectado ao hub poderia monitorar a temperatura e enviar alertas a telefones celulares quando as leituras forem demasiadamente altas por três vezes consecutivas.

Resumo e próximas etapas

Neste artigo, discutimos como o protocolo MQTT é usado em aplicativos do mundo real. Usamos um dispositivo Raspberry Pi para gerenciar sensores ambientais e enviar as leituras em mensagens MQTT. Um broker MQTT na IBM Internet of Things Platform escuta tais mensagens. Ele grava (e, potencialmente, poderia despachar) essas leituras ambientais no lado do servidor. Agora, é hora de começar a usar seus próprios aplicativos MQTT!

Caso esteja pronto para colocar em uso seu conhecimento recém-adquirido de MQTT, confira este tutorial “Adquira aptidões de IoT desenvolvendo um sistema de monitoramento de portas.”