Desarrollo de borde IIoT:uso de protocolos OPC UA

Nota del editor:La Internet industrial de las cosas (IIoT) promete proporcionar una visión profunda de las operaciones industriales y mejorar la eficiencia de las máquinas y los sistemas conectados. Las aplicaciones IIoT a gran escala se basan en arquitecturas en capas para recopilar datos de una amplia gama de sensores, mover datos de manera confiable y segura a la nube y realizar los análisis necesarios para brindar esa información y eficiencia. En Desarrollo de aplicaciones de Internet industrial, los autores proporcionan un examen detallado de la arquitectura IIoT y discuten enfoques para cumplir con los requisitos generales asociados con estos sistemas.

Adaptado de Desarrollo de aplicaciones de Internet industrial, por Alena Traukina, Jayant Thomas, Prashant Tyagi, Kishore Reddipalli.

---

Capítulo 3. Desarrollo de bordes de IIoT (continuación)
Por Alena Traukina, Jayant Thomas, Prashant Tyagi, Kishore Reddipalli

Protocolos industriales M2M - OPC UA

En esta sección, intentaremos crear una aplicación de IoT simple para enviar datos desde un módulo de simulador de sensor a un dispositivo receptor (una PC o una nube), utilizando un concentrador Raspberry Pi y el protocolo OPC UA:

Flujo de datos desde un simulador de sensor a un dispositivo receptor

El protocolo OPC UA es similar a Modbus, pero funciona con más tipos de datos y no tiene limitaciones importantes, al tiempo que proporciona seguridad, compresión y baja latencia.

El protocolo fue desarrollado por la Fundación OPC como un protocolo de comunicación industrial de máquina a máquina. OPC UA (Arquitectura unificada) es una versión mejorada de Comunicaciones de plataforma abierta ( OPC ), siendo uno de los principales cambios que el nuevo protocolo está disponible de forma gratuita y sin restricciones.

En la siguiente tabla, puede encontrar una descripción más detallada del protocolo para comprender si es adecuado para sus necesidades:

Clave Valor Código abiertoSíLa capa OSITransporte o aplicaciónTipos de datos Entero, flotante, cadena, booleano, fecha, hora, etc.

Tabla 5:Especificaciones del protocolo OPC UA

Para construir la aplicación, necesitaremos lo siguiente:

• Software necesario
  • Node.js 6+ (https:/ / nodejs. org / en / download /)
  • PostgreSQL (https:/ / www. postgresql. org / download /)
  • La CLI de Cloud Foundry (https:/ / github. com / cloudfoundry / cli # descargas)
  • Solicitud (https:/ / www. npmjs. com / package / request)
  • NodeOPCUA (https:/ / www. npmjs. com / package / node- opcua)
  • Async (https:/ / www. npmjs. com / package / async)
  • Docker (https:/ / docs. docker. com / engine / installation /)
• Hardware necesario
  • Raspberry Pi 3 (modelo B)
  • Un adaptador de corriente (2A / 5V)
  • Una tarjeta microSD (8 GB +) y un adaptador SD
  • Cable Ethernet para una conexión de red por cable
    

Preparar una tarjeta SD

Para preparar una tarjeta SD, siga la secuencia de acciones descrita:

1. Descargue la última imagen de Raspbian LITE (disponible en https:// raspberrypi.org/downloads/raspbian/).

2. Conecte su tarjeta SD a una computadora y use Etcher (https:// io /) para actualizar el archivo .img de Raspbian a la SD tarjeta.

3. Habilitar SSH:

cd / Volumes / boot touch ssh

4. Para habilitar Wi-Fi, cree conf con el siguiente contenido:

network ={
ssid =”YOUR_SSID”
psk =”YOUR_WIFI_PASSWORD”
}

Para crear un archivo en una consola Linux, puede usar el editor GNU nano. Está preinstalado en la mayoría de las distribuciones de Linux. Todo lo que necesita es ejecutar el comando nano FILE_NAME y seguir las instrucciones que se muestran.

5. Cree el / home / pi / hub

6. Cree el archivo /home/pi/hub/package.json con el siguiente contenido:

{
“nombre”:“hub”,
“versión”:“1.0.0”,
“descripción”:“”,
“ main ":" index.js "," scripts ":{
" start ":" node index.js ",
" test ":" echo "Error:no se ha especificado ninguna prueba" &&exit 1 ″
},
“autor”:“”,
“licencia”:“ISC”, “dependencias”:{
“async”:“^ 2.4.0”,
“node-opcua”:“0.0.64”,
“request”:“^ 2.81.0”
}
}

7. Cree el archivo /home/pi/hub/index.js con el siguiente contenido, reemplazando

REMOTE-SERVER-ADDRESS.com y REMOTE-SENSOR-ADDRESS con valores reales:
var opcua =require (“node-opcua”); var async =require ("async");
var request =require ("request");
var sesión, suscripción;
var client =new opcua.OPCUAClient ();
var sensor =“opc.tcp:// REMOTE-SENSOR- ADDRESS:4334 / UA / resourcePath”;
var receptor =“http://REMOTE-SERVER-ADDRESS.com:8080”;
async.series ([
// estableciendo la función de conexión (cb) {
client.connect (sensor, function (err) {
if (err) {
console.log ("Conexión a" + sensor + "fallido");
} else {
console.log ("Conexión exitosa");
}
cb (err);
});
},
// iniciar la función de sesión (cb) {
client.createSession (function (err, res) {
if (! Err) session =res;
cb (err);
});
},
// leer valor
function (cb) {
session.readVariableValue (“ ns =1; s =Variable1 ”, function (err, dataValue) {
if (! err) console.log (“ Variable1 =“, dataValue.value.value);
cb (err);
});
},
// escribir valor
function (cb) {
session.writeSingleNode (“ns =1; s =Variable1”, new opcua.Variant ({
DataType:opcua.DataType.Double, value:100
}), function (err) {
cb (err);
});
},
// suscribirse a los cambios
function (cb) {
subscription =new opcua.ClientSubscription (session, {
maxNotificationsPerPublish:5,
prioridad:5,
publishingEnabled:verdadero,
RequestLifetimeCount:5,
RequestMaxKeepAliveCount:3,
RequestPublishingInterval:500,
});
suscripción.on ("iniciado", función () {
console.log ("id. de suscripción:",
subscription.subscriptionId);
}). on ("terminado", función () {
cb ();
});
setTimeout (function () {
subscription.terminate ();
}, 5000);
// instala el elemento monitoreado
var monitor =subscription .monitor ({
atributoId:opcua. AttributeIds.Value,
nodeId:opcua.resolveNodeId (“ns =1; s =Variable1”),
},
{
discardOldest:true,
sampleInterval:50,
queueSize:5,
},
opcua.read_service.TimestampsToReturn.Both
);
monitor.on ("cambiado", function (dataValue) {
console.log (“Variable1 =“, dataValue.value.value);
// enviar al receptor
var data ={
dispositivo:“sensor1”,
Marca de tiempo:Date.now (),
Variable1:dataValue.value.value
};
request.post ({url:receiver, form:data}, function (err) {
if (err) console.log (“No se pudo enviar” +
JSON.stringify (datos) + ”a” + receptor);
});
});
},
// cerrar sesión
function (cb) {
session.close (function (err) {
if (err) console.log (“No se pudo Cerrar la sesión"); cb ();
});
}
],
function (err) {if (err) {
console.log ("Falló con error:" , err);
} else {
console.log ("Finalizado satisfactoriamente");
}
client.disconnect (function () {
});
}
);

8. Cree el archivo / home / pi / hub / Dockerfile con el siguiente contenido:

FROM hypriot / rpi-node:boron-onbuild

9. Cree el / home / pi / sensor

10. Cree el archivo /home/pi/sensor/package.json con el siguiente contenido:

{
“nombre”:“sensor”,
“versión”:“1.0.0”,
“descripción”:“”,
“ main ”:“ index.js ”,
“ scripts ”:{
“ start ”:“ node index.js ”,
“ test ”:“ echo “Error:no se especificó ninguna prueba” &&salida 1 ″
},
“autor”:“”,
“licencia”:“ISC”,
“dependencias”:{
“nodo-opcua ”:“ 0.0.64 ”
}
}

11. Cree el archivo /home/pi/sensor/index.js con el siguiente contenido:

var opcua =require (“node-opcua”);
var min =1;
var max =100;
var host =new opcua.OPCUAServer ({ buildInfo:{
buildDate:nueva fecha (2018, 8, 8),
buildNumber:"1234",
productName:"productName",
},
puerto :4334,
resourcePath:“UA / resourcePath”,
});
host.initialize (function () {
var space =host.engine.addressSpace;
Var componentOf =space.addObject ({
BrowseName:"BrowseName",
organizedBy:space.rootFolder.objects,
});
var variable1 =0;
// generar nuevo valor
setInterval (function () {
variable1 =Math.floor (max - Math.random () * (max - min));
}, 500);
space.addVariable ({
BrowseName:"BrowseName",
componentOf:componentOf,
dataType:"Double",
nodeId:"ns =1; s =Variable1 ”, // un valor de string nodeID
:{
get:function () {
return new opcu a.Variant ({dataType:opcua.DataType.Double, value:variable1});
},
set:function (variant) {
variable1 =parseFloat (variant.value);
return opcua.StatusCodes.Good;
}
}
});
host.start (function () {
var endpoint =
host.endpoints [0] .endpointDescriptions () [0] .endpointUrl; console.log ("Punto final:", punto final);
});
});

12. Configure los valores mínimo y máximo al comienzo del

archivo /home/pi/sensor/index.js.

13. Cree el archivo / home / pi / sensor / Dockerfile con el siguiente contenido:

FROM hypriot / rpi-node:boron-onbuild