Estoy escribiendo este documento al mismo tiempo que me estoy adentrando en el conocimiento de la nueva plataforma de Blynk.. Intentaré resumir mi experiencia desde que comence a utilizarla desde la la ultima etapa hasta ahora.
La antigua App de Blynk que esta referida ahora como “Blynk legacy”, era bastante intuitiva y bajo mi punto de vista bastante completa en cuanto a dispositivos y modos de conexión, como BLE y Bluetooth clásico,, aspecto ahora no contemplado. La cantidad de widgets a utilizar se limitaba por la energía que debias adquitir en forma de pequeñas cantidades a abonar. Por el contrario ahora, entiendo las necesidades de expansión empresarial, tienes que suscribirte para tener acceso a 10 dispositivos y pagar mensual o anualmente..
Tendrás que dedicar un tiempo para ponerte al dia a la hora de iniciarte en la nueva app,. Por eso,aunque la documentación es muy buena y el apoyo por email es inmejorable, pongo mi granito de arena en forma de experiencia personal a traves de un sencillo sketch que he utilizado en mi primera puesta en marcha.
Para comenzar
- Crear una cuenta en Blynk usando Blynk.Console or Blynk.App for iOS or Android.
- Pasar a Developer Mode en la consola web o en la app
- Tener disponible para pruebas un dispositivo como (ESP32, Arduino, Raspberry Pi, etc).La lista de dispositivos admitidos la puede ver here.
Primera conexión On Line:
En primer lugar ,dentro de la ” Blynk Console” vamos a crear una plantilla llamada “Test01”
En principio no vamos a editar esta plantilla, solo hemos elegido el dispositivo que es un ESp32 y el tipo de conexión Wifi.
A continuacion nos vamos a la lupa ,buscar y añadiremos un dispositivo nuevo que se asociará a esta plantilla;
Una vez creado el nuevo dispositivo hay que copiar donde viene marcado en amarillo para incorporarlo a
nuestro sketch:
observese que el BLYNK_AUTH_TOKEN lo hemos vuelto a poner en la variable “auth”
#define BLYNK_PRINT Serial
#define BLYNK_TEMPLATE_ID "TMPL8GVQ-W-f"
#define BLYNK_DEVICE_NAME "Test01"
#define BLYNK_AUTH_TOKEN "kvrZ-Y80CWnkUcP8jECNwOhQZsxX9PnG"
#include <BlynkSimpleEsp32.h>
char ssid[] = "xxxxxxx";//NOMBRE DE NUESTRA RED WIFI
char pass[] = "xxxxxxx";//Contraseña
char auth[] = "kvrZ-Y80CWnkUcP8jECNwOhQZsxX9PnG";Ya podemos abrir la App para añadir los widgets y datastream que explican en la documentación;
pero antes vamos a preparar un sencillo sketch de prueba que contenga transmisión y recepcion de datos a la nube Blynk.
En este sketch queremos que desde la app pulsemos un “switch” y se ponga en marcha un cronometro en el dispositivo con la peculiaridad de que tambien enviará una cadena de texto informando cuando el cronometro este a cero y cuando se ponga en marcha. Aqui pongo el codigo completo:
#define BLYNK_PRINT Serial
#define BLYNK_TEMPLATE_ID "TMPL8GVQ-W-f"
#define BLYNK_DEVICE_NAME "Test01"
#define BLYNK_AUTH_TOKEN "kvrZ-Y80CWnkUcP8jECNwOhQZsxX9PnG"
#include <BlynkSimpleEsp32.h>
unsigned long timer;
unsigned long tref;
char ssid[] = "xxxxxx";
char pass[] = "xxxxxx";
char auth[] = "kvrZ-Y80CWnkUcP8jECNwOhQZsxX9PnG";
//recibir datos de la app
uint8_t v0;
BLYNK_WRITE(V0){v0=param.asInt();}//Recibir datos de la app
//FUNCION PARA QUE V0 PERMANEZCA CONECTADO ANTE UNA DESCONEXION CUANDO REANUDE
BLYNK_CONNECTED()
{
Blynk.syncVirtual(V0); // will cause BLYNK_WRITE(V0) to be executed
}
//enviar datos a la nube
BlynkTimer timer1; // Announcing the timer1//se podria utilizar el mismo temporizador para diferentes variables
BlynkTimer timer2; // Announcing the timer2
//declaración de variables
double v1;
String v2="start ready";
//definiendo funciones,las nombro segun el datastream a utilizar (pin virtual)antepodiendo "s"
void sv1(){
Blynk.virtualWrite(V1,v1); // sending sensor value of v1 to Blynk app
}
void sv2(){
Blynk.virtualWrite(V2, v2); // sending sensor value v2 to Blynk app
}
void setup(void) {
Serial.begin(9600);
timer1.setInterval(1000L, sv1); //timer will run every sec
timer2.setInterval(1000L, sv2);
Blynk.begin(auth, ssid, pass);
}
void loop(){
timer=(millis()-tref)/1000;
Blynk.run();
timer1.run(); // Initiates BlynkTimer1
timer2.run();// Initiates BlynkTimer2
if (v0){v2.replace("start ready","started");v1= timer; }else {v1=0;tref=millis();v2.replace("started","start ready");}
}
CONCEPTOS PARA SU CONOCIMIENTO
Cómo llegan los datos de Blynk al dispositivo
Blynk puede controlar cualquier dispositivo compatible de forma remota utilizando la interfaz web Blynk.Console o Blynk.Apps para iOS y Android.
Cuando toca un botón o desliza el control deslizante en la aplicación móvil, el valor se envía al dispositivo a través de un flujo de datos usando el protocolo Blynk.
Datastream es un canal que le dice a Blynk qué tipo de datos fluyen a través de él.
Aunque antes se podía controlar los GPIO directamente mediante el uso de flujos de datos digitales y analógicos, actulmente solo se usan flujos de datos de pines virtuales.
(…Los pines virtuales están diseñados para intercambiar cualquier dato entre su hardware y Blynk. Cualquier cosa que conecte a su hardware podrá comunicarse con Blynk. Con Virtual Pins, puede enviar algo desde la aplicación, procesarlo en el microcontrolador y luego enviarlo de regreso al teléfono inteligente. Puede activar funciones, leer dispositivos I2C, convertir valores, controlar servos y motores de CC, etc.
Los pines virtuales se pueden usar para interactuar con bibliotecas externas (Servo, LCD y otras) e implementar funciones personalizadas.
Los pines virtuales son realmente solo una forma de enviar un mensaje desde la aplicación al código que se ejecuta en su placa (a través del servidor Blynk).
No hay correlación entre los pines virtuales y cualquiera de los pines GPIO físicos en su hardware. Si desea que un pin virtual cambie el estado de uno de sus pines físicos, debe escribir el código para que esto suceda.
Tienes mucho más control sobre lo que hacen tus widgets cuando usas pines virtuales. Por ejemplo, si desea que un solo botón de aplicación encienda o apague varios relés al mismo tiempo, eso es simple con pines virtuales, pero casi imposible con pines digitales.
Los pines virtuales son más predecibles (estables si lo desea) que manipular pines digitales.
Los “datastreams” son canales que se utilizan para enviar datos entre el dispositivo y Blynk.Cloud. Usaremos este flujo de datos para enviar valores aleatorios desde su dispositivo.
Haga clic en el botón “choose datastream”y elija Pin virtual en el menú desplegable:)
RECIBIENDO ORDENES DESDE LA NUBE
SWITCH (V0)
Utilizaremos el pin virtual V0 asociado al widget “switch” con valores 0/255 y en el sketch utilizare una variable tipo “int”que llamo v0 (v en minuscula para acordarme que esta ligada al datastream V0), y ahora solo habra que escribir la función así:
int v0;
BLYNK_WRITE(V0){v0=param.asInt();}De esta forma los valores recibidos desde “switch” se trasladaran a la variable v0. En este caso, se tratara de ver si “Switch” esta enviando “0” o “255”, para que v0 cambie tambien de valor en finción del tipo de variable escogida para el.
Basta con expresar: “if (v0)” para entender que v0=255 como variable” int” o
que v0=HIGH=1 si hemos definido “boolean v0”, pero tambien podemor expresar “if (v0==255) cuando es “int” o “if(v0==1) cuando es “boolean”
Algunos flujos de datos envían sus valores en forma de texto o números de punto flotante/doble
Para permitirle usar estos valores, la biblioteca Blynk también permite lo siguiente:
param.asStrng()
param.asFloat()
Pero, como solo estamos tratando con ceros y unos, que son números enteros, usaremos el método param.asInt.
Es interesante señalar tambien que si hubieramos elegido otro dipo de widget como por ejemplo un “SLIDER”,con valores digitales de 0a 255, podriamos multiplicar los casos condicionados de la variable “uint8_t v0” en función del valor recibido del SLIDER,con lo que las orderes se multiplican usando solo un widget ,en contraposicón de las unicas dos posibilidades que ofrece un “switch”
Sincronización del estado de salida con la aplicación al inicio
Cuando el dispositivo se inicia (se reinicia), no sabrá el estado del widget de botón en la aplicación, por lo que puede estar en un estado diferente al que muestra el widget de botón en la aplicación. Esto se corregirá cuando cambie el widget de botón en la aplicación, pero esa no es una solución muy satisfactoria.
Podemos obligar al servidor Blynk a enviar el valor más reciente para el pin virtual mediante el comando Blynk.syncVirtual(vPin). Esto hace que se ejecute el comando BLYNK_WRITE(vPin) correspondiente.
Para ejecutar automáticamente el comando BlynkSyncVirtual(vPin) cuando el dispositivo se conecta al servidor Blynk (que normalmente será después de un reinicio pero también podría estar después de una desconexión) podemos usar otra función especial llamada:
BLYNK_CONNECTED()
{
Blynk.syncVirtual(V0); // will cause BLYNK_WRITE(V0) to be executed
}De otro modo podemos decir que si SWITCH estaba en “off” cuando se produce la desconexión,se mantendrá en” “off” en la reanudacion,pero si estaba en “0n” y se desconecta el hardware,,en su reanudación no volvera a conectarse automaticamente a mens que escribamos esta funcion en nuestro sketch
ENVIANDO DATOS A LA NUBE
En la documentación original recalcan con insistencia el concepto de datastream y lo maravilloso que es usar pines virtuales. Creo que con el sencillo sketch que prepare lo vams a entender bien:
Primero tenemos que comprender que debemos poner en marcha uno o varios temporizadores de Blynk para que los datos enviados no colapsen el el canal de transmisión. En el ejemplo he utilizado un tiempo de 1000 mseg entre cada envio de datos que justamente van a coincidir con el cronometro del hardware que quiero enviar ( “timer=millis()-tref/1000)
...
BlynkTimer timer1; // Announcing the timer1//se podria utilizar el mismo temporizador para diferentes variables
BlynkTimer timer2; // Announcing the timer2
....
void setup(void) {
Serial.begin(9600);
timer1.setInterval(1000L, sv1); //timer1 will run every sec
timer2.setInterval(1000L, sv2); //timer2 will run every sec
Blynk.begin(auth, ssid, pass);
Utilizo dos temporizadores porque uno hara que la información del cronometro se pase cada segundo y el otro lo utilizaré para enviar una cadena de texto tambien cada segundo.
aclarado esto volvamos a nuestra app y añadamos dos datastreams nuevos con un widget de naturaleza “string” (V2) como es una entrada de texto y otro widget tipo double (V1) a presentar en un display numerico con valores ente 0 y 65000
Volviendo al sketch tenemos que declarar dos funciones sv1() y sv2() que asocian los data Stream V1y V2, pero previamente declaramos los tipos de variables asociadas a usar v1 y v2, de nuevo la misma letra con minuscula para ayudarme´a su identificación.
//enviar datos a la nube
BlynkTimer timer1; // Announcing the timer1//se podria utilizar el mismo temporizador para diferentes variables
BlynkTimer timer2; // Announcing the timer2
//declaración de variables
double v1;
String v2="start ready";
//definiendo funciones,las nombro segun el datastream a utilizar (pin virtual)antepodiendo "s"
void sv1(){
Blynk.virtualWrite(V1,v1); // sending sensor value of v1 to Blynk app
}
void sv2(){
Blynk.virtualWrite(V2, v2); // sending sensor value v2 to Blynk app
}En función del estado de SWITCH las cariables v1 y v2 tomaran valores diferentes como se muestra en el void loop().
Definimos el cronometro como timer=(millis()-tref)/1000, de modo que v1 sera igual a “timer” cuando “switch” este en “on” y “0” cuando este en off al mismo tiempo que “tref” sea hace = millis().
La variable string v2 que esta enviando la cadena “start ready”a la nube cada segundo pasa a enviar la cadena “started” cuando “switch” esta en “on” . para luego volver a convertirse en la cadena “start ready”
gracias a v2.replace(“start ready”,”started”) y v2.replace(“started”,”start ready”)
void loop(){
timer=(millis()-tref)/1000;
Blynk.run();
timer1.run(); // Initiates BlynkTimer1
timer2.run();// Initiates BlynkTimer2
if (v0){v2.replace("start ready","started");v1= timer; }else {v1=0;tref=millis();v2.replace("started","start ready");}
}
Por ultimo veamos como ha quedado nuestra TemplateID, y una de sus utilidades.
como sabemos hemos añadido un dispositivo de hardware a esta plantilla con estos tres datastream-Pero veamos que ocurre si en la app borramos el widget asociado al datastream V2,comprobaremos que su datastream permanece mientras no se borre particularementeasi como en el datastream del dispositivo
Del mismo modo si queremos añadir un nuevo dispositivo nos preguntara si queremos asociarlo a un nuevo templateId o asociarlo a uno existente, si lo asociamos y borramos un widget de un dispositivo desaparecera de todos los dispositivos asociados pero no sus datastream.
