Monitore seus próprios Tweets usando Thinger, NodeMCU e IFTTT

o artigo anterior conhecemos a plataforma IFTTT (IF This Than That) e vimos que a plataforma disponibiliza vários recursos, que podem ser usados inclusive para aplicações embarcadas e Internet das Coisas (IoT).

Hoje mostraremos a placa NodeMCU conectada à plataforma Thinger e, usando a plataforma IFTTT, mostraremos no display uma postagem própria no Twitter.

Thinger

Thinger é uma plataforma Open Source destinada ao uso em IoT. Funciona semelhante ao conhecido Thingspeak. Utilizaremos esta plataforma para demonstrar o uso da biblioteca da própria IDE do Arduino. Nesse artigo daremos apenas o básico da plataforma Thinger, voltado para nosso teste aqui.

Clicando em Sign up criaremos nossa conta no Thinger.

Após criar a conta e confirmar seu e-mail, uma tela de console ficará disponível.

Aqui podemos ver que a plataforma Thinger só nos permite conectar dois dispositivos. Para criarmos nosso primeiro dispositivo, clique em Devices na barra lateral.

Na tela, clique em Add Device para criarmos nosso primeiro dispositivo virtual.

Aqui, criamos a identificação do dispositivo, podemos por uma breve descrição do mesmo e definimos uma chave credencial para acessar o dispositivo. A credencial pode ser gerada aleatoriamente caso preferir. Após preencher os três campos, basta criar em Add Device para que o mesmo passe a existir.

Clicando novamente em Devices, agora vemos nosso dispositivo criado e disponível para trabalharmos com ele. Para visualizarmos os detalhes que usaremos ao programar a NodeMCU na IDE do Arduino, clique no dispositivo, conforme mostrado abaixo:

Aqui podemos visualizar o status da placa, o endereço IP externo (aquele que é visível em toda a internet), os dados enviados e os dados recebidos. Como ainda não temos nosso dispositivo físico conectado, o status é Offline. Após programarmos nossa placa NodeMCU, voltaremos aqui para continuarmos a configurar nosso dispositivo virtual.

NodeMCU e IDE da Arduino

Na próxima figura mostramos como fazer a montagem da NodeMCU com o display OLED. O display usado aqui foi o de 0,96” 128×64.

Para usar a placa NodeMCU na IDE do Arduino, você precisa da biblioteca da mesma disponibilizada. Caso ainda não a tenha, poderá instalar a biblioteca seguindo os passos ensinados pelo nosso amigo Josemar Alves em seu artigo “Gravando o ESP8266-01 na IDE do Arduino”.

Agora, as bibliotecas para uso do display OLED, recomendo instalar as das Adafruit. Nesse caso instalaremos a Adafruit SSD 1306 e a Adafruit GFX Library. Para os que estão iniciando, para instalar uma biblioteca na IDE do Arduino basta ir em Sketch – Incluir Biblioteca – Gerenciar Bibliotecas. Aqui podemos pesquisar pelas bibliotecas que usaremos. Nesse caso basta pesquisar pelos nomes citados acima e clicar em instalar que ficarão disponíveis.

Para conexão com o Thinger, precisamos instalar a biblioteca Thinger.io do mesmo modo.

O código fonte será explicado abaixo por partes:

/*************************************************************/
/*                NODEMCU, Thinger e IFTTT                   */
/*                                                           */
/* Demonstração de uso das bibliotecas em uma aplicação de   */ 
/* conectividade                                             */
/*************************************************************/

/*************************************************************/
/*                      Bibliotecas                          */
/*************************************************************/
#include <SPI.h>
#include <ESP8266WiFi.h>
#include <ThingerWifi.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Aqui estão a bibliotecas necessárias para o uso em nosso código-fonte. Uma observação importante está no uso da biblioteca Adafruit_GFX.h. É através dela que temos os textos e imagem criados para o display OLED. Funciona em suporte a outra biblioteca, a Adafruit_SSD1306.

/*************************************************************/
/*                           Macros                          */
/*************************************************************/

//Display OLED, Adafruit
#define OLED_RESET LED_BUILTIN
Adafruit_SSD1306 display(OLED_RESET);

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2

#define LOGO16_GLCD_HEIGHT 16 
#define LOGO16_GLCD_WIDTH  16 

//Conexão no Thinger
#define USERNAME "wavieira2010"
#define DEVICE_ID "NODEMCUIOT"
#define DEVICE_CREDENTIAL "1A2b3C4d5E"

//Conexão com o roteador
#define SSID "Another"
#define SSID_PASSWORD "Will#200890#"

ThingerWifi thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL);

A parte destinada às macros do código-fonte. Nessa etapa, na parte de conexão com o roteador, substitua os valores pelos relacionados à sua rede Wifi e na parte de conexão no Thinger use os dados do seu dispositivo virtual criado na plataforma Thinger anteriormente.

/*************************************************************/
/*                      Inicializações                       */
/*************************************************************/
void setup() 
{
  //serial para comunicação com o display OLED
  Serial.begin(9600);

  //Configuração e inicialização do display OLED
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  
  display.display();
  delay(2000);
  
  //Limpa Display OLED
  display.clearDisplay();

  //Tela de boas vindas
  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(18,0);
  display.clearDisplay();
  display.println("NodeMCU");
  display.setCursor(10,20);
  display.println("IoT Cloud");
  display.display();
  delay(5000);

Nas inicializações, vamos dividir em duas etapas. Essa primeira é destinada à configuração e exibição da tela de boas-vindas de nosso dispositivo.

//conectando a placa na página no thinger: https://console.thinger.io/#/login
  thing.add_wifi(SSID, SSID_PASSWORD);

  //COnfigurando as variáveis a serem usadas durante a comunicação com a página thinger
  thing["twitter"] << [](pson& in)
  {
    display.clearDisplay();

    //Cria as variáveis do tipo String para o Thinger
    String sName   = (in["name"]);
    String sTweet  = (in["tweet"]);

    //Escreve as informações trocadas através da API thinger no display OLED
    display.setTextSize(1);
    display.setCursor(5,0);
    display.print("NAME: ");
    display.println(sName);

    display.setCursor(5,20);
    display.println("Tweet: "); 
    display.setCursor(5,30);
    display.println(sTweet);
    display.display();
  };
}

Continuando nosso código, na parte das inicializações, a segunda etapa é destinada à configuração e criação das interfaces de interação com a plataforma Thinger. Para quem interessar em se aprofundar sobre detalhes da plataforma, a documentação encontra-se neste site.

Primeiramente, mandamos a conexão com a rede Wifi. Em seguida, iremos criar um vetor com dois itens do tipo String. O nosso vetor aqui será chamado de twitter e conterá as variáveis de entrada sName e sTweet.

Aqui já colocamos para atualizar as informações no display dessas respectivas variáveis conforme vemos no código-fonte.

O loop principal de nosso programa é bem simples, pois apenas atualiza o status do Thinger.

/*************************************************************/
/*                      Loop Principal                       */
/*************************************************************/
void loop() 
{
  //Monitora API Thinger
  thing.handle();
}

Faça o download do código completo: NodeMCU _Tweet.ino

Thinger e IFTTT

Após terminar de carregar o programa na NodeMCU, se tudo foi feito corretamente, ao voltar na plataforma Thinger veremos que a placa indicará que está conectada.

Clicando agora no dispositivo, veremos que as informações de nosso dispositivo mudaram, indicando a conexão e mostrando detalhes de funcionamento. Infelizmente o único navegador que não permite essa visualização é o Google Chrome.

Para testarmos se realmente temos o vetor Twitter, clique em View API. Se foi criado corretamente, esse vetor aparecerá conforme figura abaixo.

Clicando no twitter – Private, podemos testar se nossa API está configurada corretamente. Primeiro veremos se os dados estão no formato que precisamos (String) e colocaremos textos em seus campos. Após isso clicaremos em Run e veremos se esses dados serão exibidos em nosso display.

Agora criaremos a chave de acesso, token, que será a liberação de acesso a ser usado pelo IFTTT no Thinger para colocar o tweet no display OLED. No dispositivo na tela do Thinger, clique em +Add em Device Tokens.

Em Token Name dê um nome de identificação da funcionalidade desse token de acesso. Já em Token Access, selecione a segunda opção para limitar o uso dos recursos disponibilizados pela placa NodeMCU. Isso é muito útil quando temos mais recursos que serão usados por outras aplicações que imaginarmos.

Em Select or type the accessible resources while using this token, ao clicar no campo editável já veremos o nome do campo de acesso twitter. Basta selecionar este e por fim clicar em OK.

Antes de fechar a tela, copie o Device Token gerado, que usaremos no IFTTT para que funcione corretamente.

Clique no botão Close para concluir esse processo. Aqui concluímos a configuração do Thinger.

Para maiores detalhes de como criar a conta e como funciona o IFTTT, consulte o artigo de minha autoria “IFTTT – Uma plataforma simples para aplicações IoT”.

Na tela do IFTTT, clique em New Applet para começarmos a configurar a última etapa.

Selecionaremos o Twitter e a opção New Tweet by you. Assim monitoraremos apenas os próprios tweets.

Para esta configuração, marquei as opções de retweets e @replies para detectar todas as ações que tenho no Twitter.

Agora iremos configurar no That a nossa placa, através do thinger. Procure pela API Maker.

Selecionando Make a web request (única opção pelo Maker), teremos agora de configurar todos os itens do acesso entre o IFTTT e o Thinger. As informações estão disponibilizadas no Thinger clicando em View API do dispositivo, em twitter – Private e em Show Query.

Assim, basta apenas usarmos o famoso CRTL+C e CRTL-V para configurarmos o IFTTT. Seguindo conforme abaixo.

Copie o link visto no item Method e cole em URL*. Coloque a interrogação “?” no final do link e digite “authorization=”. Após cole o Device Token, que será a autorização para acesso ao Thinger. Caso não tenha copiado anteriormente, você poderá copiar em Authorization todo o conteúdo após a palavra Bearer.

O método a ser usado será o POST, dado que o IFTTT irá postar as informações para o Thinger, e de lá para nosso display OLED através da NodeMCU. Para adequar ao que foi feito, em Content Type, selecione application/json.

Copie e cole o conteúdo do Request Body do Thinger. Para configurar adequadamente, clique entre as aspas após a palavra Name, clique em +ingredient e selecione UserName. Já nas aspas após a palavra tweet clique em +ingredient e selecione Text. Após basta clicar em Create Action.

Pronto, podemos testar se realmente está funcionando. Abaixo nas imagens seguem os resultados.

Conclusões

Nesse artigo podemos ver a interação entre o hardware e duas plataformas trabalhando juntas: a nossa NodeMCU junto com a plataforma Thinger e a plataforma IFTTT. De um modo geral, a mescla do IFTTT com o Thinger nos abre inúmeras possibilidades de uso, como monitorar a temperatura e a umidade de um determinado local e usar por exemplo e-mail para receber notificações se algo sair fora do normal, ou contabilizar uma postagem específica do Facebook.