Desenvolvimento de borda IIoT - Usando protocolos OPC UA

Nota do Editor:A Internet das Coisas Industrial (IIoT) promete fornecer uma visão profunda das operações industriais e aumentar a eficiência das máquinas e sistemas conectados. Os aplicativos IIoT em grande escala contam com arquiteturas em camadas para coletar dados de uma ampla gama de sensores, mover dados de maneira confiável e segura para a nuvem e realizar a análise necessária para fornecer essa percepção e eficiência. No Industrial Internet Application Development, os autores fornecem um exame detalhado da arquitetura IIoT e discutem abordagens para atender aos amplos requisitos associados a esses sistemas.

Adaptado de Industrial Internet Application Development, por Alena Traukina, Jayant Thomas, Prashant Tyagi, Kishore Reddipalli.

---

Capítulo 3. Desenvolvimento do IIoT Edge (continuação)
Por Alena Traukina, Jayant Thomas, Prashant Tyagi, Kishore Reddipalli

Protocolos industriais M2M - OPC UA

Nesta seção, tentaremos construir um aplicativo IoT simples para enviar dados de um módulo simulador de sensor para um dispositivo receptor (um PC ou uma nuvem), usando um hub Raspberry Pi e o protocolo OPC UA:

Fluxo de dados de um simulador de sensor para um dispositivo receptor

O protocolo OPC UA é semelhante ao Modbus, mas funciona com mais tipos de dados e não tem limitações sérias, enquanto fornece segurança, compactação e baixa latência.

O protocolo foi desenvolvido pela OPC Foundation como um protocolo de comunicação máquina a máquina industrial. OPC UA (Arquitetura Unificada) é uma versão aprimorada das Comunicações de Plataforma Aberta ( OPC ) protocolo, com uma das principais alterações sendo que o novo protocolo está disponível gratuitamente, sem quaisquer restrições.

Na tabela a seguir, você pode encontrar uma descrição mais detalhada do protocolo para entender se ele é adequado para suas necessidades:
Chave Valor Código aberto SimA camada OSITipo de dados de transporte ou aplicativoInteger, float, string, Booleano, data, hora e assim por dianteLimitaçõesNão é adequado para uma arquitetura complexaOperações possíveis Ler / gravar / monitorar / consultar variáveisLatencyLowUsageIIoTSecuritySimCompressãoSim
Tabela 5:especificações do protocolo OPC UA

Para construir o aplicativo, precisaremos do seguinte:

• Software necessário
  • Node.js 6+ (https:/ / nodejs. org / en / download /)
  • PostgreSQL (https:// www. postgresql. org / download /)
  • CLI Cloud Foundry (https:// github. com / cloudfoundry / cli # downloads)
  • Solicitação (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 necessário
  • Raspberry Pi 3 (modelo B)
  • Um adaptador de energia (2A / 5V)
  • Um cartão microSD (8 GB +) e um adaptador SD
  • Cabo Ethernet para uma conexão de rede com fio
    

Preparando um cartão SD

Para preparar um cartão SD, siga a sequência de ações conforme descrito:

1. Baixe a imagem Raspbian LITE mais recente (disponível em https:// raspberrypi.org/downloads/raspbian/).
   

2. Conecte seu cartão SD a um computador e use o Etcher (https:// io /) para fazer o flash do arquivo Raspbian .img no SD cartão.
   

3. Ativar SSH:
   

cd / Volumes / boot touch ssh

4. Para habilitar o Wi-Fi, crie conf com o seguinte conteúdo:
   

rede ={
ssid =”YOUR_SSID”
psk =”YOUR_WIFI_PASSWORD”
}
Para criar um arquivo em um console Linux, você pode usar o editor GNU nano. Ele é pré-instalado na maioria das distribuições Linux. Tudo que você precisa é executar o comando nano FILE_NAME e seguir as instruções exibidas.

5. Crie o / home / pi / hub
   

6. Crie o arquivo /home/pi/hub/package.json com o seguinte conteúdo:
   

{
“nome”:“hub”,
“versão”:“1.0.0”,
“descrição”:“”,
“ main ”:“ index.js ”,“ scripts ”:{
“ start ”:“ node index.js ”,
“ test ”:“ echo “Erro:nenhum teste especificado” &&exit 1 ″
},
“autor”:“”,
“licença”:“ISC”, “dependências”:{
“assíncrono”:“^ 2.4.0”,
“node-opcua”:“0.0.64”,
“solicitar”:“^ 2.81.0”
}
}

7. Crie o arquivo /home/pi/hub/index.js com o seguinte conteúdo, substituindo
   

REMOTE-SERVER-ADDRESS.com e REMOTE-SENSOR-ADDRESS com valores reais:
var opcua =require (“node-opcua”); var async =require (“async”);
var request =require (“request”);
var sessão, assinatura;
var client =new opcua.OPCUAClient ();
var sensor =“opc.tcp:// REMOTE-SENSOR- ADDRESS:4334 / UA / resourcePath”;
var receiver =“http://REMOTE-SERVER-ADDRESS.com:8080”;
async.series ([
// estabelecendo a função de conexão (cb) {
client.connect (sensor, function (err) {
if (err) {
console.log (“Conexão com” + sensor + “falhou”);
} else {
console.log (“Conexão bem-sucedida”);
}
cb (err);
});
},
// iniciar função de sessão (cb) {
client.createSession (função (err, res) {
if (! Err) sessão =res;
cb (err);
});
},
// ler o valor
função (cb) {
session.readVariableValue (“ ns =1; s =Variable1 ”, função (err, dataValue) {
if (! err) console.log (“ Variable1 =“, dataValue.value.value);
cb (err);
});
},
// escrever valor
função (cb) {
session.writeSingleNode (“ns =1; s =Variable1”, novo opcua.Variant ({
DataType:opcua.DataType.Double, value:100
}), function (err) {
cb (err);
});
},
// subscrever as alterações
function (cb) {
subscription =new opcua.ClientSubscription (session, {
maxNotificationsPerPublish:5,
prioridade:5,
publishingEnabled:true,
requiredLifetimeCount:5,
requiredMaxKeepAliveCount:3,
requiredPublishingInterval:500,
});
subscription.on (“started”, function () {
console.log (“ID de assinatura:“,
subscription.subscriptionId);
}). on (“encerrado”, function () {
cb ();
});
setTimeout (function () {
subscription.terminate ();
}, 5000);
// instalar item monitorado
var monitor =subscription .monitor ({
attributeId:opcua. AttributeIds.Value,
nodeId:opcua.resolveNodeId (“ns =1; s =Variable1”),
},
{
discardOldest:true,
samplingInterval:50,
queueSize:5,
},
opcua.read_service.TimestampsToReturn.Both
);
monitor.on (“alterado”, função (dataValue) {
console.log (“Variable1 =“, dataValue.value.value);
// enviar para o receptor
var data ={
dispositivo:“sensor1”,
Timestamp:Date.now (),
Variable1:dataValue.value.value
};
request.post ({url:receiver, form:data}, function (err) {
if (err) console.log (“Falha ao enviar” +
JSON.stringify (data) + ”para” + receptor);
});
});
},
// fechar sessão
função (cb) {
sessão.close (função (errar) {
if (errar) console.log (“Falha ao Fechar sessão"); cb ();
});
}
],
function (err) {if (err) {
console.log (“Falha com erro:” , err);
} else {
console.log (“Concluído com sucesso”);
}
client.disconnect (function () {
});
}
);

8. Crie o arquivo / home / pi / hub / Dockerfile com o seguinte conteúdo:
   

FROM hypriot / rpi-node:boron-onbuild

9. Crie o / home / pi / sensor
   

10. Crie o arquivo /home/pi/sensor/package.json com o seguinte conteúdo:
    

{
“nome”:“sensor”,
“versão”:“1.0.0”,
“descrição”:“”,
“ main ”:“ index.js ”,
“ scripts ”:{
“ start ”:“ node index.js ”,
“ test ”:“ echo “Erro:nenhum teste especificado” &&exit 1 ″
},
“autor”:“”,
“licença”:“ISC”,
“dependências”:{
“node-opcua ”:“ 0.0.64 ”
}
}

11. Crie o arquivo /home/pi/sensor/index.js com o seguinte conteúdo:
    

var opcua =require (“node-opcua”);
var min =1;
var max =100;
var host =new opcua.OPCUAServer ({ buildInfo:{
buildDate:new Date (2018, 8, 8),
buildNumber:“1234”,
productName:“productName”,
},
porta :4334,
resourcePath:“UA / resourcePath”,
});
host.initialize (function () {
var space =host.engine.addressSpace;
Var componentOf =space.addObject ({
browseName:“browseName”,
organizadoBy:space.rootFolder.objects,
});
var variable1 =0;
// gerar novo 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 ”, // uma string nodeID
valor:{
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 (“Endpoint:“, endpoint);
});
});

12. Configure os valores mínimo e máximo no início do
    

arquivo /home/pi/sensor/index.js.

13. Crie o arquivo / home / pi / sensor / Dockerfile com o seguinte conteúdo:
    

FROM hypriot / rpi-node:boron-onbuild