Tutorial: como fazer registros de IOTA Tangle com Raspberry Pi 3

Aqui vamos mostrar os passos de como se faz a captura de um sinal de sensor e como seus dados são registrados na rede IOTA Tangle.

Após apresentarmos a ideia sobre as aplicações do IOTA Tangle no artigo Do Blockchain ao Tangle, vamos detalhar os conceitos e explicar, passo a passo, como fazemos a publicação de um sinal de sensor nessa rede. Buscamos uma forma de fácil compreensão ao leitor, tanto da montagem dos recursos utilizados, como do processo de captura e registro dos dados.

Cabe lembrar que estamos tratando aqui de uma Tecnologia de Registros Distribuídos (DLT – Distributed ledger technology), que nada mais é do que um livro de registros distribuído, ou seja, há uma cópia de dados registrados em todos os nodos de uma rede de computadores onde ele esteja instalado. Na DLT, os registros são invioláveis (não são editáveis) e podem ser públicos (legíveis por qualquer um na rede) ou privados (distribuídos seletivamente por uma entidade autenticadora). No exemplo deste artigo vamos tratar apenas de registros públicos.

A rede IOTA é então uma DLT que não necessita cadastro e pode ser usada sem nenhum tipo de pagamento. Por outro lado, todo dado enviado à rede é validado criptograficamente para registrar quem fez a anotação. Para isso, quem interage com a rede possui um tipo de senha chamado semente (seed), que é a chave criptográfica para criar endereços de envio de dados à rede IOTA. Uma vez gerada a semente, ela deve ser sempre usada como identificação para gravar ou ler seu histórico de escrita na rede.

O conjunto de dados gravado numa rede IOTA é chamado de The Tangle (O Emaranhado), por isso dizemos aqui que estamos trabalhando com o IOTA Tangle. Uma vez enviado um pacote de dados (bundle) numa transação, ele é distribuído aos nodos da rede e ficará registrado para sempre, que é a característica de uma DLT. Cada transação de um bundle tem um código único de identificação, o que permite sua conferência e validação.

Para demonstrar como funciona o processamento do registro de dados no IOTA Tangle, apresentamos a seguir os passos de um experimento prático com todas as etapas necessárias para sua compreensão.

lib

Experimento IOTA Tangle com Raspberry Pi 3

Figura 1 - Esquema do experimento IOTA Tangle no Raspberry

Para fazer o experimento, escolhemos o computador Raspberry Pi 3 por ser um dispositivo de baixa potência, do tamanho de um cartão de crédito, desenvolvido para sistemas IoT. Na figura 1, mostramos que os dados de temperatura e umidade são capturados pelo sensor DHT22, processados por um programa em Python, que envia-os para o Broker, disponibilizando-os ao Escritor NodeJS, que faz o registro desses dados no IOTA Tangle.

As seções a seguir, de BROKER MQTT até EXECUÇÃO FINAL DE TESTES, tiveram como referência o artigo How to send sensor data from python to IOTA tangle with MAM .

BROKER MQTT

Broker MQTT é um protocolo de mensagens leves para sensores e pequenos dispositivos móveis otimizados para redes TCP/IP não confiáveis ou de alta latência, bastante usado em projetos de IoT. O Broker MQTT pode ter vários sensores publicando nele ao mesmo tempo, como também muitos clientes coletando essas informações ao mesmo tempo.

Em nosso experimento, o Broker MQTT é o módulo que faz a intermediação: recebe os dados do programa em Python para que o Escritor NodeJS possa pegá-los e publicá-los, usando o protocolo MQTT.

Instalando o Broker no Raspberry:

$ sudo apt update
$ sudo apt upgrade
$ sudo apt install mosquitto mosquitto-clients

Testando Broker MQTT:

$ sudo service mosquitto status

Retorno que indica que o Broker está funcionando corretamente:

 
  mosquitto.service - LSB: mosquitto MQTT v3.1 message broker
    Loaded: loaded (/etc/init.d/mosquitto; generated; vendor preset: enabled)
    Active: active (running) since Tue 2019-01-01 23:42:51 CET; 25min ago
      Docs: man:systemd-sysv-generator(8)
    CGroup: /system.slice/mosquitto.service
            └─20726 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf 

Teste de publicação no Broker MQTT:

$ mosquitto_pub -d -t sensors/data -m "{temperatura: 23}"

O vídeo a seguir mostra essa primeira parte de instalação e teste do Broker MQTT.

ESCRITOR NODEJS

O código em NodeJS é o que coleta as informações do Broker MQTT usando o comando mosquitto_sub. Após coletar a informação, o comando faz seu registro no IOTA Tangle utilizando o MAM (Masked Authenticated Messaging).

O MAM é um protocolo de comunicação de dados que adiciona funcionalidade para emitir e acessar um fluxo de dados criptografados, independentemente do tamanho ou custo do dispositivo. O protocolo de consenso da IOTA adiciona integridade a esses fluxos de mensagens. Dadas essas propriedades, o MAM atende a uma necessidade importante em setores onde integridade e privacidade se encontram.

  • Repositório que será instalado a parte do Escritor NodeJS:
$ git clone https://github.com/magictimelapse/mqtt-iota
$ cd mqtt-iota/js
$ npm install
$ cd node_modules
$ git clone https://github.com/rckey/mam.node.js
  • Execução de teste do Escritor NodeJS:
$ cd mqtt_iota/js
$ node mqtt_to_mam_tangle.js
  • Retorno:
connected and subscribed to mqtt sensors/data stream

Agora ele está esperando ser publicado algum dado no Broker para ele pegar e fazer o registro no IOTA Tangle.

O vídeo a seguir mostra a instalação do Escritor NodeJS.

EXECUÇÃO FINAL DE TESTES

Antes de executar a parte final dos testes, devemos trocar o canal onde será registrado no IOTA Tangle.

  • Vá no diretório /mqtt-iota/js e abra o arquivo mqtt_to_mam_tangle.js com qualquer editor de texto e troque o nome do servidor que está após “const iota_host = ” para ‘https://iota1.chain.garden:443‘ (com as aspas simples) ou para o endereço do nodo de sua preferência.

O vídeo a seguir mostra como é feita a alteração do endereço do nodo a registrar no IOTA Tangle.

  • Executando a parte do Escritor Node.js:
$ cd mqtt-iota/js
$ node mqtt_to_mam_tangle.js

O programa Python é o que faz funcionar o sensor DHT22 e também o envio dos dados ao Broker MQTT com o comando mosquitto_pub. Neste caso, que é somente para testes, ele ainda não está capturando dados reais do sensor e sim publicando dados randômicos. Serão publicados dados reais somente na última parte de nosso experimento, quando alterarmos o código em Python para fazer a leitura do sensor.

  • Executando parte teste do Python em outro terminal:
$ cd mqtt-iota/python
$ python data_producer.py

O vídeo a seguir mostra o teste da conexão da transferência dos dados do programa Python até o Escritor NodeJS.

A seção referente ao sensor de umidade DHT22, a seguir, teve como base o artigo Raspberry Pi: Measure Humidity and Temperature with DHT11/DHT22.

CAPTURANDO DADOS COM O SENSOR DE UMIDADE DHT22

O DHT22 é um sensor que captura umidade e temperatura, semelhante ao DHT11, embora um pouco maior. Ambos utilizam apenas 1 pino de dados para conexão ao microcontrolador, mas internamente eles possuem diferenças significativas. Por exemplo, o DHT22 é capaz de medir uma faixa mais ampla de temperatura e umidade do que o DHT11, apesar deste ser mais rápido.

O DHT22 será conectado no Raspberry Pi com a ajuda de um protoboard, um resistor de 4,7 KOhms e alguns jumpers. O código de execução de leitura do sensor é feito em Python também.

Observação: o experimento também pode ser feito com o sensor DHT11.

A conexão do sensor com o Raspberry é mostrada na Figura 2.

Figura 2 - Circuito de ligação do DHT22 com Raspberry Pi 3

O vídeo a seguir mostra a montagem do sensor DHT22 em protoboard.

  • Instalando pacotes:
$ sudo apt-get update
$ sudo apt-get install build-essential python-dev python-openssl git
  • Carregando a biblioteca dos sensores:
$ git clone https://github.com/adafruit/Adafruit_Python_DHT.git && cd Adafruit_Python_DHT
$ sudo python setup.py install
  • Teste rápido da leitura dos dados de temperatura e umidade: 
$ cd examples
  • Com o sensor DHT22, executar:
$ sudo ./AdafruitDHT.py 22 4
  • Com o sensor DHT11, executar:
$ sudo ./AdafruitDHT.py 11 4
  • Exemplo de retorno:
 Temp=24.0*  Humidity=41.0%

O vídeo a seguir mostra o teste de captura de dados enviados pelo sensor DHT22.

PARTE FINAL

A parte final é onde reúne todas as partes, unindo o código que faz a postagem no Broker MQTT com o que captura as informações do sensor.

Para começar, entraremos no diretório Adafruit_Python_DHT e copiaremos tudo (será necessário para funcionar o sensor), para colar no diretório mqtt-iota/python que é o local onde ficará o código final do Python.

  • Executando programa Python final:
$ git clone https://gitlab.com/conexum/raspitangle.git
  • Entrar no diretório que foi clonado pelo git (Raspitangle) e copiar o arquivo Raspitangle.py e colar no diretório mqtt-iota/python/examples .

O vídeo a seguir mostra a alteração do programa Python para permitir a captura de dados do sensor .

  • Com a parte do Escritor NodeJS já sendo executada em outro terminal, aplicar a parte final:
$ cd mqtt-iota/python/examples
$ python Raspitangle.py
  • No terminal do NodeJS deverá aparecer um retorno parecido com esse:
root:9PDEUUFUTPLBNGORASBZGYXLWC9KLWWPGZFF9T9AHUKMLHHEVDWJJDUNXFJNADDHKT9ZKCNCVEY9MJRTZEWUHGASKY

Esse será o Token de confirmação do registro no IOTA Tangle, que também, servirá de acesso aos dados.

O vídeo a seguir mostra a postagem completa no IOTA Tangle dos registros do sensor.

A seção CLIENTE a seguir teve como referência o artigo Air Quality Sensor + Masked Authenticated Message Broker.

CLIENTE

Para obter as informações registradas no IOTA Tangle como cliente, pode-se acessar esse endereço do IOTA mam studio e utilizar o Token, que é conhecido como “Root Address”. Também existe a opção de executar esse serviço localmente, fazendo o git clone e a seguinte instalação:

$ git clone https://github.com/Evanfeenstra/mam-client.git
$ cd mam-client
$ sudo npm install
$ yarn upgrade
  • Antes de fazer o start, ir no diretório mam-client/src e renomear o arquivo App.js para app.js.
$ npm start
  • Após, deve-se abrir o navegador, acessar o http://localhost:3000/ e utilizar o “Root Address” para ter acesso às informações.

O vídeo a seguir mostra como obter as informações registradas no IOTA Tangle.

Neste último vídeo, podemos ver a recuperação dessas informações preservadas de qualquer tipo de alteração ou violação nos dados. As informações de temperatura e umidade registradas pelo sensor foram envidas através do primeiro código em Python para o BrokerMQTT. Em seguida, a parte do Escritor NodeJS que já estava aguardando os dados do Broker. O Escritor pega essas informações, e com o protocolo MAM, escreve-as no IOTA Tangle. Logo após serem aceitas no livro, não se pode quebrar os nodos desse emaranhado, podendo apenas ser pesquisados, por serem registros públicos. Isso tudo faz com que os dados tenham um alto grau de confiabilidade, para que assim sejam utilizados em diversos nichos na área tecnológica, como a própria IoT.

Sobre os autores:

Douglas Viegas

Técnico em Eletrônica

Desenvolvedor de sistemas, colabora com a Conexum desde 2019.

Daniel Muller

Desenvolvedor de Sistemas

Responsável na Conexum por Inteligência Artificial, IoT e Linguística Computacional.

About the author: Douglas Viegas