Adafruit IO – Uma nova plataforma de IoT

Adafruit IO – Uma nova plataforma de IoT

A Adafruit acho que a grande maioria aqui já conhece. Se trata de uma grande empresa internacional na área de embarcados e eletrônica, ela fabrica diversos hardwares e também mantém seu blog, fórum, videos no YouTube, bibliotecas para seu hardware dentre outras características. E agora ela tem sua própria plataforma de IoT, a Adafruit IO.

Adafruit IO

A própria Adafruit possui relatado em seu site o problema que a equipe possuía em conectar os seus hardwares de maneira fácil com a nuvem, mesmo com as inúmeras plataformas existentes e consagradas no mercado, ainda não seria o que eles almejavam. Diante deste motivo, eles solucionaram o problema criando a Adafruit IO.

O ecossistema da plataforma basicamente é composto por:

  • Broker MQTT
  • Websockets
  • API
  • Dashboard
  • Bibliotecas para tornar a utilização de seus hardwares mais fáceis.

O que será desenvolvido neste artigo?

Neste artigo iremos demonstrar o passo a passo para que você possa utilizar a Adafruit IO em seus projetos.

Portanto iremos desenvolver um projeto que contará com um sensor e um atuador. O sensor de temperatura será o MCP9808 da Adafruit, já o atuador será um módulo relé de dois canais.

Todo conjunto usará o ESP8266 NodeMCU juntamente com o protocolo MQTT para interagirmos com a plataforma.

Materiais necessários

Abaixo segue a lista de materiais que serão utilizados no desenvolvimento deste projeto. Ambos estão disponíveis em nosso site para compra.

O sensor de temperatura MCP9808 Adafruit

Sensor de temperatura MCP9808

O MCP9808 se trata de um sensor de temperatura de alta precisão o qual utiliza  comunicação I2C para recebimento dos dados. Possui uma precisão de +- 0,25ºC entre 40ºC a +125ºC.

Uma das grandes vantagens deste sensor, é que o mesmo possui tensão de operação que varia de 2.7 a 5,5 Volts, ou seja, você pode usar facilmente com placas Arduino, esp8266, Raspberry PI dentre outros embarcados sem se preocupar com circuito externo.

Por padrão este sensor vem configurado para funcionar no endereço I2C 0x18. Logo será necessário apenas efetuar o download da biblioteca.

O módulo relé de 2 canais

Módulo rele 5V 2 canais

O shield da foto acima se trata de um shield relé 5v de 2 canais. Como mencionado, o mesmo funciona com operação em 5 Volts e tolera acionamentos de até 220 Volts ao limite de 10A.

Outro fator positivo deste relé, é que ele também pode ser acionado em diferentes tipos de embarcados: Arduino, ESP8266 e Raspberry PI por exemplo.

No projeto será usado somente 1 canal do módulo, o qual terá como objetivo acionar uma lâmpada Led a partir da dashboard da Adafruit.

Configuração da plataforma Adafruit IO

Para ter acesso na plataforma, primeiramente será preciso criar uma conta na Adafruit – caso não tiver, e em seguida você poderá se beneficiar dos recursos disponíveis.

Para efetuar o cadastro, você deverá acessar o link https://io.adafruit.com/ e caso já possua a conta, é só logar. Dado esse passo, você será redirecionado para uma página contendo a listagem de suas Dashboards – em primeiro momento estará vazio.

Você terá uma tela parecida como mostra a imagem abaixo:

Obs: a minha tela já possui algumas dashboards devido ao fato de já estar testando a plataforma.

Tela inicial

Para começar você deverá criar sua Dashboard, para isso, clique no botão Actions e em seguida em Create a new Dashboard, uma modal deverá abrir. Entre com o nome de sua preferência e uma descrição, caso queira. Neste caso, darei o nome de FilipeFlop, para finalizar a criação clique no botão Create.

Abrindo a dashboard criada, você verá uma tela vazia, como demonstra na imagem abaixo.

Dashboard

Será nesta tela que você irá adicionar seus Widgets. Mas Douglas, o que são os tais Widgets? Widgets se trata de um componente web. Para ficar mais claro, vamos aos exemplos: podemos citar um botão ON/OFF, um color picker, um gráfico, dentre outros.

Tais widgets serão responsáveis pela representação de seus itens conectados. No nosso caso teremos dois: Um gráfico mostrando a temperatura e um botão ON/OFF para interagirmos com nossa lâmpada.

Para criarmos nossos widgets, você deverá clicar no botão azul representado pelo ícone de soma. Clicando nele, abrirá uma modal para que você escolha o bloco(widget) que será adicionado emsua Dashboard.

Veja na imagem abaixo a ilustração da modal que foi aberta:

Widgets disponíveis

Widgets disponíveis

Até o momento da escrita deste artigo temos 10 widgets disponíveis para uso, sendo eles:

  • Toogle
  • Momentary Button
  • Slider
  • Gauge
  • Text
  • Stream
  • Image
  • Line Chart
  • Color Picker
  • Map

Portanto para começarmos, iremos adicionar um gráfico para que o mesmo represente a temperatura que será enviada a partir do  sensor de temperatura.

Escolhendo o gráfico – Line Chart -, uma modal será aberta pedindo para que você escolha um Feed, provavelmente você não terá nenhum feed cadastrado(eu tenho pois já efetuei diversos testes antes do desenvolvimento deste artigo), iremos cadastrar um feed com o nome de mcp9808. Veja na imagem a tela que aparecerá para você.

Feeds

 

Após ter criado seu feed marque o item criado na tabela abaixo e clique em Next Step. Nesta outra etapa, será mostrado as configurações para o bloco escolhido. Deixarei o padrão sugerido pela plataforma. Veja na imagem abaixo, a demonstração da tela de configurações.

Configuração do widget

Após efetuar as configurações, somente clique no botão Create block.

Com o bloco criado, temos nosso primeiro widget adicionado. Falta um, concorda? Para fazer a adição do próximo widget, neste caso o Toogle -, você só precisa repetir os mesmos passos que efetuamos para adição do gráfico, com a diferença que você escolherá outro widget e associará a outro Feed.

Obs: darei o nome rele01 para o feed responsável por ligar/desligar a lâmpada.

Veja na imagem abaixo como ficou nossa Dashboard contendo nossos dois widgets que serão usados no projeto.

Dashboard

Caso você queira organizar sua dashboard, a Adafruit disponibiliza uma interatividade chamada Drag and Drop, onde você arrasta os blocos de acordo com sua preferência para organizá-los.

Caso queria efetuar esta mudança, você precisa clicar no primeiro quadradinho verde, assim você irá habilitar o modo de edição da dashboard, deixe sua dashboard de acordo com sua preferência e salve suas configurações clicando no mesmo quadrado que terá o seguinte texto: “DONE EDITING”.

Com a edição, a dashboard ficou como ilustra na figura abaixo:

Dashboard configurada

Dashboard configurada

Recapitulando: De forma resumida,  o que você fez nesses passos foi:

  • Se cadastrar na plataforma;
  • Criar a dashboard;
  • Adicionar os Widgets conforme a finalidade deste artigo.

Obs: os nomes dados aos feeds serão usados posteriormente no firmware que será desenvolvido no esp8266. Então lembre-se deles :).

Esquemático projeto conexão Adafruit IO

A imagem abaixo mostra como devem ficar as suas conexões:

Esquemático conexão

Obs: Caso for utilizar o projeto em sua casa – por exemplo, é recomendado alimentar o módulo relé com uma fonte externa de 5 Volts.

Dependências do projeto

Como dependência do nosso projeto, terá que ser instalado 2 bibliotecas, ambas da Adafruit. A primeira será a lib do sensor de temperatura, já a outra, será a lib para efetuar a comunicação via MQTT com a plataforma da adafruit.

Ambas libs estão hospedadas nos repositórios da Adafruit no github, você pode facilmente baixá-las e instalar em sua IDE:

Dica: Você pode facilmente instalá-las diretamente da IDE do Arduino através do gerenciador de bibliotecas contido na ide. Abrindo o gerenciador é só procurar pelo nome da lib e instalá-la. E estará tudo pronto :).

Código NodeMCU conexão Adafruit IO

Com a dashboard já configurada e nossas dependências já instaladas, começaremos a desenvolver nosso firmware. O firmware terá em torno de 200 linhas, mas não se assuste, pois a maioria se treta de configurações básicas como rede wifi, mqtt.

Para ficar claro o fluxo que será desenvolvido, veja na listagem abaixo como nosso firmware ficará dividido:

  • Inclusão das bibliotecas
  • Credenciais da rede Wifi
  • Credenciais da Adafruit IO
  • Variáveis globais
  • Declaração dos feeds
  • Declaração dos prototypes
  • Setup
  • Loop
  • Implementação dos prototypes

Para o desenvolvimento e upload para nosso nodemcu, será utilizado a IDE do Arduino. Portanto veja como deverá ficar o script do nodemcu no sketch abaixo.

/************************* Inclusão das Bibliotecas *********************************/
#include "ESP8266WiFi.h"
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

#include "Adafruit_MCP9808.h"

/************************* Conexão WiFi*********************************/

#define WIFI_SSID       "homewifi_D68" // nome de sua rede wifi
#define WIFI_PASS       "********"     // senha de sua rede wifi

/********************* Credenciais Adafruit io *************************/

#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "douglaszuqueto" // Seu usuario cadastrado na plataforma da Adafruit
#define AIO_KEY         "********"       // Sua key da dashboard

/********************** Variaveis globais *******************************/

WiFiClient client;

Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

int rele01 = D5; // pino do rele

Adafruit_MCP9808 mcp9808 = Adafruit_MCP9808(); // instancia o objeto do sensor

long previousMillis = 0;

/****************************** Declaração dos Feeds ***************************************/

/* feed responsavel por receber os dados da nossa dashboard */
Adafruit_MQTT_Subscribe _rele01 = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/rele01", MQTT_QOS_1);

/* feed responsavel por enviar os dados do sensor para nossa dashboard */
Adafruit_MQTT_Publish _mcp9808 = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/mcp9808", MQTT_QOS_1);

/* Observe em ambas declarações acima a composição do tópico mqtt
  --> AIO_USERNAME "/feeds/mcp9808"
  O mpc9808 será justamente o nome que foi dado la na nossa dashboard, portanto o mesmo nome atribuido la, terá de ser colocado aqui tambem
*/

/*************************** Declaração dos Prototypes ************************************/

void initSerial();
void initPins();
void initWiFi();
void initMQTT();
void initMCP9808();
void conectar_broker();

/*************************** Sketch ************************************/

void setup() {
  initSerial();
  initPins();
  initWiFi();
  initMQTT();
  initMCP9808();
}

void loop() {
  conectar_broker();
  mqtt.processPackets(5000);

  // Função responsável por ler e enviar o valor do sensor a cada 5 segundos
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis > 5000 && mqtt.connected()) {
    previousMillis = currentMillis;

    mcp9808.shutdown_wake(0);
    float c = mcp9808.readTempC();

    delay(200);
    Serial.print("Temp: "); Serial.print(c); Serial.println("*C\t");

    if (! _mcp9808.publish(c)) {
      Serial.println("Falha ao enviar o valor do sensor.");
    }
    mcp9808.shutdown_wake(1);

  }
}

/*************************** Implementação dos Prototypes ************************************/

/* Conexao Serial */
void initSerial() {
  Serial.begin(115200);
  delay(10);
}

/* Configuração dos pinos */
void initPins() {
  pinMode(rele01, OUTPUT);
  digitalWrite(rele01, HIGH);
}

/* Configuração da conexão WiFi */
void initWiFi() {
  Serial.print("Conectando-se na rede "); Serial.println(WIFI_SSID);

  WiFi.begin(WIFI_SSID, WIFI_PASS);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.println("Conectado à rede com sucesso"); Serial.println("Endereço IP: "); Serial.println(WiFi.localIP());
}

/* Configuração da conexão MQTT */
void initMQTT() {
  _rele01.setCallback(rele01_callback);
  mqtt.subscribe(&_rele01);
}

/* Inicialização do Sensor */
void initMCP9808() {
  if (!mcp9808.begin()) {
    Serial.println("Sensor MCP não pode ser iniciado!");
    while (1);
  }
}

/*************************** Implementação dos Callbacks ************************************/

/* callback responsavel por tratar o feed do rele */
void rele01_callback(char *data, uint16_t len) {
  String state = data;

  if (state == "ON") {
    digitalWrite(rele01, LOW);
  } else {
    digitalWrite(rele01, HIGH);
  }

  Serial.print("Led: "); Serial.println(state);

}

/*************************** Demais implementações ************************************/

/* Conexão com o broker e também servirá para reestabelecer a conexão caso caia */
void conectar_broker() {
  int8_t ret;

  if (mqtt.connected()) {
    return;
  }

  Serial.println("Conectando-se ao broker mqtt...");

  uint8_t num_tentativas = 3;
  while ((ret = mqtt.connect()) != 0) {
    Serial.println(mqtt.connectErrorString(ret));
    Serial.println("Falha ao se conectar. Tentando se reconectar em 5 segundos.");
    mqtt.disconnect();
    delay(5000);
    num_tentativas--;
    if (num_tentativas == 0) {
      Serial.println("Seu ESP será resetado.");
      while (1);
    }
  }

  Serial.println("Conectado ao broker com sucesso.");
}

Testando a Adafruit IO

Para realizar os testes, basta pegar o script acima e modificá-lo de acordo com seu cenário. Digo isso pois, você precisa colocar suas informações da rede wifi, suas informações da Adafruit, e também o nome dos feeds caso tenha colocado diferente do que foi criado aqui.

Um detalhe importante é o uso de uma Key que é utilizada para realizar a autenticação nos servidores da Adafruit. Você irá deverá encontrá-la em sua dashboard no ícone que remete a uma chave. Só copie e substitua no seu código.

Com tudo devidamente configurado, você deverá fazer o upload do firmware para seu nodemcu. Quando o upload estiver terminado, abre o monitor serial para acompanhar o que está acontecendo.

Em um primeiro momento, você deverá ter uma tela semelhante a da imagem abaixo.

Monitor serial

Perceba que tudo ocorreu bem – conexão com a rede wifi e também com o broker da Adafruit IO. Veja também, que a temperatura imediatamente já começou a ser publicada.

Para testar o acionamento de nosso rele, basta ir até a dashboard e acionar o botão on/off. Feito isso, você já começará a observar uma certa interatividade entre o botão com o rele e também o sensor com o gráfico.

Veja os resultados com o gráfico e o rele acionado e também como ficou o protótipo do projeto desenvolvido neste artigo nas imagens abaixo, respectivamente.

Resultado - Dashboard

Resultado – Dashboard

Considerações finais sobre a Adafruit IO

Realmente a plataforma da Adafruit me impressionou, pois ela agrega bastante a um simples protótipo de um projeto. A história começa no hardware e vai parar na Web. Particularmente dou muito valor a uma empresa assim, que vai muito além do que simplesmente oferecer um produto.

Aqui, neste artigo usamos algo relativamente simples, para dar aquele “start”, para apresentar a plataforma a vocês. Continuarei testando e validando a plataforma como também suas bibliotecas oferecidas.

Para quem se interessou pela plataforma, pelo que observei a Adafruit possui liberado o código fonte do back-end da plataforma no seu github, logo você pode baixar, instalar em sua raspberry pi e até mesmo em um servidor que esteja na nuvem – Eu efetuei rápidos testes, e realmente funciona :). Fica aqui o link do repositório: https://github.com/adafruit/adafruit-io-node

Referências

Gostou? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP !

3
Adafruit IO – Uma nova plataforma de IoT
6 votos, 5.00 classificação média (100% pontuação)

Formado em Técnico em Informática e Graduado em Análise e Desenvolvimento de Sistemas, ambos pelo Instituto Federal Farroupilha - RS. Colaborador do site FILIPEFLOP.

Compartilhe este Post

11 Comentários

  1. Ivan Assaritti - 23 de fevereiro de 2017

    Olá Douglas,

    Primeiramente parabéns pelo artigo e pesquisa.

    Estou apenas aguardando meu 8266 chegar para conferir.

    Entretanto em vez de usar o MCP9808 eu pretendo usar um DHTxx (temp+Humid) que eu sei que a ADAFRUIT tem biblioteca. Só que pretendo criar um log no dashboard para que haja a coleta de, por exemplo uma semana de dados. Será que há essa opção?

    Abraços!

    • Douglas Zuqueto - 23 de fevereiro de 2017

      Olá Ivan, tudo bem?

      Primeiramente, muito obrigado pelo feedback :D.

      Então, sobre a substituição não tem problema algum, somente terá que adaptar o firmware.

      Sobre o log, creio que não tenha exatamente esta funcionalidade. Porém possui o Widget Stream, que é um log de tudo que está acontecendo de acordo com seu feed.

      Uma alternativa seria baixar os dados(formato csv ou json) que queira de acordo com seu Feed e depois manipulá-los através de um script python(por exemplo).

      Se você entende de Python e caso lhe interesse, eu escrevi em meu blog como integrar uma aplicação com banco de dados sqlite, bem simples mesmo, porém é algo bem funcional, segue o link -> https://douglaszuqueto.com/artigos/integrando-a-aplicacao-web-com-banco-de-dados

  2. Gerbert Santos - 20 de fevereiro de 2017

    Zuquetto, ótimo post!! Sabe se existe algum app android para acesser o dashboard Adafruit IO?

  3. Paulo Cesar - 31 de janeiro de 2017

    Para usar o Momentary Button, basta utilizar a mesma estrutura do Toggle? Obrigado!

    • Douglas Zuqueto - 31 de janeiro de 2017

      Olá Paulo, tudo bem com você?

      Sim, as etapas serão as mesmas. O que mudará será o feed e as configurações caso queira.
      Vale ressaltar que o Momentary Button enviará somente 1 comando diferente do Toogle que envia 2 comandos(ON/OFF). Citando um exemplo de aplicação seria inverter o estado do rele quando o botão fosse clicado.

      Atenciosamente,
      Douglas Zuqueto

  4. JAGoris - 31 de janeiro de 2017

    Zuquetto, parabéns muito bom este tutorial. É mais um broker que estou testando. Pela sua experiencia, saberia me informar se existe a possibilidade de alterar a cor da tela de fundo, pois nesta tela preta é muito ruim de visualizar os componentes.
    Acho que este é o único inconveniente deste MQTT.

Deixe uma resposta