MQTT: um protocolo de rede aberto e sua importância na IoT

Lembre-se do nome MQTT, já que é um protocolo de comunicação de rede do tipo M2M (Machine to Machine) que vai soar um pouco. Está se tornando bastante popular graças à nova era da Internet das Coisas ou IoT (Internet of Things) por sua sigla em inglês. Além disso, é um protocolo aberto, o que oferece muitas vantagens.

Na verdade, ele se tornou um dos pilares centrais da IoT, pois é muito bom em dispositivos com algumas limitações de transmissão como essas. A sigla MQTT vem de Transporte de telemetria de enfileiramento de mensagens, um padrão aberto da OASIS e ISO (ISO / IEC 20922) para comunicações de rede e que geralmente é executado no famoso TCP / IP.

Protocolos de rede

Os protocolos de comunicação São regras que permitem que dois ou mais dispositivos ou sistemas se comuniquem entre si. Ou seja, é um protocolo de transmissão de informações por diversos meios e com formato definido, seja implementado por software e hardware (ou ambos).

El padrão do protocolo define uma infinidade de características de comunicação. Pode ir desde as regras de sincronização, semântica, sintaxe, formato de pacote, etc. E a verdade é que não são desprezíveis, pois graças a esses protocolos hoje podemos usar a Internet e outras redes de comunicação ...

E, claro, não existe apenas um protocolo, mas muitos. Por exemplo, os famosos DNS, FTP, MQTT, HTTP e HTTPS, IMAP, LDAP, NTP, DHCP, SSH, Telnet, SNMP, SMTP, etc., para a camada de aplicativo. Já na camada de transporte encontram-se alguns tão famosos como TCP, UDP, etc., bem como os da camada Internet como IPv4 ou IPv6 (aquele que possibilitou o maior número de IPs disponíveis e a chegada de a IoT), IPSec, etc., e outros da camada de link, como DSL, Ethernet, WiFi, ARP, etc.

Sobre os protocolos IoT

Claro, existem protocolos de comunicação específicos ou que podem ser aplicados ao Internet das coisas. Ou seja, considerando a seção anterior, seriam uma série de padrões definidos para que dois ou mais dispositivos IoT possam se comunicar e se entender, e geralmente são M2M, ou seja, comunicação máquina a máquina. muitos dispositivos IoT conectados e compartilhando informações de sensores ou outras fontes.

Devido ao grande número de dispositivos IoT, esses protocolos devem atender aos requisitos além das limitações de largura de banda, velocidade, etc. (note que muitos dispositivos são embutidos e baratos), o que geralmente é em alguns dispositivos. E quero dizer o fato de que deve ser escalável, para poder adicionar mais dispositivos conectados, se necessário e sem afetar o sistema global.

Além disso, eles precisam ter um baixa dependência acoplamento entre dispositivos, de modo que não sejam gerados problemas se um dispositivo for removido. E é claro que, ao mesmo tempo, busca-se alta interoperabilidade para que funcione com um grande número de dispositivos e sistemas muito variados, já que o mundo da IoT é bastante heterogêneo.

Outros recursos úteis seriam a facilidade de implementá-los, a segurançaetc. Lembre-se de que a IoT está criando grandes desafios no aspecto de segurança. Ainda mais quando muitos dos dispositivos conectados são geralmente críticos em certos casos ... por exemplo, brinquedos para menores.

Conceitos importantes

Dito isso, é preciso dizer que as soluções para IoT utilizam um servidor centralizado para receber as mensagens de todos os dispositivos conectados que as emitem e distribuí-las a todos os dispositivos IoT conectados que estão escutando. Esse servidor é conhecido como roteador ou corretor. Algo que está longe do relacionamento cliente-servidor convencional em alguns aspectos.

Além disso, as metodologias que você pode encontrar nestes protocolos de comunicação para IoT são:

• PubSub: Publicar / Susbcribe é um padrão de mensagem em que um dispositivo (Sub) informa ao corretor que deseja receber uma mensagem, enquanto outro dispositivo (Pub) publica mensagens para o corretor distribuir para os outros dispositivos que estão esperando por eles.
• rRPC: Chamadas de procedimento de remoder de roteador é outro padrão de execução de processo remoto. Nele, um dispositivo (Callee) informa à corretora que realizará determinado procedimento e a corretora o distribui para outro dispositivo (chamador) no qual o referido processo é executado.

Agora, para realizar essas metodologias ou padrões, um infraestrutura de mensagens. E, neste sentido, dois podem ser distinguidos:

• Fila de Mensagens: serviço de mensagens em que uma única fila de mensagens é gerada para todos os clientes que iniciam uma assinatura para o broker. Este último manterá as mensagens armazenadas até que sejam entregues ao cliente. Se o cliente ou destinatário não estiver conectado, ele será mantido até que seja conectado. Esses tipos de serviços são como aqueles usados ​​em aplicativos de mensagens instantâneas, como Telegra, WhatsApp, Messenger, etc.
• Serviço de mensagens: é outro serviço em que o corretor envia as mensagens ao cliente destinatário conectado, filtrando pelo tipo de mensagem. Se o cliente ou dispositivo receptor for desconectado, as mensagens serão perdidas (embora possa haver algum sistema de registro).

Protocolos de IoT

Tendo visto o acima, agora vamos dar uma olhada mais de perto Protocolos IoT que são mais conhecidos. Entre os mais proeminentes do M2M estão:

• AMQP (protocolo de enfileiramento de mensagens avançado): é um protocolo do tipo PubSub da Message Queue. Projetado para ter boa interoperabilidade e garantir confiabilidade. Especial para aplicações corporativas, de alto desempenho, redes de alta latência, críticas, etc.
• WAMP (protocolo de mensagens de aplicativos da Web): é outro protocolo aberto do tipo PubSub, como rRPC, e é executado em WebSockets.
• CoAP (protocolo de aplicativo restrito): é um protocolo especialmente desenvolvido para aplicações de baixa capacidade.
• TOMP (protocolo de transmissão de mensagens orientadas a texto): protocolo muito simples e para alcançar a interoperabilidade máxima. HTTP é usado para transmitir mensagens de texto.
• XMPP (protocolo eXtensible Messaging and Presence): outro protocolo usado em IoT para aplicativos de mensagens instantâneas e baseado em XML. Janeiro, este caso também está aberto.
• WMQ (Fila de mensagens do WebSphere): protocolo desenvolvido pela IBM. É do tipo Message Queue, como o nome sugere, e é orientado a mensagens.
• MQTT: (consulte a próxima seção)

Tudo sobre MQTT

El Protocolo MQTT É um protocolo de comunicação Message Queue, que segue o padrão PubSub, e do tipo M2M, como já mencionei. É amplamente usado na IoT e se baseia na pilha TCP / IP usada na Internet.

No caso do MQTT, toda conexão é mantida aberta e é reutilizado em todas as comunicações necessárias. Algo diferente do que acontece em outros protocolos conhecidos, que cada comunicação ocorra requer uma nova conexão.

Vantagens

As vantagens do protocolo MQTT são bastante evidentes em termos de comunicações M2M para IoT. Além de tudo o que foi dito acima, é um protocolo que fornece:

• Escalabilidade, para conectar mais e mais clientes.
• Decoupling entre clientes, para menos dependência.
• Assincronismo.
• Simplicidade.
• Leveza para não consumir muitos recursos (embora com a segurança TLS / SSL aumente).
• Energeticamente eficiente para dispositivos que dependem de bateria ou funcionam 24/7, não necessita de grande largura de banda (ideal para conexões lentas, como algumas wireless).
• Segurança e qualidade, para maior confiabilidade e robustez nas comunicações.

História

MQTT foi criado na década de 90, com uma versão inicial do protocolo em 1999. Foi criado pelo Dr. Andy Stanford-Clark da IBM e Arlen Nipper da Cirrus Link (anteriormente Eurotech).

La ideia inicial era criar um protocolo para monitorar um duto que percorria o deserto, com um protocolo de comunicação eficiente (baixo consumo de banda), leve, e que com baixo consumo de energia. Na época era muito caro, mas agora se tornou um protocolo barato e aberto.

O protocolo inicial foi melhorado com o aparecimento de novas versões, como MQTT v3.1 (2013) sob a especificação OASIS (Organização para o Avanço de Padrões de Informação Estruturada), etc. Você deve saber que no início era um protocolo proprietário da IBM, mas que seria lançado em 2010, acabou se tornando um padrão no OASIS ...

Como funciona a conexão MQTT

O protocolo MQTT usa um filtro, para as mensagens que são enviadas para cada cliente, com base em tópicos ou tópicos que são organizados hierarquicamente. Dessa forma, um cliente pode postar uma mensagem sobre um tópico específico. Dessa forma, todos os clientes ou dispositivos conectados que assinam o tópico receberão mensagens por meio do broker.

Assim como o MQ, as mensagens permanecerão na fila e eles não são perdidos até que o cliente receba essa mensagem.

As ligações, como também indiquei, são feitas via TCP / IP, e o servidor ou corretor manterá um registro dos clientes conectados. Por padrão, os dispositivos usarão as portas de comunicação número 1883, embora você também possa encontrar uma porta 8883 se estiver usando SSL / TLS para aumentar a segurança.

Para que a conexão seja possível, não são necessários apenas clientes, servidores e portas. Também outros pacotes ou mensagens enviadas para que a comunicação ocorra:

• Estabelecer conexão: CONECTAR mensagem / pacote enviado pelo cliente com todas as informações necessárias. Essas informações incluem o ID do cliente, nome de usuário, senha, etc. O corretor ou servidor responde com um pacote CONNACK que informará ao cliente que a conexão foi aceita, rejeitada, etc.
• Envie e receba mensagens: uma vez que a conexão é estabelecida, PUBLICAR pacotes ou mensagens são usados ​​com o tópico e a carga útil da mensagem enviada ao corretor. Por outro lado, o cliente ou clientes interessados ​​usam os pacotes ASSINAR e UNSUSCRIBE para assinar ou cancelar sua assinatura, respectivamente. O corretor também responderá com um pacote SUBACK e UNSUBACK respectivamente para relatar o sucesso da operação solicitada pelo cliente.
• Mantendo a conexão: para garantir que a conexão permaneça aberta, os clientes podem enviar periodicamente um pacote PINGREQ que será combinado com um pacote PINGRESP do servidor.
• Terminar conexão: quando um cliente se desconecta, ele envia um pacote DISCONNECT para relatar esse evento.

Essa mensagens ou pacotes Os que mencionei têm uma estrutura igual a outros pacotes de outros protocolos de rede:

• Cabeçalho ou cabeçalho fixo: é uma parte fixa que ocupa entre 2 a 5 bytes. Ele contém um código de controle, ID do tipo de mensagem enviada e seu comprimento. Entre 1-4 bytes são usados ​​para codificar o comprimento, usando os primeiros 7 bits de cada octeto como dados para o comprimento e um bit adicional de continuidade para determinar se há mais de um byte que compõe o comprimento da mensagem.
• Cabeçalho variável: nem sempre é obrigatório, mas opcional. Ele só está contido em alguns pacotes em certas situações ou mensagens específicas.
• Conteúdo ou dados: o pacote de dados é o que realmente contém a mensagem a ser enviada. Pode ser de alguns kB até um limite de 256 MB.

Se você está interessado em saber o código correspondente em hexadecimal para os tipos de mensagens enviadas são:

Qualidade e segurança das comunicações

Outro detalhe importante das mensagens por MQTT é o qualidade de serviço ou QoSe segurança. A robustez do sistema de comunicação em caso de falhas e a sua segurança dependerá disso.

Quanto à sua qualidade, ela pode ser determinada 3 níveis diferentes:

• QoS 0 (desconhecido)- A mensagem é enviada apenas uma vez, e em caso de falha não será entregue. É usado quando não é crítico.
• QoS 1 (reconhecer): a mensagem será enviada quantas vezes forem necessárias para garantir a entrega ao cliente. A desvantagem é que o cliente pode receber a mesma mensagem várias vezes.
• QoS 2 (garantido)- Semelhante ao anterior, mas com garantia de entrega apenas uma vez. Muitas vezes, é usado para sistemas mais críticos onde é necessária maior confiabilidade.

Por outro lado, quanto a Segurança MQTT, várias medidas podem ser utilizadas para garantir sua força neste sentido. Como já mencionei antes, a autenticação do nome de usuário e senha, como muitos outros protocolos, pode ser garantida por meio de SSL / TLS. Embora muitos dispositivos IoT com baixa capacidade ou recursos possam ter problemas com a sobrecarga de trabalho ao usar este tipo de comunicação segura ...

Por esse motivo, muitos dispositivos IoT que usam MQTT usam senhas e usuários em texto plano, o que poderia fazer com que alguém farejasse o tráfego da rede para obtê-los facilmente. E se isso não bastasse, o broker também pode ser configurado para aceitar conexões anônimas, o que permitiria a qualquer usuário estabelecer comunicações, envolvendo maior risco.

Usando MQTT com Arduino

Claro que você pode usar o protocolo MQTT com Arduino e outras placas de desenvolvimento, bem como a Rapsberry Pi, etc. Para fazer isso, você deve fornecer conectividade à sua placa Arduino, se ela não tiver. Além disso, a biblioteca Cliente Arduino para MQTT isso o ajudará nessas tarefas. Esta biblioteca é compatível com:

• ArduinoYUN
• Arduino WiFi (escudo)
• Arduino Ethernet (escudo)
• Módulo ESP8266
• Intel Galileo / Edison
• Raspberry Pi
• ...

Logo que ao código para usar MQTT em algumas aplicações, a verdade é que é simples. Na imagem do Fritzing você pode ver uma placa Arduino UNO ao qual a conectividade foi adicionada pelo Arduino Ethernet e também foi conectado um sensor de umidade e temperatura DHT22, embora pudesse ser qualquer outra coisa ...

Ok, dito isso, para o código que você tem que gerar em Arduino IDE Para trabalhar com o protocolo MQTT no Arduino, é simples assim:

• Pára enviar mensagens MQTT

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>
#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT22

// Direccion MAC del adaptador Ethernet
byte mac[] = { 0xCE, 0xAB, 0x0E, 0x3F, 0xFE, 0xD4 };

// IP del servidor (broker)
IPAddress mqtt_server(192, 168, 1, 4);

// Topic o tema con el que se trabaja
const char* topicName = "test";

DHT dht(DHTPIN, DHTTYPE);
EthernetClient ethClient;
PubSubClient client(ethClient);

void setup()
{
  Serial.begin(9600);
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Fallo en Ethernet usando DHCP");
  }
// Puerto 1883 de comunicación
  client.setServer(mqtt_server, 1883);
  dht.begin();
}

void loop()
{
  if (!client.connected()) {
    Serial.print("Conectando ...\n");
    client.connect("Cliente Arduino");
  }
  else {
    // Envío de informacion del sensor de temperatura y humedad
    float temp = dht.readTemperature();
    char buffer[10];
    dtostrf(temp,0, 0, buffer);
    client.publish(topicName, buffer);
  }
  // Tiempo entre envíos en ms (cada 10 segundos)
  delay(10000);
}

• Pára receber mensagens por MQTT você só precisa da placa Arduino UNO e conexão, com Arduino Ethernet ou qualquer outro elemento. Quanto ao código, um exemplo seria:

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

// Direccion MAC del adaptador Ethernet
byte mac[] = { 0xCE, 0xAB, 0x0E, 0x3F, 0xFE, 0xD4 };

// IP del servidor (broker)
IPAddress mqtt_server(192, 168, 1, 4);

// Topic o tema con el que trabajr
const char* topicName = "test";

EthernetClient ethClient;
PubSubClient client(ethClient);

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("El mensaje ha llegado [");
  Serial.print(topic);
  Serial.print("] ");
  int i=0;
  for (i=0;i<length;i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

void setup()
{
  Serial.begin(9600);
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Fallo en Ethernet al usar configuración DHCP");
  }
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback)
}

void loop()
{
  if (!client.connected()) {
      Serial.print("Conectando ...");
      if (client.connect("rece_arduino")) {
        Serial.println("conectado");
        client.subscribe(topicName);
      } else {
        delay(10000);
      }
  }
  // Cliente a la escucha
  client.loop();
}

Para obter mais informações, você pode faça o download gratuitamente do Manual em PDF com o curso Arduino IDE para iniciar a programação.