MKR1000 a Google Sheets sin interrupciones: Sube datos de sensores por WiFi

Componentes y suministros

	Arduino MKR1000	×	1
	Sensor DHT11 de temperatura y humedad (4 pines)	×	1
	Cables jumper (genéricos)	×	1
	Protoboard (genérica)	×	1

Aplicaciones y servicios en línea

	Arduino IDE
	Google Sheets

Sobre este proyecto

Este proyecto permite procesar datos con vuestro MKR1000 y enviar esos datos a Google Sheets en la nube vía WiFi. Este proyecto se puede lograr sin registro de tarjeta de crédito ni uso de APIs propietarias de "caja negra". Para este ejemplo específico uso el sensor ambiental DHT11, barato y omnipresente, pero podéis alterar fácilmente el código Arduino incluido para cualquier sensor o dispositivo que queráis. Vale la pena señalar que este proyecto podría combinarse fácilmente en un sketch con uno de mis proyectos relacionados, que sube datos del DHT11 a Thingspeak.com para gráficos.

Esta es la primera de cuatro partes. En la primera parte configuraréis vuestra propia Google Sheet para aceptar vuestros datos WiFi usando el código de Google App Script incluido.

Parte 1: Crear y desplegar vuestra Google Sheet

1. Registraos para obtener un correo electrónico gratuito de Google si no tenéis uno.

2. Iniciad sesión en vuestra cuenta gratuita de Google y cread una nueva "Google Sheet", esta es la hoja de cálculo que se poblará con los valores del sensor DHT vía WiFi. En este punto necesitaréis copiar y guardar la clave URL de vuestra hoja de cálculo. Esta clave aparece en la URL entre "/d/" y "/edit" de vuestra nueva hoja de cálculo (ver círculo azul).

3. Nombrad vuestra hoja de cálculo algo original como "Datos Ambientales", ahora debemos crear nuestro Google App Script (similar a JavaScript) que procesará nuestros datos y poblará nuestra hoja correctamente. Para insertar nuestro Google App Script primero navegamos desde nuestra hoja de cálculo al Editor de Scripts:

Herramientas → Editor de Scripts

Ahora estaremos en la página del Editor de Scripts de Google. Ahora podemos nombrar nuestro Gscript algo extra-creativo como "Mi Gscript Ambiental". En este punto nos quedan cuatro cosas por hacer en la página del editor de scripts.

A) Copiar y pegar el código de Google Script incluido en el Editor

B) Copiar y pegar la clave URL de la hoja de cálculo guardada previamente (paso 2) en la línea correcta del código de Google Script (entre comillas) donde dice:

var id = ' '; // ID de la hoja de cálculo

C) Guardar el script: Archivo → Guardar todo

D) Desplegar como aplicación web: Publicar → Desplegar como aplicación web…

4. Nuestro paso final para configurar nuestra Google Sheet implicará configurar los parámetros de despliegue web. Es importante que establezcáis todos estos campos correctamente. Si no establecéis los cuatro campos exactamente, vuestra hoja de cálculo no funcionará correctamente.

Campo 1) Copiar y guardar la "URL actual de la aplicación web:" que acaba de generarse, la necesitaremos más tarde cuando configuremos nuestra API en PushingBox.

Campo 2) Guardar una versión del proyecto como "nueva" en cada iteración, es importante notar que si no creáis una nueva versión del proyecto para cada revisión del script que hagáis (si decidís hacer alguna revisión), vuestras revisiones no se actualizarán en la web. Es contraintuitivo y fácil de descuidar, pero así es como Google tiene configurado este sistema actualmente.

Campo 3) "Ejecutar la aplicación como: " estableced esto a "yo (vuestro GMail aquí)".

Campo 4) "Quién tiene acceso a la aplicación: " estableced esto a "cualquiera, incluso anónimo".

Parte 2: Configurar PushingBox

Pushingbox.com sirve como un intermediario API simple, gratuito y fácil para permitir que nuestros datos DHT sean digeribles por Google Sheets. La necesidad de usar la API intermediaria PushingBox es convertir nuestros datos transmitidos por HTTP en datos HTTPS encriptados compatibles con Google. Podríamos intentar hacer un algoritmo de encriptación no trivial para satisfacer el requisito estándar, pero usar PushingBox es más fácil, y nos dan hasta 1.000 peticiones al día gratis. Además, no tenemos que lidiar con APIs de "caja negra" en las que podemos introducir nuestros propios parámetros, pero luego tenemos poco control sobre la personalización y ninguna idea real de cómo funciona realmente la función. A continuación, los pasos para configurar PushingBox para que funcione con nuestros datos:

1. Crear una cuenta en PushingBox usando vuestro Gmail.

2. En la parte superior haced clic en "Mis Servicios"

3. Ahora en "Mis Servicios" id al cuadro "Añadir un servicio" y haced clic en "Añadir un servicio".

4. El servicio que queréis crear es el último elemento de la lista de servicios y se llama: ”CustomURL, ¡Configura tu propio servicio!”. Ahora seleccionad este servicio CustomUrl.

5. Se abrirá un cuadro y pedirá tres elementos. Rellenadlos como se indica a continuación y luego dad a enviar.

Nombre de vuestra configuración CustomURL:

URL raíz: Esta URL comenzará con https://script.google.com... ya que es la dirección de vuestro Google Script guardada en la Parte 1

Método:

6. Después de enviar vuestro servicio, ahora debéis crear un escenario para el servicio. Para ello seleccionad "Mis Escenarios" en la parte superior de la página.

7. Introducid un nombre apropiado para vuestro escenario en el cuadro "Crear un escenario o añadir un dispositivo". Después de nombrar vuestro servicio, haced clic en el botón "añadir" a la derecha.

8. Ahora pedirá "Añadir una acción para vuestro escenario". Ahora debéis elegir el botón "Añadir una acción a este servicio" que aparece junto al nombre del servicio que creasteis en el paso anterior. Esto asigna vuestro nuevo escenario a vuestro nuevo servicio.

9. Se abrirá un cuadro de datos pidiendo vuestro método "Get" o "Post" (usamos el método Get aunque parezca contraintuitivo). Para registrar todos nuestros datos DHT (cinco puntos de datos) en vuestra Google Sheet, necesitáis vincular los nombres de variables listados en vuestro Google App Script con los nombres listados en nuestro sketch de Arduino. Formatear los nombres correctamente en la API de PushingBox logrará esta vinculación. Copiad y pegad la siguiente cadena en vuestro cuadro.

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

Nota: La declaración comienza con " ? " para indicar "GET".

El resultado debería verse como sigue, pero con vuestro propio nombre de escenario y número de Device ID:

Aseguraos de copiar vuestra cadena "DeviceID", la necesitaréis tanto para las pruebas preliminares en el siguiente paso como luego para el Sketch de Arduino en la Parte 4.

3. Probar la API

Antes de pasar al último paso, en el que programamos el MKR1000 para enviar los datos de nuestro DHT a través de la web, sería útil probar que todo lo que hemos hecho hasta ahora es correcto. Si esperamos a completar la parte de hardware, la causa de cualquier error puede ser más difícil de rastrear. Afortunadamente tenemos un método simple de probar nuestro código hasta ahora. Podemos simplemente introducir algunos datos pseudo-codificados directamente en la barra de direcciones de nuestro navegador y comprobar que nuestra Google Sheet se actualiza correctamente. Aquí tenéis un ejemplo de lo que podéis copiar y pegar en la barra de direcciones de vuestro navegador.

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

Si queréis, podéis incluso volver a introducir nuevos datos falsos con valores diferentes para filas subsiguientes, pero recordad que solo tenéis 1.000 peticiones por día de PushingBox, ¡así que no os volváis locos! Si este procedimiento no actualizó vuestra hoja de cálculo, volved atrás y revisad las Partes 1-3 de esta guía en busca de errores antes de intentar la Parte 4.

Parte 4

Después de confirmar que pudisteis enviar algunos datos pseudo-codificados directamente desde vuestro navegador a vuestra Google Sheet, ya estáis listos para el siguiente paso que implica enviar datos directamente desde el MKR1000 a Google Sheets vía PushingBox sobre WiFi. Antes de poder subir y ejecutar el sketch de Arduino incluido en el MKR1000, debéis completar los siguientes tres pasos.

Hardware

1. Cablear el MKR1000 al DHT: Es una tarea simple, especialmente si usáis el MKR1000. Os recomiendo alimentar el DHT con 5 voltios, que está disponible en el MKR1000, listado como 5v. Supuestamente el DHT puede funcionar a 3.3v pero no he encontrado las lecturas del DHT fiables a ese voltaje más bajo. Tenéis la opción de usar varios pines diferentes para introducir los datos del DHT al MKR1000, pero en mi sketch uso el Pin 5 que corresponde al Pin D5 en el MKR1000 en la parte superior de la placa.

Software(1)

2. Hay unos pasos para configurar vuestro Arduino IDE para que funcione con vuestro MKR1000. Estos pasos incluyen descargar dos librerías y configurar el Arduino IDE (1.6.4 o posterior) con el paquete de placa MRK1000 correcto (Herramientas → Placa → Gestor de tarjetas). Muchos de vosotros ya habréis instalado todo el software necesario, para los que no, a continuación tenéis enlaces para obtener las librerías necesarias y el paquete de soporte de la placa MKR1000. También notar que tuve que usar una versión anterior del paquete de placa MKR1000 ya que el último paquete de soporte de placa MKR1000 no funcionaba correctamente. Espero que este problema se haya resuelto para cuando leáis esto.

https://www.arduino.cc/en/Reference/WiFi101

Las dos librerías requeridas para el sketch:

• https://github.com/arduino-libraries/WiFi101

• https://learn.adafruit.com/dht

Software(2)

3. Ahora estáis listos para el paso final del proyecto, necesitáis copiar y pegar el sketch de Arduino incluido, personalizarlo para vuestro dispositivo y luego subir el sketch a vuestro MKR1000. El sketch también transmite la salida serie a 9600 baudios para que podáis monitorizar los datos que se envían vía WiFi. Los tres campos en el sketch de Arduino que debéis personalizar son:

A) Nombre de vuestra WiFi

B) Contraseña de vuestra WiFi

C) Vuestro Device ID de PushingBox (devid)

¡Eso es todo, habéis terminado! Si todo se completó correctamente, vuestra salida se verá algo como la imagen de abajo:

Gracias a todas las personas que construyeron la mayoría de los componentes de software sobre los que se construyó este proyecto. He listado sus nombres en los comentarios del código para la atribución adecuada. Por favor, sentíos libres de usar las piezas de este proyecto que necesitéis para crear vuestra propia magia.

-SDB

Código

• MKR1000 a Google Sheets vía PushingBox usando el DHT
• Google Script para recibir datos inalámbricos en formato HTTPS
• Cadena URL de PushingBox (para pegamento HTTPS)

MKR1000 a Google Sheets vía PushingBox usando el DHTArduino

Este Sketch de Arduino envía datos vía WiFi a PushingBox para encriptación y luego a PushingBox para registrar esos datos en vuestra Google Sheet

//-----------------------------------------------
//Este sketch está combinado de Adafruit DHT sensor y tdicola para la librería dht.h
// https://learn.adafruit.com/dht/overview
// https://gist.github.com/teos0009/acad7d1e54b97f4b2a88
//otros Autores Arduino y Google Script asociado:
//Aditya Riska Putra
//Ahmed Reza Rafsanzani
//Ryan Eko Saputro
//Ver también:
//https://jarkomdityaz.appspot.com/
//
//ELINS UGM
//
//Modificado para proyecto Hackster.io para el MKR1000
//por Stephen Borsay(Portland, OR, USA)
//Como Arduino no puede https, necesitamos usar la API de Pushingbox (usa http) para
//ejecutar el Google Script (usa https). Alternativamente usar la encriptación SecureWifi de Ivan
#include <WiFi101.h>
#include "DHT.h"
#define DHTPIN 5 // pin al que estamos conectados, pin1 es el 5º pin desde el final
// Descomentad el tipo de sensor DHT que estéis 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 de pushingbox
const String devid = "YOUR_DEVICEID"; //device ID en Pushingbox para nuestro Escenario
const char* MY_SSID = "YOUR SSID";
const char* MY_PWD = "YOUR WiFi PASSWORD";
int status = WL_IDLE_STATUS;
// si no queréis usar DNS (y reducir el tamaño del sketch)
// usad la IP numérica en lugar del nombre para el servidor:
//IPAddress server(74,125,232,128); // IP numérica para Google (sin DNS)
void setup() {
//Inicializar serie y esperar a que el puerto abra:
Serial.begin(9600);
while (!Serial) {
; // esperar a que el puerto serie conecte. Necesario solo para puerto USB nativo
}
// comprobar la presencia del shield:
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("WiFi shield not present");
// no continuar:
while (true);
}
// intentar conectar a la red Wifi:
while (status != WL_CONNECTED) {
Serial.print("Attempting to connect to SSID: ");
Serial.println(MY_SSID);
//Conectar a red WPA/WPA2. Cambiad esta línea si usáis red abierta/WEP
status = WiFi.begin(MY_SSID, MY_PWD);
// esperar 10 segundos para la conexión:
delay(10000);
}
Serial.println("Connected to wifi");
printWifiStatus();
}
void loop() {
// Esperar entre mediciones.
delay(10000);
//preferiría usar float, pero el tamaño del paquete o la conversión de float no funciona
//revisaré en el futuro con una función de string o conversión de float
int humidityData = dht.readHumidity();
// Leer temperatura como Celsius (por defecto)
int celData = dht.readTemperature();
// Leer temperatura como Fahrenheit (isFahrenheit = true)
int fehrData = dht.readTemperature(true);
// Comprobar si alguna lectura falló y salir pronto (para intentarlo de nuevo).
if (isnan(humidityData) || isnan(celData) || isnan(fehrData)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
// Calcular índice de calor en Fahrenheit (por defecto)
int hifData = dht.computeHeatIndex(fehrData, humidityData);
// Calcular índice de calor en Celsius (isFahreheit = 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...");
// si obtenéis una conexión, informad vía serie:
WiFiClient client;
//Instanciar objeto WiFi, puede tener ámbito desde aquí o globalmente
//Servicio API usando WiFi Client a través de PushingBox luego retransmitido a 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 proporciona una conexión persistente, permitiendo peticiones en lote
// o en tubería a un búfer de salida
client.println(" HTTP/1.1");
client.print("Host: ");
client.println(WEBSITE);
client.println("User-Agent: MKR1000/1.0");
//para MKR1000, a diferencia de esp8266, no cerrar conexión
client.println();
Serial.println("\nData Sent");
}
}
void printWifiStatus() {
// imprimir el SSID de la red a la que estáis conectados:
Serial.print("SSID: ");
Serial.println(WiFi.SSID());
// imprimir la dirección IP de vuestro shield WiFi:
IPAddress ip = WiFi.localIP();
Serial.print("IP Address: ");
Serial.println(ip);
// imprimir la intensidad de la señal recibida:
long rssi = WiFi.RSSI();
Serial.print("signal strength (RSSI):");
Serial.print(rssi);
Serial.println(" dBm");
}

Google Script para recibir datos inalámbricos en formato HTTPSJavaScript

Pegad esto en el Editor de Scripts de vuestra Google Sheet para recibir vuestros datos inalámbricos. Recuerda que tiene que ser formato HTTPS encriptado/certificado de seguridad, por eso uso PushingBox

//-----------------------------------------------
//Publicado originalmente por Mogsdad@Stackoverflow
//Modificado para jarkomdityaz.appspot.com
//Modificado para Hackster.io por Stephen Borsay
//-----------------------------------------------
/* Petición GET query: https://script.google.com/macros/s/<gscript id>/exec?celData=data_here
----------------------------------------------------------------------
GScript, PushingBox y Variables Arduino/ESP8266 en orden:
humidityDat celData fehrData hicData hifData
----------------------------------------------------
*/
/* Usando API de hoja de cálculo */
function doGet(e) {
Logger.log( JSON.stringify(e) ); // ver parámetros
var result = 'Ok'; // asumir éxito
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 tiempo = new Date();
rowData[0] = new Date(); // Timestamp en columna 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 en columna 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));
// Escribir nueva fila abajo
var newRange = sheet.getRange(newRow, 1, 1, rowData.length);
newRange.setValues([rowData]);
}
// Devolver resultado de la operación
return ContentService.createTextOutput(result);
}
/**
* Eliminar comillas simples o dobles al principio y final
*/
function stripQuotes( value ) {
return value.replace(/^["']|["']$/g, "");
}

Cadena URL de PushingBox (para pegamento HTTPS)HTML

Esta es vuestra cadena para conectar los nombres de variables de vuestro Arduino/MKR1000 que se transmiten a Google Sheets con los mismos nombres exactos. Usando PushingBox como intermediario habilitador de seguridad RESTfully.

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

Piezas personalizadas y cajas

otros datos

otros inalámbricos https://github.com/sborsay/Arduino_Wireless

Esquemáticos

Layout