La lectura de sensores es una actividad frecuente y la CPU ESP8266 no es una de las más poderosas actualmente, sin embargo aún la versión más pequeña, la ESP01, es capaz de hacer tareas interesante. Dos problemas están relacionados con el uso de los sensores y son:

a) la visualización.

b) el registro.

En este instructable se mostrará un ejemplo de uso de la ESP01 en que se registran los valores diarios en un gráfico que puede ser visto en una página Web, ya sea en el escritorio o en un celular, resolviendo ambos problemas. El celular debe estar en la misma LAN que el dispositivo sensor.

En el ejemplo, de mostrará la temperatura y la presión atmosférica, usando el sensor BMP280 u otro cualquiera que admita acceso I2C.

El programa nos permite almacenar un día de datos siempre que midamos tras algunos segundos, lo cual es adecuado para variables de clima, como en el presente ejemplo.

Dado que el 8266 tiene un stack TCP/IP, se genera un web Server para la visualización y para obtener una medida del tiempo usando un servidor NTP de la red.

La capacidad Web nos permite mostrar los datos en cualquier navegador, especialmente un celular y ocupar un sistema de gráficos nos una visión de los cambios en el día e incluso podemos comparar con el día anterior. Todo esto se puede lograr utilizando la representación gráfica basada en SVG (gráficos escalables).

El ejemplo que se desarrolla acá utiliza ideas de varios creadores, especialmente los brillantes Random Nerds, Sara y Rui Santos de Portugal. Además usé la idea de otro creador cuya referencia perdí pero a quien le debo la idea del uso de SVG.

Un aspecto importante es que este esquema nos permite almacenar la información histórica en el mismo ESP01, de modo que no es necesario tener un Web activo para mantener la historia.

Para ver la página web con los resultados se necesita saber la dirección IP que el router asigna al dispositivo. Yo ocupo el programa 'Net Analyzer' disponible en Android. También se puede averiguar ingresando al Router como administrador.

Supplies

a) CPU ESP01 US $0.49/ lote de10 unidades

b) Sensor de presión barométrica Digital BMP280 o BME280 US$ 0,60

c) Adaptador programador ESP01 UART US $1,01

El costo total es de alrededor de 1,7 USD aproximadamente más los gastos de envío en valores de Ali Express.:

También se necesita un computador para desarrollar el programa en un ambiente IDE de Arduino.

Step 1: El Programa

Sin duda el lector encontrará varios instructables que enseñan muy bien cómo usar el IDE de Arduino con la CPU ESP8266 y el empleo de un programador USB para estos fines, el cual también permitirá alimentar el sistema con un cargador de 5V y eventualmente, conectado al computador de escritorio o laptop para depurar el comportamiento del sistema.

El programa se ha dividido en varios módulos o rutinas tratando que la personalización adecuada para cada caso, se realice en pocos lugares del código, facilitando la reutilización del código con diferentes sensores.

En el programa principal hay dos áreas a personalizar con las bibliotecas del sensor y sus instancias así como también algunos parámetros de la medida.

En el ejemplo se puede ver:

a) En el programa principal, un área con las librerías propias del sensor y

b) un área con parámetros propios del uso del sensor

c) Además una rutina que inicializa al sensor (inisensor() ;)

d) Una rutina que lee al sensor y pone las lecturas en las variables ‘sensor’. (getSensorReadings();).

El resto del programa no necesita alterarse para funcionar.

Step 2: Cómo Funciona.

En el listado del programa podemos ver: ( acentos omitidos).

----------------------------------------------------------------------------------

// Parametros a personalizar segun SENSOR<<<<<<<<<<<<<<<<<<<

String CPU = "ESP01 BMP280 "; // como referencia

String titulo = "Clima con BMP280";

String unidad1="pascales";

String unidad2="grados C";

String H1 = "Pascales y grados C";

int lapso=86400; // segundos a medir= 1 dia

float escala1 = 1.005; // margen sobre maximo y minimo del grafico=+/-escala

float escala2 = 1.1; // margen sobre el maximo y minimo del grafico=+/-escala

//factores para manejar multiplos o submultiplos de las medidas

float rango1 = 1; // segun unidades directas del sensor

float rango2 = 100.; //centesimas de grado

----------------------------------------------------------

Entre estos parámetros, los primeros Strings declrados permiten manejar los textos de presentación de la página Web.

El parámetro 'int lapso' indica el número de segundos que forman un ciclo de medida, en este caso, 86400 segundos, es decir, un día.

La cantidad total de puntos que se pueden graficar está limitado por la memoria del ESP01, la cual que es de sólo 1Mb. Este valor nos permite manejar 410 puntos para 2 variables. Es este modo, si se quiere grafica 24 horas, debemos medir 86400 segundos/ 400 puntos, igual a 211 segundos/muestra. Ocupando otras versiones de la CPU, con más memoria, se podrá tener mayores lapsos o mayores frecuencias de las medidas.

Los parámetros 'escala...' indica el margen vertical del gráfico de modo que un valor de 1.015 indica que la escala estará limitada en más y menos 1,5% del valor central.

La escala se evalúa nuevamente si la medida excede estos márgenes, de modo de mostrar siempre visible el valor medido. La determinamos por prueba y error según el caso.

Los datos de manejan internamente como enteros de modo que si queremos ver las centésimas del valor medido debemos utilizar los parámetros 'rango...' para modificar el rango de la lectura. Un valor de 100 permitirá graficar las centésimas y el valor 1 nos entrega la medida leída directamente en el sensor.

Una serie de parámetros define la estructura del gráfico a mostrar. El más importante es:

const int largoH = 410;

Este valor está limitado por la memoria disponible que en el caso del ESP01 es de 1MB.

Step 3: Las Rutinas

Las rutinas:

void inisensor();

void getSensorReadings();

son las únicas que se deben adaptar a cada sensor y permiten inicializar y leer el sensor, respectivamente. Los valores leídos se registran en las variables 'sensor1' y 'sensor2' y son copiadas desde los ejemplos de uso que traen las bibliotecas del sensor.

Hemos procurado incluir los comentarios necesarios para la comprensión del código. En él hay muchas partes que he copiado de los ejemplos disponibles, especialmente los excelente tutoriales de Sara y Rui Santos en su sitio https://randomnerdtutorials.com/ los que son muy didácticos y bien documentados. Mucho del material tiene el copywrite de estos generosos ingenieros.

Los programas incluidos son los siguientes:

void inisensor(); // ya comentado

void getSensorReadings(); // ya comentado

void iniwifi(); // conecta al router con las credenciales adecuadas

void fecha(); // cliente NTP

void calculos(); //Proceso de lectura y almcenamiento de datos. Definición de escala.

void handleRoot(); // genera la página web

void handleNotFound(); // en caso de falla del web

void drawGraph(); // genera un gráfico SVG con la información disponible

static void smartDelay(unsigned long ms); // retardo que atiende el web esperando

Además el programa principal.ino, que tiene las rutinas de inicialización setup() y el loop() que se muestran en el archivo adjunto.

El corazón de este ejemplo son las rutinas

void handleRoot(); // genera la página Web (que se debe bajar con copy-paste)

void drawGraph(); // genera el SVG.

Con ellas se genera una gráfica apta para registros de horas o días

Step 4: Rutinas Web

Por motivos que desconozco, esta rutina no pude ser anexada como los otros archivos.

Por ello, el lector deberá llevarlo con copy-paste a un archivo de tipo '.ino' el directorio donde está el programa principal. Esta rutina genera la página Web y coloca los valores que definen el proyecto.

------------------------------------------8<-------------------------------------------

void handleRoot() {/////////////////////////////////////////

StreamString buff;

buff.reserve(640);// Preallocate a large chunk to avoid memory fragmentation OJO con '\'= continuacion

buff.printf("\

<html>\

<head>\

<title>%s</title>\

<style>\

body {background-color: #cccccc; font-family: Arial; Color: #000088; }\

</style>\

</head>\

<body><h1>%S</h1>\

<p>Fecha incio : %4d-%2d-%2d %02d:%02d:%02d \

Fecha actual: %4d-%2d-%2d %02d:%02d:%02d</p>\

<p> Ultimo valor rojo = %7.2f %S</p>\

<p> Ultimo valor azul = %7.2f %S</p>\

<p> en x = %7d cada: %7d segundos= %7d = %7.2f minutos</p>\

<p>Escala del sensor rojo: minimo= %7.1f maximo= %7.1f %S</p>\

<p>Escala del sensor azul: minimo= %7.1f maximo= %7.1f %S</p>\

<p>%S - %S</p>\

<img src=\"/test.svg\" />\

</body>\

</html>", cada, titulo.c_str(), H1.c_str(), annoi, mesi, diai, horai, minutoi, segundoi, \

anno, mes, dia, hora, minuto, segundo, sensor1 / rango1,unidad1, sensor2 / rango2,unidad2, \

h , cada, h * cada, h * cada / 60., minH1 / rango1, maxH1 / rango1,unidad1, \

minH2 / rango2, maxH2 / rango2,unidad2, CPU.c_str(), WiFi.localIP().toString().c_str());

// Serial.print(" buff "); Serial.println(buff.length());

server.send(200, "text/html", buff.c_str());

}//////////////////////////////////////

----------------------------------------------8<--------------------------------------------------------

Step 5: Comentarios.

a) La Medida del Tiempo: Aprovechando las habilidades TCP/IP del chip 8266 la fecha y hora la obtenemos a partir de un servidor NTP que el lector podrá cambiar, si le parece. Dado que las lecturas se hacen en el rango de los minutos, no es una carga fuerte para los servidores.

b) Gráfico: el web Server realizado en la CPU utiliza un javascript para construir un gráfico del tipo SVG por lo que la comunicación entre el Servidor Web y el navegador es enteramente ASCII.

Para mejor visibilidad de la curva, se grafican los puntos cada 2 pixeles del rectángulo SVG, de modo que el ancho del canvas triplica el numero de puntos en este caso, 410x2=820. Esto se controla con el parámetro 'e'.

c) Limitaciones: por la forma de comunicar la información, la frecuencia de medición no logra supera las dos o tres segundos por muestra siendo por tanto muy adecuado a medidas como las meteorológicas, las que se visualizan en formato diario y basta revisarlas cada varios minutos.

d) Adaptaciones: el código mostrado permite, sin dudas, muchas mejoras en manos de programadores avezados, entre los cuales no me encuentro. Pero el objetivo es mostrar un sistema sencillo y económico pudiendo multiplicarse a bajo costo.

e) La alimentación del circuito se realiza a través del mismo programador que alimenta la CPU con 3,3 Volts a partir de la conexión USB de 5 Volts. Naturalmente que también se puede realizar un esquema con baterías o celdas solares considerando, eso sí , que el 8266 consume varios mili amperes a 3.3 Volts.

f) Una mejora importante puede ser aprovechar las capacidades de "dormir" que dispone el chip, de modo de despertarlo solamente cuando necesita medir. Sin embargo, la realización ESP01 no permite fácilmente acceder a esta facilidad. Otras tarjetas Espressif pueden usarlo y tienen más memoria.

g) se ha mostrado cómo hacer un registro de largo plazo en forma económica.

Step 6: El Circuito

Las únicas soldaduras necesarias son las que permiten la conexión del ESP01 con el sensor a través de 4 alambres:

- Vcc, 3,3 Volts.

- GND,

- SDA al pin IO 0 del conector de 8 pines.

- SCL al pin IO 2 del mismo.

Step 7: Resultados

En la figura se puede ver una captura de pantalla que muestra la presión, en Pascales y la temperatura en grados centígrados.

Una línea vertical indica la separación entre los datos actuales y los del día anterior que van siendo barridos a medida que la medición continúa. Considerando el pequeño costo, es factible realizar varios ejemplares y medir, por ejemplo, temperaturas en diferentes partes de la casa.