MKR1000 para Google Sheets: Envie Dados de Sensores via WiFi

Componentes e Materiais

Arduino MKR1000	×	1
Sensor de Temperatura e Umidade DHT11 (4 pinos)	×	1
Jumpers (genéricos)	×	1
Protoboard (genérica)	×	1

Aplicativos e Serviços Online

• Arduino IDE
• Google Sheets

Sobre o Projeto

Este projeto permite processar dados com seu MKR1000 e enviar esses dados para o Google Sheets na nuvem via WiFi. Este projeto pode ser realizado sem cadastro de cartão de crédito ou uso de APIs proprietárias de "caixa preta". Para este exemplo específico, uso o sensor ambiental DHT11, barato e onipresente, porém você pode facilmente alterar o código Arduino incluído para qualquer sensor ou dispositivo que desejar. Vale apontar que este projeto pode ser facilmente combinado em um sketch com um de meus projetos relacionados, que faz upload de dados do DHT11 para o Thingspeak.com para gráficos.

Esta é a primeira de quatro partes. Na primeira parte, você configurará sua própria Planilha Google para aceitar seus dados WiFi usando o código Google App Script incluído.

Parte 1: Criando e Implantando sua Planilha Google

1. Cadastre-se para um e-mail Google gratuito se não tiver um.

2. Faça login em sua conta Google gratuita e crie uma nova "Planilha Google". Esta é a planilha que será populada pelos valores do sensor DHT via WiFi. Neste momento, você precisará copiar e salvar a chave da URL da sua planilha. Esta chave está listada na URL entre "/d/" e "/edit" da sua nova planilha (veja o círculo azul).

3. Nomeie sua Planilha algo como "Dados Ambientais". Agora devemos criar nosso Google App Script (semelhante a JavaScript) que processará nossos dados e populá a planilha corretamente. Para inserir nosso Google App Script, primeiro navegamos da planilha para o Editor de Scripts:

Ferramentas → Editor de Scripts

Agora estamos na página do Google Script Editor. Podemos nomear nosso GScript algo como "Meu GScript Ambiental". Neste ponto, temos quatro coisas a fazer na página do Editor de Scripts:

• A) Copie e cole o código Google Script incluído no Editor
• B) Copie e cole a chave da URL da planilha salva anteriormente (passo 2) na linha correta do código Google Script (entre aspas) onde diz:

  var id = ' '; // ID da Planilha

• C) Salve o script: Arquivo → Salvar Tudo
• D) Implante como Aplicativo Web: Publicar → Implantar como Aplicativo Web…

4. Nossa etapa final para configurar a Planilha Google envolverá configurar os parâmetros de implantação Web. É importante definir todos estes campos corretamente. Se você não definir os quatro campos exatamente, sua planilha não funcionará corretamente.

1. Campo 1) Copie e salve a "URL do aplicativo Web atual:" que acabou de ser gerada, precisaremos dela depois ao configurar nossa API no PushingBox.
2. Campo 2) Salve uma versão do projeto como "nova" a cada iteração. É importante notar que se você não criar uma nova versão do projeto para cada revisão do script que fizer (se decidir fazer revisões), suas revisões não serão atualizadas na Web. Isso é contra-intuitivo e fácil de negligenciar, mas é assim que o Google configurou este sistema atualmente.
3. Campo 3) "Execute the app as: " defina como "eu (seu GMail aqui)".
4. Campo 4) "Who has access to the app: " defina como "qualquer pessoa, até anônimos".

Parte 2: Configurando o PushingBox

O Pushingbox.com serve como um intermediário API simples, gratuito e fácil, permitindo que nossos dados do DHT sejam compreensíveis para o Google Sheets. A necessidade de usar a API intermediária PushingBox é transformar nossos dados transmitidos via HTTP em dados HTTPS criptografados compatíveis com o Google. Poderíamos tentar criar um algoritmo de criptografia não trivial para satisfazer o requisito padrão, mas usar o PushingBox é mais fácil, e temos até 1.000 requisições por dia gratuitamente. Além disso, não precisamos lidar com APIs de "caixa preta" nas quais inserimos nossos próprios parâmetros, mas temos pouco controle sobre personalização e nenhuma ideia real de como a função funciona. Abaixo estão os passos para configurar o PushingBox para trabalhar com nossos dados:

1. Crie uma conta no PushingBox usando seu Gmail.
2. No topo, clique em "Meus Serviços".
3. Agora em "Meus Serviços", vá à caixa "Adicionar um serviço" e clique em "Adicionar um serviço".
4. O serviço que você criará é o último item da lista de serviços e se chama: "CustomURL, Configure seu próprio serviço !". Selecione este serviço CustomURL.
5. Uma caixa abrirá pedindo três itens. Preencha-os como abaixo e clique em enviar:
   • Nome da sua configuração CustomURL:
   • URL Raiz: Esta URL começará com https://script.google.com... pois este é o endereço do seu Google Script salvo na Parte 1
   • Método:

6. Após enviar seu serviço, você deve agora criar um cenário para o serviço. Para isso, selecione "Meus Cenários" no topo da página.
7. Insira um nome apropriado para seu cenário na caixa "Criar um cenário ou adicionar um dispositivo". Após nomear seu serviço, clique no botão "adicionar" à direita.
8. Agora será pedido para "Adicionar uma ação para seu cenário". Você deve escolher o botão "Adicionar uma ação a este serviço" listado ao lado do nome do serviço criado no passo anterior. Isso atribui seu novo cenário ao seu novo serviço.
9. Uma caixa de dados abrirá pedindo seu método "Get" ou "Post" (usamos o método Get embora pareça contra-intuitivo). Para registrar todos os nossos dados do DHT (cinco pontos de dados) em sua Planilha Google, você precisa vincular os nomes das variáveis listadas no seu Google App Script aos nomes listados no nosso sketch Arduino. Formatar os nomes corretamente na API do PushingBox realizará esta tarefa de vinculação. Copie e cole a seguinte string na sua caixa:

?humidityData=$humidityData$&celData=$celData$&fehrData=$fehrData$ &hicData=$hicData$&hifData=$hifData$

Nota: A declaração começa com " ? " para indicar "GET".

O resultado deve parecer com o seguinte, mas com seu próprio nome de cenário e número de Device ID:

Certifique-se de copiar sua string "DeviceID", você precisará dela tanto para testes preliminares no próximo passo, quanto depois para o Sketch Arduino na Parte 4.

Parte 3: Testando a API

Antes de prosseguirmos para a última etapa, na qual programamos o MKR1000 para enviar os dados do DHT pela web, seria útil testar se tudo o que fizemos até agora está correto. Se esperarmos para completar a parte de hardware, a causa de quaisquer erros pode ser mais difícil de rastrear. Felizmente, temos um método simples de testar nosso código até aqui. Podemos simplesmente inserir alguns pseudo-dados codificados diretamente na barra de endereços do navegador e verificar se nossa Planilha Google está sendo atualizada corretamente. Aqui está um exemplo do que você pode copiar e colar na barra de endereços do seu navegador.

https://api.pushingbox.com/pushingbox?devid=(SEU-DEVID-AQUI)&humidityData=33&celData=44&fehrData=111&hicData=22&hifData=77

Se quiser, pode até inserir novos dados falsos com valores diferentes para linhas subsequentes. Lembre-se, você tem apenas 1.000 requisições por dia do PushingBox, então não exagere! Se este procedimento não atualizou sua planilha, volte e revise as Partes 1-3 deste tutorial em busca de erros antes de tentar a Parte 4.

Parte 4

Após confirmar que conseguiu enviar alguns pseudo-dados codificados diretamente do seu navegador para sua Planilha Google, você está pronto para a próxima etapa, que envolve enviar dados diretamente do MKR1000 para o Google Sheets via PushingBox sobre WiFi. Antes de fazer upload e executar o sketch Arduino incluído no MKR1000, você deve completar os seguintes três passos.

Hardware

1. Conectando o MKR1000 ao DHT: Esta é uma tarefa simples, especialmente se usando o MKR1000. Recomendo alimentar o DHT com 5 volts, disponível no MKR1000, listado como 5v. Supostamente o DHT pode funcionar com 3.3v, mas não achei as leituras confiáveis na voltagem menor. Você tem a opção de usar vários pinos diferentes para entrada dos dados do DHT no MKR1000, mas no meu sketch uso o Pino 5 que mapeia para o Pino D5 no MKR1000 na parte superior da placa.

Software (1)

2. Existem alguns passos para configurar sua Arduino IDE para trabalhar com seu MKR1000. Estes passos incluem baixar duas bibliotecas e configurar a Arduino IDE (1.6.4 ou posterior) com o pacote correto da Placa MKR1000 (Ferramentas → Placa → Gerenciador de Placas). Muitos de vocês já terão instalado todo o software necessário. Para aqueles que não têm, abaixo estão links para obter as bibliotecas necessárias e o pacote de suporte da placa MKR1000. Observe também que tive que usar uma versão anterior do pacote da placa MKR1000, pois o mais recente não funcionava corretamente. Espero que este problema tenha sido resolvido quando você ler isto.

• Referência WiFi101

As duas bibliotecas necessárias para o sketch:

• Biblioteca WiFi101
• Biblioteca DHT (Adafruit)

Software (2)

3. Você está pronto para a etapa final do projeto. Precisa copiar e colar o sketch Arduino incluído, personalizá-lo para seu dispositivo e fazer upload do sketch no seu MKR1000. O sketch também transmite saída serial a 9600 baud para que você possa monitorar os dados sendo enviados via WiFi. Os três campos no sketch Arduino que você deve personalizar são:

• A) Nome da sua rede WiFi (SSID)
• B) Senha do seu WiFi
• C) Seu Device ID do PushingBox (devid)

Pronto! Se tudo foi completado corretamente, sua saída será algo como a imagem abaixo:

Obrigado a todas as pessoas que construíram a maioria dos componentes de software sobre os quais este projeto foi construído. Listei seus nomes nos comentários do código para atribuição adequada. Sinta-se à vontade para usar quaisquer partes deste projeto que precisar para criar sua própria mágica.

-SDB

Código

MKR1000 para Google Sheets via PushingBox usando DHT Arduino

Este Sketch Arduino envia dados via WiFi para o PushingBox para criptografia e depois para o Google Sheets registrar esses dados.

//-----------------------------------------------
// Este sketch é combinado da biblioteca DHT da Adafruit e tdicola para dht.h
// https://learn.adafruit.com/dht/overview
// https://gist.github.com/teos0009/acad7d1e54b97f4b2a88
// Outros autores Arduino e Google Script associado:
// Aditya Riska Putra
// Ahmed Reza Rafsanzani
// Ryan Eko Saputro
// Veja Também:
// https://jarkomdityaz.appspot.com/
// ELINS UGM
// Modificado para projeto Hackster.io para o MKR1000
// por Stephen Borsay (Portland, OR, EUA)
// Como Arduino não faz https, precisamos usar a API PushingBox (usa http) para
// executar o Google Script (usa https). Alternativamente use a criptografia SecureWifi do Ivan
#include <WiFi101.h>
#include "DHT.h"
#define DHTPIN 5 // pino conectado, pino 1 é o 5º pino da extremidade
// Descomente o tipo de sensor DHT que você está usando!
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT21 // DHT 21
//#define DHTTYPE DHT22 // DHT 22
DHT dht(DHTPIN, DHTTYPE);
const char WEBSITE[] = "api.pushingbox.com"; // servidor API pushingbox
const String devid = "YOUR_DEVICEID"; // device ID no PushingBox para nosso Cenário
const char* MY_SSID = "YOUR SSID";
const char* MY_PWD = "YOUR WiFi PASSWORD";
int status = WL_IDLE_STATUS;
// se não quiser usar DNS (e reduzir tamanho do sketch)
// use IP numérico em vez do nome do servidor:
//IPAddress server(74,125,232,128); // IP numérico para Google (sem DNS)
void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // aguarda porta serial conectar. Necessário apenas para porta USB nativa
  }
  // verifica presença do shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    while (true);
  }
  // tenta conectar à rede WiFi:
  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(MY_SSID);
    // Conecta a rede WPA/WPA2. Mude esta linha se usar rede aberta/WEP
    status = WiFi.begin(MY_SSID, MY_PWD);
    // aguarda 10 segundos para conexão:
    delay(10000);
  }
  Serial.println("Connected to wifi");
  printWifiStatus();
}
void loop() {
  // Aguarda entre medições.
  delay(10000);
  // prefiro usar float, mas tamanho do pacote ou conversão float não está funcionando
  // revisarei no futuro com função string ou conversão float
  int humidityData = dht.readHumidity();
  // Lê temperatura como Celsius (padrão)
  int celData = dht.readTemperature();
  // Lê temperatura como Fahrenheit (isFahrenheit = true)
  int fehrData = dht.readTemperature(true);
  // Verifica se alguma leitura falhou e sai cedo (para tentar novamente).
  if (isnan(humidityData) || isnan(celData) || isnan(fehrData)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }
  // Calcula índice de calor em Fahrenheit (padrão)
  int hifData = dht.computeHeatIndex(fehrData, humidityData);
  // Calcula índice de calor em Celsius (isFahrenheit = false)
  int hicData = dht.computeHeatIndex(celData, humidityData, false);
  Serial.print("Humidity: ");
  Serial.print(humidityData);
  Serial.print(" %\t");
  Serial.print("Temperature: ");
  Serial.print(celData);
  Serial.print(" *C ");
  Serial.print(fehrData);
  Serial.print(" *F\t");
  Serial.print("Heat index: ");
  Serial.print(hicData);
  Serial.print(" *C ");
  Serial.print(hifData);
  Serial.println(" *F\n");
  Serial.println("\nSending Data to Server...");
  // se obtiver conexão, reporta via serial:
  WiFiClient client; // Instancia objeto WiFi
  // Serviço API usando WiFi Client através do PushingBox e retransmitido para Google
  if (client.connect(WEBSITE, 80)) {
    client.print("GET /pushingbox?devid=" + devid + "&humidityData=" + (String) humidityData + "&celData=" + (String) celData + "&fehrData=" + (String) fehrData + "&hicData=" + (String) hicData + "&hifData=" + (String) hifData);
    // HTTP 1.1 fornece conexão persistente, permitindo requisições em lote
    // ou encadeadas para um buffer de saída
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(WEBSITE);
    client.println("User-Agent: MKR1000/1.0");
    // para MKR1000, diferente do esp8266, não feche a conexão
    client.println();
    Serial.println("\nData Sent");
  }
}
void printWifiStatus() {
  // imprime o SSID da rede à qual você está conectado:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());
  // imprime o endereço IP do seu shield WiFi:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);
  // imprime a força do sinal recebido:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

Google Script para receber dados sem fio em formato HTTPS JavaScript

Cole isso no Editor de Scripts da sua Planilha Google para receber seus dados sem fio. Lembre-se que deve ser em formato HTTPS criptografado/certificado de segurança, por isso uso o PushingBox.

//-----------------------------------------------
// Publicado originalmente por Mogsdad@Stackoverflow
// Modificado para jarkomdityaz.appspot.com
// Modificado para Hackster.io por Stephen Borsay
//-----------------------------------------------
/* GET request query: https://script.google.com/macros/s/<gscript id>/exec?celData=data_here
----------------------------------------------------------------------
GScript, PushingBox e Variáveis Arduino/ESP8266 em ordem:
humidityDat celData fehrData hicData hifData
---------------------------------------------------- */
/* Usando API da planilha */
function doGet(e) {
  Logger.log( JSON.stringify(e) ); // visualiza parâmetros
  var result = 'Ok'; // assume sucesso
  if (e.parameter == undefined) {
    result = 'No Parameters';
  } else {
    var id = '<YOUR_SPREADSHEET_URL_HERE>';//docs.google.com/spreadsheetURL/d
    var sheet = SpreadsheetApp.openById(id).getActiveSheet();
    var newRow = sheet.getLastRow() + 1;
    var rowData = [];
    //var waktu = new Date();
    rowData[0] = new Date(); // Timestamp na coluna A
    for (var param in e.parameter) {
      Logger.log('In for loop, param='+param);
      var value = stripQuotes(e.parameter[param]);
      //Logger.log(param + ':' + e.parameter[param]);
      switch (param) {
        case 'humidityData': // Parâmetro
          rowData[1] = value; // Valor na coluna B
          break;
        case 'celData':
          rowData[2] = value;
          break;
        case 'fehrData':
          rowData[3] = value;
          break;
        case 'hicData':
          rowData[4] = value;
          break;
        case 'hifData':
          rowData[5] = value;
          break;
        default:
          result = "unsupported parameter";
      }
    }
    Logger.log(JSON.stringify(rowData));
    // Escreve nova linha abaixo
    var newRange = sheet.getRange(newRow, 1, 1, rowData.length);
    newRange.setValues([rowData]);
  }
  // Retorna resultado da operação
  return ContentService.createTextOutput(result);
}
/**
 * Remove aspas simples ou duplas no início e fim
 */
function stripQuotes( value ) {
  return value.replace(/^["']|['"]$/g, "");
}

String URL do PushingBox (para cola HTTPS) HTML

Esta é sua string para conectar os nomes das variáveis do Arduino/MKR1000 sendo transmitidas ao Google Sheets com os mesmos nomes exatos. Usando PushingBox como intermediário habilitador de segurança RESTfully.

?humidityData=$humidityData$&celData=$celData$&fehrData=$fehrData$&hicData=$hicData$&hifData=$hifData$

Peças Personalizadas e Gabinetes

outros dados

outros sem fio: https://github.com/sborsay/Arduino_Wireless

Esquemáticos

Layout