Conectar uma lâmpada inteligente à nuvem com Iotery através de MQTT e HTTP
Programar não é necessário!
Começar a conectar um dispositivo único com a nuvem pode ser bem difícil. Geralmente, precisa-se de firmware para rodar no dispositivo, infraestrutura para aceitar conexões e administrar dados, e uma interface (ex. navegador web ou assistente de voz) para comunicar a intenção do usuário. Se tiver uma idéia que quer levar para a fase de Prova de Conceito rápido, qualquer coisa que facilita o processo é muito atraente.
Há várias tecnologias que podem ser utilizadas para orquestrar comunicação entre as peças, mas, neste artigo, vamos focar no MQTT e HTTP, pois assim teremos uma robusta transferencia de dados (HTTP) com atualizações ao vivo para aplicações com urgência (MQTT).
Para isso iremos utilizar o sistema Iotery. Para quem não sabe, Iotery é um serviço de IoT que fornece um RESTful API (através HTTP) e um broker MQTT para conectar com segurança. Eles também possuem um Smart Light Emulator que pode ser usado como nosso firmware.
Começando com Iotery
Para usar o Smart Light Emulator do Iotery, precisamos criar uma conta gratuita aqui.
No próximo passo, você vai precisar criar uma equipe. Fique à vontade para escolher o nome que quiser.
Agora podemos criar uma lâmpada virtual inteligente. Você consegue encontrar o emulador neste endereço https://emulator.iotery.io/smart-light. A tela vai parecer mais ou menos assim:
Ao clicar no botão “connect” no canto superior direito, uma caixa de diálogo aparecerá dizendo “Connect Smart Light to Iotery”.
Por haver tantos tipos de aplicações no mundo de IoT, Iotery precisa ser configurado para caber com seu caso de uso. Felizmente, esse emulador pode fazer a configuração por nós. Clique no link “Still need to configure Iotery?” no canto inferior esquerdo da caixa de diálogo para começar o processo. O sistema vai pedir uma chave API da sua equipe (Team API Key/API Secret), que você consegue encontrar na parte “System” do site, mas segue o link direto: https://iotery.io/system. E então clique em “Next” até chegar a mensagem “Create a device”. Chegado nesta etapa, crie uma senha (Secret) para seu dispositivo.
Após finalizar (Finish) este processo, você já terá configurado os seguintes registros:
- Device Types (Tipos de Dispositivos): Smart Light (Luz Inteligente)
- Data Types (Tipos de Dados): On/Off State (Estado Ligado/Desilgado)
- Command Types (Tipos de Commandos): Turn Light On (Ligar) and Turn Light Off (Desligar)
- Device (Dispositivo): My Iotery Smart Light
A caixa de diálogo “Connect Smart Light to Iotery” voltará a aparecer para você, mas desta vez com as credencias já preenchidas. O emulador vai usar essas credencias (Team ID e Device Serial, Key, e Secret) para fazer o login com Iotery. Observe que, um UUID (ex. Team ID) é só um ID único feito de dígitos 0–9 e a-f. Cada registro feito no Iotery vai ter seu próprio UUID. Clique no botão “submit” para conectar.
Interagindo com a lâmpada virtual inteligente
Nesse ponto, sua lâmpada estará conectada.Aparecerá uma luz verde pulsando com a mensagem “online” ao lado. O ícone da lâmpada terá um fundo mais escuro também.
Esse emulador representa uma lâmpada inteligente física que poderia ser usada em sua casa. O firmware é escrito com JavaScript e funciona dentro do navegador. Porém, esse firmware usa a mesma API RESTful (HTTP) e conexão MQTT que você poderia colocar num circuito físico, como Raspberry Pi ou Arduino por exemplo. Isso também significa que pode usar firmware escrito em qualquer linguagem de programação que quiser, assim que usa a mesma API. Vamos falar destes detalhes mais tarde. Agora, vamos atuar nossa lâmpada através da nuvem!
Clique no link “Iotery Dashboard” abaixo do ícone, que vai te levar para a pagina de comandos do seu dispositivo:
Clique no botão “Execute command” do lado do IOTERY_TURN_LIGHT_ON, e verá sua lâmpada ativar.
É de responsabilidade do dispositivo ser a fonte da resposta oficial a respeito do estado Ligado/Desligado (On/Off State). Então assim que recebe um comando para ligar (Turn On), o emulador vai ligar e depois relatar seu estado novo para a nuvem. Esse pode ser visto na guia Information para o dispositivo no Iotery Dashboard em baixo de Live Data:
Pode confirmar que IOTERY_ON_OFF_STATE tem o valor de 1 para “ligado”. Experimente alternar o estado da lâmpada diretamente clicando no ícone no emulador. Você verá a informação embaixo de Live Data atualizar valor “0” para “desligado”. Então, independentemente se o comando é iniciado por um cliente (ex. Iotery Dashboard) ou diretamente no dispositivo, o sistema permanecerá sincronizado.
Agora que já interagimos com um dispositivo virtual (Iotery Smart Light Emulator) e com um cliente conectado com a nuvem (Iotery Dashboard), o próximo passo vai ser falar da arquitetura da nuvem e como tudo se conecta.
Arquitetura da Nuvem
Até agora, não temos visto como as peças diferentes desse sistema são conectadas. Os três componentes principais são: o dispositivo (device), a nuvem (cloud) do Iotery, e a interface do cliente. O Iotery Smart Light Emulator é nosso dispositivo e o Iotery Dashboard é a nossa interface do cliente. A nuvem do Iotery tem funcionado no fundo servindo como se fosse a cola que conecta os dois.
REST e MQTT
As duas tecnologias principais que são utilizadas para comunicação com a nuvem são REST (através HTTP) e MQTT. A nuvem do Iotery fornece um API RESTful com um endpoint aqui https://api.iotery.io/v1. REST é mais ou menos uma coleção de convenções que podem ser usadas em cima do HTTP. Os métodos padrões de HTTP como GET, POST, PUT, PATCH, e DELETE servem para administrar dados com REST. Olhe no material seguinte se quiser saber mais sobre REST.
Há extensas documentações sobre o API do Iotery que pode ser achada aqui https://iotery.io/docs. Enquanto HTTP serve como uma solução robusta para transferencia de dados, esse protocolo de requisição-resposta deixa cada conexão em algo temporário. Então, se você quiser “atualizações ao vivo” para seu dispositivo, teria que enviar requisições constantemente. Isso é lento e um desperdício de transferência dados. Por isso o MQTT veio para nos salvar! Vamos falar superficialmente do MQTT, mas se quiser saber mais, tem um material aqui:
MQTT significa Message Queue Telemetry Transport e é feito em cima da camada TCP, assim como HTTP. Porém, ao contrário de usar HTTP que abre e fecha TCP sockets, MQTT mantêm uma conexão aberta e reconecta se cair. MQTT é um leve protocolo de publish-subscribe que tem três tipos de papéis: broker, publisher, e subscriber. Dados são organizados segundo “topics”. Por exemplo, o topic usado para nosso comando de Ligar é ‘devices/+deviceUuid/commands’. Nesse caso ‘+deviceUuid’ é o UUID do dispositivo para sua lâmpada. Publishers podem colocar dados no topic do broker MQTT e subscribers daquele topic vão receber os dados quase imediatamente.
Juntando Tudo
Agora que temos uma ideia geral de como tudo está conectado, vamos ver o fluxo de dados que aconteceu quando conectamos nosso emulador com a nuvem e começamos a atua-lo através o Iotery Dashboard.
1. Login do Dispositivo
Quatro peças de informações são necessárias para fazer o login do dispositivo:
- Team ID
- Device Serial
- Device Key
- Device Secret
Quando foi criada a sua equipe através o Iotery Dashboard, um UUID foi gerado para identificar aquela equipe (Team ID). O processo de configuração no emulador levou você no caminho para criar um registro do dispositivo e usou o segredo (device secret) que foi fornecido. Esse processo, também atribuiu automaticamente um número de série (device serial) e chave (device key) do dispositivo. Esse número de série e chave só são mais duas peças de informações para identificar o dispositivo na nuvem.
O processo de login utiliza a rota abaixo da API REST no Iotery. O HTTP Request body é o que vai do dispositivo para Iotery e o HTTP Response Body é o que Iotery manda de volta para o dispositivo.
POST https://api.iotery.io/v1/embedded/basic/get-token HTTP Request Body
{
"teamUuid": "e9f6fa1a-f015-11e9-bef3-a02aef343366",
"serial": "5077D843",
"key": "1496BD8860D2",
"secret": "secret"
} HTTP Response Body
{
"token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJlYTNkZDBjYS1mMDE1LTExZTktYmVmMy1hMDJhZWYzNDMzNjYiLCJpYXQiOjE1NzEyMzEyNTQsImV4cCI6MTU3MzgyMzI1NH0.Pgk9Ia1g_sZIaS7GSza11rdpX0ZJf7Ca1jEVeRNqbmI", "expiration": 1573823254,
"device": {
"uuid": "ea3dd0ca-f015-11e9-bef3-a02aef343366",
"deviceTypeUuid": "ea15c666-f015-11e9-bef3-a02aef343366",
"key": "1496BD8860D2",
"serial": "5077D843",
"name": "My Iotery Smart Light",
...
}
}
As mensagens de requisição (Request Body) e resposta (Response Body) são no formato JSON. Pode ver que no Response Body da rota https://api.iotery.io/v1/embedded/basic/get-token, o Iotery fornece um token JWT, que tem um tempo de validade, e é usado para autorização nas outras mensagens com as rotas da API REST e conexões com o broker MQTT. O Smart Light Emulator vai guardar esse token JWT e usa-lo com outras credencias para se inscrever (subscribe) no topic ‘devices/+deviceUuid/commands’ do broker MQTT. Aí, a luz verde está ligada e o emulador mostra o texto “connected”.
2. Gerar um Comando (Command Instance)
Quando você se cadastrou e fez o login no Iotery Dashboard, seu navegador passou por um processo similar do emulador. Aliás, o navegador usou uma rota da API para obter um token JWT. Pela pagina de comandos (Commands) do dispositivo, você conseguiu gerar comandos (command instances) na nuvem através da seguinte rota:
POST https://api.iotery.io/v1/devices/:deviceUuid/command-instancesEsse HTTP POST diz ao Iotery para gerar um comando do tipo que escolheu (ex. Ligar ou Desligar). Aí, esse comando é publicado (published) pela nuvem para o topic ‘devices/+deviceUuid/commands’ no broker MQTT. O Smart Light Emulator (o dispositivo) se inscreveu nesse topic, por isso ele recebe o comando quase imediatamente e o pedido é atendido.
3. Sincronização da Nuvem e do Dispositivo
Depois que um dispositivo recebe um comando da nuvem, ele precisa deixar a nuvem saber que esse pedido foi atendido e também avisar do novo estado.
O dispositivo comunica para a nuvem que o comando foi executado através a seguinte rota:
PATCH https://api.iotery.io/v1/embedded/command-instances/:commandInstanceUuid/executedDepois disso, o dispositivo deve mandar uma mensagem sobre o novo estado dele (ex. ligado ou desligado). Isso pode ser feito pela rota de dados:
POST https://api.iotery.io/v1/embedded/devices/:deviceUuid/dataEssa comunicação fecha o circulo de informação e fornece um histórico de comandos e estados do dispositivo, tudo guardado dentro do Iotery. Se o dispositivo for comandado diretamente, como quando a gente ficou alternando ele no emulador, o dispositivo também precisa avisar ao Iotery. Para começar, o dispositivo usa a rota abaixo para criar um registro de comando já executado:
POST https://api.iotery.io/v1/embedded/command-instances/executedDepois, a mesma rota de dados é utilizada para avisar do novo estado (ligado ou desligado):
POST https://api.iotery.io/v1/embedded/devices/:deviceUuid/dataEssas mensagens na rota de dados estão disponíveis para serem vistas na aba “Information” do dispositivo no Iotery Dashboard. Os dados mais recentes vão aparecer embaixo da seção Live Data como a gente viu antes. Isso é possível porque o Iotery Dashboard se inscreve no topic ‘devices/+deviceUuid/data’ no broker MQTT.
Terminando
Já fizemos o trabalho de conectar e controlar uma lâmpada virtual inteligente com a nuvem, tudo através do Iotery. Aqui você recebeu uma curta introdução da arquitetura do Iotery ,que usa uma API RESTful (com HTTP) e MQTT. Espero que tenha se divertido e aprendido um pouco nesta caminhada!
Agora que tem o poder do Iotery em suas mãos, você pode começar a conectar qualquer dispositivo que quiser na nuvem sem precisar construir tudo do zero. O Iotery fornece a infraestrutura e uma interface de cliente que pode usar imediatamente. Se quiser conectar seu próprio dispositivo, só precisa desenvolver o firmware e usar as rotas da API REST e topics MQTT do Iotery.
Se tiver interesse em ver um outro projecto IoT que usa Iotery, tem um ótimo material de como conectar um Raspberry Pi usando Python.
Até a próxima!
