ESP8266 y Google SpreadSheets

En artículos anteriores abordamos el tema de guardar datos de los sensores en Excel, sea por medio de un script en Python que recibe los datos por medio de MQTT o mediante el puerto serie; en esta ocasión quiero trabajar con las planillas de calculo de Google, puesto que ofrecen la posibilidad de escribir scripts para automatizar tareas.

Serán estos scripts los que nos ayudaran a guardar la información de los sensores conectados al microcontrolador (para el ejemplo utilizare un ESP8266, pero puede ser cualquiera) en una planilla.

Utilizaremos un sensor de gases MQ-5 para el ejemplo, pero es posible utilizar cualquier sensor disponible; el objetivo es registrar en la planilla la fecha y hora de la medición y el valor de la lectura.

Comenzaremos ingresando en Google Drive y creando una Hoja de Cálculo nueva, la llamaremos nivelGas y en la columna A indicaremos como titulo Fecha y Hora; en la columna B Nivel Gas a modo informativo.

Luego que se haya guardado la planilla, debemos crear el script que realizara los cambios sobre la misma; para ello vamos al menú Herramientas – Editor de secuencias de comandos:

Se abrirá una nueva ventana en nuestro navegado que contiene un editor para que podamos cargar el código que utilizaremos:

Aquí debemos indicar el nombre del proyecto, en mi caso utilizare modificarHoja y debemos copiar el siguiente código:


1
2
3
4
5
6
7
8
9
10
function doPost(e) {
   var ss1 = SpreadsheetApp.getActiveSpreadsheet();
   var sheet = ss1.getSheets()[0];

   var fechaHora = Utilities.formatDate(new Date(), "GMT-3", "yyyy-MM-dd HH:mm:ss");
   valor = String(e.parameters.data);
   sheet.appendRow([fechaHora,valor]);
   
   return ContentService.createTextOutput("Completo");
}

Este sencillo programa toma la hoja de cálculos abierta y de la misma identifica la primer hoja y por ultimo agrega una fila con los datos que fueron enviados desde el NodeMCU.

Por ultimo debemos establecer los permisos y accesos sobre el script para poder ejecutar correctamente, debemos ir a Publicar – Implementar como aplicación web

Debemos elegir que se ejecute como nuestro usuario y que cualquier persona incluso los anónimos tengan acceso a la aplicación; luego confirmamos las opciones que se nos presenta.

Copiamos la url que nos presenta, la utilizaremos en el programa del ESP8266.

Construiremos un sencillo circuito para tomar datos del entorno y guardarlos en la hoja de calculo, utilizaremos un sensor de gas MQ-5 que va conectado:

NodeMCUMQ-5
3v3VCC
GNDGND
A0A0

En el Arduino IDE utilizaremos las librerías y variables siguientes:


1
2
3
4
5
6
7
8
9
10
11
12
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

const char* ssid = "SSID"; //Replace with your own
const char* password = "PASSWORD";

const char* myDomain = "script.google.com";

String script = "/macros/s/XXXXXXXXXXXXXXXXXXXXX/exec";

long ultimoReporte=0;
long periodoReportes = 60 * 1000;

Donde ssid y password reemplazamos por los valores correspondientes a nuestra red wifi y en el variable script reemplazamos XXXXXXXXXXXXXXXXXXXXX por la correspondiente que nos otorgo Google Script.

Luego el metodo setup() es sencillo solo establecemos la salida serie y la conexion a la red. En el metodo loop tendremos lo siguiente:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
void loop() {
 
  if ((millis() - ultimoReporte) > periodoReportes) {
   
    if(WiFi.status() != WL_CONNECTED) {
      setup_wifi();
    }
    ultimoReporte = millis();
    int valor = analogRead(0);
    Serial.println(valor);
    enviarDatosCloud(valor);
  }

}

Respecto a la función enviarDatosCloud(), es la que se conecta al script de Google y pasa los parametros determinados:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
void enviarDatosCloud(int valor) {
  WiFiClientSecure clientSecure;
  if (clientSecure.connect(myDomain, 443)) {
    Serial.println("Connection successful");  

    String Data = "data="+String(valor);
    clientSecure.println("POST " + script + " HTTP/1.1");
    clientSecure.println("Host: " + String(myDomain));
    clientSecure.println("Content-Length: " + String(Data.length()));
    clientSecure.println("Content-Type: application/x-www-form-urlencoded");
    clientSecure.println();
   
    clientSecure.print(Data);    
    Serial.println("Waiting for response.");
    long int StartTime=millis();
    while (!clientSecure.available()) {
      Serial.print(".");
      delay(100);
      if ((StartTime+60000) < millis()) {
        Serial.println();
        Serial.println("No response.");
        break;
      }
    }
    Serial.println();
   
    while (clientSecure.available()) {
      Serial.print(char(clientSecure.read()));
    }  
   
  } else {
    Serial.println("Connected to " + String(myDomain) + " failed.");
  }
  clientSecure.stop();
}

Si todo esta correcto deberíamos poder compilar y al cabo de 60 segundos se actualizara nuestra hoja de cálculo; podemos cambiar el tiempo de actualización cambiando el valor de la variable periodoReportes.

En breve publicare en github el repositorio con el código del ejemplo.

Teclado y pantalla lcd con solo dos pines

Un problema habitual al trabajar con estos componentes es que requieren muchos puertos de nuestro microcontrolador; para el caso de ejemplo utilizaremos un ESP8266, un NodeMCU.

¿Cual es la trampa?

Necesitamos de otro chip que se ocupe de extender los puertos necesarios, para el caso del teclado utilizaremos un MCP23017, es lo que tengo a mano, pero estimo que puede ser cualquier chip de la familia. Requeriremos además tres resistencias de 10k, el diagrama de como conectarlo es el siguiente:

Requeriremos además instalar la librería keypad, si ya la tenemos instalada no será necesario. Para instalar desde el IDE de Arduino, debemos ir al menú Programa – Incluir Librería – Añadir desde ZIP.

Además también sera necesario arduino_keypads-master, simplemente debemos descomprimir dentro de la carpeta Libraries (en mi caso esta en C:\Users\Guillermo\Documents\Arduino\libraries ).

Luego que se hayan instalados estas librerías y construido el circuito anterior, es conveniente chequear cual es la dirección que tiene nuestro chip MCP23017 para poder comunicarnos adecuadamente con él; para ello cargaremos en el nodemcu un sketch para buscar las direcciones disponibles:

Si copia y pega el código verifique que no vayan caracteres incorrectos, tengo la mala experiencia que en oportunidades al pegar no llevar el carácter adecuado.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include  < Wire.h >
 
void setup() {
  Wire.begin();
 
  Serial.begin(9600);
  Serial.println("\nI2C Scanner");
}
 
 
void loop() {
  byte error, address;
  int nDevices;
 
  Serial.println("Scanning...");
 
  nDevices = 0;
  for(address = 1; address < 127; address++ )  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
 
    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    } else if (error==4) {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
 
  delay(5000);           // wait 5 seconds for next scan
}

Si todo esta correctamente conectado, en el monitor serie deberíamos ver un mensaje como el siguiente:

Donde 0x20 es la dirección de MCP23017.

El paso siguiente seria cargar el ejemplo para poder interactuar con el teclado:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <Keypad_MC17.h>
#include <Keypad.h>
#include <Wire.h>

#define I2CADDR 0x20

const byte ROWS = 4; //four rows
const byte COLS = 4; //five columns

char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'#','0','*','D'}
};
byte rowPins[ROWS] = {7, 6, 5, 4};
byte colPins[COLS] = {3, 2, 1, 0};

Keypad_MC17 customKeypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS, I2CADDR);

void setup(){
//  Wire.begin( );
  customKeypad.begin( );        // GDY120705
  Serial.begin(9600);
  Serial.println("Iniciando");
}
 
void loop(){
  char customKey = customKeypad.getKey();
 
  if (customKey != NO_KEY){
    Serial.println(customKey);
  }
}

De esta forma podemos conectar el teclado a una placa NodeMCU, también funciona con Arduino, utilizando solo dos pines.

Queda por ver si es posible utilizar los otros 8 pines restantes del MCP23017 para realizar otras operaciones y ampliar aún mas la cantidad de entradas y salidas.