Requisitos
Una cuenta activa de Ubidots
1. Configuración de Ubidots
Dirígete a la sección "dispositivos" en tu cuenta de Ubidots.
Haz clic en el botón "+" para crear el dispositivo que recibirá los datos.
Selecciona "Dispositivo en blanco".
Establece un nombre de dispositivo según tus requisitos. Luego, la etiqueta del dispositivo se configurará automáticamente.
Deberías ver el nuevo dispositivo sin variables por el momento.
Haz clic en el dispositivo recién creado.
Copia la Etiqueta API del dispositivo, ID y Token en el portapapeles. Los necesitarás más tarde.
Dado que la seguridad es importante, querrás cifrado TLS para asegurar los mensajes que van a la nube. Dirígete al siguiente enlace; allí encontrarás el certificado PEM de Ubidots.
Copia todo el contenido en un editor de texto y guárdalo como "root.crt".
2. Configuración del PFC200
Inicia sesión en el WBM de tu PFC200 usando cualquier navegador web de tu elección. Escribe la dirección IP de tu controlador PFC200 en la barra de búsqueda.
Si se te piden credenciales, ingresa las predeterminadas:
Usuario: admin
Contraseña: wago
Asegúrate de que el firmware de tu PFC200 sea 04.01.10(23) o superior.
Dirígete a la pestaña de Configuración para configurar el dispositivo para conexiones salientes estableciendo un DNS como se muestra a continuación:
Verifica que el reloj del PFC200 esté configurado en la zona horaria correcta.
Verifica que puedes acceder al PFC200 iniciando una sesión SSH en el dispositivo. Usa la misma dirección IP y credenciales mencionadas anteriormente.
Desde el dispositivo, haz un ping a www.google.com para verificar el estado de la conectividad a Internet. Si se recibe una respuesta con las estadísticas de la conexión, el dispositivo está configurado correctamente. La sesión SSH puede finalizar ahora.
Ve a la sección de Conectividad a la nube bajo la pestaña de Configuración y luego selecciona Conexión 1. Edita los siguientes ajustes como muestra el GIF:
En Plataforma en la nube selecciona "MQTT Anycloud".
Configura el nombre de host como industrial.api.ubidots.com
Marca la casilla TLS y configura el número de puerto en 8883.
Introduce el ID del dispositivo de Ubidots obtenido anteriormente en el campo Client ID.
Introduce el Token completo de Ubidots en el campo User.
Deja el campo Password vacío.
En el ajuste de Protocolo de datos, selecciona Native MQTT.
Habilita FTP a través de la pestaña de Puertos y Servicios.
Inserta el certificado root.crt en la ruta
/etc/ssl/certs/dentro del controlador WAGO. Puedes hacerlo mediante FTP en el WAGO o utilizando SCP.Haz clic en el botón "Enviar" y luego reinicia el Controlador WAGO PFC200 haciendo clic en el botón "Reiniciar" en la esquina superior derecha del WBM.
Después de que se complete el reinicio, visita la página "Estado de la conexión" en el WBM. Entonces, deberías ver la conexión en funcionamiento.
3. Configuración de Codesys
Dirígete al sitio web de WAGO para descargar la versión más reciente de Codesys. Una vez descargado, instálalo y lánzalo.
Crea un nuevo proyecto, selecciona Proyecto vacío y asígnale un nombre.
Agrega el WAGO PFC200 al proyecto haciendo clic derecho en el proyecto recién creado y seleccionando la opción Agregar dispositivo:
Busca el Controlador WAGO PFC200 y luego haz clic en Agregar dispositivo.
Una vez agregado, el proyecto se verá así:
Crea un POU haciendo clic derecho en la opción aplicación en tu proyecto, luego selecciona Agregar objeto → POU. Asígnale el nombre de Main.
Crea una Configuración de Tarea haciendo clic en aplicación → Agregar objeto → Configuración de tarea. Deja el nombre predeterminado para esto y luego haz clic en el botón Agregar.
Haz clic en el botón Agregar llamada y agrega Main en la ventana emergente.
Nota que tu proyecto tiene dos nuevas pestañas:
Main
Tarea
Configura una Puerta de enlace e intenta conectarte en línea haciendo clic en la opción "Online" → "Login". Codesys te pedirá que crees una "Ruta activa".
Escanea la red haciendo clic en el botón "Escanear red" y selecciona el PFC200. Cuando se te pidan un nombre de usuario y una contraseña, usa las credenciales mencionadas anteriormente en esta guía. Ahora el dispositivo está en línea.
Vuelve a desconectarte y luego ve al Administrador de Bibliotecas.
Haz clic en "Agregar Biblioteca" e instala WagoAppCloud y WagoAppJSON.
4. Configuración de MQTT
En el explorador de proyectos, selecciona el bloque de función FbPublishMQTT_2.
La siguiente es la descripción del bloque de función FbPublishMQTT_2:
sTopic es una cadena que representa el tema MQTT: /v2.0/devices/{DEVICE_LABEL}’
eQualityOfService indica la cantidad de veces que se publicará un mensaje al broker MQTT (el broker de Ubidots en este caso). Establécelo en 1.
dwSize es una variable dinámica que almacena la longitud en bytes de la cadena de mensaje que se enviará al broker.
aData es el puntero de los datos de la carga útil JSON que se publicarán en el broker. Los datos deben copiarse de la cadena JSON a esta matriz aData.
xTrigger actuará como el disparador para comenzar a publicar datos.
xBusy, xError y oStatus son indicadores de resolución de problemas.
Crea un temporizador para actuar como el intervalo de publicación, que, en este caso, es cada 1 segundo.
Copia el siguiente código en el editor de código del proyecto.
TimerOn(IN := TRUE, PT := T#1S);
sPayload := '{"var1": 23, "var2": 46, "var3": 1}';
IF TimerOn.Q THEN
xTrigger := TRUE;
TimerOn(IN := FALSE);
IF NOT oFbPublishMQTT_2.xBusy THEN
// Copy payload string
dwBytesCount := Length(sPayload);
MemCopy(pDest := ADR(aBuffer), pSource := ADR(sPayload), udiSize := dwBytesCount);
// Trigger the transmission
xTrigger := TRUE;
ELSE
// Busy statistics counter
dwBusyCounter := dwBusyCounter + 1;
END_IF
IF oFbPublishMQTT_2.xError THEN
// Error statistics counter
dwErrorCounter := dwErrorCounter + 1;
END_IF
END_IF
oFbPublishMqtt_2(sTopic:= '/v2.0/devices/joes_test',
eQualityOfService:= 1,
dwSize := dwBytesCount,
aData := aBuffer,
xTrigger := xTrigger);
Crea el programa que inicializará el bloque de función de publicación MQTT. Copiar el siguiente código en el editor de código del proyecto lo hará:
PROGRAM Main
VAR
oFbPublishMQTT_2 : WagoAppCloud.FbPublishMQTT_2(eConnection := eConnectionId.Connection1);
aBuffer : ARRAY[0..1999] OF BYTE;
dwBytesCount : DWORD;
sPayload : STRING(1024);
xTrigger : BOOL;
TimerOn: TON;
dwBusyCounter: DWORD;
dwErrorCounter: DWORD;
END_VAR
Al final, debería verse así:
El siguiente paso es crear el mensaje JSON que se publicará. Para hacerlo, necesitarás el bloque de función Fb_JSON_Writer_02 de la biblioteca WagoAppJSON previamente instalada. A continuación, se muestra la descripción de los componentes de este bloque de función:
sJSON_BaseFrame albergará la plantilla de la cadena JSON. Cualquier variable dinámica tendrá el marcador de posición '#Parameter' dentro de la cadena de plantilla.
aParameterValues es una matriz de todas las variables que están representadas en la cadena de plantilla como #Parameter. Dado que esta matriz es una cadena, deberás convertir tus valores en cadenas antes de ponerlos en la matriz.
xTrigger hará que el bloque de función JSON se dispare y cree una cadena JSON representada por la cadena de plantilla y la matriz de valores.
sOutput será el resultado final de la cadena JSON.
Para crear la carga útil del mensaje JSON, es importante tener en cuenta que el tipo es una cadena con el formato de comillas alrededor del nombre de la variable y nada alrededor del valor, así que sigue este formato:
'{"var_name_1": var_1_val, "var_name_2": var_2_val}'
Con eso en mente, la declaración de variables que compone el código de configuración para la publicación MQTT y el escritor JSON es como se muestra a continuación:
PROGRAM Main
VAR
//Variables for MQTT publish
oFbPublishMQTT_2 : WagoAppCloud.FbPublishMQTT_2(eConnection := eConnectionId.Connection1);
aBuffer : ARRAY[0..1999] OF BYTE;
dwBytesCount : DWORD;
dwBusyCounter: DWORD;
dwErrorCounter: DWORD;
xTrigger : BOOL;
//Variables for MQTT subscribe
oFbSubMQTT_2 : WagoAppCloud.FbSubscribeMQTT_2(eConnection := eConnectionId.Connection1);
aSubBuffer : ARRAY[0..1999] OF BYTE;
xDataReceived: BOOL;
dwSubSize: DWORD;
//Variables for JSON_Writer
oFbJSON : WagoappJSON.Fb_JSON_Writer_02;
MyTemplateString : STRING(JSON_MAX_STRING):= '{"val1": #Parameter, "val2" : #Parameter, "val3": #Parameter}'; //String template
MyValueArray : ARRAY[0..2] OF STRING; //Array of values, must start at index 0
xJSONTrigger : BOOL;
value_var1 : INT; //Raw values to be transmitted. Must be converted to string first.
value_var2 : INT;
value_var3 : INT;
TimerOn: TON;
sPayload : STRING(2000);
END_VAR
Configura el disparador JSON y, en general, el flujo del código como sigue:
TimerOn(IN := TRUE, PT := T#1S);
value_var1 := 40;
value_var2 := 50;
value_var3 := 2;
MyValueArray[0] := INT_TO_STRING(value_var1);
MyValueArray[1] := INT_TO_STRING(value_var2);
MyValueArray[2] := INT_TO_STRING(value_var3);
IF TimerOn.Q THEN
xTrigger := TRUE;
xJSONTrigger := TRUE;
TimerOn(IN := FALSE);
IF NOT oFbPublishMQTT_2.xBusy THEN
// Copy payload string
dwBytesCount := Length(sPayload);
MemCopy(pDest := ADR(aBuffer), pSource := ADR(sPayload), udiSize := dwBytesCount);
// Trigger the transmission
xTrigger := TRUE;
ELSE
// Busy statistics counter
dwBusyCounter := dwBusyCounter + 1;
END_IF
IF oFbPublishMQTT_2.xError THEN
// Error statistics counter
dwErrorCounter := dwErrorCounter + 1;
END_IF
END_IF
oFbJson(sJSON_BaseFrame := MyTemplateString,
aParameterValues := MyValueArray,
xTrigger := xJSONTrigger,
sOutput := sPayload);
oFbPublishMqtt_2(sTopic:= '/v2.0/devices/joes_test',
eQualityOfService:= 1,
dwSize := dwBytesCount,
aData := aBuffer,
xTrigger := xTrigger);
Ve a la barra de herramientas y haz clic en Online → Login. Esto ejecutará el programa y enviará los datos a Ubidots.
Puedes consultar el repositorio oficial de este proyecto en el siguiente enlace.
