Conteúdo


Implementação de blockchain para aplicativos cognitivos de IoT, Parte 2

Use dados de sensor de veículo para executar transações inteligentes no Blockchain

Integre o IBM Watson IoT Platform aos serviços do IBM Blockchain para desenvolver um caso de uso de amostra

Comments

Conteúdos da série:

Esse conteúdo é a parte # de # na série: Implementação de blockchain para aplicativos cognitivos de IoT, Parte 2

Fique ligado em conteúdos adicionais dessa série.

Esse conteúdo é parte da série:Implementação de blockchain para aplicativos cognitivos de IoT, Parte 2

Fique ligado em conteúdos adicionais dessa série.

Na Parte 1, foi discutido o uso do blockchain nas soluções de IoT e como as diferentes empresas estão utilizando essas duas tecnologias para construir soluções completas, automatizadas e seguras. Na Parte 2, mostraremos como usar o IBM Watson IoT Platform e o serviço IBM Blockchain para desenvolver um caso de uso de amostra.

Detalhes do caso de uso

Este cenário centraliza-se principalmente nos dados de veículo, como as mensagens de Veículo para Veículo (V2V), as mensagens de Veículo para Infraestrutura (V2I) e os dados integrados de monitoramento do veículo. Portanto, os atributos típicos incluem registro de data e hora, latitude, longitude, elevação, velocidade, vetor de direção e aceleração do veículo conectado e dos veículos próximos. Embora não estejam incluídos nesta demonstração, podem ser utilizados dados integrados adicionais para o veículo gerenciado, como nível de combustível e níveis de óleo, assim como outros dados de suporte (informações meteorológicas, condições de rodovias e regulamentações de direção específicas do local), para ampliar ainda mais o caso de uso.

É relativamente fácil construir rapidamente um aplicativo cognitivo de IoT, que se integre com uma instância do serviço IBM Blockchain.

A Tabela 1 descreve os participantes de nosso cenário.

Tablela 1. Principais participantes
ParticipanteDescrição
VeículoOs sensores internos do carro e os sensores V2V/V2I enviam todos os dados relacionados necessários para executar as transações no blockchain.
Autoridade governamentalNormalmente, a autoridade governamental monitora os padrões de condução (com base em zonas específicas) e define pontuações para os motoristas. Ela pode impor penalidades, com base nesses padrões de condução (como o excesso de velocidade).
Motorista ou proprietárioVisualiza as pontuações do motorista.
SeguradoraLê a pontuação do motorista e atualiza as regras do chaincode para ajustar os valores relacionados ao seguro (como o prêmio do seguro).

O aplicativo de demonstração inclui uma visualização do livro-razão, que armazena todas as interações que os participantes listados acima têm com os veículos gerenciados (ativos). A autoridade governamental e a seguradora podem usar a visualização do livro-razão para revisar e avaliar o Comportamento do Motorista de um veículo específico e de veículos próximos. Embora não esteja incluído nesse aplicativo de demonstração, ele também pode ser estendido para permitir que os prestadores de serviços de automóveis determinem o desempenho e o status do veículo na estrada e acionem registros de manutenção com base nas regras configuradas no blockchain.

Assim, todos os participantes podem reagir com base nos dados recebidos e acionar ações nos atributos do livro-razão que possuem. Alguns cenários possíveis são descritos na Tabela 2:

Tablela 2. Cenários
ParticipanteCenárioAção de contrato inteligente
SeguradoraRevisar pontuação/prêmio do seguroSe a pontuação de condução for inferior a um determinado limite, revise a pontuação/prêmio do seguro
Veículo (IoT)Registre o padrão de condução ou a condução perigosaAtualize a pontuação de condução
Veículo (IoT)Registre o status das peças do veículoMantenha o status das peças atualizado com base em entradas em tempo real
Veículo (V2V/V2I)Identifique a condução perigosa

Registre a infração de trânsito
Atualize a pontuação de condução

Atualize o registro de tráfego
Autoridade governamentalEnvie o caso de tráfegoCaso ocorra uma violação, crie um caso de tráfego

Pode suportar multa automática com base em infração de trânsito identificada

Aqui estão os detalhes desses cenários:

  • Classe de ativo primário:
    • Veículo—abrange dados de condução do veículo, dados de peças do veículo, pontuação de condução, registro de seguro, dados de infração de trânsito
  • Eventos:
    • Condução arriscada—derivado dos dados de IoT do veículo, que registram local, movimento, velocidade, direção e assim por diante
    • Violação de tráfego ou condução perigosa—registrados a partir dos dados de V2V/V2I
    • Pontuação do seguro revisada— derivado dos outros eventos, como condução arriscada e infração de trânsito
    • Caso de tráfego resolvido—quando a autoridade governamental resolveu o caso relativo à infração de trânsito
  • Regras e alertas:
    • Caso de tráfego pendente a regra gera um alerta em um evento de infração de trânsito, até ser liberado por um evento resolvido de caso de tráfego
    • Longo histórico de condução perigosa pode acionar outras ações relacionadas

Consulte a Introdução aos contratos inteligentes do Hyperledger para padrões e melhores práticas de IoT para obter informações adicionais sobre instância de contrato, comportamento, estado e assim por diante.

Visão geral de arquitetura

Com a tecnologia blockchain, sempre que uma nova transação é incluída, um processo de consenso ocorre, antes que a transação seja confirmada no livro-razão. Se os dados da transação forem grandes, a latência aumenta à medida que o serviço de consenso realiza sua tarefa. Isso significa que pode levar algum tempo até que a transação se torne visível como "confirmada" para os sistemas de monitoramento. É possível considerar esse atraso como uma latência de consenso.

Além disso, um aplicativo que interaja com o blockchain geralmente precisa saber quais dados precisam ou não ser repudiáveis. Para os dados que não precisam ser não repudiáveis, é possível armazená-los diretamente nos repositórios em vez de no blockchain.

Como isso coloca efetivamente um limite na velocidade e no volume de inclusão dos dados no blockchain, os dados em tempo real dos sensores V2V e de IoT do veículo não serão enviados diretamente para blockchain.

No design desse aplicativo de demonstração, estamos focados principalmente no processamento do blockchain. Os dados em tempo real provenientes de V2V e de IoT são analisados para identificar eventos específicos, que são então enviados para o serviço de blockchain. Isso garante uma separação adequada entre o processamento em tempo real e o processamento de blockchain.

Essa demonstração não inclui nenhum componente que exija acesso imediato a dados em tempo real.

A Figura 1 ilustra a arquitetura de alto nível do aplicativo de demonstração:

Figura 1. Arquitetura do aplicativo
Application architecture
Application architecture

Sensores e o Watson IoT Platform

Os sensores de veículo integrados são responsáveis pelo monitoramento dos dados do veículo durante a condução e também pelo envio desses dados ao Watson IoT Platform. Existem dois tipos principais de dados de sensores, que são usados para esse aplicativo de demonstração:

  • Os dispositivos integrados de monitoramento de veículos monitoram velocidade, local, direção e outros parâmetros necessários para analisar os padrões de condução.
  • Os sensores V2V e V2I receberão eventos recebidos de veículos ou infraestrutura próximos e os transmitirão ao Watson IoT Platform para análise adicional.

Utilizamos um simulador de dispositivo para simular os dados do sensor necessários para essa demonstração.

O Watson IoT Platform recebe todos os eventos do veículo, provenientes dos sensores. Os serviços baseados no Bluemix analisam esses eventos para encontrar padrões de condução e, em seguida, encaminhar os eventos de saída para uma instância do serviço IBM Blockchain, para ações subsequentes.

Contratos inteligentes e o IBM Blockchain

O contrato inteligente utilizado nessa demonstração é derivado do Contrato Genérico de Amostra de IoT e adaptado a um cenário de condução de carro. Esse contrato inteligente é executado em um blockchain baseado em Hyperledger Fabric e foi projetado para integração com o Watson IoT Platform.

Como no Contrato Genérico de Amostra de IoT, duas classes de mensagens são tratadas no livro-razão do blockchain:

  • Transações, que mudam o estado do livro-razão
  • Consultas, que leem o estado do livro-razão

Esse contrato inteligente herda recursos muito úteis do Contrato Genérico de Amostra de IoT, como o armazenamento do histórico de ativos, a primeira atualização mais recente, um mecanismo de regras para aumentar ou limpar alertas, um mecanismo de alertas para rastrear os alertas ativos e um padrão de "estado parcial como um evento".

O aplicativo cliente baseado em Node.js fornece às partes interessadas o acesso a todos os dados armazenados no armazenamento seguro do IBM Blockchain, resultante da execução do chaincode. As partes interessadas (seguradora, motorista, autoridade governamental) podem visualizar o resultado das transações, pois os dados de IoT são recebidos e processados pelo chaincode.

O aplicativo cliente usa a API de REST do IBM Blockchain para consultar o chaincode e exibir os dados através de uma simples interface baseada na web.

Detalhes da implementação

Esta seção descreve uma abordagem detalhada para implementar o caso de uso mencionado acima. Descrevemos os componentes de implementação necessários e como eles interagem para alcançar a funcionalidade necessária. Em seguida, listamos as etapas individuais do fluxo funcional e como essas etapas são implementadas usando os serviços Bluemix e o IBM Watson IoT Platform.

Obtenha a amostra de código do aplicativo clienteObtenha a amostra de código do contrato inteligente

A Figura 2 mostra os diferentes componentes do aplicativo de demonstração.

Figura 2. Componentes do aplicativo
Application components
Application components

Os seguintes componentes desempenham um papel importante na análise dos dados provenientes dos sensores:

  • Orquestração do Node-RED—O serviço Node-RED Starter , no Bluemix, é usado para orquestrar os eventos de IoT e enviar esses eventos, após o aumento, ao serviço de análise de padrão de condução.
  • Análise do Comportamento do MotoristaOs serviços de Comportamento do Motorista do Watson IoT utilizam os dados do evento aumentado para analisar os padrões de uso do veículo e do Comportamento do Motorista.

A Figura 3 mostra como os componentes interagem para implementar a funcionalidade necessária, usando os serviços de análise Node-RED e Comportamento do Motorista. Nesse Cenário, acionamos os contratos inteligentes diretamente do aplicativo customizado baseado no Node.js.

Figura 3. Fluxo do aplicativo de demonstração
Flow of the demo application
Flow of the demo application

Veja abaixo como o processo funciona:

  1. O proprietário registra o seu veículo usando o aplicativo cliente, o que, por sua vez, cria os ativos no blockchain.
  2. Os sensores no veículo registrado enviam dados de análise do veículo para o Watson IoT Platform.
  3. Os dados do sensor são analisados usando a orquestração baseada no Nodes-RED (detalhes fornecidos abaixo), que chama o serviço Comportamento do Motorista.
  4. O resultado do serviço Comportamento do Motorista é usado para acionar o serviço de blockchain, que executa os contratos inteligentes e as ações descritas acima.

Coleta de dados integrados de IoT e de V2V

Os dados de V2V e de IoT serão coletados pelo dispositivo integrado do veículo, que os enviará para o Watson IoT Platform. Para o aplicativo de demonstração, usaremos um simulador de dispositivo para enviar os dados de condução do dispositivo, conforme mostrado na listagem de códigos abaixo.

Dados dos sensores do veículo

Os dados de sensor do veículo são uma sequência ordenada de eventos automotivos. Cada evento consiste em título, latitude, longitude, velocidade e registro de data e hora, que são recuperados do veículo para uma viagem. Os dados do sensor de amostra usados para a análise do padrão de condução são mostrados aqui:

Lista 1. Dados do sensor de amostra
{
    "heading":273.995431,
    "latitude":30.398981,
    "longitude":97.746804,
    "speed":8.256416399999999,
    "timestamp":"2016-03-11T13:43:17.000Z",
    "trip_id":"1HGFM82644B006001_2017-02-10"
}

Dados dos sensores de V2V

Dois tipos de mensagens simuladas de comunicação veicular são enviados para o Watson IoT Platform:

  1. Mensagem básica de segurança (BSM)—Isso inclui as mensagens de V2V recebidas pelo receptor no carro conectado. As BSMs incluem luzes de freio de emergência, velocidade do veículo e direção.
  2. Mensagem de alerta na estrada (RSA)—Essas mensagens são acionadas por componentes de infraestrutura na estrada. As mensagens RSA incluem sinais de trânsito, avisos de veículos parados, incidentes e desvios.

Uma mensagem BSM de amostra de V2V é mostrada aqui:

Lista 2. Mensagem BSM de amostra de V2V
{
    "msgID": "basicSafetyMessage",
    "secMark":10,
    "id": 1111111111,
    "lat":60369542144,
    "lng": -984987654,
    "elev": 13000,
    "speed": 10000,
    "heading": 1820,
    "accelset": {
        "lat":0,
        "lng":0,
        "vert": 0,
        "yaw": 0
    },
    "brakes": {
        "wheelBrakes": 11110000,
        "traction": "off",
        "abs": "off"
    },
    "steering": 1501,
    "throttle": 60,
    "lightSet": {},
    "size": {
        "width": 213,
        "length": 640
    },
    "valueCnt1": 0,
    "items1": {},
    "valueCnt2": 0,
    "items2": {}	
}

Essas mensagens são analisadas para produzir eventos específicos de condução (como violações do sinal de trânsito, violações do limite de velocidade e colisões próximas), que são transmitidas à instância do Bluemix Blockchain para análise e gravação.

Vinculando eventos de V2V e de IoT com o livro-razão distribuído

Uma vez que o IoT Platform recebe os dados, o fluxo correspondente do Node-RED é acionado. O fluxo filtra os dados, aumenta-os e aplica regras específicas, conforme necessário. Em nosso aplicativo de demonstração, os dados integrados são enviados pelo fluxo do Node-RED para o serviço Comportamento do Motorista. O serviço Comportamento do Motorista identifica os eventos com base em viagens, como uma tarefa em lote. Na conclusão da tarefa, o aplicativo de demonstração aciona uma transação no serviço de blockchain. Assim, em nosso aplicativo de demonstração, cada viagem faz com que uma transação seja incluída no blockchain.

Fluxo de trabalho do Node-RED

A Figura 4 mostra o fluxo de trabalho do Node-RED, que está sendo usado em nosso aplicativo de demonstração.

Figura 4. Fluxo de trabalho do Node-RED
Node-RED workflow
Node-RED workflow

O objetivo desse fluxo do Node-RED é permitir que dados de IoT sejam enviados ao serviço Comportamento do Motorista, com aumentos de mapa geográfico, conforme necessário.

O fluxo lê a mensagem de IoT recebida e inclui o ID de locatário e o nome do host adequados para o serviço Comportamento do Motorista, associado ao seu aplicativo Bluemix. Os dados respectivos do dispositivo são extraídos da mensagem de IoT recebida e colocados em um formato que pode ser lido pelo serviço Comportamento do Motorista.

Esses dados são combinados com informações do mapa geográfico do serviço de Mapeamento de Contexto. Duas APIs de Mapeamento de Contexto são chamadas: /matching e /link. Os logs gerados mostram quais dados serão incluídos na mensagem.

Para nossa demonstração, enviaremos dados de viagem simulados (a sequência de eventos mostrada acima) ao serviço Comportamento do Motorista, que gera comportamentos de condução específicos para a viagem. Consulte a documentação para obter uma descrição dos eventos de comportamento gerados a partir dos dados do sensor.

Finalmente, a API /carProbe do serviço Comportamento do Motorista é chamada com a mensagem, para que o serviço possa incluir os dados de análise com relação à uma viagem específica em seu armazenamento de dados.

Os nós de "log" de cor verde são para a produção do resultado da depuração. Os nós de "atraso" correspondentes garantem que a mensagem do log seja totalmente gravada no resultado antes de passar para o próximo nó, de modo que as mensagens de log não se sobrescrevam.

É possível obter mais informações sobre os detalhes da API na documentação do serviço Bluemix, além de mais informações sobre como configurar esse fluxo neste tutorial.

Executando transações do livro-razão

Os eventos —e, portanto, as transações —podem ser acionados por eventos iniciados pelo IoT Platform ou pelos participantes.

Uma vez que uma transação é recebida por um par de validação no serviço de blockchain, ele iniciará um consenso com outros pares de validação na rede. No Serviço Bluemix Blockchain padrão, existem quatro pares de validação. Uma vez alcançado um consenso, os pares de validação confirmarão a transação.

Com base nas transações recebidas e confirmadas no livro-razão, um participante pode iniciar uma transação de acompanhamento. Por exemplo, quando um evento de condução inválido é recebido, a autoridade governamental pode iniciar uma transação para reduzir a pontuação de condução.

Esquema de contrato inteligente

Contratos inteligentes processam os dados provenientes dos sensores e do serviço de comportamento do motorista. A listagem de códigos abaixo mostra o esquema de amostras usado no aplicativo de demonstração, para processar todos os eventos nas transações. Isso é baseado na amostra Trade Lane para IoT avançada.

Lista 3. Esquema de amostra usado para processar todos os eventos de transação
"state": {
	            "type": "object",
	            "description": "um conjunto de propriedades que constitui um estado de ativo completo. Inclui propriedades de evento e qualquer outra propriedade calculada, como alertas relacionados à conformidade.",
	            "properties": {
	                "assetID": {
	                    "$ref": "#/definitions/assetID"
	                },
	                "vehicleID": {
	                		"$ref": "#/definitions/vehicleID"
	                },
	                "timestamp": {
	                    "type": "string",
	                    "description": "Registro de data e hora do evento."
	                },
	                "lastKnownLocation": {
	                    "$ref": "#/definitions/geo"
	                },
	                "extension": {
	                    "type": "object",
	                    "description": "Estado gerenciado por aplicativo. Opaque para contratar.",
	                    "properties": {
	                   		"authorityRating": {
	                    		"$ref": "#/definitions/rating"
	                    	},
	                   		"insurerRating": {
	                    		"$ref": "#/definitions/rating"
	                    	},
	                    	"lastTrip": {
	                    		"$ref": "#/definitions/trip"
	                    	}
	                    }
	                },
	                "txntimestamp": {
	                    "type": "string",
	                    "description": "Registro de data e hora de transação correspondente ao do blockchain."
	                },
	                "txnuuid": {
	                    "type": "string",
	                    "description": "UUID de transação correspondente ao do blockchain."
	                },
	                "compliant": {
	                    "type": "boolean",
	                    "description": "Uma indicação específica do contrato de que este ativo está em conformidade."
	                },
	                "alerts": {
	                    "$ref": "#/definitions/alertStatus"
	                },
	                "lastEvent": {
	                    "$ref": "#/definitions/eventWithFunction"
	                }
	            }
	        }

Desenvolvendo o aplicativo cliente

Utilizamos o SDK do Node.js do Bluemix para desenvolver o aplicativo cliente da web de amostra, que interage e consulta os dados do blockchain. O aplicativo cliente consulta o blockchain para mostrar os detalhes de ativos e transações. Ele também aciona os dados simulados enviados para o Watson IoT Platform e, em seguida, para o serviço de análise do motorista, para obter a pontuação de Comportamento do Motorista.

Configuração de chamada da API de REST do blockchain

Essa é a configuração usada por todas as chamadas de API de REST. Estabelece o par com o qual você está se conectando, o ID do usuário e o segredo, para autenticar a chamada API e os argumentos de chamada.

Lista 4. Configuração de chamada da API de REST do blockchain
var config = {
		host: "<peer id>-vp0.us.blockchain.ibm.com", 
		port: "5003", 
		secure_context: "<user id>", 
		enroll_secret: "<enroll secret>",
		protocol: "https",
		debug_mode: true,
		chaincodeURL: "<peer id>-vp0.us.blockchain.ibm.com:5003/chaincode",
		name: blk_chaincode,
		path: blk_chaincode,
		messageId: "",
		contract_version: "1.0",
		timeout: 3000,
		template: {
				"jsonrpc": "2.0",
				"method": "{{method}}",
				"params": {
					"type": 1,
					"chaincodeID":{
						"name":"mycc",
					},
					"ctorMsg": {
						"function":"{{function}}",
						"args":[],
					},
					"secureContext": "<user id>",
				},
				"id": 0
			},
	};

As seções abaixo fornecem um guia passo a passo para implementar o aplicativo de demonstração. Os fragmentos de código mostram como usar a API de REST do IBM Blockchain, para registrar ativos, atualizar os dados do ativo e consultar o blockchain em busca de dados de ativos atuais e históricos.

1a. Registre um ativo

O usuário registra o veículo que possui como um ativo. A Figura 5 mostra os detalhes do ativo suportados pelo aplicativo de demonstração.

Figura 5. Detalhes do ativo do aplicativo de demonstração
Demo application asset details
Demo application asset details

1b. Crie um novo ativo

Método de blockchain a ser usado: createAsset(). Além disso, um banco de dados Cloudant é usado como o repositório do veículo para a demonstração. O veículo é inserido no banco de dados após a criação do ativo no blockchain.

Lista 5. createAsset()
// Prepare the rest body for createAsset
createBody.method = 'invoke';
createBody.params.ctorMsg.function = 'createAsset';
createBody.params.ctorMsg.args = ["{\"assetID\":\""+ input_vin +"\",\"ownerName\":\""+ input_ownerName +"\",\"createDate\":\""+ v_createdt +"\",\"numberPlate\":\""+ input_numberPlate +"\"}"];
	
// Call blockchain createAsset function using rest api
https.request(options, function(res4) {
	  res4.setEncoding('utf8');
	  res4.on('data', function (chunk) {
	    console.log('BODY: ' + chunk);
	  });
	
// Prepare the vehicle JSON structure for inserting into Cloudant
var vehicle = {
		vin: input_vin,
		owner: input_ownerName,
		number: input_numberPlate,
		status: 'active',
		createDate: v_createdt
	};
var v_id = input_vin + ' - ' + input_numberPlate;

// Insert the vehicle into Cloudant
db.insert(vehicle, v_id, function(err, body, header) {
    if (err) {
      return console.log(v_id + ' -- [insert] ', err.message);
    }
  });

}).end(JSON.stringify(createBody));

Isso completa a preparação do ativo para rastreamento. A Etapa 2 mostra como capturar e aumentar os dados de IoT.

2a. Envie os dados simulados do veículo para os veículos registrados

Uma vez que um veículo é registrado, será necessário enviar os dados do sensor integrado do veículo. Um simulador de dispositivo é usado para enviar dados de análise do veículo para o Watson IoT Platform. Consulte o código do simulador do dispositivo para obter dados de condução do veículo do simulador.

Esse fragmento de código mostra como enviar dados para o Watson IoT Platform:

Lista 6. Envio de dados para o Watson IoT Platform
deviceClient.connect();
deviceClient.on('connect', function(){

if(iotDeviceConnectionStatus == false) {
 	iotDeviceConnectionStatus = true;	
     var i=0;
     console.log("connected");
     var IOTSent = setInterval(function sendIOTData() {
        if (i >= totalcount)
        {	
                deviceClient.disconnect();
                iotDeviceConnectionStatus = false;
                selectedVehicle.sim_status_id="1";
                iotDataSent = true;
                clearInterval(IOTSent);
                return;
        }
        datatopublish.d = carprobesampledata[i];
        i++;
	   processingStatus = "Capturing car data "+i+"/"+totalcount;
        console.log(processingStatus);
	   var driveTimestamp = new Date().toISOString();
        datatopublish.d.timestamp = drivedate + driveTimestamp.substr(10,driveTimestamp.length);
        datatopublish.d.trip_id = assetid+moment(new Date()).format('DD');
        datatopublish.ts = drivedate + moment(new Date()).format('THH:mm:ss.SSSZZ');
      
        deviceClient.publish('load', 'json', JSON.stringify(datatopublish), 0);
    	},delay*800);
    	console.log("End of on connect..");
    }
});

2b. Após o recebimento dos dados brutos do sensor pelo IoT Platform, aumente-os com os dados de mapeamento de contexto

O fluxo customizado do Node-RED descrito acima recebe os eventos do IoT Platform. O fluxo recebe os dados do sensor do IoT Platform. Implementamos o fluxo para chamar o serviço de Mapeamento de Contexto e aumentar os dados.

2c. Envie os dados aumentados à análise do motorista

O fluxo do Node-RED envia os dados aumentados do sensor para o serviço Análise do Motorista, para que os dados sejam armazenados.

Em seguida, será necessário coordenar a análise dos dados e atualizar os resultados da análise no ativo do blockchain. Nesse tutorial, essa coordenação é feita pelo aplicativo de demonstração do simulador de front-end.

3a. Quando o conjunto de dados estiver pronto na Análise do Motorista, acione a análise dos dados

O usuário deve continuar a ver o status atualizado na IU.

A URL da API de envio de tarefa de análise (POST) do motorista é a seguinte:

https://automotive.internetofthings.ibmcloud.com/driverinsights/jobcontrol/job?tenant_id=yourtenantid&from= dateoftravel&to=dateoftravel

Authorization Basic userid:secretkey

O ID de usuário e a chave secreta são provenientes do serviço Comportamento do Motorista, anexado ao seu aplicativo Bluemix. A data "até" também pode ser posterior à data "de", se desejar analisar diversos dias de dados em um único lote.

Lista 7. data "até" e data "de"
var new_event_date = moment(selectedVehicle.lastEventDate, 'DD-MMM-YYYY').add(1, 'days').format('YYYY-MM-DD');
path_str = "&from=" + new_event_date + "&to=" + new_event_date;
console.log(path_str);
driver_path_post =
“https://automotive.internetofthings.ibmcloud.com/driverinsights/jobcontrol/job?tenant_id=<tenant_id>”+
path_str;
    request(
    {
		url : driver_path_post,
		method : 'POST',
		headers : {
            "Authorization" : auth,
            "content-Type" : 'application/x-www-form-urlencoded'
        }
     },
     function (error, response, body) {
	    	var jsonbody = JSON.parse(body);
        	selectedVehicle.job_id = jsonbody.job_id;
        	selectedVehicle.sim_status_id = "2";
        	selectedVehicle.sim_status_desc = "Análise do motorista em andamento. Isso pode levar alguns minutos. Job id = " + jsonbody.job_id;
          res7.render('index', { title : 'Home', moment: moment, selectedVehicle : selectedVehicle, vehicleList : db_vehicle_list, sim_triggered : 'true'});
	});

Isso retornará um job_id em JSON, conforme a seguir:

    {
        "job_id": "4f9b70ef-6bcd-4a21-b311-e57ba9729a3d"
    }

Com esse job_id, aguarde a conclusão da análise do motorista. Isso pode levar um minuto, com nossos dados de amostra.

Aqui está a URL da API do status da tarefa (GET):

https://automotive.internetofthings.ibmcloud.com/driverinsights/drbresult/tripSummaryList?tenant_id=yourtenantid&job_id=yourjobid

O fragmento de código é mostrado aqui:

Lista 8. API de status da tarefa
path_str = "&job_id=" + selectedVehicle.job_id;
driver_path_get =
“https://automotive.internetofthings.ibmcloud.com/driverinsights/jobcontrol/job?tenant_id=<tenant_id>”
+ path_str;
    request(
        {
            url : driver_path_get,
            method : 'GET',
            headers : {
                "Authorization" : auth,
                "content-Type" : 'application/x-www-form-urlencoded'
            }
        },
        function (error, response, body) {
        	var jbody_1 = JSON.parse(body);
        	var sim_stat = jbody_1["job_status"];
        	console.log("job status - " + sim_stat);
        	if(sim_stat=="SUCCEEDED")
        	{
	            	selectedVehicle.sim_status_id = "3";
	        	selectedVehicle.sim_status_desc = "A análise do motorista está concluída. Buscando resultados...";
        	}	
});

O JSON retornado conterá o status da tarefa como "EM EXECUÇÃO" ou "BEM-SUCEDIDA". Se estiver no estado "EM EXECUÇÃO", chame a mesma API após um intervalo.

Uma vez que os resultados da análise do motorista estão disponíveis, a estrutura de dados resultante precisa ser transformada em uma estrutura de dados que será aceita pelo chaincode implementado.

Em nosso código de amostra, com o propósito de brevidade, essa estrutura é mantida praticamente a mesma; nenhuma transformação importante é necessária.

3b. Obtenha os resultados da análise do motorista

Para buscar os detalhes da viagem, duas chamadas são feitas para a API de serviço do motorista. A primeira chamada é feita com o ID do locatário e o ID da tarefa, para recuperar o UUID da viagem:
https://automotive.internetofthings.ibmcloud.com/driverinsights/drbresult/tripSummaryList?tenant_id=<tenant_id>&job_id=<job_id>

E a segunda chamada é feita com o UUID da viagem, para recuperar os detalhes da viagem:
https://automotive.internetofthings.ibmcloud.com/driverinsights/drbresult/trip?tenant_id=<tenant_id>&trip_uuid=<trip_uuid>

As pontuações do motorista e da seguradora são atualizadas nessa estrutura de dados. A pontuação é reduzida se eventos de má condução forem detectados, e aumentada se nenhum evento for detectado, indicando boa condução.

3c. Faça a solicitação para o blockchain com os novos dados do ativo com relação ao ID do ativo, assim, o estado do ativo será atualizado

Em seguida, o método updateAsset de nosso chaincode é chamado, com uma array de sequências, como o argumento de entrada. O comprimento da array é 1. Assim, o elemento zero-th da array conterá a estrutura de dados obtida na etapa acima.

Lista 9. Chamando o método updateAsset
// Prepare the rest body for updateAsset
updateBody.method = 'invoke';
updateBody.params.ctorMsg.function = 'updateAsset';
updateBody.params.ctorMsg.args = ["{\"assetID\":\""+ input_vin +"\",\"lastEvent\":\""+ input_lastEvent +"\"}"];
	
// Call blockchain updateAsset function using rest api
https.request(options, function(res4) {
	  res4.setEncoding('utf8');
	  res4.on('data', function (chunk) {
	    console.log('BODY: ' + chunk);
	  });
}).end(JSON.stringify(updateBody));

4. Consulte o blockchain para obter o estado do ativo

Chame o readAsset() com o ID do ativo, para obter as pontuações mais recentes e mostrá-las na IU.

Lista 10. readAsset()
var queryBody = config.template;
queryBody.params.chaincodeID.name = blk_chaincode;
// Prepare the rest body for readAsset
queryBody.method = 'query';
queryBody.params.ctorMsg.function = 'readAsset';
queryBody.params.ctorMsg.args = [ "{\"assetID\":\""+selected_vin+"\"}"];

console.log('queryBody - ' + JSON.stringify(queryBody));
var raw_str;	
// Call blockchain readAsset function using rest api
https.request(options, function(res2) {
	  res2.setEncoding('utf8');
	  res2.on('data', function (chunk) {
	    console.log('BODY: ' + chunk);
	    raw_str+=chunk;
	    var json_str = eval('(' + chunk + ')');
	    var json_msg = eval('(' + json_str.result.message + ')');
	    selectedVehicle.assetID = json_msg.assetID;
	    selectedVehicle.createDate = json_msg.createDate;
	    selectedVehicle.ownerName = json_msg.ownerName;
	    selectedVehicle.numberPlate = json_msg.numberPlate;
	    selectedVehicle.lastEventDate = moment(new Date(json_msg.txntimestamp)).format('DD-MMM-YYYY');
	  });
	}).end(JSON.stringify(queryBody));

Consulte o blockchain para obter o histórico de estado do ativo

Conforme mostrado no seguinte fragmento de código, os dados do histórico são recuperados chamando o método readAssetHistory() do chaincode. Usando os dados do histórico, pode-se listar as viagens feitas com o veículo e mostrá-las em um mapa, conforme as latitudes e longitudes.

Lista 11. Recuperação dos dados do histórico
queryBody.method = 'query';
queryBody.params.ctorMsg.function = 'readAssetHistory';
queryBody.params.ctorMsg.args = [ "{\"assetID\":\""+selectedVehicle.assetID+"\"}"];
 
// Call blockchain readAsset function using rest api
https.request(options, function(res2) {
      res2.setEncoding('utf8');
      res2.on('data', function (chunk) {
        console.log('BODY: ' + chunk);
        var jbody_1 = JSON.parse(chunk);
        var json_msg = jbody_1[0].result.message;
      });
    }).end(JSON.stringify(queryBody));

Conclusão

Conforme demonstrado nesse tutorial (e nas amostras de código), é relativamente fácil construir rapidamente um aplicativo cognitivo de IoT que se integre à uma instância do serviço IBM Blockchain. Os dados dos sensores de IoT podem ser analisados e transmitidos a contratos inteligentes de blockchain, para executar regras e concluir transações que possam ser validadas e acordadas por todos os pares participantes.

Esse aplicativo pode ser melhorado, incluindo serviços cognitivos adicionais que integram, por exemplo, dados meteorológicos durante uma viagem ou restrições de condução em locais diferentes, para analisar melhor como os motoristas respondem em diferentes condições. Soluções semelhantes também podem ser usadas para analisar o desempenho de novos motoristas em cenários de treinamento.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing, Internet of Things
ArticleID=1057950
ArticleTitle=Implementação de blockchain para aplicativos cognitivos de IoT, Parte 2: Use dados de sensor de veículo para executar transações inteligentes no Blockchain
publish-date=02082018